Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data. In R, functional programming can help you write more concise, readable, and maintainable code. This section will cover the key concepts of functional programming in R, including higher-order functions, anonymous functions, and the use of the purrr package.

• Definition: A pure function is a function where the return value is only determined by its input values, without observable side effects.
• Example:

  # Pure function example
  add <- function(x, y) {
    return(x + y)
  }
  result <- add(2, 3)  # result is 5
  

• Definition: Higher-order functions are functions that can take other functions as arguments and/or return them as results.
• Example:

  # Higher-order function example
  apply_function <- function(f, x) {
    return(f(x))
  }
  square <- function(x) {
    return(x * x)
  }
  result <- apply_function(square, 4)  # result is 16
  

• Definition: Anonymous functions are functions that are defined without a name, often used as arguments to higher-order functions.
• Example:

  # Anonymous function example
  result <- sapply(1:5, function(x) x^2)  # result is c(1, 4, 9, 16, 25)
  

• Definition: Closures are functions that capture the environment in which they were created.
• Example:

  # Closure example
  make_multiplier <- function(n) {
    return(function(x) x * n)
  }
  times_three <- make_multiplier(3)
  result <- times_three(4)  # result is 12
  

The purrr package is part of the tidyverse and provides a set of tools for functional programming in R. It makes it easier to work with functions and lists.

• Definition: Mapping functions apply a function to each element of a list or vector.
• Example:

  library(purrr)
  
  # Using map to apply a function to each element
  result <- map(1:5, ~ .x^2)  # result is a list of squares: list(1, 4, 9, 16, 25)
  

• Definition: Reducing functions combine elements of a list or vector into a single value.
• Example:

  # Using reduce to sum elements
  result <- reduce(1:5, `+`)  # result is 15
  

• Definition: Predicate functions return a logical value (TRUE or FALSE) based on a condition.
• Example:

  # Using keep to filter elements
  result <- keep(1:10, ~ .x %% 2 == 0)  # result is a list of even numbers: list(2, 4, 6, 8, 10)
  

Write a pure function multiply that takes two arguments and returns their product.

Create a higher-order function apply_twice that takes a function and a value, and applies the function to the value twice.

Use an anonymous function with sapply to calculate the cube of each number in a vector.

Use the map function from the purrr package to calculate the factorial of each number in a list.

• Mutable State: Avoid using global variables or modifying variables outside the function scope to ensure functions remain pure.
• Side Effects: Be cautious of functions that perform I/O operations (e.g., printing, reading files) as they can introduce side effects.
• Readability: Use descriptive names for functions and variables to make your code more readable and maintainable.

In this section, you learned about the principles of functional programming in R, including pure functions, higher-order functions, anonymous functions, and closures. You also explored the purrr package, which provides powerful tools for functional programming. By mastering these concepts, you can write more efficient and maintainable R code. Next, you will delve into parallel computing to further enhance your programming skills.