NEWS.md
future_mapply() and future_Map() was updated to match the new behavior of mapply() and Map() in R (>= 4.2.0), which follows the “max-or-0-if-any” recycling rule.citEntry() in CITATION used argument notes instead of note.Add argument future.envir to all future_nnn() functions, which is passed as argument envir to future().
Add option future.apply.debug for debugging features specific to this package. It defaults to option future.debug.
future_apply() gained argument simplify, which is added to R-devel (to become R 4.1.0).future_apply(X, FUN, ...) would pass all future.* arguments except future.globals, future.packages, and future.labels to the FUN function instead of processing them locally. This would often result in the FUN producing an error on “unused argument”. It also affected future.seed not being applied, which means for some FUN functions that did not produce this error, non-reproducible results could have been produced.future_.mapply() corresponding to .mapply() in the base package.future_mapply() would chunk up MoreArgs when future.seed = TRUE.future_nnn() functions set a label on each future that reflects the name of the future_nnn() function and the index of the chunk, e.g. "future_lapply-3". The format can be controlled by argument future.label.future_apply().future_lapply(X) and future_mapply(FUN, X) would drop names argument of the returned empty list when length(X) == 0.
Package could set .Random.seed to NULL, instead of removing it, which in turn would produce a warning on “‘.Random.seed’ is not an integer vector but of type ‘NULL’, so ignored” when the next random number generated.
Now future.conditions defaults to the same as argument conditions of future::future(). If the latter changes, this package will follow.
Debug messages are now prepended with a timestamp.
future_by().future.stdout and future.conditions for controlling whether standard output and conditions (e.g. messages and warnings) produced during the evaluation of futures should be captured and relayed or not. Standard output is guaranteed to be relayed in the same order as it would when using sequential processing. Analogously for conditions. However, standard output is always relayed before conditions. Errors are always relayed. Relaying of non-error conditions requires future (>= 1.11.0).Elements can be processed in random order by setting attribute ordering to "random" of argument future.chunk.size or future.scheduling, e.g. future.chunk.size = structure(TRUE, ordering = "random"). This can help improve load balancing in cases where there is a correlation between processing time and ordering of the elements. Note that the order of the returned values is not affected when randomizing the processing order.
Swapped order of arguments future.lazy and future.seed to be consistent with ditto arguments of future::future().
For list objects X where X != as.list(X), future_lapply(X) did not give the same result as lapply(X). Analogously for future_vapply(X).
future_mapply() could drop class attribute on elements iterated over, because .subset() was used internally instead of `[`(). For instance, iteration over Date objects were affected.
apply(), Map(), replicate(), sapply(), and tapply(), which are all GPL (>= 2).Added future_apply(), future_mapply(), and future_Map().
Added argument future.chunk.size as an alternative to argument future.scheduling for controlling the average number of elements processed per future (“chunk”). In R 3.5.0, the parallel package introduced argument chunk.size.
The maximum total size of globals allowed (option future.globals.maxSize) per future (“chunk”) is now scaled up by the number of elements processed by the future (“chunk”) making the protection approximately invariant to the amount of chunking (arguments future.scheduling and future.chunk.size).
future_lapply(X, ...) did not search for globals in X.
future_vapply() did not return the same dimension names as vapply() when FUN.VALUE had no names but FUN(X[[1]]) had.
future_eapply(), future_tapply(), future_vapply(), and future_replicate().future_lapply(x, ...) is now much faster and more memory efficient for large x vectors because it uses internal fold() function that is more efficient (memory and speed) version of base::Reduce(f, x), especially when length(x) is large.Added future_sapply().
Added future_lapply() - originally from the future package.
Created package.