The purpose of this package is to provide worry-free parallel alternatives to base-R functions lapply() and friends. The goal is that in most cases one should be able to just replace lapply() in the code with the futurized equivalent future_lapply() and things will just work. For example, instead of doing:

library("stats")
x <- 1:10
y <- lapply(x, FUN = quantile, probs = 1:3/4)

one can do:

library("future")
plan(multiprocess)
library("stats")
x <- 1:10
y <- future_lapply(x, FUN = quantile, probs = 1:3/4)

Reproducibility is part of the core design, which means that perfect, parallel random number generation (RNG) is supported regardless of the amount of chunking, type of load balancing, and future backend being used. To enable parallel RNG, use argument future.seed = TRUE.

Where does the future.apply package fit in the software stack? You can think of it as a sibling to foreach, BiocParallel, plyr, etc. Just as parallel provides parLapply(), foreach provides foreach(), BiocParallel provides bplapply(), and plyr provides llply(), future.apply provides future_lapply(). Below is a table summarizing this idea:

Note that, except for the parallel package, none of these higher-level APIs implement their own parallel backends, but they rather enhance existing ones. The foreach framework leverages backends such as doParallel, doMC and doFuture, and the future.apply framework leverages the future ecosystem and therefore backends such as built-in parallel and future.batchtools.

By separating future_lapply() and friends from the future package, it helps clarifying the purpose of the future package, which is to define and provide the core Future API, which higher-level parallel APIs can build on and for which any futurized parallel backends can be plugged into.

1. Implement future_*apply() versions for all common *apply() functions that exist in base R. This also involves writing a large set of package tests asserting the correctness and the same behavior as the corresponding *apply() functions.

2. Harmonize all future_*apply() functions with each other, e.g. the future-specific arguments.

3. Consider additional future_*apply() functions and features that fit in this package but don't necessarily have a corresponding function in base R. Examples of this may be "apply" functions that return futures rather than values, mechanisms for benchmarking, and richer control over load balancing.

The API and identity of the future.apply package will be kept close to the *apply() functions in base R. In other words, it will neither keep growing nor be expanded with new, more powerful apply-like functions beyond those core ones in base R. Such extended functionality should be part of a separate package.

R package future.apply is available on CRAN and can be installed in R as:

install.packages('future.apply')

This Git repository uses the Git Flow branching model (the git flow extension is useful for this). The develop branch contains the latest contributions and other code that will appear in the next release, and the master branch contains the code of the latest release, which is exactly what is currently on CRAN.

Contributing to this package is easy. Just send a pull request. When you send your PR, make sure develop is the destination branch on the future.apply repository. Your PR should pass R CMD check --as-cran, which will also be checked by Travis CI and AppVeyor CI when the PR is submitted.

Resource:	CRAN	Travis CI	Appveyor
Platforms:	Multiple	Linux & macOS	Windows
R CMD check
Test coverage