What's the difference between lapply and do.call?

functional-programming, r

Solution

There is a function called `Map` that may be similar to map in other languages:

`lapply` returns a list of the same length as X, each element of which is the result of applying FUN to the corresponding element of X.

`do.call` constructs and executes a function call from a name or a function and a list of arguments to be passed to it.

`Map` applies a function to the corresponding elements of given vectors... `Map` is a simple wrapper to `mapply` which does not attempt to simplify the result, similar to Common Lisp's mapcar (with arguments being recycled, however). Future versions may allow some control of the result type.

- `Map` is a wrapper around `mapply`

- `lapply` is a special case of `mapply`

- Therefore `Map` and `lapply` will be similar in many cases.

For example, here is `lapply`:

lapply(iris, class)
$Sepal.Length
[1] "numeric"

$Sepal.Width
[1] "numeric"

$Petal.Length
[1] "numeric"

$Petal.Width
[1] "numeric"

$Species
[1] "factor"

And the same using `Map`:

Map(class, iris)
$Sepal.Length
[1] "numeric"

$Sepal.Width
[1] "numeric"

$Petal.Length
[1] "numeric"

$Petal.Width
[1] "numeric"

$Species
[1] "factor"

`do.call` takes a function as input and splatters its other arguments to the function. It is widely used, for example, to assemble lists into simpler structures (often with `rbind` or `cbind`).

For example:

x <- lapply(iris, class)
do.call(c, x)
Sepal.Length  Sepal.Width Petal.Length  Petal.Width      Species 
   "numeric"    "numeric"    "numeric"    "numeric"     "factor"

Problem

I'm learning R recently and confused by two function: `lapply`and `do.call`. It seems that they're just similar to `map` function in Lisp. But why are there two functions with such a different name? Why doesn't R just use a function called `map`?

Original source