Functional Programming R Exercises: 18 Practice Problems

Explanation: sapply() treats a function as a value: you pass class (no parentheses) and it gets invoked on each list element. Because every result is a length-one character, sapply() simplifies the output to a named vector instead of returning a list. If you wanted to preserve list shape, lapply() is the safer choice and vapply(lst, class, character(1)) is the strictest.

Explanation: Returning a function turns prefix into part of the inner function's enclosing environment. That captured value persists for every later call, which is the essence of a closure. The same pattern produces euro <- make_formatter("EUR ") for free, with no copy-paste. format(..., nsmall = 2) keeps trailing zeros (so 12.50 does not collapse to 12.5).

Explanation: The \(x) lambda syntax (added in R 4.1) is identical to function(x) but two characters cheaper, which matters when you have many short callbacks. Use it for one-off helpers you would not reuse: anything you would name (like cube) deserves a top-level function() binding so it shows up in stack traces.

Explanation: A data frame is internally a list of columns, so sapply() iterates column-by-column. Because the per-column result is always a single numeric value, the output collapses to a named vector. For type-stable production code prefer vapply(mtcars, median, numeric(1)): if any column ever returns something unexpected, vapply() fails loudly instead of silently switching to a list.

Explanation: map_dbl() is the type-stable variant of map(): it guarantees a double vector or errors at the first non-numeric result. The \(col) lambda is needed only because max() takes the extra na.rm argument; for the bare max case map_dbl(airquality, max) would also work but would return NA for any column containing missing values.

Explanation: map2_*() is the right call when two inputs must move in lockstep: it errors if the vectors differ in length, which would mask a bug if you used vectorised arithmetic alone. For three or more parallel inputs you would graduate to pmap_dbl() and pass a list. The plain vectorised form (after - before) / before * 100 works here too, but map2_dbl() makes the iteration explicit.

Explanation: pmap_*() takes a single list of equal-length vectors and binds the i-th element of each to the lambda's positional arguments. It scales to any number of inputs, unlike map2_*(). A common alternative is to bind columns into a tibble and call pmap_dbl(df, \(q, p, t) ...): the column names then become the parameter names, which reads cleanly when the vectors have meaningful labels.

Explanation: Reduce() collapses a list by folding a binary function pairwise: it computes intersect(lst[[1]], lst[[2]]) first, then intersects the result with lst[[3]]. This generalises to N lists with zero loop code. The pattern works for any associative binary op: Reduce(union, ...), Reduce("+", ...), Reduce(merge, list_of_dfs), and so on.

Explanation: Where reduce() keeps only the final value, accumulate() returns every intermediate state, which is exactly what cumulative wealth or running totals require. The .init = 1 argument seeds the fold with a starting wealth, so the output has length five for an input of four returns. A vectorised shortcut for this specific case is cumprod(1 + r), but the accumulate form generalises to any non-trivial state update rule.

Explanation: Subtraction is not associative: left-to-right gives ((10 - 4) - 2) - 1 = 3, but right = TRUE evaluates 2 - 1 = 1 first, then 4 - 1 = 3, then 10 - 3 = 7. The same flag matters for any non-associative op (division, string concatenation order). It is also faster than building the expression manually with do.call() because Reduce avoids intermediate allocations.

Explanation: keep() and discard() are the inverse of each other and accept any predicate that returns a logical scalar per element. They preserve the input container shape: a list in, a list out, so you can still feed the result into another map(). The base R equivalent is Filter(is.numeric, lst), which behaves identically and ships with every R install.

Explanation: A predicate is just a function returning TRUE or FALSE per element. Here the lambda \(x) nchar(x) < 5 works on each string. The vectorised base alternative is names[nchar(names) >= 5], which is faster on large vectors but less composable if you later chain through a pipeline of keep() / discard() / map() steps with mixed predicates.

Explanation: The <<- super-assignment writes to count in the enclosing function's environment instead of creating a new local binding. That captured environment is what makes the counter persist between calls. Each call to make_counter() produces an independent counter with its own private state, which is the closure idiom for object-without-class encapsulation.

Explanation: Function factories let you parameterise a family of functions with shared logic. square <- power(2), cube <- power(3), and quartic <- power(4) all share one definition. The risk is lazy evaluation: if n were itself a complex expression, it would not be evaluated until the inner function is called. Use force(n) inside the factory if you build many factories in a loop to lock in the value early.

Explanation: The naive recursive Fibonacci recomputes the same subproblems exponentially many times. Storing results in a closure-private cache reduces it to linear work. Recall() refers to the currently executing function, which is robust to renaming the returned function later. The <<- writes the new value into the enclosing environment so the next call sees the updated cache.

Explanation: compose(f, g) returns a new function equivalent to function(x) f(g(x)): rightmost arg runs first. Composition is useful when you want to pass a single pre-built pipeline as a callback to map() or apply() without redefining the lambda each time. Pass .dir = "forward" if you prefer left-to-right reading order, which mirrors the magrittr pipe.

Explanation: partial() fixes a subset of arguments and returns a new function awaiting the rest. It is the canonical way to remove keyword-argument boilerplate from callbacks: map_dbl(df, mean_na) reads cleaner than map_dbl(df, \(x) mean(x, na.rm = TRUE)). Internally partial() constructs a function whose default args are the pre-supplied values, so call-site overrides still work.

Explanation: The accumulator pattern turns recursion into a tail call (the recursive call is the final operation), which is the functional alternative to a for loop with a running total. R does not actually optimise tail calls, so this version will hit the default stack limit around 1:5000. For real work prefer the vectorised sum(x): the recursive form is here to illustrate the structure, not to replace base arithmetic.