Back trace the expressions evaluated when an error was caught

backtrace(future, envir = parent.frame(), ...)

Arguments

future

A future with a caught error.

envir

the environment where to locate the future.

...

Not used.

Value

A list with the future's call stack that led up to the error.

Examples

my_log <- function(x) log(x)
foo <- function(...) my_log(...)

f <- future({ foo("a") })
res <- tryCatch({
  v <- value(f)
}, error = function(ex) {
  t <- backtrace(f)
  print(t)
})
#> [[1]]
#> tryCatch(withCallingHandlers({
#>     NULL
#>     saveRDS(do.call(do.call, c(readRDS("/tmp/hb/RtmpmB3n2n/callr-fun-3e325e68b769"), 
#>         list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, 
#>         quote = TRUE), file = "/tmp/hb/RtmpmB3n2n/callr-res-3e326c667aa8")
#>     flush(stdout())
#>     flush(stderr())
#>     NULL
#>     invisible()
#> }, error = function(e) {
#>     {
#>         callr_data <- as.environment("tools:callr")$`__callr_data__`
#>         err <- callr_data$err
#>         assign(".Traceback", .traceback(4), envir = callr_data)
#>         dump.frames("__callr_dump__")
#>         assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data)
#>         rm("__callr_dump__", envir = .GlobalEnv)
#>         e$call <- deparse(conditionCall(e), nlines = 6)
#>         e2 <- err$new_error(conditionMessage(e), call. = conditionCall(e))
#>         class(e2) <- c("callr_remote_error", class(e2))
#>         e2$error <- e
#>         calls <- sys.calls()
#>         dcframe <- which(vapply(calls, function(x) length(x) >= 
#>             1 && identical(x[[1]], quote(do.call)), logical(1)))[1]
#>         if (!is.na(dcframe)) 
#>             e2$`_ignore` <- list(c(1, dcframe + 1L))
#>         e2$`_pid` <- Sys.getpid()
#>         e2$`_timestamp` <- Sys.time()
#>         if (inherits(e, "rlib_error_2_0")) 
#>             e2$parent <- e$parent
#>         e2 <- err$add_trace_back(e2, embed = FALSE)
#>         saveRDS(list("error", e2), file = paste0("/tmp/hb/RtmpmB3n2n/callr-res-3e326c667aa8", 
#>             ".error"))
#>     }
#> }, interrupt = function(e) {
#>     {
#>         callr_data <- as.environment("tools:callr")$`__callr_data__`
#>         err <- callr_data$err
#>         assign(".Traceback", .traceback(4), envir = callr_data)
#>         dump.frames("__callr_dump__")
#>         assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data)
#>         rm("__callr_dump__", envir = .GlobalEnv)
#>         e$call <- deparse(conditionCall(e), nlines = 6)
#>         e2 <- err$new_error(conditionMessage(e), call. = conditionCall(e))
#>         class(e2) <- c("callr_remote_error", class(e2))
#>         e2$error <- e
#>         calls <- sys.calls()
#>         dcframe <- which(vapply(calls, function(x) length(x) >= 
#>             1 && identical(x[[1]], quote(do.call)), logical(1)))[1]
#>         if (!is.na(dcframe)) 
#>             e2$`_ignore` <- list(c(1, dcframe + 1L))
#>         e2$`_pid` <- Sys.getpid()
#>         e2$`_timestamp` <- Sys.time()
#>         if (inherits(e, "rlib_error_2_0")) 
#>             e2$parent <- e$parent
#>         e2 <- err$add_trace_back(e2, embed = FALSE)
#>         saveRDS(list("error", e2), file = paste0("/tmp/hb/RtmpmB3n2n/callr-res-3e326c667aa8", 
#>             ".error"))
#>     }
#> }, callr_message = function(e) {
#>     try(signalCondition(e))
#> }), error = function(e) {
#>     NULL
#>     try(stop(e))
#> }, interrupt = function(e) {
#>     NULL
#>     e
#> })
#> 
#> [[2]]
#> tryCatchList(expr, classes, parentenv, handlers)
#> 
#> [[3]]
#> tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
#>     names[nh], parentenv, handlers[[nh]])
#> 
#> [[4]]
#> doTryCatch(return(expr), name, parentenv, handler)
#> 
#> [[5]]
#> tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
#> 
#> [[6]]
#> tryCatchOne(expr, names, parentenv, handlers[[1L]])
#> 
#> [[7]]
#> doTryCatch(return(expr), name, parentenv, handler)
#> 
#> [[8]]
#> withCallingHandlers({
#>     NULL
#>     saveRDS(do.call(do.call, c(readRDS("/tmp/hb/RtmpmB3n2n/callr-fun-3e325e68b769"), 
#>         list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, 
#>         quote = TRUE), file = "/tmp/hb/RtmpmB3n2n/callr-res-3e326c667aa8")
#>     flush(stdout())
#>     flush(stderr())
#>     NULL
#>     invisible()
#> }, error = function(e) {
#>     {
#>         callr_data <- as.environment("tools:callr")$`__callr_data__`
#>         err <- callr_data$err
#>         assign(".Traceback", .traceback(4), envir = callr_data)
#>         dump.frames("__callr_dump__")
#>         assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data)
#>         rm("__callr_dump__", envir = .GlobalEnv)
#>         e$call <- deparse(conditionCall(e), nlines = 6)
#>         e2 <- err$new_error(conditionMessage(e), call. = conditionCall(e))
#>         class(e2) <- c("callr_remote_error", class(e2))
#>         e2$error <- e
#>         calls <- sys.calls()
#>         dcframe <- which(vapply(calls, function(x) length(x) >= 
#>             1 && identical(x[[1]], quote(do.call)), logical(1)))[1]
#>         if (!is.na(dcframe)) 
#>             e2$`_ignore` <- list(c(1, dcframe + 1L))
#>         e2$`_pid` <- Sys.getpid()
#>         e2$`_timestamp` <- Sys.time()
#>         if (inherits(e, "rlib_error_2_0")) 
#>             e2$parent <- e$parent
#>         e2 <- err$add_trace_back(e2, embed = FALSE)
#>         saveRDS(list("error", e2), file = paste0("/tmp/hb/RtmpmB3n2n/callr-res-3e326c667aa8", 
#>             ".error"))
#>     }
#> }, interrupt = function(e) {
#>     {
#>         callr_data <- as.environment("tools:callr")$`__callr_data__`
#>         err <- callr_data$err
#>         assign(".Traceback", .traceback(4), envir = callr_data)
#>         dump.frames("__callr_dump__")
#>         assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data)
#>         rm("__callr_dump__", envir = .GlobalEnv)
#>         e$call <- deparse(conditionCall(e), nlines = 6)
#>         e2 <- err$new_error(conditionMessage(e), call. = conditionCall(e))
#>         class(e2) <- c("callr_remote_error", class(e2))
#>         e2$error <- e
#>         calls <- sys.calls()
#>         dcframe <- which(vapply(calls, function(x) length(x) >= 
#>             1 && identical(x[[1]], quote(do.call)), logical(1)))[1]
#>         if (!is.na(dcframe)) 
#>             e2$`_ignore` <- list(c(1, dcframe + 1L))
#>         e2$`_pid` <- Sys.getpid()
#>         e2$`_timestamp` <- Sys.time()
#>         if (inherits(e, "rlib_error_2_0")) 
#>             e2$parent <- e$parent
#>         e2 <- err$add_trace_back(e2, embed = FALSE)
#>         saveRDS(list("error", e2), file = paste0("/tmp/hb/RtmpmB3n2n/callr-res-3e326c667aa8", 
#>             ".error"))
#>     }
#> }, callr_message = function(e) {
#>     try(signalCondition(e))
#> })
#> 
#> [[9]]
#> saveRDS(do.call(do.call, c(readRDS("/tmp/hb/RtmpmB3n2n/callr-fun-3e325e68b769"), 
#>     list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, 
#>     quote = TRUE), file = "/tmp/hb/RtmpmB3n2n/callr-res-3e326c667aa8")
#> 
#> [[10]]
#> do.call(do.call, c(readRDS("/tmp/hb/RtmpmB3n2n/callr-fun-3e325e68b769"), 
#>     list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, 
#>     quote = TRUE)
#> 
#> [[11]]
#> (function (what, args, quote = FALSE, envir = parent.frame()) 
#> {
#>     if (!is.list(args)) 
#>         stop("second argument must be a list")
#>     if (quote) 
#>         args <- lapply(args, enquote)
#>     .Internal(do.call(what, args, envir))
#> })(base::quote(function (..., crayon_enabled, crayon_colors, 
#>     pkgdown_internet) 
#> {
#>     options(crayon.enabled = crayon_enabled, crayon.colors = crayon_colors, 
#>         pkgdown.internet = pkgdown_internet)
#>     pkgdown::build_site(...)
#> }), base::quote(list(pkg = list(package = "future", version = "1.23.0-9002", 
#>     src_path = "/tmp/hb/RtmpmB3n2n/future", dst_path = "/tmp/hb/RtmpmB3n2n/future/docs", 
#>     install_metadata = FALSE, desc = <environment>, meta = list(
#>         url = "https://future.futureverse.org", home = list(links = list(
#>             list(text = "Roadmap/Milestones", href = "https://github.com/HenrikBengtsson/future/milestones"), 
#>             list(text = "The Futureverse Project", href = "https://www.futureverse.org/"), 
#>             list(text = "Futureverse User Forum (new!)", href = "https://github.com/HenrikBengtsson/future/discussions"))), 
#>         navbar = list(structure = list(right = c("futureverse", 
#>         "pkgs", "cran", "github")), components = list(futureverse = list(
#>             icon = "fas fa-fast-backward", href = "https://www.futureverse.org/"), 
#>             pkgs = list(text = "Packages", menu = list(list(text = "BiocParallel.FutureParam", 
#>                 href = "https://BiocParallel.FutureParam.futureverse.org"), 
#>                 list(text = "doFuture", href = "https://doFuture.futureverse.org"), 
#>                 list(text = "furrr", href = "https://furrr.futureverse.org"), 
#>                 list(text = "future", href = "https://future.futureverse.org"), 
#>                 list(text = "future.apply", href = "https://future.apply.futureverse.org"), 
#>                 list(text = "future.batchtools", href = "https://future.batchtools.futureverse.org"), 
#>                 list(text = "future.callr", href = "https://future.callr.futureverse.org"), 
#>                 list(text = "future.tests", href = "https://future.tests.futureverse.org"), 
#>                 list(text = "globals", href = "https://globals.futureverse.org"), 
#>                 list(text = "listenv", href = "https://listenv.futureverse.org"), 
#>                 list(text = "parallelly", href = "https://parallelly.futureverse.org"), 
#>                 list(text = "progressr", href = "https://progressr.futureverse.org"), 
#>                 list(text = "future.mapreduce (experimental)", 
#>                   href = "https://future.mapreduce.futureverse.org"), 
#>                 list(text = "marshal (experimental)", href = "https://marshal.futureverse.org"))), 
#>             cran = list(icon = "fab fa-r-project", href = "https://cloud.r-project.org/package=future"))), 
#>         template = list(params = list(docsearch = list(api_key = "aa6e02fc501886fb0f7c91ac4e300456", 
#>             index_name = "futureverse", algoliaOptions = list(
#>                 facetFilters = "project:future")), ganalytics = "G-SB3EQSD9FR"))), 
#>     figures = list(dev = "ragg::agg_png", dpi = 96L, dev.args = list(), 
#>         fig.ext = "png", fig.width = 7.29166666666667, fig.height = NULL, 
#>         fig.retina = 2L, fig.asp = 0.618046971569839, bg = NULL), 
#>     repo = list(url = list(home = "https://github.com/HenrikBengtsson/future/", 
#>         source = "https://github.com/HenrikBengtsson/future/blob/master/", 
#>         issue = "https://github.com/HenrikBengtsson/future/issues/", 
#>         user = "https://github.com/")), development = list(destination = "dev", 
#>         mode = "release", version_label = "default", version_tooltip = "Released version", 
#>         in_dev = FALSE), topics = list(name = c(`ClusterFuture-class.Rd` = "ClusterFuture-class", 
#>     `ConstantFuture-class.Rd` = "ConstantFuture-class", `Future-class.Rd` = "Future-class", 
#>     FutureCondition.Rd = "FutureCondition", FutureGlobals.Rd = "FutureGlobals", 
#>     FutureResult.Rd = "FutureResult", `MulticoreFuture-class.Rd` = "MulticoreFuture-class", 
#>     `MultiprocessFuture-class.Rd` = "MultiprocessFuture-class", 
#>     `UniprocessFuture-class.Rd` = "UniprocessFuture-class", as_lecyer_cmrg_seed.Rd = "as_lecyer_cmrg_seed", 
#>     backtrace.Rd = "backtrace", cluster.Rd = "cluster", clusterExportSticky.Rd = "clusterExportSticky", 
#>     find_references.Rd = "find_references", future.Rd = "future", 
#>     future.options.Rd = "future.options", futureOf.Rd = "futureOf", 
#>     futureSessionInfo.Rd = "futureSessionInfo", futures.Rd = "futures", 
#>     getExpression.Rd = "getExpression", getGlobalsAndPackages.Rd = "getGlobalsAndPackages", 
#>     `grapes-conditions-grapes.Rd` = "%conditions%", `grapes-globals-grapes.Rd` = "%globals%", 
#>     `grapes-label-grapes.Rd` = "%label%", `grapes-lazy-grapes.Rd` = "%lazy%", 
#>     `grapes-plan-grapes.Rd` = "%plan%", `grapes-seed-grapes.Rd` = "%seed%", 
#>     `grapes-stdout-grapes.Rd` = "%stdout%", `grapes-tweak-grapes.Rd` = "%tweak%", 
#>     make_rng_seeds.Rd = "make_rng_seeds", mandelbrot.Rd = "mandelbrot", 
#>     multicore.Rd = "multicore", multiprocess.Rd = "multiprocess", 
#>     multisession.Rd = "multisession", nbrOfWorkers.Rd = "nbrOfWorkers", 
#>     nullcon.Rd = "nullcon", pid_exists.Rd = "pid_exists", plan.Rd = "plan", 
#>     private_length.Rd = ".length", `re-exports.Rd` = "re-exports", 
#>     readImmediateConditions.Rd = "readImmediateConditions", remote.Rd = "remote", 
#>     requestCore.Rd = "requestCore", resetWorkers.Rd = "resetWorkers", 
#>     resolve.Rd = "resolve", resolved.Rd = "resolved", result.Rd = "result.Future", 
#>     run.Rd = "run.Future", save_rds.Rd = "save_rds", sequential.Rd = "sequential", 
#>     sessionDetails.Rd = "sessionDetails", signalConditions.Rd = "signalConditions", 
#>     sticky_globals.Rd = "sticky_globals", tweak.Rd = "tweak", 
#>     usedCores.Rd = "usedCores", value.Rd = "value"), file_in = c("ClusterFuture-class.Rd", 
#>     "ConstantFuture-class.Rd", "Future-class.Rd", "FutureCondition.Rd", 
#>     "FutureGlobals.Rd", "FutureResult.Rd", "MulticoreFuture-class.Rd", 
#>     "MultiprocessFuture-class.Rd", "UniprocessFuture-class.Rd", 
#>     "as_lecyer_cmrg_seed.Rd", "backtrace.Rd", "cluster.Rd", "clusterExportSticky.Rd", 
#>     "find_references.Rd", "future.Rd", "future.options.Rd", "futureOf.Rd", 
#>     "futureSessionInfo.Rd", "futures.Rd", "getExpression.Rd", 
#>     "getGlobalsAndPackages.Rd", "grapes-conditions-grapes.Rd", 
#>     "grapes-globals-grapes.Rd", "grapes-label-grapes.Rd", "grapes-lazy-grapes.Rd", 
#>     "grapes-plan-grapes.Rd", "grapes-seed-grapes.Rd", "grapes-stdout-grapes.Rd", 
#>     "grapes-tweak-grapes.Rd", "make_rng_seeds.Rd", "mandelbrot.Rd", 
#>     "multicore.Rd", "multiprocess.Rd", "multisession.Rd", "nbrOfWorkers.Rd", 
#>     "nullcon.Rd", "pid_exists.Rd", "plan.Rd", "private_length.Rd", 
#>     "re-exports.Rd", "readImmediateConditions.Rd", "remote.Rd", 
#>     "requestCore.Rd", "resetWorkers.Rd", "resolve.Rd", "resolved.Rd", 
#>     "result.Rd", "run.Rd", "save_rds.Rd", "sequential.Rd", "sessionDetails.Rd", 
#>     "signalConditions.Rd", "sticky_globals.Rd", "tweak.Rd", "usedCores.Rd", 
#>     "value.Rd"), file_out = c("ClusterFuture-class.html", "ConstantFuture-class.html", 
#>     "Future-class.html", "FutureCondition.html", "FutureGlobals.html", 
#>     "FutureResult.html", "MulticoreFuture-class.html", "MultiprocessFuture-class.html", 
#>     "UniprocessFuture-class.html", "as_lecyer_cmrg_seed.html", 
#>     "backtrace.html", "cluster.html", "clusterExportSticky.html", 
#>     "find_references.html", "future.html", "future.options.html", 
#>     "futureOf.html", "futureSessionInfo.html", "futures.html", 
#>     "getExpression.html", "getGlobalsAndPackages.html", "grapes-conditions-grapes.html", 
#>     "grapes-globals-grapes.html", "grapes-label-grapes.html", 
#>     "grapes-lazy-grapes.html", "grapes-plan-grapes.html", "grapes-seed-grapes.html", 
#>     "grapes-stdout-grapes.html", "grapes-tweak-grapes.html", 
#>     "make_rng_seeds.html", "mandelbrot.html", "multicore.html", 
#>     "multiprocess.html", "multisession.html", "nbrOfWorkers.html", 
#>     "nullcon.html", "pid_exists.html", "plan.html", "private_length.html", 
#>     "re-exports.html", "readImmediateConditions.html", "remote.html", 
#>     "requestCore.html", "resetWorkers.html", "resolve.html", 
#>     "resolved.html", "result.html", "run.html", "save_rds.html", 
#>     "sequential.html", "sessionDetails.html", "signalConditions.html", 
#>     "sticky_globals.html", "tweak.html", "usedCores.html", "value.html"
#>     ), alias = list(`ClusterFuture-class.Rd` = c("ClusterFuture-class", 
#>     "ClusterFuture", "MultisessionFuture", "MultisessionFuture-class"
#>     ), `ConstantFuture-class.Rd` = c("ConstantFuture-class", 
#>     "ConstantFuture"), `Future-class.Rd` = c("Future-class", 
#>     "Future"), FutureCondition.Rd = c("FutureCondition", "FutureMessage", 
#>     "FutureWarning", "FutureError", "RngFutureCondition", "RngFutureWarning", 
#>     "RngFutureError", "UnexpectedFutureResultError"), FutureGlobals.Rd = c("FutureGlobals", 
#>     "as.FutureGlobals", "as.FutureGlobals.FutureGlobals", "as.FutureGlobals.Globals", 
#>     "as.FutureGlobals.list", "[.FutureGlobals", "c.FutureGlobals", 
#>     "unique.FutureGlobals"), FutureResult.Rd = c("FutureResult", 
#>     "as.character.FutureResult", "print.FutureResult"), `MulticoreFuture-class.Rd` = c("MulticoreFuture-class", 
#>     "MulticoreFuture"), `MultiprocessFuture-class.Rd` = c("MultiprocessFuture-class", 
#>     "MultiprocessFuture"), `UniprocessFuture-class.Rd` = c("UniprocessFuture-class", 
#>     "UniprocessFuture", "SequentialFuture", "TransparentFuture"
#>     ), as_lecyer_cmrg_seed.Rd = c("as_lecyer_cmrg_seed", "is_lecyer_cmrg_seed"
#>     ), backtrace.Rd = "backtrace", cluster.Rd = "cluster", clusterExportSticky.Rd = "clusterExportSticky", 
#>         find_references.Rd = c("find_references", "assert_no_references"
#>         ), future.Rd = c("future", "futureCall", "futureAssign", 
#>         "%<-%", "%->%"), future.options.Rd = c("future.options", 
#>         "future.cmdargs", ".future.R", "future.startup.script", 
#>         "R_FUTURE_STARTUP_SCRIPT", "future.debug", "R_FUTURE_DEBUG", 
#>         "future.demo.mandelbrot.region", "R_FUTURE_DEMO_MANDELBROT_REGION", 
#>         "future.demo.mandelbrot.nrow", "R_FUTURE_DEMO_MANDELBROT_NROW", 
#>         "future.fork.multithreading.enable", "R_FUTURE_FORK_MULTITHREADING_ENABLE", 
#>         "future.globals.maxSize", "R_FUTURE_GLOBALS_MAXSIZE", 
#>         "future.globals.method", "R_FUTURE_GLOBALS_METHOD", "future.globals.onMissing", 
#>         "R_FUTURE_GLOBALS_ONMISSING", "future.globals.resolve", 
#>         "R_FUTURE_GLOBALS_RESOLVE", "future.globals.onReference", 
#>         "R_FUTURE_GLOBALS_ONREFERENCE", "future.plan", "R_FUTURE_PLAN", 
#>         "future.resolve.recursive", "R_FUTURE_RNG_ONMISUSE", 
#>         "future.wait.alpha", "R_FUTURE_WAIT_ALPHA", "future.wait.interval", 
#>         "R_FUTURE_WAIT_INTERVAL", "future.wait.timeout", "R_FUTURE_WAIT_TIMEOUT", 
#>         "R_FUTURE_RESOLVED_TIMEOUT", "future.output.windows.reencode", 
#>         "R_FUTURE_OUTPUT_WINDOWS_REENCODE"), futureOf.Rd = "futureOf", 
#>         futureSessionInfo.Rd = "futureSessionInfo", futures.Rd = "futures", 
#>         getExpression.Rd = c("getExpression", "getExpression.Future"
#>         ), getGlobalsAndPackages.Rd = "getGlobalsAndPackages", 
#>         `grapes-conditions-grapes.Rd` = "%conditions%", `grapes-globals-grapes.Rd` = c("%globals%", 
#>         "%packages%"), `grapes-label-grapes.Rd` = "%label%", 
#>         `grapes-lazy-grapes.Rd` = "%lazy%", `grapes-plan-grapes.Rd` = "%plan%", 
#>         `grapes-seed-grapes.Rd` = "%seed%", `grapes-stdout-grapes.Rd` = "%stdout%", 
#>         `grapes-tweak-grapes.Rd` = "%tweak%", make_rng_seeds.Rd = "make_rng_seeds", 
#>         mandelbrot.Rd = c("mandelbrot", "as.raster.Mandelbrot", 
#>         "plot.Mandelbrot", "mandelbrot_tiles"), multicore.Rd = "multicore", 
#>         multiprocess.Rd = "multiprocess", multisession.Rd = "multisession", 
#>         nbrOfWorkers.Rd = c("nbrOfWorkers", "nbrOfFreeWorkers"
#>         ), nullcon.Rd = "nullcon", pid_exists.Rd = "pid_exists", 
#>         plan.Rd = "plan", private_length.Rd = ".length", `re-exports.Rd` = c("re-exports", 
#>         "as.cluster", "autoStopCluster", "availableCores", "availableWorkers", 
#>         "makeClusterMPI", "makeClusterPSOCK", "makeNodePSOCK", 
#>         "supportsMulticore"), readImmediateConditions.Rd = "readImmediateConditions", 
#>         remote.Rd = "remote", requestCore.Rd = "requestCore", 
#>         resetWorkers.Rd = "resetWorkers", resolve.Rd = "resolve", 
#>         resolved.Rd = "resolved", result.Rd = c("result.Future", 
#>         "result"), run.Rd = c("run.Future", "run"), save_rds.Rd = "save_rds", 
#>         sequential.Rd = c("sequential", "uniprocess", "transparent"
#>         ), sessionDetails.Rd = "sessionDetails", signalConditions.Rd = "signalConditions", 
#>         sticky_globals.Rd = "sticky_globals", tweak.Rd = "tweak", 
#>         usedCores.Rd = "usedCores", value.Rd = c("value", "values", 
#>         "value.Future", "value.list", "value.listenv", "value.environment"
#>         )), funs = list(`ClusterFuture-class.Rd` = c("ClusterFuture()", 
#>     "MultisessionFuture()"), `ConstantFuture-class.Rd` = "ConstantFuture()", 
#>         `Future-class.Rd` = "Future()", FutureCondition.Rd = c("FutureCondition()", 
#>         "FutureMessage()", "FutureWarning()", "FutureError()", 
#>         "RngFutureCondition()", "RngFutureWarning()", "RngFutureError()", 
#>         "UnexpectedFutureResultError()"), FutureGlobals.Rd = "FutureGlobals()", 
#>         FutureResult.Rd = c("FutureResult()", "as.character(<i>&lt;FutureResult&gt;</i>)", 
#>         "print(<i>&lt;FutureResult&gt;</i>)"), `MulticoreFuture-class.Rd` = "MulticoreFuture()", 
#>         `MultiprocessFuture-class.Rd` = "MultiprocessFuture()", 
#>         `UniprocessFuture-class.Rd` = c("UniprocessFuture()", 
#>         "SequentialFuture()", "TransparentFuture()"), as_lecyer_cmrg_seed.Rd = c("as_lecyer_cmrg_seed()", 
#>         "is_lecyer_cmrg_seed()"), backtrace.Rd = "backtrace()", 
#>         cluster.Rd = "cluster()", clusterExportSticky.Rd = "clusterExportSticky()", 
#>         find_references.Rd = c("find_references()", "assert_no_references()"
#>         ), future.Rd = c("future()", "futureAssign()", "`%&lt;-%`", 
#>         "futureCall()"), future.options.Rd = character(0), futureOf.Rd = "futureOf()", 
#>         futureSessionInfo.Rd = "futureSessionInfo()", futures.Rd = "futures()", 
#>         getExpression.Rd = "getExpression()", getGlobalsAndPackages.Rd = "getGlobalsAndPackages()", 
#>         `grapes-conditions-grapes.Rd` = "`%conditions%`", `grapes-globals-grapes.Rd` = c("`%globals%`", 
#>         "`%packages%`"), `grapes-label-grapes.Rd` = "`%label%`", 
#>         `grapes-lazy-grapes.Rd` = "`%lazy%`", `grapes-plan-grapes.Rd` = "`%plan%`", 
#>         `grapes-seed-grapes.Rd` = "`%seed%`", `grapes-stdout-grapes.Rd` = "`%stdout%`", 
#>         `grapes-tweak-grapes.Rd` = "`%tweak%`", make_rng_seeds.Rd = "make_rng_seeds()", 
#>         mandelbrot.Rd = "mandelbrot()", multicore.Rd = "multicore()", 
#>         multiprocess.Rd = "multiprocess()", multisession.Rd = "multisession()", 
#>         nbrOfWorkers.Rd = c("nbrOfWorkers()", "nbrOfFreeWorkers()"
#>         ), nullcon.Rd = "nullcon()", pid_exists.Rd = "pid_exists()", 
#>         plan.Rd = "plan()", private_length.Rd = ".length()", 
#>         `re-exports.Rd` = character(0), readImmediateConditions.Rd = "readImmediateConditions()", 
#>         remote.Rd = "remote()", requestCore.Rd = "requestCore()", 
#>         resetWorkers.Rd = "resetWorkers()", resolve.Rd = "resolve()", 
#>         resolved.Rd = "resolved()", result.Rd = "result(<i>&lt;Future&gt;</i>)", 
#>         run.Rd = "run(<i>&lt;Future&gt;</i>)", save_rds.Rd = "save_rds()", 
#>         sequential.Rd = c("sequential()", "transparent()"), sessionDetails.Rd = "sessionDetails()", 
#>         signalConditions.Rd = "signalConditions()", sticky_globals.Rd = "sticky_globals()", 
#>         tweak.Rd = "tweak()", usedCores.Rd = "usedCores()", value.Rd = "value()"), 
#>         title = c(`ClusterFuture-class.Rd` = "A cluster future is a future whose value will be resolved asynchronously in a parallel process", 
#>         `ConstantFuture-class.Rd` = "A future with a constant value", 
#>         `Future-class.Rd` = "A future represents a value that will be available at some point in the future", 
#>         FutureCondition.Rd = "A condition (message, warning, or error) that occurred while orchestrating a future", 
#>         FutureGlobals.Rd = "A representation of a set of globals used with futures", 
#>         FutureResult.Rd = "Results from resolving a future", 
#>         `MulticoreFuture-class.Rd` = "A multicore future is a future whose value will be resolved asynchronously in a parallel process", 
#>         `MultiprocessFuture-class.Rd` = "A multiprocess future is a future whose value will be resolved asynchronously in a parallel process", 
#>         `UniprocessFuture-class.Rd` = "An uniprocess future is a future whose value will be resolved synchronously in the current process", 
#>         as_lecyer_cmrg_seed.Rd = "Get a L'Ecuyer-CMRG seed either from an input seed or the current RNG state", 
#>         backtrace.Rd = "Back trace the expressions evaluated when an error was caught", 
#>         cluster.Rd = "Create a cluster future whose value will be resolved asynchronously in a parallel process", 
#>         clusterExportSticky.Rd = "Export globals to the sticky-globals environment of the cluster nodes", 
#>         find_references.Rd = "Get the first or all references of an <span style=\"R\">R</span> object", 
#>         future.Rd = "Create a future", future.options.Rd = "Options used for futures", 
#>         futureOf.Rd = "Get the future of a future variable", 
#>         futureSessionInfo.Rd = "Get session information specific to the future framework", 
#>         futures.Rd = "Get all futures in a container", getExpression.Rd = "Inject code for the next type of future to use for nested futures", 
#>         getGlobalsAndPackages.Rd = "Retrieves global variables of an expression and their associated packages", 
#>         `grapes-conditions-grapes.Rd` = "Control whether standard output should be captured or not", 
#>         `grapes-globals-grapes.Rd` = "Specify globals and packages for a future assignment", 
#>         `grapes-label-grapes.Rd` = "Specify label for a future assignment", 
#>         `grapes-lazy-grapes.Rd` = "Control lazy / eager evaluation for a future assignment", 
#>         `grapes-plan-grapes.Rd` = "Use a specific plan for a future assignment", 
#>         `grapes-seed-grapes.Rd` = "Set random seed for future assignment", 
#>         `grapes-stdout-grapes.Rd` = "Control whether standard output should be captured or not", 
#>         `grapes-tweak-grapes.Rd` = "Temporarily tweaks the arguments of the current strategy", 
#>         make_rng_seeds.Rd = "Produce Reproducible Seeds for Parallel Random Number Generation", 
#>         mandelbrot.Rd = "Mandelbrot convergence counts", multicore.Rd = "Create a multicore future whose value will be resolved asynchronously in a forked parallel process", 
#>         multiprocess.Rd = "Create a multiprocess future whose value will be resolved asynchronously using multicore or a multisession evaluation", 
#>         multisession.Rd = "Create a multisession future whose value will be resolved asynchronously in a parallel <span style=\"R\">R</span> session", 
#>         nbrOfWorkers.Rd = "Get the number of workers available", 
#>         nullcon.Rd = "Creates a connection to the system null device", 
#>         pid_exists.Rd = "Check whether a process PID exists or not", 
#>         plan.Rd = "Plan how to resolve a future", private_length.Rd = "Gets the length of an object without dispatching", 
#>         `re-exports.Rd` = "Functions Moved to 'parallelly'", 
#>         readImmediateConditions.Rd = "Read All 'immediateCondition' RDS Files", 
#>         remote.Rd = "Create a remote future whose value will be resolved asynchronously in a remote process", 
#>         requestCore.Rd = "Request a core for multicore processing", 
#>         resetWorkers.Rd = "Free up active background workers", 
#>         resolve.Rd = "Resolve one or more futures synchronously", 
#>         resolved.Rd = "Check whether a future is resolved or not", 
#>         result.Rd = "Get the results of a resolved future", run.Rd = "Run a future", 
#>         save_rds.Rd = "Robustly Saves an Object to RDS File Atomically", 
#>         sequential.Rd = "Create a sequential future whose value will be in the current <span style=\"R\">R</span> session", 
#>         sessionDetails.Rd = "Outputs details on the current <span style=\"R\">R</span> session", 
#>         signalConditions.Rd = "Signals Captured Conditions", 
#>         sticky_globals.Rd = "Place a sticky-globals environment immediately after the global environment", 
#>         tweak.Rd = "Tweak a future function by adjusting its default arguments", 
#>         usedCores.Rd = "Get number of cores currently used", 
#>         value.Rd = "The value of a future or the values of all elements in a container"
#>         ), rd = list(`ClusterFuture-class.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>             "\n", "% Please edit documentation in R/ClusterFuture-class.R,", 
#>             "\n", "%   R/MultisessionFuture-class.R", "\n", list(
#>                 "ClusterFuture-class"), "\n", list("ClusterFuture-class"), 
#>             "\n", list("ClusterFuture"), "\n", list("MultisessionFuture"), 
#>             "\n", list("MultisessionFuture-class"), "\n", list(
#>                 "A cluster future is a future whose value will be resolved asynchronously in a parallel process"), 
#>             "\n", list("\n", "ClusterFuture(\n", "  expr = NULL,\n", 
#>                 "  substitute = TRUE,\n", "  envir = parent.frame(),\n", 
#>                 "  globals = TRUE,\n", "  packages = NULL,\n", 
#>                 "  local = !persistent,\n", "  persistent = FALSE,\n", 
#>                 "  workers = NULL,\n", "  user = NULL,\n", "  master = NULL,\n", 
#>                 "  revtunnel = TRUE,\n", "  homogeneous = NULL,\n", 
#>                 "  ...\n", ")\n", "\n", "MultisessionFuture(\n", 
#>                 "  expr = NULL,\n", "  substitute = TRUE,\n", 
#>                 "  envir = parent.frame(),\n", "  persistent = FALSE,\n", 
#>                 "  workers = NULL,\n", "  ...\n", ")\n"), "\n", 
#>             list("\n", list(list("expr"), list("An ", list(), 
#>                 " ", list("expression"), ".")), "\n", "\n", list(
#>                 list("substitute"), list("If TRUE, argument ", 
#>                   list("expr"), " is\n", list(list("substitute"), 
#>                     "()"), ":ed, otherwise not.")), "\n", "\n", 
#>                 list(list("envir"), list("The ", list("environment"), 
#>                   " from where global objects should be\n", "identified.")), 
#>                 "\n", "\n", list(list("globals"), list("(optional) a logical, a character vector, or a named list\n", 
#>                   "to control how globals are handled.\n", "For details, see section 'Globals used by future expressions'\n", 
#>                   "in the help for ", list(list("future()")), 
#>                   ".")), "\n", "\n", list(list("packages"), list(
#>                   "(optional) a character vector specifying packages\n", 
#>                   "to be attached in the ", list(), " environment evaluating the future.")), 
#>                 "\n", "\n", list(list("local"), list("If TRUE, the expression is evaluated such that\n", 
#>                   "all assignments are done to local temporary environment, otherwise\n", 
#>                   "the assignments are done to the global environment of the ", 
#>                   list(), " process\n", "evaluating the future.")), 
#>                 "\n", "\n", list(list("persistent"), list("If FALSE, the evaluation environment is cleared\n", 
#>                   "from objects prior to the evaluation of the future.")), 
#>                 "\n", "\n", list(list("workers"), list("A ", 
#>                   list(list("cluster")), " object,\n", "a character vector of host names, a positive numeric scalar,\n", 
#>                   "or a function.\n", "If a character vector or a numeric scalar, a ", 
#>                   list("cluster"), " object\n", "is created using ", 
#>                   list(list("makeClusterPSOCK"), "(workers)"), 
#>                   ".\n", "If a function, it is called without arguments ", 
#>                   list("when the future\n", "is created"), " and its value is used to configure the workers.\n", 
#>                   "The function should return any of the above types.")), 
#>                 "\n", "\n", list(list("user"), list("(optional) The user name to be used when communicating\n", 
#>                   "with another host.")), "\n", "\n", list(list(
#>                   "master"), list("(optional) The hostname or IP address of the master\n", 
#>                   "machine running this node.")), "\n", "\n", 
#>                 list(list("revtunnel"), list("If TRUE, reverse SSH tunneling is used for the\n", 
#>                   "PSOCK cluster nodes to connect back to the master ", 
#>                   list(), " process.  This\n", "avoids the hassle of firewalls, port forwarding and having to know\n", 
#>                   "the internal / public IP address of the master ", 
#>                   list(), " session.")), "\n", "\n", list(list(
#>                   "homogeneous"), list("If TRUE, all cluster nodes is assumed to use the\n", 
#>                   "same path to ", list("Rscript"), " as the main ", 
#>                   list(), " session.  If FALSE, the\n", "it is assumed to be on the PATH for each node.\n", 
#>                   "If NULL, then ", list(list("parallelly::makeClusterPSOCK()")), 
#>                   " will decide on TRUE\n", "or FALSE depending on ", 
#>                   list("workers"), ".")), "\n", "\n", list(list(
#>                   "..."), list("Additional named elements passed to ", 
#>                   list(list("Future()")), ".")), "\n"), "\n", 
#>             list("\n", list("ClusterFuture()"), " returns an object of class ", 
#>                 list("ClusterFuture"), ".\n", "\n", list("MultisessionFuture()"), 
#>                 " returns an object of class\n", list("MultisessionFuture"), 
#>                 ", which inherits from ", list("ClusterFuture"), 
#>                 ".\n"), "\n", list("\n", "A cluster future is a future whose value will be resolved asynchronously in a parallel process\n"), 
#>             "\n", list("\n", "To evaluate an expression using \"cluster future\", see function\n", 
#>                 list(list("cluster()")), ".\n"), "\n", list("internal"), 
#>             "\n"), `ConstantFuture-class.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>             "\n", "% Please edit documentation in R/ConstantFuture-class.R", 
#>             "\n", list("ConstantFuture-class"), "\n", list("ConstantFuture-class"), 
#>             "\n", list("ConstantFuture"), "\n", list("A future with a constant value"), 
#>             "\n", list("\n", "ConstantFuture(..., globals = TRUE, envir = emptyenv())\n"), 
#>             "\n", list("\n", list(list("..."), list("Additional named elements of the future.")), 
#>                 "\n", "\n", list(list("globals"), list("(optional) a logical, a character vector, or a named list\n", 
#>                   "to control how globals are handled.\n", "For details, see section 'Globals used by future expressions'\n", 
#>                   "in the help for ", list(list("future()")), 
#>                   ".")), "\n", "\n", list(list("envir"), list(
#>                   "The ", list("environment"), " from where global objects should be\n", 
#>                   "identified.")), "\n"), "\n", list("\n", "An object of class ", 
#>                 list("ConstantFuture"), ".\n"), "\n", list("\n", 
#>                 "A constant future is a future whose expression is a constant\n", 
#>                 "and therefore by definition is already resolved upon creation.\n"), 
#>             "\n", list("internal"), "\n"), `Future-class.Rd` = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/Future-class.R", 
#>             "\n", list("Future-class"), "\n", list("Future-class"), 
#>             "\n", list("Future"), "\n", list("A future represents a value that will be available at some point in the future"), 
#>             "\n", list("\n", "Future(\n", "  expr = NULL,\n", 
#>                 "  envir = parent.frame(),\n", "  substitute = TRUE,\n", 
#>                 "  stdout = TRUE,\n", "  conditions = \"condition\",\n", 
#>                 "  globals = NULL,\n", "  packages = NULL,\n", 
#>                 "  seed = FALSE,\n", "  lazy = FALSE,\n", "  local = TRUE,\n", 
#>                 "  gc = FALSE,\n", "  earlySignal = FALSE,\n", 
#>                 "  label = NULL,\n", "  ...\n", ")\n"), "\n", 
#>             list("\n", list(list("expr"), list("An ", list(), 
#>                 " ", list("expression"), ".")), "\n", "\n", list(
#>                 list("envir"), list("The ", list("environment"), 
#>                   " from where global objects should be\n", "identified.")), 
#>                 "\n", "\n", list(list("substitute"), list("If TRUE, argument ", 
#>                   list("expr"), " is\n", list(list("substitute"), 
#>                     "()"), ":ed, otherwise not.")), "\n", "\n", 
#>                 list(list("stdout"), list("If TRUE (default), then the standard output is captured,\n", 
#>                   "and re-outputted when ", list("value()"), 
#>                   " is called.\n", "If FALSE, any output is silenced (by sinking it to the null device as\n", 
#>                   "it is outputted).\n", "If NA (not recommended), output is ", 
#>                   list("not"), " intercepted.")), "\n", "\n", 
#>                 list(list("conditions"), list("A character string of conditions classes to be captured\n", 
#>                   "and relayed.  The default is to relay messages and warnings.\n", 
#>                   "To not intercept any types of conditions, use ", 
#>                   list("conditions = NULL"), ".\n", "Attribute ", 
#>                   list("exclude"), " can be used to ignore specific classes, e.g.\n", 
#>                   list("conditions = structure(\"condition\", exclude = \"message\")"), 
#>                   " will capture\n", "all ", list("condition"), 
#>                   " classes except those that inherits from the ", 
#>                   list("message"), " class.\n", "Errors are always relayed.")), 
#>                 "\n", "\n", list(list("globals"), list("(optional) a logical, a character vector, or a named list\n", 
#>                   "to control how globals are handled.\n", "For details, see section 'Globals used by future expressions'\n", 
#>                   "in the help for ", list(list("future()")), 
#>                   ".")), "\n", "\n", list(list("packages"), list(
#>                   "(optional) a character vector specifying packages\n", 
#>                   "to be attached in the ", list(), " environment evaluating the future.")), 
#>                 "\n", "\n", list(list("seed"), list("(optional) If TRUE, the random seed, that is, the state of the\n", 
#>                   "random number generator (RNG) will be set such that statistically sound\n", 
#>                   "random numbers are produced (also during parallelization).\n", 
#>                   "If FALSE (default), it is assumed that the future expression does neither\n", 
#>                   "need nor use random numbers generation.\n", 
#>                   "To use a fixed random seed, specify a L'Ecuyer-CMRG seed (seven integer)\n", 
#>                   "or a regular RNG seed (a single integer).  If the latter, then a\n", 
#>                   "L'Ecuyer-CMRG seed will be automatically created based on the given seed.\n", 
#>                   "Furthermore, if FALSE, then the future will be monitored to make sure it\n", 
#>                   "does not use random numbers.  If it does and depending on the value of\n", 
#>                   "option ", list(list("future.rng.onMisuse")), 
#>                   ", the check is\n", "ignored, an informative warning, or error will be produced.\n", 
#>                   "If ", list("seed"), " is NULL, then the effect is as with ", 
#>                   list("seed = FALSE"), "\n", "but without the RNG check being performed.")), 
#>                 "\n", "\n", list(list("lazy"), list("If FALSE (default), the future is resolved\n", 
#>                   "eagerly (starting immediately), otherwise not.")), 
#>                 "\n", "\n", list(list("local"), list("If TRUE, the expression is evaluated such that\n", 
#>                   "all assignments are done to local temporary environment, otherwise\n", 
#>                   "the assignments are done to the global environment of the ", 
#>                   list(), " process\n", "evaluating the future.")), 
#>                 "\n", "\n", list(list("gc"), list("If TRUE, the garbage collector run (in the process that\n", 
#>                   "evaluated the future) only after the value of the future is collected.\n", 
#>                   "Exactly when the values are collected may depend on various factors such\n", 
#>                   "as number of free workers and whether ", list(
#>                     "earlySignal"), " is TRUE (more\n", "frequently) or FALSE (less frequently).\n", 
#>                   list("Some types of futures ignore this argument."))), 
#>                 "\n", "\n", list(list("earlySignal"), list("Specified whether conditions should be signaled as soon\n", 
#>                   "as possible or not.")), "\n", "\n", list(list(
#>                   "label"), list("An optional character string label attached to the future.")), 
#>                 "\n", "\n", list(list(list()), list("Additional named elements of the future.")), 
#>                 "\n"), "\n", list("\n", "An object of class ", 
#>                 list("Future"), ".\n"), "\n", list("\n", "A ", 
#>                 list("future"), " is an abstraction for a ", 
#>                 list("value"), " that may\n", "available at some point in the future.  A future can either be\n", 
#>                 list("unresolved"), " or ", list("resolved"), 
#>                 ", a state which can be checked\n", "with ", 
#>                 list(list("resolved()")), ".  As long as it is ", 
#>                 list("unresolved"), ", the\n", "value is not available.  As soon as it is ", 
#>                 list("resolved"), ", the value\n", "is available via ", 
#>                 list(list("value"), "()"), ".\n"), "\n", list(
#>                 "\n", "A Future object is itself an ", list("environment"), 
#>                 ".\n"), "\n", list("\n", "One function that creates a Future is ", 
#>                 list(list("future()")), ".\n", "It returns a Future that evaluates an ", 
#>                 list(), " expression in the future.\n", "An alternative approach is to use the ", 
#>                 list(list("%<-%")), " infix\n", "assignment operator, which creates a future from the\n", 
#>                 "right-hand-side (RHS) ", list(), " expression and assigns its future value\n", 
#>                 "to a variable as a ", list(list("promise")), 
#>                 ".\n"), "\n", list("internal"), "\n"), FutureCondition.Rd = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/FutureCondition-class.R", 
#>             "\n", list("FutureCondition"), "\n", list("FutureCondition"), 
#>             "\n", list("FutureMessage"), "\n", list("FutureWarning"), 
#>             "\n", list("FutureError"), "\n", list("RngFutureCondition"), 
#>             "\n", list("RngFutureWarning"), "\n", list("RngFutureError"), 
#>             "\n", list("UnexpectedFutureResultError"), "\n", 
#>             list("A condition (message, warning, or error) that occurred while orchestrating a future"), 
#>             "\n", list("\n", "FutureCondition(message, call = NULL, uuid = future$uuid, future = NULL)\n", 
#>                 "\n", "FutureMessage(message, call = NULL, uuid = future$uuid, future = NULL)\n", 
#>                 "\n", "FutureWarning(message, call = NULL, uuid = future$uuid, future = NULL)\n", 
#>                 "\n", "FutureError(message, call = NULL, uuid = future$uuid, future = NULL)\n", 
#>                 "\n", "RngFutureCondition(\n", "  message = NULL,\n", 
#>                 "  call = NULL,\n", "  uuid = future$uuid,\n", 
#>                 "  future = NULL\n", ")\n", "\n", "RngFutureWarning(...)\n", 
#>                 "\n", "RngFutureError(...)\n", "\n", "UnexpectedFutureResultError(future, hint = NULL)\n"), 
#>             "\n", list("\n", list(list("message"), list("A message condition.")), 
#>                 "\n", "\n", list(list("call"), list("The call stack that led up to the condition.")), 
#>                 "\n", "\n", list(list("uuid"), list("A universally unique identifier for the future associated with\n", 
#>                   "this FutureCondition.")), "\n", "\n", list(
#>                   list("future"), list("The ", list("Future"), 
#>                     " involved.")), "\n", "\n", list(list("hint"), 
#>                   list("(optional) A string with a suggestion on what might be wrong.")), 
#>                 "\n"), "\n", list("\n", "An object of class FutureCondition which inherits from class\n", 
#>                 list("condition"), " and FutureMessage, FutureWarning,\n", 
#>                 "and FutureError all inherits from FutureCondition.\n", 
#>                 "Moreover, a FutureError inherits from ", list(
#>                   "error"), ",\n", "a FutureWarning from ", list(
#>                   "warning"), ", and\n", "a FutureMessage from ", 
#>                 list("message"), ".\n"), "\n", list("\n", "While ", 
#>                 list("orchestrating"), " (creating, launching, querying, collection)\n", 
#>                 "futures, unexpected run-time errors (and other types of conditions) may\n", 
#>                 "occur.  Such conditions are coerced to a corresponding FutureCondition\n", 
#>                 "class to help distinguish them from conditions that occur due to the\n", 
#>                 list("evaluation"), " of the future.\n"), "\n", 
#>             list("internal"), "\n"), FutureGlobals.Rd = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/FutureGlobals-class.R", 
#>             "\n", list("FutureGlobals"), "\n", list("FutureGlobals"), 
#>             "\n", list("as.FutureGlobals"), "\n", list("as.FutureGlobals.FutureGlobals"), 
#>             "\n", list("as.FutureGlobals.Globals"), "\n", list(
#>                 "as.FutureGlobals.list"), "\n", list("[.FutureGlobals"), 
#>             "\n", list("c.FutureGlobals"), "\n", list("unique.FutureGlobals"), 
#>             "\n", list("A representation of a set of globals used with futures"), 
#>             "\n", list("\n", "FutureGlobals(object = list(), resolved = FALSE, total_size = NA_real_, ...)\n"), 
#>             "\n", list("\n", list(list("object"), list("A named list.")), 
#>                 "\n", "\n", list(list("resolved"), list("A logical indicating whether these globals\n", 
#>                   "have been scanned for and resolved futures or not.")), 
#>                 "\n", "\n", list(list("total_size"), list("The total size of all globals, if known.")), 
#>                 "\n", "\n", list(list(list()), list("Not used.")), 
#>                 "\n"), "\n", list("\n", "An object of class ", 
#>                 list("FutureGlobals"), ".\n"), "\n", list("\n", 
#>                 "A representation of a set of globals used with futures\n"), 
#>             "\n", list("\n", "This class extends the ", list(
#>                 "Globals"), " class by adding\n", "attributes ", 
#>                 list("resolved"), " and ", list("total_size"), 
#>                 ".\n"), "\n", list("internal"), "\n"), FutureResult.Rd = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/FutureResult-class.R", 
#>             "\n", list("FutureResult"), "\n", list("FutureResult"), 
#>             "\n", list("as.character.FutureResult"), "\n", list(
#>                 "print.FutureResult"), "\n", list("Results from resolving a future"), 
#>             "\n", list("\n", "FutureResult(\n", "  value = NULL,\n", 
#>                 "  visible = TRUE,\n", "  stdout = NULL,\n", 
#>                 "  conditions = NULL,\n", "  rng = FALSE,\n", 
#>                 "  ...,\n", "  started = .POSIXct(NA_real_),\n", 
#>                 "  finished = Sys.time(),\n", "  version = \"1.8\"\n", 
#>                 ")\n", "\n", list(list("as.character"), list(
#>                   "FutureResult")), "(x, ...)\n", "\n", list(
#>                   list("print"), list("FutureResult")), "(x, ...)\n"), 
#>             "\n", list("\n", list(list("value"), list("The value of the future expression.\n", 
#>                 "If the expression was not fully resolved (e.g. an error) occurred,\n", 
#>                 "the the value is ", list("NULL"), ".")), "\n", 
#>                 "\n", list(list("visible"), list("If TRUE, the value was visible, otherwise invisible.")), 
#>                 "\n", "\n", list(list("conditions"), list("A list of zero or more list elements each containing\n", 
#>                   "a captured ", list("condition"), " and possibly more meta data such as the\n", 
#>                   "call stack and a timestamp.")), "\n", "\n", 
#>                 list(list("rng"), list("If TRUE, the ", list(
#>                   ".Random.seed"), " was updated from resolving the\n", 
#>                   "future, otherwise not.")), "\n", "\n", list(
#>                   list(list()), list("(optional) Additional named results to be returned.")), 
#>                 "\n", "\n", list(list("started, finished"), list(
#>                   list("POSIXct"), " timestamps\n", "when the evaluation of the future expression was started and finished.")), 
#>                 "\n", "\n", list(list("version"), list("The version format of the results.")), 
#>                 "\n"), "\n", list("\n", "An object of class FutureResult.\n"), 
#>             "\n", list("\n", "Results from resolving a future\n"), 
#>             "\n", list("\n", "This function is only part of the ", 
#>                 list("backend"), " Future API.\n", "This function is ", 
#>                 list("not"), " part of the frontend Future API.\n"), 
#>             "\n", list(list("Note to developers"), list("\n", 
#>                 "\n", "The FutureResult structure is ", list(
#>                   "under development"), " and may change at anytime,\n", 
#>                 "e.g. elements may be renamed or removed.  Because of this, please avoid\n", 
#>                 "accessing the elements directly in code.  Feel free to reach out if you need\n", 
#>                 "to do so in your code.\n")), "\n", "\n", list(
#>                 "internal"), "\n"), `MulticoreFuture-class.Rd` = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/MulticoreFuture-class.R", 
#>             "\n", list("MulticoreFuture-class"), "\n", list("MulticoreFuture-class"), 
#>             "\n", list("MulticoreFuture"), "\n", list("A multicore future is a future whose value will be resolved asynchronously in a parallel process"), 
#>             "\n", list("\n", "MulticoreFuture(\n", "  expr = NULL,\n", 
#>                 "  substitute = TRUE,\n", "  envir = parent.frame(),\n", 
#>                 "  globals = TRUE,\n", "  lazy = FALSE,\n", "  ...\n", 
#>                 ")\n"), "\n", list("\n", list(list("expr"), list(
#>                 "An ", list(), " ", list("expression"), ".")), 
#>                 "\n", "\n", list(list("substitute"), list("If TRUE, argument ", 
#>                   list("expr"), " is\n", list(list("substitute"), 
#>                     "()"), ":ed, otherwise not.")), "\n", "\n", 
#>                 list(list("envir"), list("The ", list("environment"), 
#>                   " from where global objects should be\n", "identified.")), 
#>                 "\n", "\n", list(list("globals"), list("(optional) a logical, a character vector, or a named list\n", 
#>                   "to control how globals are handled.\n", "For details, see section 'Globals used by future expressions'\n", 
#>                   "in the help for ", list(list("future()")), 
#>                   ".")), "\n", "\n", list(list("lazy"), list(
#>                   "If FALSE (default), the future is resolved\n", 
#>                   "eagerly (starting immediately), otherwise not.")), 
#>                 "\n", "\n", list(list("..."), list("Additional named elements passed to ", 
#>                   list(list("Future()")), ".")), "\n"), "\n", 
#>             list("\n", "An object of class ", list("MulticoreFuture"), 
#>                 ".\n"), "\n", list("\n", "A multicore future is a future whose value will be resolved asynchronously in a parallel process\n"), 
#>             "\n", list("\n", "To evaluate an expression using \"multicore future\", see function\n", 
#>                 list(list("multicore()")), ".\n"), "\n", list(
#>                 "internal"), "\n"), `MultiprocessFuture-class.Rd` = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/MultiprocessFuture-class.R", 
#>             "\n", list("MultiprocessFuture-class"), "\n", list(
#>                 "MultiprocessFuture-class"), "\n", list("MultiprocessFuture"), 
#>             "\n", list("A multiprocess future is a future whose value will be resolved asynchronously in a parallel process"), 
#>             "\n", list("\n", "MultiprocessFuture(expr = NULL, substitute = TRUE, envir = parent.frame(), ...)\n"), 
#>             "\n", list("\n", list(list("expr"), list("An ", list(), 
#>                 " ", list("expression"), ".")), "\n", "\n", list(
#>                 list("substitute"), list("If TRUE, argument ", 
#>                   list("expr"), " is\n", list(list("substitute"), 
#>                     "()"), ":ed, otherwise not.")), "\n", "\n", 
#>                 list(list("envir"), list("The ", list("environment"), 
#>                   " from where global objects should be\n", "identified.")), 
#>                 "\n", "\n", list(list(list()), list("Additional named elements passed to ", 
#>                   list(list("Future()")), ".")), "\n"), "\n", 
#>             list("\n", "An object of class ", list("MultiprocessFuture"), 
#>                 ".\n"), "\n", list("\n", "A multiprocess future is a future whose value will be resolved asynchronously in a parallel process\n"), 
#>             "\n", list("\n", "To evaluate an expression using \"multiprocess future\", see function\n", 
#>                 list(list("multiprocess()")), ".\n"), "\n", list(
#>                 "internal"), "\n"), `UniprocessFuture-class.Rd` = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/UniprocessFuture-class.R", 
#>             "\n", list("UniprocessFuture-class"), "\n", list(
#>                 "UniprocessFuture-class"), "\n", list("UniprocessFuture"), 
#>             "\n", list("SequentialFuture"), "\n", list("TransparentFuture"), 
#>             "\n", list("An uniprocess future is a future whose value will be resolved synchronously in the current process"), 
#>             "\n", list("\n", "UniprocessFuture(\n", "  expr = NULL,\n", 
#>                 "  substitute = TRUE,\n", "  envir = parent.frame(),\n", 
#>                 "  globals = TRUE,\n", "  packages = NULL,\n", 
#>                 "  lazy = FALSE,\n", "  local = TRUE,\n", "  ...\n", 
#>                 ")\n", "\n", "SequentialFuture(\n", "  expr = NULL,\n", 
#>                 "  envir = parent.frame(),\n", "  substitute = TRUE,\n", 
#>                 "  lazy = FALSE,\n", "  globals = TRUE,\n", "  local = TRUE,\n", 
#>                 "  ...\n", ")\n", "\n", "TransparentFuture(\n", 
#>                 "  expr = NULL,\n", "  envir = parent.frame(),\n", 
#>                 "  substitute = TRUE,\n", "  lazy = FALSE,\n", 
#>                 "  globals = TRUE,\n", "  local = FALSE,\n", 
#>                 "  ...\n", ")\n"), "\n", list("\n", list(list(
#>                 "expr"), list("An ", list(), " ", list("expression"), 
#>                 ".")), "\n", "\n", list(list("substitute"), list(
#>                 "If TRUE, argument ", list("expr"), " is\n", 
#>                 list(list("substitute"), "()"), ":ed, otherwise not.")), 
#>                 "\n", "\n", list(list("envir"), list("The ", 
#>                   list("environment"), " from where global objects should be\n", 
#>                   "identified.")), "\n", "\n", list(list("globals"), 
#>                   list("(optional) a logical, a character vector, or a named list\n", 
#>                     "to control how globals are handled.\n", 
#>                     "For details, see section 'Globals used by future expressions'\n", 
#>                     "in the help for ", list(list("future()")), 
#>                     ".")), "\n", "\n", list(list("packages"), 
#>                   list("(optional) a character vector specifying packages\n", 
#>                     "to be attached in the ", list(), " environment evaluating the future.")), 
#>                 "\n", "\n", list(list("lazy"), list("If FALSE (default), the future is resolved\n", 
#>                   "eagerly (starting immediately), otherwise not.")), 
#>                 "\n", "\n", list(list("local"), list("If TRUE, the expression is evaluated such that\n", 
#>                   "all assignments are done to local temporary environment, otherwise\n", 
#>                   "the assignments are done to the global environment of the ", 
#>                   list(), " process\n", "evaluating the future.")), 
#>                 "\n", "\n", list(list(list()), list("Additional named elements passed to ", 
#>                   list(list("Future()")), ".")), "\n"), "\n", 
#>             list("\n", "An object of class ", list("UniprocessFuture"), 
#>                 ".\n"), "\n", list("\n", "An uniprocess future is a future whose value will be resolved synchronously in the current process\n"), 
#>             "\n", list("\n", "To evaluate an expression using \"uniprocess future\", see functions\n", 
#>                 list(list("uniprocess()")), ".\n"), "\n", list(
#>                 "internal"), "\n"), as_lecyer_cmrg_seed.Rd = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/rng.R", "\n", list(
#>                 "as_lecyer_cmrg_seed"), "\n", list("as_lecyer_cmrg_seed"), 
#>             "\n", list("is_lecyer_cmrg_seed"), "\n", list("Get a L'Ecuyer-CMRG seed either from an input seed or the current RNG state"), 
#>             "\n", list("\n", "as_lecyer_cmrg_seed(seed)\n", "\n", 
#>                 "is_lecyer_cmrg_seed(seed)\n"), "\n", list("\n", 
#>                 list(list("seed"), list("TRUE or NA, or a numeric vector of length one or seven.")), 
#>                 "\n"), "\n", list("\n", list("as_lecyer_cmrg_seed(seed)"), 
#>                 " returns a L'Ecuyer-CMRG seed, which is a\n", 
#>                 "7-digit integer vector, based on the input ", 
#>                 list("seed"), ".\n", "If already a L'Ecuyer-CMRG seed, then ", 
#>                 list("seed"), " is return as-is.\n", "If a scalar integer, then a random L'Ecuyer-CMRG seed is created based\n", 
#>                 "on this seed as the current RNG state.\n", "If ", 
#>                 list("seed = TRUE"), " and the current seed is already a L'Ecuyer-CMRG seed,\n", 
#>                 "then then current seed (", list(".Random.seed"), 
#>                 ") is return as-is.\n", "If ", list("seed = TRUE"), 
#>                 " and the current seed is ", list("not"), " of the 'L'Ecuyer-CMRG' kind,\n", 
#>                 "or ", list("seed = NA"), ", then a random one is created (based on the current RNG\n", 
#>                 "state).\n", "Any other values, including FALSE, is an error.\n", 
#>                 "\n", list("is_lecyer_cmrg_seed(seed)"), " returns TRUE if ", 
#>                 list("seed"), " is L'Ecuyer-CMRG seed,\n", "otherwise FALSE.\n"), 
#>             "\n", list("\n", "Get a L'Ecuyer-CMRG seed either from an input seed or the current RNG state\n"), 
#>             "\n", list("\n", "The ", list("as_lecyer_cmrg_seed()"), 
#>                 " function preserves the current RNG state, that\n", 
#>                 "is, it leaves ", list("globalenv()$.Random.seed"), 
#>                 " intact, which means it also leaved\n", "the RNG kind (", 
#>                 list("RNGkind()"), ") intact.\n", "\n", "Per ", 
#>                 list(list("base::RNGkind()")), ", a L'Ecuyer-CMRG seed comprise a length-seven integer\n", 
#>                 "vector of format ", list(".Random.seed <- c(rng.kind, n)"), 
#>                 " where ", list("length(n) == 6L"), " and ", 
#>                 list("rng.kind"), " fulfills ", list("rng.kind %% 10000L == 407L"), 
#>                 ".\n"), "\n", list("\n", "# The current RNG kind\n", 
#>                 "okind <- RNGkind()\n", "oseed <- globalenv()$.Random.seed\n", 
#>                 "\n", "# (a) A L'Ecuyer-CMRG seed based on a numeric-scalar seed\n", 
#>                 "seed1 <- future:::as_lecyer_cmrg_seed(42)\n", 
#>                 "str(seed1)\n", "## int [1:7] 10407 -2133391687 507561766 1260545903 1362917092 -1772566379 -1344458670\n", 
#>                 "# The RNG kind and the RNG state is preserved\n", 
#>                 "stopifnot(\n", "  future:::is_lecyer_cmrg_seed(seed1),\n", 
#>                 "  identical(RNGkind(), okind),\n", "  identical(globalenv()$.Random.seed, oseed)\n", 
#>                 ")\n", "\n", "# (b) A L'Ecuyer-CMRG seed based on a L'Ecuyer-CMRG seed\n", 
#>                 "seed2 <- future:::as_lecyer_cmrg_seed(seed1)\n", 
#>                 "str(seed2)\n", "## int [1:7] 10407 -2133391687 507561766 1260545903 1362917092 -1772566379 -1344458670\n", 
#>                 "# The input L'Ecuyer-CMRG seed is returned as-is\n", 
#>                 "stopifnot(identical(seed2, seed1))\n", "# The RNG kind and the RNG state is preserved\n", 
#>                 "stopifnot(\n", "  future:::is_lecyer_cmrg_seed(seed2),\n", 
#>                 "  identical(RNGkind(), okind),\n", "  identical(globalenv()$.Random.seed, oseed)\n", 
#>                 ")\n", "\n", "# (c) A L'Ecuyer-CMRG seed based on the current RNG state\n", 
#>                 "seed3 <- future:::as_lecyer_cmrg_seed(TRUE)\n", 
#>                 "str(seed3)\n", "## int [1:7] 10407 495333909 -1491719214 416071979 49340016 1956499377 899435966\n", 
#>                 "stopifnot(future:::is_lecyer_cmrg_seed(seed3))\n", 
#>                 "\n", "\n", "# All of the above calls preserve the RNG state including the RNG kind\n", 
#>                 "stopifnot(\n", "  identical(RNGkind(), okind),\n", 
#>                 "  identical(globalenv()$.Random.seed, oseed)\n", 
#>                 ")\n"), "\n", list("internal"), "\n"), backtrace.Rd = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/backtrace.R", "\n", 
#>             list("backtrace"), "\n", list("backtrace"), "\n", 
#>             list("Back trace the expressions evaluated when an error was caught"), 
#>             "\n", list("\n", "backtrace(future, envir = parent.frame(), ...)\n"), 
#>             "\n", list("\n", list(list("future"), list("A future with a caught error.")), 
#>                 "\n", "\n", list(list("envir"), list("the environment where to locate the future.")), 
#>                 "\n", "\n", list(list(list()), list("Not used.")), 
#>                 "\n"), "\n", list("\n", "A list with the future's call stack that led up to the error.\n"), 
#>             "\n", list("\n", "Back trace the expressions evaluated when an error was caught\n"), 
#>             "\n", list("\n", "my_log <- function(x) log(x)\n", 
#>                 "foo <- function(...) my_log(...)\n", "\n", "f <- future({ foo(\"a\") })\n", 
#>                 "res <- tryCatch({\n", "  v <- value(f)\n", "}, error = function(ex) {\n", 
#>                 "  t <- backtrace(f)\n", "  print(t)\n", "})\n", 
#>                 list("\n", "## R CMD check: make sure any open connections are closed afterward\n", 
#>                   "if (!inherits(plan(\"next\"), \"sequential\")) plan(sequential)\n"), 
#>                 "\n", "\n"), "\n"), cluster.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>             "\n", "% Please edit documentation in R/cluster.R", 
#>             "\n", list("cluster"), "\n", list("cluster"), "\n", 
#>             list("Create a cluster future whose value will be resolved asynchronously in a parallel process"), 
#>             "\n", list("\n", "cluster(..., workers = availableWorkers(), envir = parent.frame())\n"), 
#>             "\n", list("\n", list(list(list()), list("Additional named elements passed to ", 
#>                 list(list("ClusterFuture()")), ".")), "\n", "\n", 
#>                 list(list("workers"), list("A ", list(list("cluster")), 
#>                   " object,\n", "a character vector of host names, a positive numeric scalar,\n", 
#>                   "or a function.\n", "If a character vector or a numeric scalar, a ", 
#>                   list("cluster"), " object\n", "is created using ", 
#>                   list(list("makeClusterPSOCK"), "(workers)"), 
#>                   ".\n", "If a function, it is called without arguments ", 
#>                   list("when the future\n", "is created"), " and its value is used to configure the workers.\n", 
#>                   "The function should return any of the above types.")), 
#>                 "\n", "\n", list(list("envir"), list("The ", 
#>                   list("environment"), " from where global objects should be\n", 
#>                   "identified.")), "\n"), "\n", list("\n", "A ", 
#>                 list("ClusterFuture"), ".\n"), "\n", list("\n", 
#>                 "A cluster future is a future that uses cluster evaluation,\n", 
#>                 "which means that its ", list("value is computed and resolved in\n", 
#>                   "parallel in another process"), ".\n"), "\n", 
#>             list("\n", "This function is ", list("not"), " meant to be called directly.  Instead, the\n", 
#>                 "typical usages are:", list(list("html"), list(
#>                   list("<div class=\"sourceCode r\">"))), list(
#>                   "# Evaluate futures via a single background R process on the local machine\n", 
#>                   "plan(cluster, workers = 1)\n", "\n", "# Evaluate futures via two background R processes on the local machine\n", 
#>                   "plan(cluster, workers = 2)\n", "\n", "# Evaluate futures via a single R process on another machine on on the\n", 
#>                   "# local area network (LAN)\n", "plan(cluster, workers = \"raspberry-pi\")\n", 
#>                   "\n", "# Evaluate futures via a single R process running on a remote machine\n", 
#>                   "plan(cluster, workers = \"pi.example.org\")\n", 
#>                   "\n", "# Evaluate futures via four R processes, one running on the local machine,\n", 
#>                   "# two running on LAN machine 'n1' and one on a remote machine\n", 
#>                   "plan(cluster, workers = c(\"localhost\", \"n1\", \"n1\", \"pi.example.org\")\n"), 
#>                 list(list("html"), list(list("</div>"))), "\n"), 
#>             "\n", list("\n", list("\n", "\n", "## Use cluster futures\n", 
#>                 "cl <- parallel::makeCluster(2, timeout = 60)\n", 
#>                 "plan(cluster, workers = cl)\n", "\n", "## A global variable\n", 
#>                 "a <- 0\n", "\n", "## Create future (explicitly)\n", 
#>                 "f <- future({\n", "  b <- 3\n", "  c <- 2\n", 
#>                 "  a * b * c\n", "})\n", "\n", "## A cluster future is evaluated in a separate process.\n", 
#>                 "## Regardless, changing the value of a global variable will\n", 
#>                 "## not affect the result of the future.\n", 
#>                 "a <- 7\n", "print(a)\n", "\n", "v <- value(f)\n", 
#>                 "print(v)\n", "stopifnot(v == 0)\n", "\n", "## CLEANUP\n", 
#>                 "parallel::stopCluster(cl)\n", "\n"), "\n"), 
#>             "\n"), clusterExportSticky.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>             "\n", "% Please edit documentation in R/sticky_globals.R", 
#>             "\n", list("clusterExportSticky"), "\n", list("clusterExportSticky"), 
#>             "\n", list("Export globals to the sticky-globals environment of the cluster nodes"), 
#>             "\n", list("\n", "clusterExportSticky(cl, globals)\n"), 
#>             "\n", list("\n", list(list("cl"), list("(cluster) A cluster object as returned by\n", 
#>                 list(list("parallel::makeCluster()")), ".")), 
#>                 "\n", "\n", list(list("globals"), list("(list) A named list of sticky globals to be exported.")), 
#>                 "\n"), "\n", list("\n", "(invisible; cluster) The cluster object.\n"), 
#>             "\n", list("\n", "Export globals to the sticky-globals environment of the cluster nodes\n"), 
#>             "\n", list("\n", "This requires that the ", list(
#>                 "future"), " package is installed on the cluster\n", 
#>                 "nodes.\n"), "\n", list("internals"), "\n"), 
#>             find_references.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/utils-marshalling.R", 
#>                 "\n", list("find_references"), "\n", list("find_references"), 
#>                 "\n", list("assert_no_references"), "\n", list(
#>                   "Get the first or all references of an ", list(), 
#>                   " object"), "\n", list("\n", "find_references(x, first_only = FALSE)\n", 
#>                   "\n", "assert_no_references(\n", "  x,\n", 
#>                   "  action = c(\"error\", \"warning\", \"message\", \"string\"),\n", 
#>                   "  source = c(\"globals\", \"value\")\n", ")\n"), 
#>                 "\n", list("\n", list(list("x"), list("The ", 
#>                   list(), " object to be checked.")), "\n", "\n", 
#>                   list(list("first_only"), list("If ", list("TRUE"), 
#>                     ", only the first reference is returned,\n", 
#>                     "otherwise all references.")), "\n", "\n", 
#>                   list(list("action"), list("Type of action to take if a reference is found.")), 
#>                   "\n", "\n", list(list("source"), list("Is the source of ", 
#>                     list("x"), " the globals or the value of the future?")), 
#>                   "\n"), "\n", list("\n", list("find_references()"), 
#>                   " returns a list of zero or more references\n", 
#>                   "identified.\n", "\n", "If a reference is detected, an informative error, warning, message,\n", 
#>                   "or a character string is produced, otherwise ", 
#>                   list("NULL"), " is returned\n", "invisibly.\n"), 
#>                 "\n", list("\n", "Get the first or all references of an ", 
#>                   list(), " object\n", "\n", "Assert that there are no references among the identified globals\n"), 
#>                 "\n", list("internal"), "\n"), future.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/future.R, R/futureAssign.R,", 
#>                 "\n", "%   R/futureAssign_OP.R, R/futureCall.R", 
#>                 "\n", list("future"), "\n", list("future"), "\n", 
#>                 list("futureCall"), "\n", list("futureAssign"), 
#>                 "\n", list("%<-%"), "\n", list("%->%"), "\n", 
#>                 list("Create a future"), "\n", list("\n", "future(\n", 
#>                   "  expr,\n", "  envir = parent.frame(),\n", 
#>                   "  substitute = TRUE,\n", "  lazy = FALSE,\n", 
#>                   "  seed = FALSE,\n", "  globals = TRUE,\n", 
#>                   "  packages = NULL,\n", "  stdout = TRUE,\n", 
#>                   "  conditions = \"condition\",\n", "  earlySignal = FALSE,\n", 
#>                   "  label = NULL,\n", "  gc = FALSE,\n", "  ...\n", 
#>                   ")\n", "\n", "futureAssign(\n", "  x,\n", "  value,\n", 
#>                   "  envir = parent.frame(),\n", "  substitute = TRUE,\n", 
#>                   "  lazy = FALSE,\n", "  seed = FALSE,\n", "  globals = TRUE,\n", 
#>                   "  packages = NULL,\n", "  stdout = TRUE,\n", 
#>                   "  conditions = \"condition\",\n", "  earlySignal = FALSE,\n", 
#>                   "  label = NULL,\n", "  gc = FALSE,\n", "  ...,\n", 
#>                   "  assign.env = envir\n", ")\n", "\n", "x %<-% value\n", 
#>                   "\n", "futureCall(\n", "  FUN,\n", "  args = list(),\n", 
#>                   "  envir = parent.frame(),\n", "  lazy = FALSE,\n", 
#>                   "  seed = FALSE,\n", "  globals = TRUE,\n", 
#>                   "  packages = NULL,\n", "  stdout = TRUE,\n", 
#>                   "  conditions = \"condition\",\n", "  earlySignal = FALSE,\n", 
#>                   "  label = NULL,\n", "  gc = FALSE,\n", "  ...\n", 
#>                   ")\n"), "\n", list("\n", list(list("expr, value"), 
#>                   list("An ", list(), " ", list("expression"), 
#>                     ".")), "\n", "\n", list(list("envir"), list(
#>                   "The ", list("environment"), " from where global objects should be\n", 
#>                   "identified.")), "\n", "\n", list(list("substitute"), 
#>                   list("If TRUE, argument ", list("expr"), " is\n", 
#>                     list(list("substitute"), "()"), ":ed, otherwise not.")), 
#>                   "\n", "\n", list(list("lazy"), list("If FALSE (default), the future is resolved\n", 
#>                     "eagerly (starting immediately), otherwise not.")), 
#>                   "\n", "\n", list(list("seed"), list("(optional) If TRUE, the random seed, that is, the state of the\n", 
#>                     "random number generator (RNG) will be set such that statistically sound\n", 
#>                     "random numbers are produced (also during parallelization).\n", 
#>                     "If FALSE (default), it is assumed that the future expression does neither\n", 
#>                     "need nor use random numbers generation.\n", 
#>                     "To use a fixed random seed, specify a L'Ecuyer-CMRG seed (seven integer)\n", 
#>                     "or a regular RNG seed (a single integer).  If the latter, then a\n", 
#>                     "L'Ecuyer-CMRG seed will be automatically created based on the given seed.\n", 
#>                     "Furthermore, if FALSE, then the future will be monitored to make sure it\n", 
#>                     "does not use random numbers.  If it does and depending on the value of\n", 
#>                     "option ", list(list("future.rng.onMisuse")), 
#>                     ", the check is\n", "ignored, an informative warning, or error will be produced.\n", 
#>                     "If ", list("seed"), " is NULL, then the effect is as with ", 
#>                     list("seed = FALSE"), "\n", "but without the RNG check being performed.")), 
#>                   "\n", "\n", list(list("globals"), list("(optional) a logical, a character vector, or a named list\n", 
#>                     "to control how globals are handled.\n", 
#>                     "For details, see section 'Globals used by future expressions'\n", 
#>                     "in the help for ", list(list("future()")), 
#>                     ".")), "\n", "\n", list(list("packages"), 
#>                     list("(optional) a character vector specifying packages\n", 
#>                       "to be attached in the ", list(), " environment evaluating the future.")), 
#>                   "\n", "\n", list(list("stdout"), list("If TRUE (default), then the standard output is captured,\n", 
#>                     "and re-outputted when ", list("value()"), 
#>                     " is called.\n", "If FALSE, any output is silenced (by sinking it to the null device as\n", 
#>                     "it is outputted).\n", "If NA (not recommended), output is ", 
#>                     list("not"), " intercepted.")), "\n", "\n", 
#>                   list(list("conditions"), list("A character string of conditions classes to be captured\n", 
#>                     "and relayed.  The default is to relay messages and warnings.\n", 
#>                     "To not intercept any types of conditions, use ", 
#>                     list("conditions = NULL"), ".\n", "Attribute ", 
#>                     list("exclude"), " can be used to ignore specific classes, e.g.\n", 
#>                     list("conditions = structure(\"condition\", exclude = \"message\")"), 
#>                     " will capture\n", "all ", list("condition"), 
#>                     " classes except those that inherits from the ", 
#>                     list("message"), " class.\n", "Errors are always relayed.")), 
#>                   "\n", "\n", list(list("earlySignal"), list(
#>                     "Specified whether conditions should be signaled as soon\n", 
#>                     "as possible or not.")), "\n", "\n", list(
#>                     list("label"), list("An optional character string label attached to the future.")), 
#>                   "\n", "\n", list(list("gc"), list("If TRUE, the garbage collector run (in the process that\n", 
#>                     "evaluated the future) only after the value of the future is collected.\n", 
#>                     "Exactly when the values are collected may depend on various factors such\n", 
#>                     "as number of free workers and whether ", 
#>                     list("earlySignal"), " is TRUE (more\n", 
#>                     "frequently) or FALSE (less frequently).\n", 
#>                     list("Some types of futures ignore this argument."))), 
#>                   "\n", "\n", list(list(list()), list("Additional arguments passed to ", 
#>                     list(list("Future()")), ".")), "\n", "\n", 
#>                   list(list("x"), list("the name of a future variable, which will hold the value\n", 
#>                     "of the future expression (as a promise).")), 
#>                   "\n", "\n", list(list("assign.env"), list("The ", 
#>                     list("environment"), " to which the variable\n", 
#>                     "should be assigned.")), "\n", "\n", list(
#>                     list("FUN"), list("A ", list("function"), 
#>                       " to be evaluated.")), "\n", "\n", list(
#>                     list("args"), list("A ", list("list"), " of arguments passed to function ", 
#>                       list("FUN"), ".")), "\n"), "\n", list("\n", 
#>                   list("f <- future(expr)"), " creates a ", list(
#>                     "Future"), " ", list("f"), " that evaluates expression ", 
#>                   list("expr"), ", the value of the future is retrieved using ", 
#>                   list("v <- value(f)"), ".\n", "\n", list("x %<-% value"), 
#>                   " (a future assignment) and\n", list("futureAssign(\"x\", value)"), 
#>                   " create a ", list("Future"), " that evaluates\n", 
#>                   "expression ", list("expr"), " and binds its value (as a\n", 
#>                   list("promise"), ") to\n", "a variable ", list(
#>                     "x"), ".  The value of the future is automatically retrieved\n", 
#>                   "when the assigned variable (promise) is queried.\n", 
#>                   "The future itself is returned invisibly, e.g.\n", 
#>                   list("f <- futureAssign(\"x\", expr)"), " and ", 
#>                   list("f <- (x %<-% expr)"), ".\n", "Alternatively, the future of a future variable ", 
#>                   list("x"), " can be retrieved\n", "without blocking using ", 
#>                   list("f <- ", list("futureOf"), "(x)"), ".\n", 
#>                   "Both the future and the variable (promise) are assigned to environment\n", 
#>                   list("assign.env"), " where the name of the future is ", 
#>                   list(".future_<name>"), ".\n", "\n", list("f <- futureCall(FUN, args)"), 
#>                   " creates a ", list("Future"), " ", list("f"), 
#>                   " that calls function ", list("FUN"), " with arguments ", 
#>                   list("args"), ", where the value of the future is retrieved using ", 
#>                   list("x <- value(f)"), ".\n"), "\n", list("\n", 
#>                   list(list("html"), list(list(list("logo.png"), 
#>                     list("options: align='right' alt='logo' width='120'")))), 
#>                   "\n", "Creates a future that evaluates an ", 
#>                   list(), " expression or\n", "a future that calls an ", 
#>                   list(), " function with a set of arguments.\n", 
#>                   "How, when, and where these futures are evaluated can be configured\n", 
#>                   "using ", list(list("plan()")), " such that it is evaluated in parallel on,\n", 
#>                   "for instance, the current machine, on a remote machine, or via a\n", 
#>                   "job queue on a compute cluster.\n", "Importantly, any ", 
#>                   list(), " code using futures remains the same regardless\n", 
#>                   "on these settings and there is no need to modify the code when\n", 
#>                   "switching from, say, sequential to parallel processing.\n"), 
#>                 "\n", list("\n", "The state of a future is either unresolved or resolved.\n", 
#>                   "The value of a future can be retrieved using ", 
#>                   list("v <- ", list("value"), "(f)"), ".\n", 
#>                   "Querying the value of a non-resolved future will ", 
#>                   list("block"), " the call\n", "until the future is resolved.\n", 
#>                   "It is possible to check whether a future is resolved or not\n", 
#>                   "without blocking by using ", list(list("resolved"), 
#>                     "(f)"), ".\n", "\n", "For a future created via a future assignment\n", 
#>                   "(", list("x %<-% value"), " or ", list("futureAssign(\"x\", value)"), 
#>                   "), the value\n", "is bound to a promise, which when queried will internally call\n", 
#>                   list(list("value()")), "  on the future and which will then be resolved\n", 
#>                   "into a regular variable bound to that value.  For example, with future\n", 
#>                   "assignment ", list("x %<-% value"), ", the first time variable ", 
#>                   list("x"), " is\n", "queried the call blocks if (and only if) the future is not yet resolved.\n", 
#>                   "As soon as it is resolved, and any succeeding queries, querying ", 
#>                   list("x"), "\n", "will immediately give the value.\n", 
#>                   "\n", "The future assignment construct ", list(
#>                     "x %<-% value"), " is not a formal\n", "assignment per se, but a binary infix operator on objects ", 
#>                   list("x"), "\n", "and expression ", list("value"), 
#>                   ".  However, by using non-standard evaluation,\n", 
#>                   "this constructs can emulate an assignment operator similar to\n", 
#>                   list("x <- value"), ". Due to ", list(), "'s precedence rules of operators,\n", 
#>                   "future expressions often need to be explicitly bracketed, e.g.\n", 
#>                   list("x %<-% { a + b }"), ".\n", "\n", "The ", 
#>                   list("futureCall()"), " function works analogously to\n", 
#>                   list(list("do.call"), "()"), ", which calls a function with a set of\n", 
#>                   "arguments.  The difference is that ", list(
#>                     "do.call()"), " returns the value of\n", 
#>                   "the call whereas ", list("futureCall()"), 
#>                   " returns a future.\n"), "\n", list(list("Eager or lazy evaluation"), 
#>                   list("\n", "\n", "By default, a future is resolved using ", 
#>                     list("eager"), " evaluation\n", "(", list(
#>                       "lazy = FALSE"), ").  This means that the expression starts to\n", 
#>                     "be evaluated as soon as the future is created.\n", 
#>                     "\n", "As an alternative, the future can be resolved using ", 
#>                     list("lazy"), "\n", "evaluation (", list(
#>                       "lazy = TRUE"), ").  This means that the expression\n", 
#>                     "will only be evaluated when the value of the future is requested.\n", 
#>                     list("Note that this means that the expression may not be evaluated\n", 
#>                       "at all - it is guaranteed to be evaluated if the value is requested"), 
#>                     ".\n", "\n", "For future assignments, lazy evaluation can be controlled via the\n", 
#>                     list("%lazy%"), " operator, e.g. ", list(
#>                       "x %<-% { expr } %lazy% TRUE"), ".\n")), 
#>                 "\n", "\n", list(list("Globals used by future expressions"), 
#>                   list("\n", "\n", "Global objects (short ", 
#>                     list("globals"), ") are objects (e.g. variables and\n", 
#>                     "functions) that are needed in order for the future expression to be\n", 
#>                     "evaluated while not being local objects that are defined by the future\n", 
#>                     "expression. For example, in\n", list("\n", 
#>                       "  a <- 42\n", "  f <- future({ b <- 2; a * b })\n"), 
#>                     "\n", "variable ", list("a"), " is a global of future assignment ", 
#>                     list("f"), " whereas\n", list("b"), " is a local variable.\n", 
#>                     "In order for the future to be resolved successfully (and correctly),\n", 
#>                     "all globals need to be gathered when the future is created such that\n", 
#>                     "they are available whenever and wherever the future is resolved.\n", 
#>                     "\n", "The default behavior (", list("globals = TRUE"), 
#>                     "),\n", "is that globals are automatically identified and gathered.\n", 
#>                     "More precisely, globals are identified via code inspection of the\n", 
#>                     "future expression ", list("expr"), " and their values are retrieved with\n", 
#>                     "environment ", list("envir"), " as the starting point (basically via\n", 
#>                     list("get(global, envir = envir, inherits = TRUE)"), 
#>                     ").\n", list("In most cases, such automatic collection of globals is sufficient\n", 
#>                       "and less tedious and error prone than if they are manually specified"), 
#>                     ".\n", "\n", "However, for full control, it is also possible to explicitly specify\n", 
#>                     "exactly which the globals are by providing their names as a character\n", 
#>                     "vector.\n", "In the above example, we could use\n", 
#>                     list("\n", "  a <- 42\n", "  f <- future({ b <- 2; a * b }, globals = \"a\")\n"), 
#>                     "\n", "\n", "Yet another alternative is to explicitly specify also their values\n", 
#>                     "using a named list as in\n", list("\n", 
#>                       "  a <- 42\n", "  f <- future({ b <- 2; a * b }, globals = list(a = a))\n"), 
#>                     "\n", "or\n", list("\n", "  f <- future({ b <- 2; a * b }, globals = list(a = 42))\n"), 
#>                     "\n", "\n", "Specifying globals explicitly avoids the overhead added from\n", 
#>                     "automatically identifying the globals and gathering their values.\n", 
#>                     "Furthermore, if we know that the future expression does not make use\n", 
#>                     "of any global variables, we can disable the automatic search for\n", 
#>                     "globals by using\n", list("\n", "  f <- future({ a <- 42; b <- 2; a * b }, globals = FALSE)\n"), 
#>                     "\n", "\n", "Future expressions often make use of functions from one or more packages.\n", 
#>                     "As long as these functions are part of the set of globals, the future\n", 
#>                     "package will make sure that those packages are attached when the future\n", 
#>                     "is resolved.  Because there is no need for such globals to be frozen\n", 
#>                     "or exported, the future package will not export them, which reduces\n", 
#>                     "the amount of transferred objects.\n", "For example, in\n", 
#>                     list("\n", "  x <- rnorm(1000)\n", "  f <- future({ median(x) })\n"), 
#>                     "\n", "variable ", list("x"), " and ", list(
#>                       "median()"), " are globals, but only ", 
#>                     list("x"), "\n", "is exported whereas ", 
#>                     list("median()"), ", which is part of the ", 
#>                     list("stats"), "\n", "package, is not exported.  Instead it is made sure that the ", 
#>                     list("stats"), "\n", "package is on the search path when the future expression is evaluated.\n", 
#>                     "Effectively, the above becomes\n", list(
#>                       "\n", "  x <- rnorm(1000)\n", "  f <- future({\n", 
#>                       "    library(\"stats\")\n", "    median(x)\n", 
#>                       "  })\n"), "\n", "To manually specify this, one can either do\n", 
#>                     list("\n", "  x <- rnorm(1000)\n", "  f <- future({\n", 
#>                       "    median(x)\n", "  }, globals = list(x = x, median = stats::median)\n"), 
#>                     "\n", "or\n", list("\n", "  x <- rnorm(1000)\n", 
#>                       "  f <- future({\n", "    library(\"stats\")\n", 
#>                       "    median(x)\n", "  }, globals = list(x = x))\n"), 
#>                     "\n", "Both are effectively the same.\n", 
#>                     "\n", "Although rarely needed, a combination of automatic identification and manual\n", 
#>                     "specification of globals is supported via attributes ", 
#>                     list("add"), " (to add\n", "false negatives) and ", 
#>                     list("ignore"), " (to ignore false positives) on value\n", 
#>                     list("TRUE"), ".  For example, with\n", list(
#>                       "globals = structure(TRUE, ignore = \"b\", add = \"a\")"), 
#>                     " any globals\n", "automatically identified except ", 
#>                     list("b"), " will be used in addition to\n", 
#>                     "global ", list("a"), ".\n", "\n", "When using future assignments, globals can be specified analogously\n", 
#>                     "using the ", list(list("%globals%")), " operator, e.g.\n", 
#>                     list("\n", "  x <- rnorm(1000)\n", "  y %<-% { median(x) } %globals% list(x = x, median = stats::median)\n"), 
#>                     "\n")), "\n", "\n", list("\n", "## Evaluate futures in parallel\n", 
#>                   "plan(multisession)\n", "\n", "## Data\n", 
#>                   "x <- rnorm(100)\n", "y <- 2 * x + 0.2 + rnorm(100)\n", 
#>                   "w <- 1 + x ^ 2\n", "\n", "\n", "## EXAMPLE: Regular assignments (evaluated sequentially)\n", 
#>                   "fitA <- lm(y ~ x, weights = w)      ## with offset\n", 
#>                   "fitB <- lm(y ~ x - 1, weights = w)  ## without offset\n", 
#>                   "fitC <- {\n", "  w <- 1 + abs(x)  ## Different weights\n", 
#>                   "  lm(y ~ x, weights = w)\n", "}\n", "print(fitA)\n", 
#>                   "print(fitB)\n", "print(fitC)\n", "\n", "\n", 
#>                   "## EXAMPLE: Future assignments (evaluated in parallel)\n", 
#>                   "fitA %<-% lm(y ~ x, weights = w)      ## with offset\n", 
#>                   "fitB %<-% lm(y ~ x - 1, weights = w)  ## without offset\n", 
#>                   "fitC %<-% {\n", "  w <- 1 + abs(x)\n", "  lm(y ~ x, weights = w)\n", 
#>                   "}\n", "print(fitA)\n", "print(fitB)\n", "print(fitC)\n", 
#>                   "\n", "\n", "## EXAMPLE: Explicitly create futures (evaluated in parallel)\n", 
#>                   "## and retrieve their values\n", "fA <- future( lm(y ~ x, weights = w) )\n", 
#>                   "fB <- future( lm(y ~ x - 1, weights = w) )\n", 
#>                   "fC <- future({\n", "  w <- 1 + abs(x)\n", 
#>                   "  lm(y ~ x, weights = w)\n", "})\n", "fitA <- value(fA)\n", 
#>                   "fitB <- value(fB)\n", "fitC <- value(fC)\n", 
#>                   "print(fitA)\n", "print(fitB)\n", "print(fitC)\n", 
#>                   "\n", list("\n", "## Make sure to \"close\" an multisession workers on Windows\n", 
#>                     "plan(sequential)\n"), "\n", "## EXAMPLE: futureCall() and do.call()\n", 
#>                   "x <- 1:100\n", "y0 <- do.call(sum, args = list(x))\n", 
#>                   "print(y0)\n", "\n", "f1 <- futureCall(sum, args = list(x))\n", 
#>                   "y1 <- value(f1)\n", "print(y1)\n"), "\n", 
#>                 list("\n", "How, when and where futures are resolved is given by the\n", 
#>                   list("future strategy"), ", which can be set by the end user using the\n", 
#>                   list(list("plan()")), " function.  The future strategy must not be\n", 
#>                   "set by the developer, e.g. it must not be called within a package.\n"), 
#>                 "\n", list("\n", "The future logo was designed by Dan LaBar and tweaked by Henrik Bengtsson.\n"), 
#>                 "\n"), future.options.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/options.R", 
#>                 "\n", list("future.options"), "\n", list("future.options"), 
#>                 "\n", list("future.cmdargs"), "\n", list(".future.R"), 
#>                 "\n", list("future.startup.script"), "\n", list(
#>                   "R_FUTURE_STARTUP_SCRIPT"), "\n", list("future.debug"), 
#>                 "\n", list("R_FUTURE_DEBUG"), "\n", list("future.demo.mandelbrot.region"), 
#>                 "\n", list("R_FUTURE_DEMO_MANDELBROT_REGION"), 
#>                 "\n", list("future.demo.mandelbrot.nrow"), "\n", 
#>                 list("R_FUTURE_DEMO_MANDELBROT_NROW"), "\n", 
#>                 list("future.fork.multithreading.enable"), "\n", 
#>                 list("R_FUTURE_FORK_MULTITHREADING_ENABLE"), 
#>                 "\n", list("future.globals.maxSize"), "\n", list(
#>                   "R_FUTURE_GLOBALS_MAXSIZE"), "\n", list("future.globals.method"), 
#>                 "\n", list("R_FUTURE_GLOBALS_METHOD"), "\n", 
#>                 list("future.globals.onMissing"), "\n", list(
#>                   "R_FUTURE_GLOBALS_ONMISSING"), "\n", list("future.globals.resolve"), 
#>                 "\n", list("R_FUTURE_GLOBALS_RESOLVE"), "\n", 
#>                 list("future.globals.onReference"), "\n", list(
#>                   "R_FUTURE_GLOBALS_ONREFERENCE"), "\n", list(
#>                   "future.plan"), "\n", list("R_FUTURE_PLAN"), 
#>                 "\n", list("future.resolve.recursive"), "\n", 
#>                 list("R_FUTURE_RNG_ONMISUSE"), "\n", list("future.wait.alpha"), 
#>                 "\n", list("R_FUTURE_WAIT_ALPHA"), "\n", list(
#>                   "future.wait.interval"), "\n", list("R_FUTURE_WAIT_INTERVAL"), 
#>                 "\n", list("future.wait.timeout"), "\n", list(
#>                   "R_FUTURE_WAIT_TIMEOUT"), "\n", list("R_FUTURE_RESOLVED_TIMEOUT"), 
#>                 "\n", list("future.output.windows.reencode"), 
#>                 "\n", list("R_FUTURE_OUTPUT_WINDOWS_REENCODE"), 
#>                 "\n", list("Options used for futures"), "\n", 
#>                 list("\n", "Below are the ", list(), " options and environment variables that are used by the\n", 
#>                   list("future"), " package and packages enhancing it.", 
#>                   list(), "\n", list(), "\n", list("WARNING: Note that the names and the default values of these options may\n", 
#>                     "change in future versions of the package.  Please use with care until\n", 
#>                     "further notice."), "\n"), "\n", list(list(
#>                   "Settings moved to the 'parallelly' package"), 
#>                   list("\n", "\n", "Several functions have been moved to the ", 
#>                     list("parallelly"), " package:\n", list("\n", 
#>                       list(), " ", list(list("parallelly::availableCores()")), 
#>                       "\n", list(), " ", list(list("parallelly::availableWorkers()")), 
#>                       "\n", list(), " ", list(list("parallelly::makeClusterMPI()")), 
#>                       "\n", list(), " ", list(list("parallelly::makeClusterPSOCK()")), 
#>                       "\n", list(), " ", list(list("parallelly::makeNodePSOCK()")), 
#>                       "\n", list(), " ", list(list("parallelly::supportsMulticore()")), 
#>                       "\n"), "\n", "\n", "The options and environment variables controlling those have been adjusted\n", 
#>                     "accordingly to have different prefixes.\n", 
#>                     "For example, option ", list("future.fork.enable"), 
#>                     " has been renamed to\n", list("parallelly.fork.enable"), 
#>                     " and the corresponding environment variable\n", 
#>                     list("R_FUTURE_FORK_ENABLE"), " has been renamed to\n", 
#>                     list("R_PARALLELLY_FORK_ENABLE"), ".\n", 
#>                     "For backward compatibility reasons, the ", 
#>                     list("parallelly"), " package will\n", "support both versions for a long foreseeable time.\n", 
#>                     "See the ", list("parallelly::parallelly.options"), 
#>                     " page for the settings.\n")), "\n", "\n", 
#>                 list(list("Options for controlling futures"), 
#>                   list("\n", "\n", list("\n", list(list(list(
#>                     "future.plan"), ":"), list("(character string or future function) Default future strategy plan used unless otherwise specified via ", 
#>                     list(list("plan()")), ". This will also be the future plan set when calling ", 
#>                     list("plan(\"default\")"), ".  If not specified, this option may be set when the ", 
#>                     list("future"), " package is ", list("loaded"), 
#>                     " if command-line option ", list("--parallel=ncores"), 
#>                     " (short ", list("-p ncores"), ") is specified; if ", 
#>                     list("ncores > 1"), ", then option ", list(
#>                       "future.plan"), " is set to ", list("multisession"), 
#>                     " otherwise ", list("sequential"), " (in addition to option ", 
#>                     list("mc.cores"), " being set to ", list(
#>                       "ncores"), ", if ", list("ncores >= 1"), 
#>                     "). (Default: ", list("sequential"), ")")), 
#>                     "\n", "\n", list(list(list("future.globals.maxSize"), 
#>                       ":"), list("(numeric) Maximum allowed total size (in bytes) of global variables identified. Used to prevent too large exports. If set of ", 
#>                       list("+Inf"), ", then the check for large globals is skipped. (Default: ", 
#>                       list("500 * 1024 ^ 2"), " = 500 MiB)")), 
#>                     "\n", "\n", list(list(list("future.globals.onReference"), 
#>                       ": (", list("beta feature - may change"), 
#>                       ")"), list("(character string) Controls whether the identified globals should be scanned for so called ", 
#>                       list("references"), " (e.g. external pointers and connections) or not.  It is unlikely that another ", 
#>                       list(), " process (\"worker\") can use a global that uses a internal reference of the master ", 
#>                       list(), " process - we call such objects ", 
#>                       list("non-exportable globals"), ".\n", 
#>                       "If this option is ", list("\"error\""), 
#>                       ", an informative error message is produced if a non-exportable global is detected.\n", 
#>                       "If ", list("\"warning\""), ", a warning is produced, but the processing will continue; it is likely that the future will be resolved with a run-time error unless processed in the master ", 
#>                       list(), " process (e.g. ", list("plan(sequential)"), 
#>                       " and ", list("plan(multicore)"), ").\n", 
#>                       "If ", list("\"ignore\""), ", no scan is performed.\n", 
#>                       "(Default: ", list("\"ignore\""), " but may change)\n")), 
#>                     "\n", "\n", list(list(list("future.resolve.recursive"), 
#>                       ":"), list("(integer) An integer specifying the maximum recursive depth to which futures should be resolved. If negative, nothing is resolved.  If ", 
#>                       list("0"), ", only the future itself is resolved.  If ", 
#>                       list("1"), ", the future and any of its elements that are futures are resolved, and so on. If ", 
#>                       list("+Inf"), ", infinite search depth is used. (Default: ", 
#>                       list("0"), ")")), "\n", "\n", list(list(
#>                       list("future.rng.onMisuse"), ": (", list(
#>                         "beta feature - may change"), ")"), list(
#>                       "(character string) If random numbers are used in futures, then parallel (L'Ecuyer-CMRG) RNG should be used in order to get statistical sound RNGs. The defaults in the future framework assume that ", 
#>                       list("no"), " random number generation (RNG) is taken place in the future expression because L'Ecuyer-CMRG RNGs come with an unnecessary overhead if not needed.  To protect against mistakes, the future framework attempts to detect when random numbers are used despite L'Ecuyer-CMRG RNGs are not in place.  If this is detected, and ", 
#>                       list("future.rng.onMisuse = \"error\""), 
#>                       ", then an informative error message is produced.  If ", 
#>                       list("\"warning\""), ", then a warning message is produced.  If ", 
#>                       list("\"ignore\""), ", no check is performed. (Default: ", 
#>                       list("\"warning\""), ")")), "\n", "\n", 
#>                     list(list(list("future.wait.timeout"), ":"), 
#>                       list("(numeric) Maximum waiting time (in seconds) for a free worker before a timeout error is generated. (Default: ", 
#>                         list("30 * 24 * 60 * 60"), " (= 30 days))")), 
#>                     "\n", "\n", list(list(list("future.wait.interval"), 
#>                       ":"), list("(numeric) Initial interval (in seconds) between polls. (Default: ", 
#>                       list("0.2"), " = 0.2 seconds)")), "\n", 
#>                     "\n", list(list(list("future.wait.alpha"), 
#>                       ":"), list("(numeric) Positive scale factor used to increase the interval after each poll. (Default: ", 
#>                       list("1.01"), ")")), "\n"), "\n")), "\n", 
#>                 "\n", list(list("Options for debugging futures"), 
#>                   list("\n", "\n", list("\n", list(list(list(
#>                     "future.debug"), ":"), list("(logical) If ", 
#>                     list("TRUE"), ", extensive debug messages are generated. (Default: ", 
#>                     list("FALSE"), ")")), "\n"), "\n")), "\n", 
#>                 "\n", list(list("Options for controlling package startup"), 
#>                   list("\n", "\n", list("\n", list(list(list(
#>                     "future.startup.script"), ":"), list("(character vector or a logical) Specifies zero of more future startup scripts to be sourced when the ", 
#>                     list("future"), " package is ", list("attached"), 
#>                     ". It is only the first existing script that is sourced. If none of the specified files exist, nothing is sourced - there will be neither a warning nor an error.\n", 
#>                     "If this option is not specified, environment variable ", 
#>                     list("R_FUTURE_STARTUP_SCRIPT"), " is considered, where multiple scripts may be separated by either a colon (", 
#>                     list(":"), ") or a semicolon (", list(";"), 
#>                     "). If neither is set, or either is set to ", 
#>                     list("TRUE"), ", the default is to look for a ", 
#>                     list(".future.R"), " script in the current directory and then in the user's home directory.  To disable future startup scripts, set the option or the environment variable to ", 
#>                     list("FALSE"), ".  ", list("Importantly"), 
#>                     ", this option is ", list("always"), " set to ", 
#>                     list("FALSE"), " if the ", list("future"), 
#>                     " package is loaded as part of a future expression being evaluated, e.g. in a background process. In order words, they are sourced in the main ", 
#>                     list(), " process but not in future processes. (Default: ", 
#>                     list("TRUE"), " in main ", list(), " process and ", 
#>                     list("FALSE"), " in future processes / during future evaluation)")), 
#>                     "\n", "\n", list(list(list("future.cmdargs"), 
#>                       ":"), list("(character vector) Overrides ", 
#>                       list(list("commandArgs"), "()"), " when the ", 
#>                       list("future"), " package is ", list("loaded"), 
#>                       ".")), "\n"), "\n")), "\n", "\n", list(
#>                   list("Options for configuring low-level system behaviors"), 
#>                   list("\n", "\n", "\n", list("\n", list(list(
#>                     list("future.fork.multithreading.enable"), 
#>                     " (", list("beta feature - may change"), 
#>                     "):"), list("(logical) Enable or disable ", 
#>                     list("multi-threading"), " while using ", 
#>                     list("forked"), " parallel processing.  If ", 
#>                     list("FALSE"), ", different multi-thread library settings are overridden such that they run in single-thread mode. Specifically, multi-threading will be disabled for OpenMP (which requires the ", 
#>                     list("RhpcBLASctl"), " package) and for ", 
#>                     list("RcppParallel"), ". If ", list("TRUE"), 
#>                     ", or not set (the default), multi-threading is allowed.  Parallelization via multi-threaded processing (done in native code by some packages and external libraries) while at the same time using forked (aka \"multicore\") parallel processing is known to unstable.  Note that this is not only true when using ", 
#>                     list("plan(multicore)"), " but also when using, for instance, ", 
#>                     list(list("mclapply"), "()"), " of the ", 
#>                     list("parallel"), " package. (Default: not set)")), 
#>                     "\n", "\n", list(list(list("future.output.windows.reencode"), 
#>                       " (", list("beta feature - may change"), 
#>                       "):"), list("(logical) Enable or disable re-encoding of UTF-8 symbols that were incorrectly encoded while captured.  On MS Windows, R cannot capture UTF-8 symbols as-is when they are captured from the standard output.  For examples, a UTF-8 check mark symbol (", 
#>                       list("\"\\u2713\""), ") would be relayed as ", 
#>                       list("\"<U+2713>\""), " (a string with eight ASCII characters).  This option will cause ", 
#>                       list("value()"), " to attempt to recover the intended UTF-8 symbols from ", 
#>                       list("<U+nnnn>"), " string components, if, and only if, the string was captured by a future resolved on MS Windows. (Default: ", 
#>                       list("TRUE"), ")")), "\n"), "\n", "\n", 
#>                     "See also ", list("parallelly::parallelly.options"), 
#>                     ".\n")), "\n", "\n", list(list("Options for demos"), 
#>                   list("\n", "\n", list("\n", list(list(list(
#>                     "future.demo.mandelbrot.region"), ":"), list(
#>                     "(integer) Either a named list of ", list(
#>                       list("mandelbrot()")), " arguments or an integer in {1, 2, 3} specifying a predefined Mandelbrot region. (Default: ", 
#>                     list("1L"), ")")), "\n", "\n", list(list(
#>                     list("future.demo.mandelbrot.nrow"), ":"), 
#>                     list("(integer) Number of rows and columns of tiles. (Default: ", 
#>                       list("3L"), ")")), "\n"), "\n")), "\n", 
#>                 "\n", list(list("Deprecated or for internal prototyping"), 
#>                   list("\n", "\n", "\n", "The following options exists only for troubleshooting purposes and must not\n", 
#>                     "be used in production.  If used, there is a risk that the results are\n", 
#>                     "non-reproducible if processed elsewhere.  To lower the risk of them being\n", 
#>                     "used by mistake, they are marked as deprecated and will produce warnings\n", 
#>                     "if set.\n", "\n", list("\n", list(list(list(
#>                       "future.globals.onMissing"), ":"), list(
#>                       "(character string) Action to take when non-existing global variables (\"globals\" or \"unknowns\") are identified when the future is created.  If ", 
#>                       list("\"error\""), ", an error is generated immediately.  If ", 
#>                       list("\"ignore\""), ", no action is taken and an attempt to evaluate the future expression will be made.  The latter is useful when there is a risk for false-positive globals being identified, e.g. when future expression contains non-standard evaluation (NSE).  (Default: ", 
#>                       list("\"ignore\""), ")")), "\n", "\n", 
#>                       list(list(list("future.globals.method"), 
#>                         ":"), list("(character string) Method used to identify globals. For details, see ", 
#>                         list(list("globalsOf"), "()"), ". (Default: ", 
#>                         list("\"ordered\""), ")")), "\n", "\n", 
#>                       list(list(list("future.globals.resolve"), 
#>                         ":"), list("(logical) If ", list("TRUE"), 
#>                         ", globals that are ", list(list("Future")), 
#>                         " objects (typically created as ", list(
#>                           "explicit"), " futures) will be resolved and have their values (using ", 
#>                         list("value()"), ") collected.  Because searching for unresolved futures among globals (including their content) can be expensive, the default is not to do it and instead leave it to the run-time checks that assert proper ownership when resolving futures and collecting their values. (Default: ", 
#>                         list("FALSE"), ")")), "\n"), "\n")), 
#>                 "\n", "\n", list(list("Environment variables that set R options"), 
#>                   list("\n", "\n", "All of the above ", list(), 
#>                     " ", list("future.*"), " options can be set by corresponding\n", 
#>                     "environment variable ", list("R_FUTURE_*"), 
#>                     " ", list("when the ", list("future"), " package is\n", 
#>                       "loaded"), ".\n", "For example, if ", list(
#>                       "R_FUTURE_RNG_ONMISUSE = \"ignore\""), 
#>                     ", then option\n", list("future.rng.onMisuse"), 
#>                     " is set to ", list("\"ignore\""), " (character string).\n", 
#>                     "Similarly, if ", list("R_FUTURE_GLOBALS_MAXSIZE = \"50000000\""), 
#>                     ", then option\n", list("future.globals.maxSize"), 
#>                     " is set to ", list("50000000"), " (numeric).\n")), 
#>                 "\n", "\n", list("\n", "# Allow at most 5 MB globals per futures\n", 
#>                   "options(future.globals.maxSize = 5e6)\n", 
#>                   "\n", "# Be strict; catch all RNG mistakes\n", 
#>                   "options(future.rng.onMisuse = \"error\")\n", 
#>                   "\n", "\n"), "\n", list("\n", "To set ", list(), 
#>                   " options or environment variables when ", 
#>                   list(), " starts (even before the ", list("future"), 
#>                   " package is loaded), see the ", list("Startup"), 
#>                   " help page.  The ", list(list("https://cran.r-project.org/package=startup"), 
#>                     list(list("startup"))), " package provides a friendly mechanism for configurating ", 
#>                   list(), "'s startup process.\n"), "\n", list(
#>                   "internal"), "\n"), futureOf.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/futureOf.R", 
#>                 "\n", list("futureOf"), "\n", list("futureOf"), 
#>                 "\n", list("Get the future of a future variable"), 
#>                 "\n", list("\n", "futureOf(\n", "  var = NULL,\n", 
#>                   "  envir = parent.frame(),\n", "  mustExist = TRUE,\n", 
#>                   "  default = NA,\n", "  drop = FALSE\n", ")\n"), 
#>                 "\n", list("\n", list(list("var"), list("the variable.  If NULL, all futures in the\n", 
#>                   "environment are returned.")), "\n", "\n", 
#>                   list(list("envir"), list("the environment where to search from.")), 
#>                   "\n", "\n", list(list("mustExist"), list("If TRUE and the variable does not exists, then\n", 
#>                     "an informative error is thrown, otherwise NA is returned.")), 
#>                   "\n", "\n", list(list("default"), list("the default value if future was not found.")), 
#>                   "\n", "\n", list(list("drop"), list("if TRUE and ", 
#>                     list("var"), " is NULL, then returned list\n", 
#>                     "only contains futures, otherwise also ", 
#>                     list("default"), " values.")), "\n"), "\n", 
#>                 list("\n", "A ", list("Future"), " (or ", list(
#>                   "default"), ").\n", "If ", list("var"), " is NULL, then a named list of Future:s are returned.\n"), 
#>                 "\n", list("\n", "Get the future of a future variable that has been created directly\n", 
#>                   "or indirectly via ", list(list("future()")), 
#>                   ".\n"), "\n", list("\n", "a %<-% { 1 }\n", 
#>                   "\n", "f <- futureOf(a)\n", "print(f)\n", "\n", 
#>                   "b %<-% { 2 }\n", "\n", "f <- futureOf(b)\n", 
#>                   "print(f)\n", "\n", "## All futures\n", "fs <- futureOf()\n", 
#>                   "print(fs)\n", "\n", "\n", "## Futures part of environment\n", 
#>                   "env <- new.env()\n", "env$c %<-% { 3 }\n", 
#>                   "\n", "f <- futureOf(env$c)\n", "print(f)\n", 
#>                   "\n", "f2 <- futureOf(c, envir = env)\n", "print(f2)\n", 
#>                   "\n", "f3 <- futureOf(\"c\", envir = env)\n", 
#>                   "print(f3)\n", "\n", "fs <- futureOf(envir = env)\n", 
#>                   "print(fs)\n"), "\n"), futureSessionInfo.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/futureSessionInfo.R", 
#>                 "\n", list("futureSessionInfo"), "\n", list("futureSessionInfo"), 
#>                 "\n", list("Get session information specific to the future framework"), 
#>                 "\n", list("\n", "futureSessionInfo(test = TRUE)\n"), 
#>                 "\n", list("\n", list(list("test"), list("If TRUE, one or more futures are created to query workers\n", 
#>                   "and validate their information.")), "\n"), 
#>                 "\n", list("\n", "Nothing.\n"), "\n", list("\n", 
#>                   "Get session information specific to the future framework\n"), 
#>                 "\n"), futures.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/futures.R", 
#>                 "\n", list("futures"), "\n", list("futures"), 
#>                 "\n", list("Get all futures in a container"), 
#>                 "\n", list("\n", "futures(x, ...)\n"), "\n", 
#>                 list("\n", list(list("x"), list("An environment, a list, or a list environment.")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "An object of same type as ", 
#>                   list("x"), " and with the same names\n", "and/or dimensions, if set.\n"), 
#>                 "\n", list("\n", "Gets all futures in an environment, a list, or a list environment\n", 
#>                   "and returns an object of the same class (and dimensions).\n", 
#>                   "Non-future elements are returned as is.\n"), 
#>                 "\n", list("\n", "This function is useful for retrieve futures that were created via\n", 
#>                   "future assignments (", list("%<-%"), ") and therefore stored as promises.\n", 
#>                   "This function turns such promises into standard ", 
#>                   list("Future"), "\n", "objects.\n"), "\n"), 
#>             getExpression.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/Future-class.R", 
#>                 "\n", list("getExpression"), "\n", list("getExpression"), 
#>                 "\n", list("getExpression.Future"), "\n", list(
#>                   "Inject code for the next type of future to use for nested futures"), 
#>                 "\n", list("\n", "getExpression(future, ...)\n"), 
#>                 "\n", list("\n", list(list("future"), list("Current future.")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "A future expression with code injected to set what\n", 
#>                   "type of future to use for nested futures, iff any.\n"), 
#>                 "\n", list("\n", "Inject code for the next type of future to use for nested futures\n"), 
#>                 "\n", list("\n", "If no next future strategy is specified, the default is to\n", 
#>                   "use ", list("sequential"), " futures.  This conservative approach protects\n", 
#>                   "against spawning off recursive futures by mistake, especially\n", 
#>                   list("multicore"), " and ", list("multisession"), 
#>                   " ones.\n", "The default will also set ", list(
#>                     "options(mc.cores = 1L)"), " (*) so that\n", 
#>                   "no parallel ", list(), " processes are spawned off by functions such as\n", 
#>                   list("parallel::mclapply()"), " and friends.\n", 
#>                   "\n", "Currently it is not possible to specify what type of nested\n", 
#>                   "futures to be used, meaning the above default will always be\n", 
#>                   "used.\n", "See ", list(list("https://github.com/HenrikBengtsson/future/issues/37"), 
#>                     list("Issue #37")), "\n", "for plans on adding support for custom nested future types.\n", 
#>                   "\n", "(*) Ideally we would set ", list("mc.cores = 0"), 
#>                   " but that will unfortunately\n", "cause ", 
#>                   list("mclapply()"), " and friends to generate an error saying\n", 
#>                   "\"'mc.cores' must be >= 1\".  Ideally those functions should\n", 
#>                   "fall back to using the non-multicore alternative in this\n", 
#>                   "case, e.g. ", list("mclapply(...)"), " => ", 
#>                   list("lapply(...)"), ".\n", "See ", list("https://github.com/HenrikBengtsson/Wishlist-for-R/issues/7"), 
#>                   "\n", "for a discussion on this.\n"), "\n", 
#>                 list("internal"), "\n"), getGlobalsAndPackages.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/globals.R", 
#>                 "\n", list("getGlobalsAndPackages"), "\n", list(
#>                   "getGlobalsAndPackages"), "\n", list("Retrieves global variables of an expression and their associated packages"), 
#>                 "\n", list("\n", "getGlobalsAndPackages(\n", 
#>                   "  expr,\n", "  envir = parent.frame(),\n", 
#>                   "  tweak = tweakExpression,\n", "  globals = TRUE,\n", 
#>                   "  resolve = getOption(\"future.globals.resolve\", NULL),\n", 
#>                   "  persistent = FALSE,\n", "  maxSize = getOption(\"future.globals.maxSize\", 500 * 1024^2),\n", 
#>                   "  ...\n", ")\n"), "\n", list("\n", list(list(
#>                   "expr"), list("An ", list(), " expression whose globals should be found.")), 
#>                   "\n", "\n", list(list("envir"), list("The environment from which globals should be searched.")), 
#>                   "\n", "\n", list(list("tweak"), list("(optional) A function that takes an expression and returned a modified one.")), 
#>                   "\n", "\n", list(list("globals"), list("(optional) a logical, a character vector, a named list, or a ", 
#>                     list("Globals"), " object.  If TRUE, globals are identified by code inspection based on ", 
#>                     list("expr"), " and ", list("tweak"), " searching from environment ", 
#>                     list("envir"), ".  If FALSE, no globals are used.  If a character vector, then globals are identified by lookup based their names ", 
#>                     list("globals"), " searching from environment ", 
#>                     list("envir"), ".  If a named list or a Globals object, the globals are used as is.")), 
#>                   "\n", "\n", list(list("resolve"), list("If TRUE, any future that is a global variables (or part of one) is resolved and replaced by a \"constant\" future.")), 
#>                   "\n", "\n", list(list("persistent"), list("If TRUE, non-existing globals (= identified in expression but not found in memory) are always silently ignored and assumed to be existing in the evaluation environment.  If FALSE, non-existing globals are by default ignore, but may also trigger an informative error if option ", 
#>                     list("future.globals.onMissing"), " in ", 
#>                     list("\"error\""), " (should only be used for troubleshooting).")), 
#>                   "\n", "\n", list(list("maxSize"), list("The maximum allowed total size (in bytes) of globals - for\n", 
#>                     "the purpose of preventing too large exports / transfers happening by\n", 
#>                     "mistake.  If the total size of the global objects are greater than this\n", 
#>                     "limit, an informative error message is produced. If\n", 
#>                     list("maxSize = +Inf"), ", then this assertion is skipped. (Default: 500 MiB).")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "A named list with elements ", 
#>                   list("expr"), " (the tweaked expression), ", 
#>                   list("globals"), " (a named list of class ", 
#>                   list("FutureGlobals"), ") and ", list("packages"), 
#>                   " (a character string).\n"), "\n", list("\n", 
#>                   "Retrieves global variables of an expression and their associated packages\n"), 
#>                 "\n", list("\n", "Internally, ", list(list("globalsOf"), 
#>                   "()"), " is used to identify globals and associated packages from the expression.\n"), 
#>                 "\n", list("internal"), "\n"), `grapes-conditions-grapes.Rd` = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/conditions_OP.R", 
#>                 "\n", list("%conditions%"), "\n", list("%conditions%"), 
#>                 "\n", list("Control whether standard output should be captured or not"), 
#>                 "\n", list("\n", "fassignment %conditions% capture\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("capture"), list(
#>                   "If TRUE, the standard output will be captured, otherwise not.")), 
#>                   "\n"), "\n", list("\n", "Control whether standard output should be captured or not\n"), 
#>                 "\n"), `grapes-globals-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/globals_OP.R", 
#>                 "\n", list("%globals%"), "\n", list("%globals%"), 
#>                 "\n", list("%packages%"), "\n", list("Specify globals and packages for a future assignment"), 
#>                 "\n", list("\n", "fassignment %globals% globals\n", 
#>                   "fassignment %packages% packages\n"), "\n", 
#>                 list("\n", list(list("fassignment"), list("The future assignment, e.g.\n", 
#>                   list("x %<-% { expr }"), ".")), "\n", "\n", 
#>                   list(list("globals"), list("(optional) a logical, a character vector, or a named list\n", 
#>                     "to control how globals are handled.\n", 
#>                     "For details, see section 'Globals used by future expressions'\n", 
#>                     "in the help for ", list(list("future()")), 
#>                     ".")), "\n", "\n", list(list("packages"), 
#>                     list("(optional) a character vector specifying packages\n", 
#>                       "to be attached in the ", list(), " environment evaluating the future.")), 
#>                   "\n"), "\n", list("\n", "Specify globals and packages for a future assignment\n"), 
#>                 "\n"), `grapes-label-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/label_OP.R", 
#>                 "\n", list("%label%"), "\n", list("%label%"), 
#>                 "\n", list("Specify label for a future assignment"), 
#>                 "\n", list("\n", "fassignment %label% label\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("label"), list(
#>                   "An optional character string label attached to the future.")), 
#>                   "\n"), "\n", list("\n", "Specify label for a future assignment\n"), 
#>                 "\n"), `grapes-lazy-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/lazy_OP.R", 
#>                 "\n", list("%lazy%"), "\n", list("%lazy%"), "\n", 
#>                 list("Control lazy / eager evaluation for a future assignment"), 
#>                 "\n", list("\n", "fassignment %lazy% lazy\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("lazy"), list(
#>                   "If FALSE (default), the future is resolved\n", 
#>                   "eagerly (starting immediately), otherwise not.")), 
#>                   "\n"), "\n", list("\n", "Control lazy / eager evaluation for a future assignment\n"), 
#>                 "\n"), `grapes-plan-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/plan_OP.R", 
#>                 "\n", list("%plan%"), "\n", list("%plan%"), "\n", 
#>                 list("Use a specific plan for a future assignment"), 
#>                 "\n", list("\n", "fassignment %plan% strategy\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("strategy"), list(
#>                   "The mechanism for how the future should be\n", 
#>                   "resolved. See ", list(list("plan()")), " for further details.")), 
#>                   "\n"), "\n", list("\n", "Use a specific plan for a future assignment\n"), 
#>                 "\n", list("\n", "The ", list(list("plan()")), 
#>                   " function sets the default plan for all futures.\n"), 
#>                 "\n"), `grapes-seed-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/seed_OP.R", 
#>                 "\n", list("%seed%"), "\n", list("%seed%"), "\n", 
#>                 list("Set random seed for future assignment"), 
#>                 "\n", list("\n", "fassignment %seed% seed\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("seed"), list(
#>                   "(optional) If TRUE, the random seed, that is, the state of the\n", 
#>                   "random number generator (RNG) will be set such that statistically sound\n", 
#>                   "random numbers are produced (also during parallelization).\n", 
#>                   "If FALSE (default), it is assumed that the future expression does neither\n", 
#>                   "need nor use random numbers generation.\n", 
#>                   "To use a fixed random seed, specify a L'Ecuyer-CMRG seed (seven integer)\n", 
#>                   "or a regular RNG seed (a single integer).  If the latter, then a\n", 
#>                   "L'Ecuyer-CMRG seed will be automatically created based on the given seed.\n", 
#>                   "Furthermore, if FALSE, then the future will be monitored to make sure it\n", 
#>                   "does not use random numbers.  If it does and depending on the value of\n", 
#>                   "option ", list(list("future.rng.onMisuse")), 
#>                   ", the check is\n", "ignored, an informative warning, or error will be produced.\n", 
#>                   "If ", list("seed"), " is NULL, then the effect is as with ", 
#>                   list("seed = FALSE"), "\n", "but without the RNG check being performed.")), 
#>                   "\n"), "\n", list("\n", "Set random seed for future assignment\n"), 
#>                 "\n"), `grapes-stdout-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/stdout_OP.R", 
#>                 "\n", list("%stdout%"), "\n", list("%stdout%"), 
#>                 "\n", list("Control whether standard output should be captured or not"), 
#>                 "\n", list("\n", "fassignment %stdout% capture\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("capture"), list(
#>                   "If TRUE, the standard output will be captured, otherwise not.")), 
#>                   "\n"), "\n", list("\n", "Control whether standard output should be captured or not\n"), 
#>                 "\n"), `grapes-tweak-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/tweak_OP.R", 
#>                 "\n", list("%tweak%"), "\n", list("%tweak%"), 
#>                 "\n", list("Temporarily tweaks the arguments of the current strategy"), 
#>                 "\n", list("\n", "fassignment %tweak% tweaks\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("tweaks"), list(
#>                   "A named list (or vector) with arguments that\n", 
#>                   "should be changed relative to the current strategy.")), 
#>                   "\n"), "\n", list("\n", "Temporarily tweaks the arguments of the current strategy\n"), 
#>                 "\n"), make_rng_seeds.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/rng.R", 
#>                 "\n", list("make_rng_seeds"), "\n", list("make_rng_seeds"), 
#>                 "\n", list("Produce Reproducible Seeds for Parallel Random Number Generation"), 
#>                 "\n", list("\n", "make_rng_seeds(count, seed = FALSE, debug = getOption(\"future.debug\", FALSE))\n"), 
#>                 "\n", list("\n", list(list("count"), list("The number of RNG seeds to produce.")), 
#>                   "\n", "\n", list(list("seed"), list("A logical specifying whether RNG seeds should be generated\n", 
#>                     "or not.  (", list("seed = NULL"), " corresponds to ", 
#>                     list("seed = FALSE"), ").\n", "If a list, then it should be of length ", 
#>                     list("count"), " and each element should\n", 
#>                     "consist of a valid RNG seed.")), "\n", "\n", 
#>                   list(list("debug"), list("If ", list("TRUE"), 
#>                     ", debug output is produced, otherwise not.")), 
#>                   "\n"), "\n", list("\n", "Returns a non-named list of length ", 
#>                   list("count"), ", or ", list("NULL"), ".\n", 
#>                   "Any seed returned is a valid RNG seed.\n"), 
#>                 "\n", list("\n", "Produce Reproducible Seeds for Parallel Random Number Generation\n"), 
#>                 "\n", list("internal"), "\n"), mandelbrot.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/mandelbrot.R", 
#>                 "\n", list("mandelbrot"), "\n", list("mandelbrot"), 
#>                 "\n", list("as.raster.Mandelbrot"), "\n", list(
#>                   "plot.Mandelbrot"), "\n", list("mandelbrot_tiles"), 
#>                 "\n", list("Mandelbrot convergence counts"), 
#>                 "\n", list("\n", "mandelbrot(...)\n"), "\n", 
#>                 list("\n", list(list("Z"), list("A complex matrix for which convergence\n", 
#>                   "counts should be calculated.")), "\n", "\n", 
#>                   list(list("xmid, ymid, side, resolution"), 
#>                     list("Alternative specification of\n", "the complex plane ", 
#>                       list("Z"), ", where\n", list("mean(Re(Z)) == xmid"), 
#>                       ",\n", list("mean(Im(Z)) == ymid"), ",\n", 
#>                       list("diff(range(Re(Z))) == side"), ",\n", 
#>                       list("diff(range(Im(Z))) == side"), ", and\n", 
#>                       list("dim(Z) == c(resolution, resolution)"), 
#>                       ".")), "\n", "\n", list(list("maxIter"), 
#>                     list("Maximum number of iterations per bin.")), 
#>                   "\n", "\n", list(list("tau"), list("A threshold; the radius when calling\n", 
#>                     "divergence (Mod(z) > tau).")), "\n"), "\n", 
#>                 list("\n", "Returns an integer matrix (of class Mandelbrot) with\n", 
#>                   "non-negative counts.\n"), "\n", list("\n", 
#>                   "Mandelbrot convergence counts\n"), "\n", list(
#>                   "\n", "counts <- mandelbrot(xmid = -0.75, ymid = 0, side = 3)\n", 
#>                   "str(counts)\n", list("\n", "plot(counts)\n"), 
#>                   "\n", "\n", list("\n", "demo(\"mandelbrot\", package = \"future\", ask = FALSE)\n"), 
#>                   "\n", "\n"), "\n", list("\n", "The internal Mandelbrot algorithm was inspired by and\n", 
#>                   "adopted from similar GPL code of Martin Maechler available\n", 
#>                   "from ftp://stat.ethz.ch/U/maechler/R/ on 2005-02-18 (sic!).\n"), 
#>                 "\n", list("internal"), "\n"), multicore.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/multicore.R", 
#>                 "\n", list("multicore"), "\n", list("multicore"), 
#>                 "\n", list("Create a multicore future whose value will be resolved asynchronously in a forked parallel process"), 
#>                 "\n", list("\n", "multicore(\n", "  ...,\n", 
#>                   "  workers = availableCores(constraints = \"multicore\"),\n", 
#>                   "  envir = parent.frame()\n", ")\n"), "\n", 
#>                 list("\n", list(list("..."), list("Additional arguments passed to ", 
#>                   list(list("Future()")), ".")), "\n", "\n", 
#>                   list(list("workers"), list("A positive numeric scalar or a function specifying the\n", 
#>                     "maximum number of parallel futures that can be active at the same time\n", 
#>                     "before blocking.\n", "If a function, it is called without arguments ", 
#>                     list("when the future\n", "is created"), 
#>                     " and its value is used to configure the workers.\n", 
#>                     "The function should return a numeric scalar.")), 
#>                   "\n", "\n", list(list("envir"), list("The ", 
#>                     list("environment"), " from where global objects should be\n", 
#>                     "identified.")), "\n"), "\n", list("\n", 
#>                   "A ", list("MulticoreFuture"), "\n", "If ", 
#>                   list("workers == 1"), ", then all processing using done in the\n", 
#>                   "current/main ", list(), " session and we therefore fall back to using\n", 
#>                   "an sequential future.  This is also the case whenever multicore\n", 
#>                   "processing is not supported, e.g. on Windows.\n"), 
#>                 "\n", list("\n", "A multicore future is a future that uses multicore evaluation,\n", 
#>                   "which means that its ", list("value is computed and resolved in\n", 
#>                     "parallel in another process"), ".\n"), "\n", 
#>                 list("\n", "This function is ", list("not"), 
#>                   " meant to be called directly.  Instead, the\n", 
#>                   "typical usages are:", list(list("html"), list(
#>                     list("<div class=\"sourceCode r\">"))), list(
#>                     "# Evaluate futures in parallel on the local machine via as many forked\n", 
#>                     "# processes as available to the current R process\n", 
#>                     "plan(multicore)\n", "\n", "# Evaluate futures in parallel on the local machine via two forked processes\n", 
#>                     "plan(multicore, workers = 2)\n"), list(list(
#>                     "html"), list(list("</div>"))), "\n", "\n", 
#>                   "For the total number of cores available including the current/main\n", 
#>                   list(), " process, see ", list(list("parallelly::availableCores()")), 
#>                   ".\n", "\n", "Not all operating systems support process forking and thereby not multicore\n", 
#>                   "futures.  For instance, forking is not supported on Microsoft Windows.\n", 
#>                   "Moreover, process forking may break some R environments such as RStudio.\n", 
#>                   "Because of this, the future package disables process forking also in\n", 
#>                   "such cases.  See ", list(list("supportsMulticore()")), 
#>                   " for details.\n", "Trying to create multicore futures on non-supported systems or when\n", 
#>                   "forking is disabled will result in multicore futures falling back to\n", 
#>                   "becoming ", list("sequential"), " futures.\n"), 
#>                 "\n", list("\n", "## Use multicore futures\n", 
#>                   "plan(multicore)\n", "\n", "## A global variable\n", 
#>                   "a <- 0\n", "\n", "## Create future (explicitly)\n", 
#>                   "f <- future({\n", "  b <- 3\n", "  c <- 2\n", 
#>                   "  a * b * c\n", "})\n", "\n", "## A multicore future is evaluated in a separate forked\n", 
#>                   "## process.  Changing the value of a global variable\n", 
#>                   "## will not affect the result of the future.\n", 
#>                   "a <- 7\n", "print(a)\n", "\n", "v <- value(f)\n", 
#>                   "print(v)\n", "stopifnot(v == 0)\n"), "\n", 
#>                 list("\n", "For processing in multiple background ", 
#>                   list(), " sessions, see\n", list("multisession"), 
#>                   " futures.\n", "\n", "Use ", list(list("availableCores()")), 
#>                   " to see the total number of\n", "cores that are available for the current ", 
#>                   list(), " session.\n", "Use ", list(list("availableCores"), 
#>                     "(\"multicore\") > 1L"), " to check\n", "whether multicore futures are supported or not on the current\n", 
#>                   "system.\n"), "\n"), multiprocess.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/multiprocess.R", 
#>                 "\n", list("multiprocess"), "\n", list("multiprocess"), 
#>                 "\n", list("Create a multiprocess future whose value will be resolved asynchronously using multicore or a multisession evaluation"), 
#>                 "\n", list("\n", "multiprocess(..., workers = availableCores(), envir = parent.frame())\n"), 
#>                 "\n", list("\n", list(list(list()), list("Additional arguments passed to ", 
#>                   list(list("Future()")), ".")), "\n", "\n", 
#>                   list(list("workers"), list("A positive numeric scalar or a function specifying the\n", 
#>                     "maximum number of parallel futures that can be active at the same time\n", 
#>                     "before blocking.\n", "If a function, it is called without arguments ", 
#>                     list("when the future\n", "is created"), 
#>                     " and its value is used to configure the workers.\n", 
#>                     "The function should return a numeric scalar.")), 
#>                   "\n", "\n", list(list("envir"), list("The ", 
#>                     list("environment"), " from where global objects should be\n", 
#>                     "identified.")), "\n"), "\n", list("\n", 
#>                   "A ", list("MultiprocessFuture"), " implemented as either a\n", 
#>                   list("MulticoreFuture"), " or a ", list("MultisessionFuture"), 
#>                   ".\n"), "\n", list("\n", "A multiprocess future is a future that uses ", 
#>                   list("multicore"), " evaluation\n", "if supported, otherwise it uses ", 
#>                   list("multisession"), " evaluation.\n", "Regardless, its ", 
#>                   list("value is computed and resolved in\n", 
#>                     "parallel in another process"), ".", list(), 
#>                   "\n", list(), "\n", list("WARNING: Consider the 'multiprocess' future plan deprecated.\n", 
#>                     "Instead, explicitly specify 'multisession' or 'multicore'.  The former works\n", 
#>                     "everywhere and is the recommended one between the two. ", 
#>                     list("Forked processing"), ",\n", "which 'multicore' uses, is unstable in various environment and setups.\n", 
#>                     "The 'multiprocess' alias is therefore being phased out."), 
#>                   "\n"), "\n", list("\n", list("\n", "\n", "## Use multiprocess futures\n", 
#>                   "plan(multiprocess)\n", "\n", "## A global variable\n", 
#>                   "a <- 0\n", "\n", "## Create future (explicitly)\n", 
#>                   "f <- future({\n", "  b <- 3\n", "  c <- 2\n", 
#>                   "  a * b * c\n", "})\n", "\n", "## A multiprocess future is evaluated in a separate R process.\n", 
#>                   "## Changing the value of a global variable will not affect\n", 
#>                   "## the result of the future.\n", "a <- 7\n", 
#>                   "print(a)\n", "\n", "v <- value(f)\n", "print(v)\n", 
#>                   "stopifnot(v == 0)\n", "\n", "## Explicitly close multisession workers, if they were used\n", 
#>                   "plan(sequential)\n"), "\n"), "\n", list("\n", 
#>                   "Internally ", list(list("multicore()")), " and ", 
#>                   list(list("multisession()")), "\n", "are used.\n"), 
#>                 "\n", list("internal"), "\n"), multisession.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/multisession.R", 
#>                 "\n", list("multisession"), "\n", list("multisession"), 
#>                 "\n", list("Create a multisession future whose value will be resolved asynchronously in a parallel ", 
#>                   list(), " session"), "\n", list("\n", "multisession(\n", 
#>                   "  ...,\n", "  workers = availableCores(),\n", 
#>                   "  lazy = FALSE,\n", "  rscript_libs = .libPaths(),\n", 
#>                   "  envir = parent.frame()\n", ")\n"), "\n", 
#>                 list("\n", list(list("..."), list("Additional arguments passed to ", 
#>                   list(list("Future()")), ".")), "\n", "\n", 
#>                   list(list("workers"), list("A positive numeric scalar or a function specifying the\n", 
#>                     "maximum number of parallel futures that can be active at the same time\n", 
#>                     "before blocking.\n", "If a function, it is called without arguments ", 
#>                     list("when the future\n", "is created"), 
#>                     " and its value is used to configure the workers.\n", 
#>                     "The function should return a numeric scalar.")), 
#>                   "\n", "\n", list(list("lazy"), list("If FALSE (default), the future is resolved\n", 
#>                     "eagerly (starting immediately), otherwise not.")), 
#>                   "\n", "\n", list(list("rscript_libs"), list(
#>                     "A character vector of ", list(), " package library folders that\n", 
#>                     "the workers should use.  The default is ", 
#>                     list(".libPaths()"), " so that multisession\n", 
#>                     "workers inherits the same library path as the main ", 
#>                     list(), " session.\n", "To avoid this, use ", 
#>                     list("plan(multisession, ..., rscript_libs = NULL)"), 
#>                     ".\n", list("Important: Note that the library path is set on the workers when they are\n", 
#>                       "created, i.e. when ", list("plan(multisession)"), 
#>                       " is called.  Any changes to\n", list(".libPaths()"), 
#>                       " in the main R session after the workers have been created\n", 
#>                       "will have no effect."), "\n", "This is passed down as-is to ", 
#>                     list(list("parallelly::makeClusterPSOCK()")), 
#>                     ".")), "\n", "\n", list(list("envir"), list(
#>                     "The ", list("environment"), " from where global objects should be\n", 
#>                     "identified.")), "\n"), "\n", list("\n", 
#>                   "A ", list("MultisessionFuture"), ".\n", "If ", 
#>                   list("workers == 1"), ", then all processing using done in the\n", 
#>                   "current/main ", list(), " session and we therefore fall back to using\n", 
#>                   "a lazy future.\n"), "\n", list("\n", "A multisession future is a future that uses multisession evaluation,\n", 
#>                   "which means that its ", list("value is computed and resolved in\n", 
#>                     "parallel in another ", list(), " session"), 
#>                   ".\n"), "\n", list("\n", "This function is ", 
#>                   list("not"), " meant to be called directly.  Instead, the\n", 
#>                   "typical usages are:", list(list("html"), list(
#>                     list("<div class=\"sourceCode r\">"))), list(
#>                     "# Evaluate futures in parallel on the local machine via as many background\n", 
#>                     "# processes as available to the current R process\n", 
#>                     "plan(multisession)\n", "\n", "# Evaluate futures in parallel on the local machine via two background\n", 
#>                     "# processes\n", "plan(multisession, workers = 2)\n"), 
#>                   list(list("html"), list(list("</div>"))), "\n", 
#>                   "\n", "The background ", list(), " sessions (the \"workers\") are created using\n", 
#>                   list(list("makeClusterPSOCK()")), ".\n", "\n", 
#>                   "For the total number of\n", list(), " sessions available including the current/main ", 
#>                   list(), " process, see\n", list(list("parallelly::availableCores()")), 
#>                   ".\n", "\n", "A multisession future is a special type of cluster future.\n"), 
#>                 "\n", list("\n", list("\n", "\n", "## Use multisession futures\n", 
#>                   "plan(multisession)\n", "\n", "## A global variable\n", 
#>                   "a <- 0\n", "\n", "## Create future (explicitly)\n", 
#>                   "f <- future({\n", "  b <- 3\n", "  c <- 2\n", 
#>                   "  a * b * c\n", "})\n", "\n", "## A multisession future is evaluated in a separate R session.\n", 
#>                   "## Changing the value of a global variable will not affect\n", 
#>                   "## the result of the future.\n", "a <- 7\n", 
#>                   "print(a)\n", "\n", "v <- value(f)\n", "print(v)\n", 
#>                   "stopifnot(v == 0)\n", "\n", "## Explicitly close multisession workers by switching plan\n", 
#>                   "plan(sequential)\n"), "\n"), "\n", list("\n", 
#>                   "For processing in multiple forked ", list(), 
#>                   " sessions, see\n", list("multicore"), " futures.\n", 
#>                   "\n", "Use ", list(list("parallelly::availableCores()")), 
#>                   " to see the total number of\n", "cores that are available for the current ", 
#>                   list(), " session.\n"), "\n"), nbrOfWorkers.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/nbrOfWorkers.R", 
#>                 "\n", list("nbrOfWorkers"), "\n", list("nbrOfWorkers"), 
#>                 "\n", list("nbrOfFreeWorkers"), "\n", list("Get the number of workers available"), 
#>                 "\n", list("\n", "nbrOfWorkers(evaluator = NULL)\n", 
#>                   "\n", "nbrOfFreeWorkers(evaluator = NULL, background = FALSE, ...)\n"), 
#>                 "\n", list("\n", list(list("evaluator"), list(
#>                   "A future evaluator function.\n", "If NULL (default), the current evaluator as returned\n", 
#>                   "by ", list(list("plan()")), " is used.")), 
#>                   "\n", "\n", list(list("background"), list("If TRUE, only workers that can process a future in the\n", 
#>                     "background are considered.  If FALSE, also workers running in the main ", 
#>                     list(), "\n", "process are considered, e.g. when using the 'sequential' backend.")), 
#>                   "\n", "\n", list(list(list()), list("Not used; reserved for future use.")), 
#>                   "\n"), "\n", list("\n", list("nbrOfWorkers()"), 
#>                   " returns a positive number in ", list(list(
#>                     "{1, 2, 3, ...}")), ", which\n", "for some future backends may also be ", 
#>                   list("+Inf"), ".\n", "\n", list("nbrOfFreeWorkers()"), 
#>                   " returns a non-negative number in\n", list(
#>                     list("{0, 1, 2, 3, ...}")), " which is less than or equal to ", 
#>                   list("nbrOfWorkers()"), ".\n"), "\n", list(
#>                   "\n", "Get the number of workers available\n"), 
#>                 "\n", list("\n", "plan(multisession)\n", "nbrOfWorkers()  ## == availableCores()\n", 
#>                   "\n", "plan(sequential)\n", "nbrOfWorkers()  ## == 1\n"), 
#>                 "\n"), nullcon.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/utils.R", 
#>                 "\n", list("nullcon"), "\n", list("nullcon"), 
#>                 "\n", list("Creates a connection to the system null device"), 
#>                 "\n", list("\n", "nullcon()\n"), "\n", list("\n", 
#>                   "Returns a open, binary ", list(list("base::connection()")), 
#>                   ".\n"), "\n", list("\n", "Creates a connection to the system null device\n"), 
#>                 "\n", list("internal"), "\n"), pid_exists.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/utils.R", 
#>                 "\n", list("pid_exists"), "\n", list("pid_exists"), 
#>                 "\n", list("Check whether a process PID exists or not"), 
#>                 "\n", list("\n", "pid_exists(pid, debug = getOption(\"future.debug\", FALSE))\n"), 
#>                 "\n", list("\n", list(list("pid"), list("A positive integer.")), 
#>                   "\n"), "\n", list("\n", "Returns ", list("TRUE"), 
#>                   " if a process with the given PID exists,\n", 
#>                   list("FALSE"), " if a process with the given PID does not exists, and\n", 
#>                   list("NA"), " if it is not possible to check PIDs on the current system.\n"), 
#>                 "\n", list("\n", "Check whether a process PID exists or not\n"), 
#>                 "\n", list("\n", "There is no single go-to function in ", 
#>                   list(), " for testing whether a PID exists\n", 
#>                   "or not.  Instead, this function tries to identify a working one among\n", 
#>                   "multiple possible alternatives.  A method is considered working if the\n", 
#>                   "PID of the current process is successfully identified as being existing\n", 
#>                   "such that ", list("pid_exists(Sys.getpid())"), 
#>                   " is ", list("TRUE"), ".  If no working\n", 
#>                   "approach is found, ", list("pid_exists()"), 
#>                   " will always return ", list("NA"), "\n", "regardless of PID tested.\n", 
#>                   "On Unix, including macOS, alternatives ", 
#>                   list("tools::pskill(pid, signal = 0L)"), "\n", 
#>                   "and ", list("system2(\"ps\", args = pid)"), 
#>                   " are used.\n", "On Windows, various alternatives of ", 
#>                   list("system2(\"tasklist\", ...)"), " are used.\n"), 
#>                 "\n", list("\n", list("\n", list(), " The Open Group Base Specifications Issue 7, 2018 edition,\n", 
#>                   "IEEE Std 1003.1-2017 (Revision of IEEE Std 1003.1-2008)\n", 
#>                   list("https://pubs.opengroup.org/onlinepubs/9699919799/functions/kill.html"), 
#>                   "\n", list(), " Microsoft, tasklist, 2018-08-30,\n", 
#>                   list("https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/tasklist"), 
#>                   "\n", list(), " R-devel thread 'Detecting whether a process exists or not by its PID?',\n", 
#>                   "2018-08-30.\n", list("https://stat.ethz.ch/pipermail/r-devel/2018-August/076702.html"), 
#>                   "\n"), "\n"), "\n", list("\n", list(list("pskill"), 
#>                   "()"), " and ", list(list("system2"), "()"), 
#>                   ".\n"), "\n", list("internal"), "\n"), plan.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/zzz.plan.R", 
#>                 "\n", list("plan"), "\n", list("plan"), "\n", 
#>                 list("Plan how to resolve a future"), "\n", list(
#>                   "\n", "plan(\n", "  strategy = NULL,\n", "  ...,\n", 
#>                   "  substitute = TRUE,\n", "  .skip = FALSE,\n", 
#>                   "  .call = TRUE,\n", "  .cleanup = TRUE,\n", 
#>                   "  .init = TRUE\n", ")\n"), "\n", list("\n", 
#>                   list(list("strategy"), list("The evaluation function (or name of it) to use\n", 
#>                     "for resolving a future.  If NULL, then the current strategy is returned.")), 
#>                   "\n", "\n", list(list(list()), list("Additional arguments overriding the default arguments\n", 
#>                     "of the evaluation function.  Which additional arguments are supported\n", 
#>                     "depends on what evaluation function is used, e.g. several support\n", 
#>                     "argument ", list("workers"), " but not all.  For details, see the individual\n", 
#>                     "functions of which some are linked to below.")), 
#>                   "\n", "\n", list(list("substitute"), list("If TRUE, the ", 
#>                     list("strategy"), " expression is\n", list(
#>                       "substitute()"), ":d, otherwise not.")), 
#>                   "\n", "\n", list(list(".skip"), list("(internal) If ", 
#>                     list("TRUE"), ", then attempts to set a strategy\n", 
#>                     "that is the same as what is currently in use, will skipped.")), 
#>                   "\n", "\n", list(list(".call"), list("(internal) Used for recording the call to this function.")), 
#>                   "\n", "\n", list(list(".cleanup"), list("(internal) Used to stop implicitly started clusters.")), 
#>                   "\n", "\n", list(list(".init"), list("(internal) Used to initiate workers.")), 
#>                   "\n"), "\n", list("\n", "If a new strategy is chosen, then the previous one is returned\n", 
#>                   "(invisible), otherwise the current one is returned (visibly).\n"), 
#>                 "\n", list("\n", "This function allows ", list(
#>                   "the user"), " to plan the future, more specifically,\n", 
#>                   "it specifies how ", list(list("future()")), 
#>                   ":s are resolved,\n", "e.g. sequentially or in parallel.\n"), 
#>                 "\n", list("\n", "The default strategy is ", 
#>                   list(list("sequential")), ", but the default can be\n", 
#>                   "configured by option ", list("future.plan"), 
#>                   " and, if that is not set,\n", "system environment variable ", 
#>                   list("R_FUTURE_PLAN"), ".\n", "To reset the strategy back to the default, use ", 
#>                   list("plan(\"default\")"), ".\n"), "\n", list(
#>                   list("Implemented evaluation strategies"), 
#>                   list("\n", "\n", list("\n", list(), list(list(
#>                     list("sequential")), ":"), list("\n", "Resolves futures sequentially in the current ", 
#>                     list(), " process.\n"), "\n", list(), list(
#>                     list(list("multisession")), ":"), list("\n", 
#>                     "Resolves futures asynchronously (in parallel) in separate\n", 
#>                     list(), " sessions running in the background on the same machine.\n"), 
#>                     "\n", list(), list(list(list("multicore")), 
#>                       ":"), list("\n", "Resolves futures asynchronously (in parallel) in separate\n", 
#>                       list("forked"), " ", list(), " processes running in the background on\n", 
#>                       "the same machine.  Not supported on Windows.\n"), 
#>                     "\n", list(), list(list(list("multiprocess")), 
#>                       ":"), list("(DEPRECATED)\n", "If multicore evaluation is supported, that will be used,\n", 
#>                       "otherwise multisession evaluation will be used.\n"), 
#>                     "\n", list(), list(list(list("cluster")), 
#>                       ":"), list("\n", "Resolves futures asynchronously (in parallel) in separate\n", 
#>                       list(), " sessions running typically on one or more machines.\n"), 
#>                     "\n", list(), list(list(list("remote")), 
#>                       ":"), list("\n", "Resolves futures asynchronously in a separate ", 
#>                       list(), " session\n", "running on a separate machine, typically on a different\n", 
#>                       "network.\n"), "\n"), "\n", "\n", "Other package may provide additional evaluation strategies.\n", 
#>                     "Notably, the ", list("future.batchtools"), 
#>                     " package implements a\n", "type of futures that will be resolved via job schedulers\n", 
#>                     "that are typically available on high-performance compute\n", 
#>                     "(HPC) clusters, e.g. LSF, Slurm, TORQUE/PBS, Sun Grid Engine,\n", 
#>                     "and OpenLava.\n", "\n", "To \"close\" any background workers (e.g. ", 
#>                     list("multisession"), "), change\n", "the plan to something different; ", 
#>                     list("plan(sequential)"), " is recommended\n", 
#>                     "for this.\n")), "\n", "\n", list(list("For package developers"), 
#>                   list("\n", "\n", "Please refrain from modifying the future strategy inside your packages /\n", 
#>                     "functions, i.e. do not call ", list("plan()"), 
#>                     " in your code.  Instead, leave\n", "the control on what backend to use to the end user.  This idea is part of\n", 
#>                     "the core philosophy of the future framework - as a developer you can never\n", 
#>                     "know what future backends the user have access to.  Moreover, by not making\n", 
#>                     "any assumptions about what backends are available, your code will also work\n", 
#>                     "automatically with any new backends developed after you wrote your code.\n", 
#>                     "\n", "If you think it is necessary to modify the future strategy within a\n", 
#>                     "function, then make sure to undo the changes when exiting the function.\n", 
#>                     "This can be done using:\n", "\n", list("\n", 
#>                       "  oplan <- plan(new_set_of_strategies)\n", 
#>                       "  on.exit(plan(oplan), add = TRUE)\n", 
#>                       "  [...]\n"), "\n", "\n", "This is important because the end-user might have already set the future\n", 
#>                     "strategy elsewhere for other purposes and will most likely not known that\n", 
#>                     "calling your function will break their setup.\n", 
#>                     list("Remember, your package and its functions might be used in a greater\n", 
#>                       "context where multiple packages and functions are involved and those might\n", 
#>                       "also rely on the future framework, so it is important to avoid stepping on\n", 
#>                       "others' toes."), "\n")), "\n", "\n", list(
#>                   list("Using plan() in scripts and vignettes"), 
#>                   list("\n", "\n", "When writing scripts or vignettes that uses futures, try to place any\n", 
#>                     "call to ", list("plan()"), " as far up (as early on) in the code as possible.\n", 
#>                     "This will help users to quickly identify where the future plan is set up\n", 
#>                     "and allow them to modify it to their computational resources.\n", 
#>                     "Even better is to leave it to the user to set the ", 
#>                     list("plan()"), " prior to\n", list("source()"), 
#>                     ":ing the script or running the vignette.\n", 
#>                     "If a ", list(list(".future.R")), " exists in the current directory and / or in\n", 
#>                     "the user's home directory, it is sourced when the ", 
#>                     list("future"), " package is\n", list("loaded"), 
#>                     ".  Because of this, the ", list(".future.R"), 
#>                     " file provides a\n", "convenient place for users to set the ", 
#>                     list("plan()"), ".\n", "This behavior can be controlled via an ", 
#>                     list(), " option - see\n", list("future options"), 
#>                     " for more details.\n")), "\n", "\n", list(
#>                   "\n", "a <- b <- c <- NA_real_\n", "\n", "# An sequential future\n", 
#>                   "plan(sequential)\n", "f <- future({\n", "  a <- 7\n", 
#>                   "  b <- 3\n", "  c <- 2\n", "  a * b * c\n", 
#>                   "})\n", "y <- value(f)\n", "print(y)\n", "str(list(a = a, b = b, c = c)) ## All NAs\n", 
#>                   "\n", "\n", "# A sequential future with lazy evaluation\n", 
#>                   "plan(sequential)\n", "f <- future({\n", "  a <- 7\n", 
#>                   "  b <- 3\n", "  c <- 2\n", "  a * b * c\n", 
#>                   "}, lazy = TRUE)\n", "y <- value(f)\n", "print(y)\n", 
#>                   "str(list(a = a, b = b, c = c)) ## All NAs\n", 
#>                   "\n", "\n", "# A multicore future (specified as a string)\n", 
#>                   "plan(\"multicore\")\n", "f <- future({\n", 
#>                   "  a <- 7\n", "  b <- 3\n", "  c <- 2\n", "  a * b * c\n", 
#>                   "})\n", "y <- value(f)\n", "print(y)\n", "str(list(a = a, b = b, c = c)) ## All NAs\n", 
#>                   "\n", "\n", "## Multisession futures gives an error on R CMD check on\n", 
#>                   "## Windows (but not Linux or macOS) for unknown reasons.\n", 
#>                   "## The same code works in package tests.\n", 
#>                   list("\n", "\n", "# A multisession future (specified via a string variable)\n", 
#>                     "plan(\"future::multisession\")\n", "f <- future({\n", 
#>                     "  a <- 7\n", "  b <- 3\n", "  c <- 2\n", 
#>                     "  a * b * c\n", "})\n", "y <- value(f)\n", 
#>                     "print(y)\n", "str(list(a = a, b = b, c = c)) ## All NAs\n", 
#>                     "\n"), "\n", "\n", "## Explicitly close multisession workers by switching plan\n", 
#>                   "plan(sequential)\n"), "\n"), private_length.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/utils.R", 
#>                 "\n", list(".length"), "\n", list(".length"), 
#>                 "\n", list("Gets the length of an object without dispatching"), 
#>                 "\n", list("\n", ".length(x)\n"), "\n", list(
#>                   "\n", list(list("x"), list("Any ", list(), 
#>                     " object.")), "\n"), "\n", list("\n", "A non-negative integer.\n"), 
#>                 "\n", list("\n", "Gets the length of an object without dispatching\n"), 
#>                 "\n", list("\n", "This function returns ", list(
#>                   "length(unclass(x))"), ", but tries to avoid\n", 
#>                   "calling ", list("unclass(x)"), " unless necessary.\n"), 
#>                 "\n", list("\n", list(list(".subset"), "()"), 
#>                   " and ", list(list(".subset2"), "()"), ".\n"), 
#>                 "\n", list("internal"), "\n"), `re-exports.Rd` = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/000.re-exports.R", 
#>                 "\n", list("re-exports"), "\n", list("re-exports"), 
#>                 "\n", list("as.cluster"), "\n", list("autoStopCluster"), 
#>                 "\n", list("availableCores"), "\n", list("availableWorkers"), 
#>                 "\n", list("makeClusterMPI"), "\n", list("makeClusterPSOCK"), 
#>                 "\n", list("makeNodePSOCK"), "\n", list("supportsMulticore"), 
#>                 "\n", list("Functions Moved to 'parallelly'"), 
#>                 "\n", list("\n", "The following function used to be part of ", 
#>                   list("future"), " but has since\n", "been migrated to ", 
#>                   list("parallelly"), ".  The migration started with\n", 
#>                   list("future"), " 1.20.0 (November 2020).  They were moved because they\n", 
#>                   "are also useful outside of the ", list("future"), 
#>                   " framework.\n"), "\n", list("\n", list("\n", 
#>                   list(), " ", list(list("parallelly::as.cluster()")), 
#>                   "\n", list(), " ", list(list("parallelly::autoStopCluster()")), 
#>                   "\n", list(), " ", list(list("parallelly::availableCores()")), 
#>                   "\n", list(), " ", list(list("parallelly::availableWorkers()")), 
#>                   "\n", list(), " ", list(list("parallelly::makeClusterMPI()")), 
#>                   "\n", list(), " ", list(list("parallelly::makeClusterPSOCK()")), 
#>                   "\n", list(), " ", list(list("parallelly::makeNodePSOCK()")), 
#>                   "\n", list(), " ", list(list("parallelly::supportsMulticore()")), 
#>                   "\n"), "\n", "\n", "For backward-compatible reasons, these functions remain available as\n", 
#>                   "exact copies also from this package (as re-exports).  For example,", 
#>                   list(list("html"), list(list("<div class=\"sourceCode r\">"))), 
#>                   list("cl <- parallelly::makeClusterPSOCK(2)\n"), 
#>                   list(list("html"), list(list("</div>"))), "\n", 
#>                   "\n", "can still be accessed as:", list(list(
#>                     "html"), list(list("<div class=\"sourceCode r\">"))), 
#>                   list("cl <- future::makeClusterPSOCK(2)\n"), 
#>                   list(list("html"), list(list("</div>"))), "\n"), 
#>                 "\n"), readImmediateConditions.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/utils-immediateCondition.R", 
#>                 "\n", list("readImmediateConditions"), "\n", 
#>                 list("readImmediateConditions"), "\n", list("Read All 'immediateCondition' RDS Files"), 
#>                 "\n", list("\n", "readImmediateConditions(\n", 
#>                   "  path = immediateConditionsPath(),\n", "  pattern = \"[.]rds$\",\n", 
#>                   "  include = getOption(\"future.relay.immediate\", \"immediateCondition\"),\n", 
#>                   "  signal = FALSE,\n", "  remove = TRUE\n", 
#>                   ")\n"), "\n", list("\n", list(list("path"), 
#>                   list("(character string) The folder where the RDS files are.")), 
#>                   "\n", "\n", list(list("pattern"), list("(character string) A regular expression selecting\n", 
#>                     "the RDS files to be read.")), "\n", "\n", 
#>                   list(list("include"), list("(character vector) The class or classes of the objects\n", 
#>                     "to be kept.")), "\n", "\n", list(list("signal"), 
#>                     list("(logical) If TRUE, the condition read are signaled.")), 
#>                   "\n", "\n", list(list("remove"), list("(logical) If TRUE, the RDS files used are removed on exit.")), 
#>                   "\n"), "\n", list("\n", "Returns a ", list(
#>                   "base::list"), " of immediateCondition objects.\n"), 
#>                 "\n", list("\n", "Read All 'immediateCondition' RDS Files\n"), 
#>                 "\n", list("internal"), "\n"), remote.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/remote.R", 
#>                 "\n", list("remote"), "\n", list("remote"), "\n", 
#>                 list("Create a remote future whose value will be resolved asynchronously in a remote process"), 
#>                 "\n", list("\n", "remote(\n", "  ...,\n", "  workers = NULL,\n", 
#>                   "  revtunnel = TRUE,\n", "  myip = NULL,\n", 
#>                   "  persistent = TRUE,\n", "  homogeneous = TRUE,\n", 
#>                   "  envir = parent.frame()\n", ")\n"), "\n", 
#>                 list("\n", list(list("..."), list("Additional named elements passed to ", 
#>                   list(list("Future()")), ".")), "\n", "\n", 
#>                   list(list("workers"), list("A ", list(list(
#>                     "cluster")), " object,\n", "a character vector of host names, a positive numeric scalar,\n", 
#>                     "or a function.\n", "If a character vector or a numeric scalar, a ", 
#>                     list("cluster"), " object\n", "is created using ", 
#>                     list(list("makeClusterPSOCK"), "(workers)"), 
#>                     ".\n", "If a function, it is called without arguments ", 
#>                     list("when the future\n", "is created"), 
#>                     " and its value is used to configure the workers.\n", 
#>                     "The function should return any of the above types.")), 
#>                   "\n", "\n", list(list("revtunnel"), list("If TRUE, reverse SSH tunneling is used for the\n", 
#>                     "PSOCK cluster nodes to connect back to the master ", 
#>                     list(), " process.  This\n", "avoids the hassle of firewalls, port forwarding and having to know\n", 
#>                     "the internal / public IP address of the master ", 
#>                     list(), " session.")), "\n", "\n", list(list(
#>                     "myip"), list("The external IP address of this machine.\n", 
#>                     "If NULL, then it is inferred using an online service (default).")), 
#>                   "\n", "\n", list(list("persistent"), list("If FALSE, the evaluation environment is cleared\n", 
#>                     "from objects prior to the evaluation of the future.")), 
#>                   "\n", "\n", list(list("homogeneous"), list(
#>                     "If TRUE, all cluster nodes is assumed to use the\n", 
#>                     "same path to ", list("Rscript"), " as the main ", 
#>                     list(), " session.  If FALSE, the\n", "it is assumed to be on the PATH for each node.\n", 
#>                     "If NULL, then ", list(list("parallelly::makeClusterPSOCK()")), 
#>                     " will decide on TRUE\n", "or FALSE depending on ", 
#>                     list("workers"), ".")), "\n", "\n", list(
#>                     list("envir"), list("The ", list("environment"), 
#>                       " from where global objects should be\n", 
#>                       "identified.")), "\n"), "\n", list("\n", 
#>                   "A ", list("ClusterFuture"), ".\n"), "\n", 
#>                 list("\n", "A remote future is a future that uses remote cluster evaluation,\n", 
#>                   "which means that its ", list("value is computed and resolved\n", 
#>                     "remotely in another process"), ".\n"), "\n", 
#>                 list("\n", "This function is ", list("not"), 
#>                   " meant to be called directly.  Instead, the\n", 
#>                   "typical usages are:", list(list("html"), list(
#>                     list("<div class=\"sourceCode r\">"))), list(
#>                     "# Evaluate futures on remote machine 'server.example.org', and\n", 
#>                     "# any nested ones sequentially (default) on that remote machine\n", 
#>                     "plan(remote, workers = \"server.example.org\")\n", 
#>                     "\n", "# Evaluate futures on remote machine 'server.example.org', and\n", 
#>                     "# nested ones in parallel on that remote machine\n", 
#>                     "plan(list(\n", "   tweak(remote, workers = \"server.example.org\"),\n", 
#>                     "   multisession\n", "))\n", "\n", "# Evaluate futures on remote machine 'server.example.org', and\n", 
#>                     "# nested ones in parallel on the remote machines n1, n2, and n3.\n", 
#>                     "plan(list(\n", "  tweak(remote, workers = \"server.example.org\"),\n", 
#>                     "  tweak(cluster, workers = c(\"n1\", \"n2\", \"n3\"))\n", 
#>                     "))\n"), list(list("html"), list(list("</div>"))), 
#>                   "\n"), "\n", list(list("'remote' versus 'cluster'"), 
#>                   list("\n", "\n", "The ", list("remote"), " plan is a very similar to the ", 
#>                     list(list("cluster")), " plan, but provides\n", 
#>                     "more convenient default argument values when connecting to remote machines.  #' Specifically, ", 
#>                     list("remote"), " uses ", list("persistent = TRUE"), 
#>                     " by default, and it sets\n", list("homogeneous"), 
#>                     ", ", list("revtunnel"), ", and ", list("myip"), 
#>                     " \"wisely\" depending on the value of\n", 
#>                     list("workers"), ".\n", "' See below for example on how ", 
#>                     list("remote"), " and ", list("cluster"), 
#>                     " are related.\n")), "\n", "\n", list("\n", 
#>                   list("\\donttest{\n", "\n", "## Use a remote machine\n", 
#>                     "plan(remote, workers = \"remote.server.org\")\n", 
#>                     "\n", "## Evaluate expression remotely\n", 
#>                     "host %<-% { Sys.info()[[\"nodename\"]] }\n", 
#>                     "host\n", "[1] \"remote.server.org\"\n", 
#>                     "\n", "\n", "## The following setups are equivalent:\n", 
#>                     "plan(remote, workers = \"localhost\")\n", 
#>                     "plan(cluster, workers = \"localhost\", persistent = TRUE)\n", 
#>                     "plan(cluster, workers = 1, persistent = TRUE)\n", 
#>                     "plan(multisession, workers = 1, persistent = TRUE)\n", 
#>                     "\n", "## The following setups are equivalent:\n", 
#>                     "plan(remote, workers = \"remote.server.org\")\n", 
#>                     "plan(cluster, workers = \"remote.server.org\", persistent = TRUE, homogeneous = FALSE)\n", 
#>                     "\n", "## The following setups are equivalent:\n", 
#>                     "cl <- makeClusterPSOCK(\"remote.server.org\")\n", 
#>                     "plan(remote, workers = cl)\n", "plan(cluster, workers = cl, persistent = TRUE)\n", 
#>                     "\n", "}"), "\n"), "\n"), requestCore.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/multicore.R", 
#>                 "\n", list("requestCore"), "\n", list("requestCore"), 
#>                 "\n", list("Request a core for multicore processing"), 
#>                 "\n", list("\n", "requestCore(\n", "  await,\n", 
#>                   "  workers = availableCores(),\n", "  timeout = getOption(\"future.wait.timeout\", 30 * 24 * 60 * 60),\n", 
#>                   "  delta = getOption(\"future.wait.interval\", 0.2),\n", 
#>                   "  alpha = getOption(\"future.wait.alpha\", 1.01)\n", 
#>                   ")\n"), "\n", list("\n", list(list("await"), 
#>                   list("A function used to try to \"collect\"\n", 
#>                     "finished multicore subprocesses.")), "\n", 
#>                   "\n", list(list("workers"), list("Total number of workers available.")), 
#>                   "\n", "\n", list(list("timeout"), list("Maximum waiting time (in seconds) allowed\n", 
#>                     "before a timeout error is generated.")), 
#>                   "\n", "\n", list(list("delta"), list("Then base interval (in seconds) to wait\n", 
#>                     "between each try.")), "\n", "\n", list(list(
#>                     "alpha"), list("A multiplicative factor used to increase\n", 
#>                     "the wait interval after each try.")), "\n"), 
#>                 "\n", list("\n", "Invisible TRUE. If no cores are available after\n", 
#>                   "extensive waiting, then a timeout error is thrown.\n"), 
#>                 "\n", list("\n", "If no cores are available, the current process\n", 
#>                   "blocks until a core is available.\n"), "\n", 
#>                 list("internal"), "\n"), resetWorkers.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/zzz.plan.R", 
#>                 "\n", list("resetWorkers"), "\n", list("resetWorkers"), 
#>                 "\n", list("Free up active background workers"), 
#>                 "\n", list("\n", "resetWorkers(x, ...)\n"), "\n", 
#>                 list("\n", list(list("x"), list("A FutureStrategy.")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "Free up active background workers\n"), 
#>                 "\n", list("\n", "This function will resolve any active futures that is currently\n", 
#>                   "being evaluated on background workers.\n"), 
#>                 "\n", list("\n", "resetWorkers(plan())\n", "\n"), 
#>                 "\n", list("internal"), "\n"), resolve.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/resolve.R", 
#>                 "\n", list("resolve"), "\n", list("resolve"), 
#>                 "\n", list("Resolve one or more futures synchronously"), 
#>                 "\n", list("\n", "resolve(\n", "  x,\n", "  idxs = NULL,\n", 
#>                   "  recursive = 0,\n", "  result = FALSE,\n", 
#>                   "  stdout = FALSE,\n", "  signal = FALSE,\n", 
#>                   "  force = FALSE,\n", "  sleep = 1,\n", "  value = result,\n", 
#>                   "  ...\n", ")\n"), "\n", list("\n", list(list(
#>                   "x"), list("A ", list("Future"), " to be resolved, or a list, an environment, or a\n", 
#>                   "list environment of futures to be resolved.")), 
#>                   "\n", "\n", list(list("idxs"), list("(optional) integer or logical index specifying the subset of\n", 
#>                     "elements to check.")), "\n", "\n", list(
#>                     list("recursive"), list("A non-negative number specifying how deep of a recursion\n", 
#>                       "should be done.  If TRUE, an infinite recursion is used.  If FALSE or zero,\n", 
#>                       "no recursion is performed.")), "\n", "\n", 
#>                   list(list("result"), list("(internal) If TRUE, the results are retrieved, otherwise not.")), 
#>                   "\n", "\n", list(list("stdout"), list("(internal) If TRUE, captured standard output is relayed, otherwise note.")), 
#>                   "\n", "\n", list(list("signal"), list("(internal) If TRUE, captured ", 
#>                     list("conditions"), " are relayed,\n", "otherwise not.")), 
#>                   "\n", "\n", list(list("force"), list("(internal) If TRUE, captured standard output and captured\n", 
#>                     list("conditions"), " already relayed is relayed again, otherwise not.")), 
#>                   "\n", "\n", list(list("sleep"), list("Number of seconds to wait before checking if futures have been\n", 
#>                     "resolved since last time.")), "\n", "\n", 
#>                   list(list("value"), list("(DEFUNCT) Use argument ", 
#>                     list("result"), " instead.")), "\n", "\n", 
#>                   list(list(list()), list("Not used.")), "\n"), 
#>                 "\n", list("\n", "Returns ", list("x"), " (regardless of subsetting or not).\n", 
#>                   "If ", list("signal"), " is TRUE and one of the futures produces an error, then\n", 
#>                   "that error is produced.\n"), "\n", list("\n", 
#>                   "This function provides an efficient mechanism for waiting for multiple\n", 
#>                   "futures in a container (e.g. list or environment) to be resolved while in\n", 
#>                   "the meanwhile retrieving values of already resolved futures.\n"), 
#>                 "\n", list("\n", "This function is resolves synchronously, i.e. it blocks until ", 
#>                   list("x"), " and\n", "any containing futures are resolved.\n"), 
#>                 "\n", list("\n", "To resolve a future ", list(
#>                   "variable"), ", first retrieve its\n", list(
#>                   "Future"), " object using ", list(list("futureOf()")), 
#>                   ", e.g.\n", list("resolve(futureOf(x))"), ".\n"), 
#>                 "\n"), resolved.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/resolved.R", 
#>                 "\n", list("resolved"), "\n", list("resolved"), 
#>                 "\n", list("Check whether a future is resolved or not"), 
#>                 "\n", list("\n", "resolved(x, ...)\n"), "\n", 
#>                 list("\n", list(list("x"), list("A ", list("Future"), 
#>                   ", a list, or an environment (which also\n", 
#>                   "includes ", list("list environment"), ".")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "A logical of the same length and dimensions as ", 
#>                   list("x"), ".\n", "Each element is TRUE unless the corresponding element is a\n", 
#>                   "non-resolved future in case it is FALSE.\n"), 
#>                 "\n", list("\n", "Check whether a future is resolved or not\n"), 
#>                 "\n", list("\n", "This method needs to be implemented by the class that implement\n", 
#>                   "the Future API.  The implementation should return either TRUE or FALSE\n", 
#>                   "and must never throw an error (except for ", 
#>                   list("FutureError"), ":s which indicate\n", 
#>                   "significant, often unrecoverable infrastructure problems).\n", 
#>                   "It should also be possible to use the method for polling the\n", 
#>                   "future until it is resolved (without having to wait infinitely long),\n", 
#>                   "e.g. ", list("while (!resolved(future)) Sys.sleep(5)"), 
#>                   ".\n"), "\n"), result.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/Future-class.R", 
#>                 "\n", list("result.Future"), "\n", list("result.Future"), 
#>                 "\n", list("result"), "\n", list("Get the results of a resolved future"), 
#>                 "\n", list("\n", list(list("result"), list("Future")), 
#>                   "(future, ...)\n"), "\n", list("\n", list(list(
#>                   "future"), list("A ", list("Future"), ".")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "The ", list("FutureResult"), 
#>                   " object.\n"), "\n", list("\n", "Get the results of a resolved future\n"), 
#>                 "\n", list("\n", "This function is only part of the ", 
#>                   list("backend"), " Future API.\n", "This function is ", 
#>                   list("not"), " part of the frontend Future API.\n"), 
#>                 "\n", list("internal"), "\n"), run.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/Future-class.R", 
#>                 "\n", list("run.Future"), "\n", list("run.Future"), 
#>                 "\n", list("run"), "\n", list("Run a future"), 
#>                 "\n", list("\n", list(list("run"), list("Future")), 
#>                   "(future, ...)\n"), "\n", list("\n", list(list(
#>                   "future"), list("A ", list("Future"), ".")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "The ", list("Future"), 
#>                   " object.\n"), "\n", list("\n", "Run a future\n"), 
#>                 "\n", list("\n", "This function can only be called once per future.\n", 
#>                   "Further calls will result in an informative error.\n", 
#>                   "If a future is not run when its value is queried,\n", 
#>                   "then it is run at that point.\n"), "\n", list(
#>                   "internal"), "\n"), save_rds.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/utils-immediateCondition.R", 
#>                 "\n", list("save_rds"), "\n", list("save_rds"), 
#>                 "\n", list("Robustly Saves an Object to RDS File Atomically"), 
#>                 "\n", list("\n", "save_rds(object, pathname, ...)\n"), 
#>                 "\n", list("\n", list(list("object"), list("The ", 
#>                   list(), " object to be save.")), "\n", "\n", 
#>                   list(list("pathname"), list("RDS file to written.")), 
#>                   "\n", "\n", list(list(list()), list("(optional) Additional arguments passed to ", 
#>                     list(list("base::saveRDS()")), ".")), "\n"), 
#>                 "\n", list("\n", "(invisible) The pathname of the RDS written.\n"), 
#>                 "\n", list("\n", "Robustly Saves an Object to RDS File Atomically\n"), 
#>                 "\n", list("\n", "Uses ", list("base::saveRDS"), 
#>                   " internally but writes the object atomically by first\n", 
#>                   "writing to a temporary file which is then renamed.\n"), 
#>                 "\n", list("internal"), "\n"), sequential.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/sequential.R", 
#>                 "\n", list("sequential"), "\n", list("sequential"), 
#>                 "\n", list("uniprocess"), "\n", list("transparent"), 
#>                 "\n", list("Create a sequential future whose value will be in the current ", 
#>                   list(), " session"), "\n", list("\n", "sequential(..., envir = parent.frame())\n", 
#>                   "\n", "transparent(..., envir = parent.frame())\n"), 
#>                 "\n", list("\n", list(list("..."), list("Additional arguments passed to ", 
#>                   list(list("Future()")), ".")), "\n", "\n", 
#>                   list(list("envir"), list("The ", list("environment"), 
#>                     " from where global objects should be\n", 
#>                     "identified.")), "\n"), "\n", list("\n", 
#>                   "A ", list("SequentialFuture"), ".\n"), "\n", 
#>                 list("\n", "A sequential future is a future that is evaluated sequentially in the\n", 
#>                   "current ", list(), " session similarly to how ", 
#>                   list(), " expressions are evaluated in ", list(), 
#>                   ".\n", "The only difference to ", list(), " itself is that globals are validated\n", 
#>                   "by default just as for all other types of futures in this package.\n"), 
#>                 "\n", list("\n", "This function is ", list("not"), 
#>                   " meant to be called directly.  Instead, the\n", 
#>                   "typical usages are:", list(list("html"), list(
#>                     list("<div class=\"sourceCode r\">"))), list(
#>                     "# Evaluate futures sequentially in the current R process\n", 
#>                     "plan(sequential)\n"), list(list("html"), 
#>                     list(list("</div>"))), "\n", "\n", "\n"), 
#>                 "\n", list(list("transparent futures (troubleshooting only)"), 
#>                   list("\n", "\n", "Transparent futures are sequential futures configured to emulate how R\n", 
#>                     "evaluates expressions as far as possible.  For instance, errors and\n", 
#>                     "warnings are signaled immediately and assignments are done to the\n", 
#>                     "calling environment (without ", list("local()"), 
#>                     " as default for all other\n", "types of futures).  This makes transparent futures useful for\n", 
#>                     "troubleshooting, especially when there are errors.  Having said that,\n", 
#>                     "using:", list(list("html"), list(list("<div class=\"sourceCode r\">"))), 
#>                     list("plan(sequential, split = TRUE)\n"), 
#>                     list(list("html"), list(list("</div>"))), 
#>                     "\n", "\n", "together with ", list("debug()"), 
#>                     " is often sufficient for troubleshooting.\n", 
#>                     "\n", list("WARNING: Transparent futures should only be used for debugging and\n", 
#>                       "troubleshooting.  They should not be used for production pipelines\n", 
#>                       "and must not be set within another package.  This is especially\n", 
#>                       "important since 'transparent' futures might be deprecated and replaced\n", 
#>                       "by better means of debugging in future releases."), 
#>                     "\n")), "\n", "\n", list("\n", "## Use sequential futures\n", 
#>                   "plan(sequential)\n", "\n", "## A global variable\n", 
#>                   "a <- 0\n", "\n", "## Create a sequential future\n", 
#>                   "f <- future({\n", "  b <- 3\n", "  c <- 2\n", 
#>                   "  a * b * c\n", "})\n", "\n", "## Since 'a' is a global variable in future 'f' which\n", 
#>                   "## is eagerly resolved (default), this global has already\n", 
#>                   "## been resolved / incorporated, and any changes to 'a'\n", 
#>                   "## at this point will _not_ affect the value of 'f'.\n", 
#>                   "a <- 7\n", "print(a)\n", "\n", "v <- value(f)\n", 
#>                   "print(v)\n", "stopifnot(v == 0)\n"), "\n"), 
#>             sessionDetails.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/sessionDetails.R", 
#>                 "\n", list("sessionDetails"), "\n", list("sessionDetails"), 
#>                 "\n", list("Outputs details on the current ", 
#>                   list(), " session"), "\n", list("\n", "sessionDetails(env = FALSE)\n"), 
#>                 "\n", list("\n", list(list("env"), list("If TRUE, ", 
#>                   list("Sys.getenv()"), " information is returned.")), 
#>                   "\n"), "\n", list("\n", "Invisibly a list of all details.\n"), 
#>                 "\n", list("\n", "Outputs details on the current ", 
#>                   list(), " session\n"), "\n", list("\n", "Note that remote futures use ", 
#>                   list("persistent = TRUE"), " by default.\n"), 
#>                 "\n", list("internal"), "\n"), signalConditions.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/signalConditions.R", 
#>                 "\n", list("signalConditions"), "\n", list("signalConditions"), 
#>                 "\n", list("Signals Captured Conditions"), "\n", 
#>                 list("\n", "signalConditions(\n", "  future,\n", 
#>                   "  include = \"condition\",\n", "  exclude = NULL,\n", 
#>                   "  resignal = TRUE,\n", "  ...\n", ")\n"), 
#>                 "\n", list("\n", list(list("future"), list("A resolved ", 
#>                   list("Future"), ".")), "\n", "\n", list(list(
#>                   "include"), list("A character string of ", 
#>                   list("condition"), "\n", "classes to signal.")), 
#>                   "\n", "\n", list(list("exclude"), list("A character string of ", 
#>                     list("condition"), "\n", "classes ", list(
#>                       "not"), " to signal.")), "\n", "\n", list(
#>                     list("resignal"), list("If TRUE, then already signaled conditions are signaled\n", 
#>                       "again, otherwise not.")), "\n", "\n", 
#>                   list(list(list()), list("Not used.")), "\n"), 
#>                 "\n", list("\n", "Returns the ", list("Future"), 
#>                   " where conditioned that were signaled\n", 
#>                   "have been flagged to have been signaled.\n"), 
#>                 "\n", list("\n", "Captured conditions that meet the ", 
#>                   list("include"), " and ", list("exclude"), 
#>                   "\n", "requirements are signaled ", list("in the order as they were captured"), 
#>                   ".\n"), "\n", list("\n", "Conditions are signaled by\n", 
#>                   list(list("signalCondition"), "()"), ".\n"), 
#>                 "\n"), sticky_globals.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/sticky_globals.R", 
#>                 "\n", list("sticky_globals"), "\n", list("sticky_globals"), 
#>                 "\n", list("Place a sticky-globals environment immediately after the global environment"), 
#>                 "\n", list("\n", "sticky_globals(erase = FALSE, name = \"future:sticky_globals\", pos = 2L)\n"), 
#>                 "\n", list("\n", list(list("erase"), list("(logical) If TRUE, the environment is erased, otherwise not.")), 
#>                   "\n", "\n", list(list("name"), list("(character) The name of the environment on the ", 
#>                     list("base::search"), "\n", "path.")), "\n", 
#>                   "\n", list(list("pos"), list("(integer) The position on the search path where the\n", 
#>                     "environment should be positioned.  If ", 
#>                     list("pos == 0L"), ", then the environment\n", 
#>                     "is detached, if it exists.")), "\n"), "\n", 
#>                 list("\n", "(invisible; environment) The environment.\n"), 
#>                 "\n", list("\n", "Place a sticky-globals environment immediately after the global environment\n"), 
#>                 "\n", list("internal"), "\n"), tweak.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/tweak.R", 
#>                 "\n", list("tweak"), "\n", list("tweak"), "\n", 
#>                 list("Tweak a future function by adjusting its default arguments"), 
#>                 "\n", list("\n", "tweak(strategy, ..., penvir = parent.frame())\n"), 
#>                 "\n", list("\n", list(list("strategy"), list(
#>                   "An existing future function or the name of one.")), 
#>                   "\n", "\n", list(list(list()), list("Named arguments to replace the defaults of existing\n", 
#>                     "arguments.")), "\n", "\n", list(list("penvir"), 
#>                     list("The environment used when searching for a future\n", 
#>                       "function by its name.")), "\n"), "\n", 
#>                 list("\n", "a future function.\n"), "\n", list(
#>                   "\n", "Tweak a future function by adjusting its default arguments\n"), 
#>                 "\n", list("\n", "Use ", list(list("plan()")), 
#>                   " to set a future to become the\n", "new default strategy.\n"), 
#>                 "\n"), usedCores.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/multicore.R", 
#>                 "\n", list("usedCores"), "\n", list("usedCores"), 
#>                 "\n", list("Get number of cores currently used"), 
#>                 "\n", list("\n", "usedCores()\n"), "\n", list(
#>                   "\n", "A non-negative integer.\n"), "\n", list(
#>                   "\n", "Get number of children (and don't count the current process)\n", 
#>                   "used by the current ", list(), " session.  The number of children\n", 
#>                   "is the total number of subprocesses launched by this\n", 
#>                   "process that are still running and whose values have yet\n", 
#>                   "not been collected.\n"), "\n", list("internal"), 
#>                 "\n"), value.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/value.R", 
#>                 "\n", list("value"), "\n", list("value"), "\n", 
#>                 list("values"), "\n", list("value.Future"), "\n", 
#>                 list("value.list"), "\n", list("value.listenv"), 
#>                 "\n", list("value.environment"), "\n", list("The value of a future or the values of all elements in a container"), 
#>                 "\n", list("\n", "value(...)\n", "\n", list(list(
#>                   "value"), list("Future")), "(future, stdout = TRUE, signal = TRUE, ...)\n", 
#>                   "\n", list(list("value"), list("list")), "(x, stdout = TRUE, signal = TRUE, ...)\n", 
#>                   "\n", list(list("value"), list("listenv")), 
#>                   "(x, stdout = TRUE, signal = TRUE, ...)\n", 
#>                   "\n", list(list("value"), list("environment")), 
#>                   "(x, stdout = TRUE, signal = TRUE, ...)\n"), 
#>                 "\n", list("\n", list(list(list()), list("All arguments used by the S3 methods.")), 
#>                   "\n", "\n", list(list("future, x"), list("A ", 
#>                     list("Future"), ", an environment, a list, or a list environment.")), 
#>                   "\n", "\n", list(list("stdout"), list("If TRUE, standard output captured while resolving futures\n", 
#>                     "is relayed, otherwise not.")), "\n", "\n", 
#>                   list(list("signal"), list("If TRUE, ", list(
#>                     "conditions"), " captured while resolving\n", 
#>                     "futures are relayed, otherwise not.")), 
#>                   "\n"), "\n", list("\n", list("value()"), " of a Future object returns the value of the future, which can\n", 
#>                   "be any type of ", list(), " object.\n", "\n", 
#>                   list("value()"), " of a list, an environment, or a list environment returns an\n", 
#>                   "object with the same number of elements and of the same class.\n", 
#>                   "Names and dimension attributes are preserved, if available.\n", 
#>                   "All future elements are replaced by their corresponding ", 
#>                   list("value()"), " values.\n", "For all other elements, the existing object is kept as-is.\n", 
#>                   "\n", "If ", list("signal"), " is TRUE and one of the futures produces an error, then\n", 
#>                   "that error is produced.\n"), "\n", list("\n", 
#>                   "Gets the value of a future or the values of all elements (including futures)\n", 
#>                   "in a container such as a list, an environment, or a list environment.\n", 
#>                   "If one or more futures is unresolved, then this function blocks until all\n", 
#>                   "queried futures are resolved.\n"), "\n")), 
#>         source = list(`ClusterFuture-class.Rd` = c("R/ClusterFuture-class.R", 
#>         "R/MultisessionFuture-class.R"), `ConstantFuture-class.Rd` = "R/ConstantFuture-class.R", 
#>             `Future-class.Rd` = "R/Future-class.R", FutureCondition.Rd = "R/FutureCondition-class.R", 
#>             FutureGlobals.Rd = "R/FutureGlobals-class.R", FutureResult.Rd = "R/FutureResult-class.R", 
#>             `MulticoreFuture-class.Rd` = "R/MulticoreFuture-class.R", 
#>             `MultiprocessFuture-class.Rd` = "R/MultiprocessFuture-class.R", 
#>             `UniprocessFuture-class.Rd` = "R/UniprocessFuture-class.R", 
#>             as_lecyer_cmrg_seed.Rd = "R/rng.R", backtrace.Rd = "R/backtrace.R", 
#>             cluster.Rd = "R/cluster.R", clusterExportSticky.Rd = "R/sticky_globals.R", 
#>             find_references.Rd = "R/utils-marshalling.R", future.Rd = c("R/future.R", 
#>             "R/futureAssign.R", "R/futureAssign_OP.R", "R/futureCall.R"
#>             ), future.options.Rd = "R/options.R", futureOf.Rd = "R/futureOf.R", 
#>             futureSessionInfo.Rd = "R/futureSessionInfo.R", futures.Rd = "R/futures.R", 
#>             getExpression.Rd = "R/Future-class.R", getGlobalsAndPackages.Rd = "R/globals.R", 
#>             `grapes-conditions-grapes.Rd` = "R/conditions_OP.R", 
#>             `grapes-globals-grapes.Rd` = "R/globals_OP.R", `grapes-label-grapes.Rd` = "R/label_OP.R", 
#>             `grapes-lazy-grapes.Rd` = "R/lazy_OP.R", `grapes-plan-grapes.Rd` = "R/plan_OP.R", 
#>             `grapes-seed-grapes.Rd` = "R/seed_OP.R", `grapes-stdout-grapes.Rd` = "R/stdout_OP.R", 
#>             `grapes-tweak-grapes.Rd` = "R/tweak_OP.R", make_rng_seeds.Rd = "R/rng.R", 
#>             mandelbrot.Rd = "R/mandelbrot.R", multicore.Rd = "R/multicore.R", 
#>             multiprocess.Rd = "R/multiprocess.R", multisession.Rd = "R/multisession.R", 
#>             nbrOfWorkers.Rd = "R/nbrOfWorkers.R", nullcon.Rd = "R/utils.R", 
#>             pid_exists.Rd = "R/utils.R", plan.Rd = "R/zzz.plan.R", 
#>             private_length.Rd = "R/utils.R", `re-exports.Rd` = "R/000.re-exports.R", 
#>             readImmediateConditions.Rd = "R/utils-immediateCondition.R", 
#>             remote.Rd = "R/remote.R", requestCore.Rd = "R/multicore.R", 
#>             resetWorkers.Rd = "R/zzz.plan.R", resolve.Rd = "R/resolve.R", 
#>             resolved.Rd = "R/resolved.R", result.Rd = "R/Future-class.R", 
#>             run.Rd = "R/Future-class.R", save_rds.Rd = "R/utils-immediateCondition.R", 
#>             sequential.Rd = "R/sequential.R", sessionDetails.Rd = "R/sessionDetails.R", 
#>             signalConditions.Rd = "R/signalConditions.R", sticky_globals.Rd = "R/sticky_globals.R", 
#>             tweak.Rd = "R/tweak.R", usedCores.Rd = "R/multicore.R", 
#>             value.Rd = "R/value.R"), keywords = list("internal", 
#>             "internal", "internal", "internal", "internal", "internal", 
#>             "internal", "internal", "internal", "internal", character(0), 
#>             character(0), "internals", "internal", character(0), 
#>             "internal", character(0), character(0), character(0), 
#>             "internal", "internal", character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), "internal", "internal", 
#>             character(0), "internal", character(0), character(0), 
#>             "internal", "internal", character(0), "internal", 
#>             character(0), "internal", character(0), "internal", 
#>             "internal", character(0), character(0), "internal", 
#>             "internal", "internal", character(0), "internal", 
#>             character(0), "internal", character(0), "internal", 
#>             character(0)), concepts = list(character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0)), internal = c(TRUE, TRUE, 
#>         TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, 
#>         FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, 
#>         TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, 
#>         FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, 
#>         TRUE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, 
#>         FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, TRUE, 
#>         FALSE, TRUE, FALSE)), tutorials = list(name = character(0), 
#>         file_out = character(0), title = character(0), pagetitle = character(0), 
#>         url = character(0)), vignettes = list(name = c("future-1-overview", 
#>     "future-2-output", "future-3-topologies", "future-4-issues", 
#>     "future-4-non-exportable-objects", "future-5-startup", "future-6-future-api-backend-specification", 
#>     "future-7-for-package-developers", "future-8-how-future-is-validated"
#>     ), file_in = c("vignettes/future-1-overview.Rmd", "vignettes/future-2-output.Rmd", 
#>     "vignettes/future-3-topologies.Rmd", "vignettes/future-4-issues.Rmd", 
#>     "vignettes/future-4-non-exportable-objects.Rmd", "vignettes/future-5-startup.Rmd", 
#>     "vignettes/future-6-future-api-backend-specification.Rmd", 
#>     "vignettes/future-7-for-package-developers.Rmd", "vignettes/future-8-how-future-is-validated.Rmd"
#>     ), file_out = c("articles/future-1-overview.html", "articles/future-2-output.html", 
#>     "articles/future-3-topologies.html", "articles/future-4-issues.html", 
#>     "articles/future-4-non-exportable-objects.html", "articles/future-5-startup.html", 
#>     "articles/future-6-future-api-backend-specification.html", 
#>     "articles/future-7-for-package-developers.html", "articles/future-8-how-future-is-validated.html"
#>     ), title = c("A Future for R: A Comprehensive Overview", 
#>     "A Future for R: Text and Message Output", "A Future for R: Future Topologies", 
#>     "A Future for R: Common Issues with Solutions", "A Future for R: Non-Exportable Objects", 
#>     "A Future for R: Controlling Default Future Strategy", "A Future for R: Future API Backend Specification", 
#>     "A Future for R: Best Practices for Package Developers", 
#>     "A Future for R: How the Future Framework is Validated"), 
#>         description = c(NA_character_, NA_character_, NA_character_, 
#>         NA_character_, NA_character_, NA_character_, NA_character_, 
#>         NA_character_, NA_character_))), examples = TRUE, run_dont_run = FALSE, 
#>     seed = 1014, lazy = FALSE, override = list(), install = FALSE, 
#>     preview = FALSE, new_process = FALSE, devel = FALSE, crayon_enabled = TRUE, 
#>     crayon_colors = 16777216L, pkgdown_internet = TRUE)), envir = base::quote(<environment>), 
#>     quote = base::quote(TRUE))
#> 
#> [[12]]
#> (function (..., crayon_enabled, crayon_colors, pkgdown_internet) 
#> {
#>     options(crayon.enabled = crayon_enabled, crayon.colors = crayon_colors, 
#>         pkgdown.internet = pkgdown_internet)
#>     pkgdown::build_site(...)
#> })(pkg = base::quote(list(package = "future", version = "1.23.0-9002", 
#>     src_path = "/tmp/hb/RtmpmB3n2n/future", dst_path = "/tmp/hb/RtmpmB3n2n/future/docs", 
#>     install_metadata = FALSE, desc = <environment>, meta = list(
#>         url = "https://future.futureverse.org", home = list(links = list(
#>             list(text = "Roadmap/Milestones", href = "https://github.com/HenrikBengtsson/future/milestones"), 
#>             list(text = "The Futureverse Project", href = "https://www.futureverse.org/"), 
#>             list(text = "Futureverse User Forum (new!)", href = "https://github.com/HenrikBengtsson/future/discussions"))), 
#>         navbar = list(structure = list(right = c("futureverse", 
#>         "pkgs", "cran", "github")), components = list(futureverse = list(
#>             icon = "fas fa-fast-backward", href = "https://www.futureverse.org/"), 
#>             pkgs = list(text = "Packages", menu = list(list(text = "BiocParallel.FutureParam", 
#>                 href = "https://BiocParallel.FutureParam.futureverse.org"), 
#>                 list(text = "doFuture", href = "https://doFuture.futureverse.org"), 
#>                 list(text = "furrr", href = "https://furrr.futureverse.org"), 
#>                 list(text = "future", href = "https://future.futureverse.org"), 
#>                 list(text = "future.apply", href = "https://future.apply.futureverse.org"), 
#>                 list(text = "future.batchtools", href = "https://future.batchtools.futureverse.org"), 
#>                 list(text = "future.callr", href = "https://future.callr.futureverse.org"), 
#>                 list(text = "future.tests", href = "https://future.tests.futureverse.org"), 
#>                 list(text = "globals", href = "https://globals.futureverse.org"), 
#>                 list(text = "listenv", href = "https://listenv.futureverse.org"), 
#>                 list(text = "parallelly", href = "https://parallelly.futureverse.org"), 
#>                 list(text = "progressr", href = "https://progressr.futureverse.org"), 
#>                 list(text = "future.mapreduce (experimental)", 
#>                   href = "https://future.mapreduce.futureverse.org"), 
#>                 list(text = "marshal (experimental)", href = "https://marshal.futureverse.org"))), 
#>             cran = list(icon = "fab fa-r-project", href = "https://cloud.r-project.org/package=future"))), 
#>         template = list(params = list(docsearch = list(api_key = "aa6e02fc501886fb0f7c91ac4e300456", 
#>             index_name = "futureverse", algoliaOptions = list(
#>                 facetFilters = "project:future")), ganalytics = "G-SB3EQSD9FR"))), 
#>     figures = list(dev = "ragg::agg_png", dpi = 96L, dev.args = list(), 
#>         fig.ext = "png", fig.width = 7.29166666666667, fig.height = NULL, 
#>         fig.retina = 2L, fig.asp = 0.618046971569839, bg = NULL), 
#>     repo = list(url = list(home = "https://github.com/HenrikBengtsson/future/", 
#>         source = "https://github.com/HenrikBengtsson/future/blob/master/", 
#>         issue = "https://github.com/HenrikBengtsson/future/issues/", 
#>         user = "https://github.com/")), development = list(destination = "dev", 
#>         mode = "release", version_label = "default", version_tooltip = "Released version", 
#>         in_dev = FALSE), topics = list(name = c(`ClusterFuture-class.Rd` = "ClusterFuture-class", 
#>     `ConstantFuture-class.Rd` = "ConstantFuture-class", `Future-class.Rd` = "Future-class", 
#>     FutureCondition.Rd = "FutureCondition", FutureGlobals.Rd = "FutureGlobals", 
#>     FutureResult.Rd = "FutureResult", `MulticoreFuture-class.Rd` = "MulticoreFuture-class", 
#>     `MultiprocessFuture-class.Rd` = "MultiprocessFuture-class", 
#>     `UniprocessFuture-class.Rd` = "UniprocessFuture-class", as_lecyer_cmrg_seed.Rd = "as_lecyer_cmrg_seed", 
#>     backtrace.Rd = "backtrace", cluster.Rd = "cluster", clusterExportSticky.Rd = "clusterExportSticky", 
#>     find_references.Rd = "find_references", future.Rd = "future", 
#>     future.options.Rd = "future.options", futureOf.Rd = "futureOf", 
#>     futureSessionInfo.Rd = "futureSessionInfo", futures.Rd = "futures", 
#>     getExpression.Rd = "getExpression", getGlobalsAndPackages.Rd = "getGlobalsAndPackages", 
#>     `grapes-conditions-grapes.Rd` = "%conditions%", `grapes-globals-grapes.Rd` = "%globals%", 
#>     `grapes-label-grapes.Rd` = "%label%", `grapes-lazy-grapes.Rd` = "%lazy%", 
#>     `grapes-plan-grapes.Rd` = "%plan%", `grapes-seed-grapes.Rd` = "%seed%", 
#>     `grapes-stdout-grapes.Rd` = "%stdout%", `grapes-tweak-grapes.Rd` = "%tweak%", 
#>     make_rng_seeds.Rd = "make_rng_seeds", mandelbrot.Rd = "mandelbrot", 
#>     multicore.Rd = "multicore", multiprocess.Rd = "multiprocess", 
#>     multisession.Rd = "multisession", nbrOfWorkers.Rd = "nbrOfWorkers", 
#>     nullcon.Rd = "nullcon", pid_exists.Rd = "pid_exists", plan.Rd = "plan", 
#>     private_length.Rd = ".length", `re-exports.Rd` = "re-exports", 
#>     readImmediateConditions.Rd = "readImmediateConditions", remote.Rd = "remote", 
#>     requestCore.Rd = "requestCore", resetWorkers.Rd = "resetWorkers", 
#>     resolve.Rd = "resolve", resolved.Rd = "resolved", result.Rd = "result.Future", 
#>     run.Rd = "run.Future", save_rds.Rd = "save_rds", sequential.Rd = "sequential", 
#>     sessionDetails.Rd = "sessionDetails", signalConditions.Rd = "signalConditions", 
#>     sticky_globals.Rd = "sticky_globals", tweak.Rd = "tweak", 
#>     usedCores.Rd = "usedCores", value.Rd = "value"), file_in = c("ClusterFuture-class.Rd", 
#>     "ConstantFuture-class.Rd", "Future-class.Rd", "FutureCondition.Rd", 
#>     "FutureGlobals.Rd", "FutureResult.Rd", "MulticoreFuture-class.Rd", 
#>     "MultiprocessFuture-class.Rd", "UniprocessFuture-class.Rd", 
#>     "as_lecyer_cmrg_seed.Rd", "backtrace.Rd", "cluster.Rd", "clusterExportSticky.Rd", 
#>     "find_references.Rd", "future.Rd", "future.options.Rd", "futureOf.Rd", 
#>     "futureSessionInfo.Rd", "futures.Rd", "getExpression.Rd", 
#>     "getGlobalsAndPackages.Rd", "grapes-conditions-grapes.Rd", 
#>     "grapes-globals-grapes.Rd", "grapes-label-grapes.Rd", "grapes-lazy-grapes.Rd", 
#>     "grapes-plan-grapes.Rd", "grapes-seed-grapes.Rd", "grapes-stdout-grapes.Rd", 
#>     "grapes-tweak-grapes.Rd", "make_rng_seeds.Rd", "mandelbrot.Rd", 
#>     "multicore.Rd", "multiprocess.Rd", "multisession.Rd", "nbrOfWorkers.Rd", 
#>     "nullcon.Rd", "pid_exists.Rd", "plan.Rd", "private_length.Rd", 
#>     "re-exports.Rd", "readImmediateConditions.Rd", "remote.Rd", 
#>     "requestCore.Rd", "resetWorkers.Rd", "resolve.Rd", "resolved.Rd", 
#>     "result.Rd", "run.Rd", "save_rds.Rd", "sequential.Rd", "sessionDetails.Rd", 
#>     "signalConditions.Rd", "sticky_globals.Rd", "tweak.Rd", "usedCores.Rd", 
#>     "value.Rd"), file_out = c("ClusterFuture-class.html", "ConstantFuture-class.html", 
#>     "Future-class.html", "FutureCondition.html", "FutureGlobals.html", 
#>     "FutureResult.html", "MulticoreFuture-class.html", "MultiprocessFuture-class.html", 
#>     "UniprocessFuture-class.html", "as_lecyer_cmrg_seed.html", 
#>     "backtrace.html", "cluster.html", "clusterExportSticky.html", 
#>     "find_references.html", "future.html", "future.options.html", 
#>     "futureOf.html", "futureSessionInfo.html", "futures.html", 
#>     "getExpression.html", "getGlobalsAndPackages.html", "grapes-conditions-grapes.html", 
#>     "grapes-globals-grapes.html", "grapes-label-grapes.html", 
#>     "grapes-lazy-grapes.html", "grapes-plan-grapes.html", "grapes-seed-grapes.html", 
#>     "grapes-stdout-grapes.html", "grapes-tweak-grapes.html", 
#>     "make_rng_seeds.html", "mandelbrot.html", "multicore.html", 
#>     "multiprocess.html", "multisession.html", "nbrOfWorkers.html", 
#>     "nullcon.html", "pid_exists.html", "plan.html", "private_length.html", 
#>     "re-exports.html", "readImmediateConditions.html", "remote.html", 
#>     "requestCore.html", "resetWorkers.html", "resolve.html", 
#>     "resolved.html", "result.html", "run.html", "save_rds.html", 
#>     "sequential.html", "sessionDetails.html", "signalConditions.html", 
#>     "sticky_globals.html", "tweak.html", "usedCores.html", "value.html"
#>     ), alias = list(`ClusterFuture-class.Rd` = c("ClusterFuture-class", 
#>     "ClusterFuture", "MultisessionFuture", "MultisessionFuture-class"
#>     ), `ConstantFuture-class.Rd` = c("ConstantFuture-class", 
#>     "ConstantFuture"), `Future-class.Rd` = c("Future-class", 
#>     "Future"), FutureCondition.Rd = c("FutureCondition", "FutureMessage", 
#>     "FutureWarning", "FutureError", "RngFutureCondition", "RngFutureWarning", 
#>     "RngFutureError", "UnexpectedFutureResultError"), FutureGlobals.Rd = c("FutureGlobals", 
#>     "as.FutureGlobals", "as.FutureGlobals.FutureGlobals", "as.FutureGlobals.Globals", 
#>     "as.FutureGlobals.list", "[.FutureGlobals", "c.FutureGlobals", 
#>     "unique.FutureGlobals"), FutureResult.Rd = c("FutureResult", 
#>     "as.character.FutureResult", "print.FutureResult"), `MulticoreFuture-class.Rd` = c("MulticoreFuture-class", 
#>     "MulticoreFuture"), `MultiprocessFuture-class.Rd` = c("MultiprocessFuture-class", 
#>     "MultiprocessFuture"), `UniprocessFuture-class.Rd` = c("UniprocessFuture-class", 
#>     "UniprocessFuture", "SequentialFuture", "TransparentFuture"
#>     ), as_lecyer_cmrg_seed.Rd = c("as_lecyer_cmrg_seed", "is_lecyer_cmrg_seed"
#>     ), backtrace.Rd = "backtrace", cluster.Rd = "cluster", clusterExportSticky.Rd = "clusterExportSticky", 
#>         find_references.Rd = c("find_references", "assert_no_references"
#>         ), future.Rd = c("future", "futureCall", "futureAssign", 
#>         "%<-%", "%->%"), future.options.Rd = c("future.options", 
#>         "future.cmdargs", ".future.R", "future.startup.script", 
#>         "R_FUTURE_STARTUP_SCRIPT", "future.debug", "R_FUTURE_DEBUG", 
#>         "future.demo.mandelbrot.region", "R_FUTURE_DEMO_MANDELBROT_REGION", 
#>         "future.demo.mandelbrot.nrow", "R_FUTURE_DEMO_MANDELBROT_NROW", 
#>         "future.fork.multithreading.enable", "R_FUTURE_FORK_MULTITHREADING_ENABLE", 
#>         "future.globals.maxSize", "R_FUTURE_GLOBALS_MAXSIZE", 
#>         "future.globals.method", "R_FUTURE_GLOBALS_METHOD", "future.globals.onMissing", 
#>         "R_FUTURE_GLOBALS_ONMISSING", "future.globals.resolve", 
#>         "R_FUTURE_GLOBALS_RESOLVE", "future.globals.onReference", 
#>         "R_FUTURE_GLOBALS_ONREFERENCE", "future.plan", "R_FUTURE_PLAN", 
#>         "future.resolve.recursive", "R_FUTURE_RNG_ONMISUSE", 
#>         "future.wait.alpha", "R_FUTURE_WAIT_ALPHA", "future.wait.interval", 
#>         "R_FUTURE_WAIT_INTERVAL", "future.wait.timeout", "R_FUTURE_WAIT_TIMEOUT", 
#>         "R_FUTURE_RESOLVED_TIMEOUT", "future.output.windows.reencode", 
#>         "R_FUTURE_OUTPUT_WINDOWS_REENCODE"), futureOf.Rd = "futureOf", 
#>         futureSessionInfo.Rd = "futureSessionInfo", futures.Rd = "futures", 
#>         getExpression.Rd = c("getExpression", "getExpression.Future"
#>         ), getGlobalsAndPackages.Rd = "getGlobalsAndPackages", 
#>         `grapes-conditions-grapes.Rd` = "%conditions%", `grapes-globals-grapes.Rd` = c("%globals%", 
#>         "%packages%"), `grapes-label-grapes.Rd` = "%label%", 
#>         `grapes-lazy-grapes.Rd` = "%lazy%", `grapes-plan-grapes.Rd` = "%plan%", 
#>         `grapes-seed-grapes.Rd` = "%seed%", `grapes-stdout-grapes.Rd` = "%stdout%", 
#>         `grapes-tweak-grapes.Rd` = "%tweak%", make_rng_seeds.Rd = "make_rng_seeds", 
#>         mandelbrot.Rd = c("mandelbrot", "as.raster.Mandelbrot", 
#>         "plot.Mandelbrot", "mandelbrot_tiles"), multicore.Rd = "multicore", 
#>         multiprocess.Rd = "multiprocess", multisession.Rd = "multisession", 
#>         nbrOfWorkers.Rd = c("nbrOfWorkers", "nbrOfFreeWorkers"
#>         ), nullcon.Rd = "nullcon", pid_exists.Rd = "pid_exists", 
#>         plan.Rd = "plan", private_length.Rd = ".length", `re-exports.Rd` = c("re-exports", 
#>         "as.cluster", "autoStopCluster", "availableCores", "availableWorkers", 
#>         "makeClusterMPI", "makeClusterPSOCK", "makeNodePSOCK", 
#>         "supportsMulticore"), readImmediateConditions.Rd = "readImmediateConditions", 
#>         remote.Rd = "remote", requestCore.Rd = "requestCore", 
#>         resetWorkers.Rd = "resetWorkers", resolve.Rd = "resolve", 
#>         resolved.Rd = "resolved", result.Rd = c("result.Future", 
#>         "result"), run.Rd = c("run.Future", "run"), save_rds.Rd = "save_rds", 
#>         sequential.Rd = c("sequential", "uniprocess", "transparent"
#>         ), sessionDetails.Rd = "sessionDetails", signalConditions.Rd = "signalConditions", 
#>         sticky_globals.Rd = "sticky_globals", tweak.Rd = "tweak", 
#>         usedCores.Rd = "usedCores", value.Rd = c("value", "values", 
#>         "value.Future", "value.list", "value.listenv", "value.environment"
#>         )), funs = list(`ClusterFuture-class.Rd` = c("ClusterFuture()", 
#>     "MultisessionFuture()"), `ConstantFuture-class.Rd` = "ConstantFuture()", 
#>         `Future-class.Rd` = "Future()", FutureCondition.Rd = c("FutureCondition()", 
#>         "FutureMessage()", "FutureWarning()", "FutureError()", 
#>         "RngFutureCondition()", "RngFutureWarning()", "RngFutureError()", 
#>         "UnexpectedFutureResultError()"), FutureGlobals.Rd = "FutureGlobals()", 
#>         FutureResult.Rd = c("FutureResult()", "as.character(<i>&lt;FutureResult&gt;</i>)", 
#>         "print(<i>&lt;FutureResult&gt;</i>)"), `MulticoreFuture-class.Rd` = "MulticoreFuture()", 
#>         `MultiprocessFuture-class.Rd` = "MultiprocessFuture()", 
#>         `UniprocessFuture-class.Rd` = c("UniprocessFuture()", 
#>         "SequentialFuture()", "TransparentFuture()"), as_lecyer_cmrg_seed.Rd = c("as_lecyer_cmrg_seed()", 
#>         "is_lecyer_cmrg_seed()"), backtrace.Rd = "backtrace()", 
#>         cluster.Rd = "cluster()", clusterExportSticky.Rd = "clusterExportSticky()", 
#>         find_references.Rd = c("find_references()", "assert_no_references()"
#>         ), future.Rd = c("future()", "futureAssign()", "`%&lt;-%`", 
#>         "futureCall()"), future.options.Rd = character(0), futureOf.Rd = "futureOf()", 
#>         futureSessionInfo.Rd = "futureSessionInfo()", futures.Rd = "futures()", 
#>         getExpression.Rd = "getExpression()", getGlobalsAndPackages.Rd = "getGlobalsAndPackages()", 
#>         `grapes-conditions-grapes.Rd` = "`%conditions%`", `grapes-globals-grapes.Rd` = c("`%globals%`", 
#>         "`%packages%`"), `grapes-label-grapes.Rd` = "`%label%`", 
#>         `grapes-lazy-grapes.Rd` = "`%lazy%`", `grapes-plan-grapes.Rd` = "`%plan%`", 
#>         `grapes-seed-grapes.Rd` = "`%seed%`", `grapes-stdout-grapes.Rd` = "`%stdout%`", 
#>         `grapes-tweak-grapes.Rd` = "`%tweak%`", make_rng_seeds.Rd = "make_rng_seeds()", 
#>         mandelbrot.Rd = "mandelbrot()", multicore.Rd = "multicore()", 
#>         multiprocess.Rd = "multiprocess()", multisession.Rd = "multisession()", 
#>         nbrOfWorkers.Rd = c("nbrOfWorkers()", "nbrOfFreeWorkers()"
#>         ), nullcon.Rd = "nullcon()", pid_exists.Rd = "pid_exists()", 
#>         plan.Rd = "plan()", private_length.Rd = ".length()", 
#>         `re-exports.Rd` = character(0), readImmediateConditions.Rd = "readImmediateConditions()", 
#>         remote.Rd = "remote()", requestCore.Rd = "requestCore()", 
#>         resetWorkers.Rd = "resetWorkers()", resolve.Rd = "resolve()", 
#>         resolved.Rd = "resolved()", result.Rd = "result(<i>&lt;Future&gt;</i>)", 
#>         run.Rd = "run(<i>&lt;Future&gt;</i>)", save_rds.Rd = "save_rds()", 
#>         sequential.Rd = c("sequential()", "transparent()"), sessionDetails.Rd = "sessionDetails()", 
#>         signalConditions.Rd = "signalConditions()", sticky_globals.Rd = "sticky_globals()", 
#>         tweak.Rd = "tweak()", usedCores.Rd = "usedCores()", value.Rd = "value()"), 
#>         title = c(`ClusterFuture-class.Rd` = "A cluster future is a future whose value will be resolved asynchronously in a parallel process", 
#>         `ConstantFuture-class.Rd` = "A future with a constant value", 
#>         `Future-class.Rd` = "A future represents a value that will be available at some point in the future", 
#>         FutureCondition.Rd = "A condition (message, warning, or error) that occurred while orchestrating a future", 
#>         FutureGlobals.Rd = "A representation of a set of globals used with futures", 
#>         FutureResult.Rd = "Results from resolving a future", 
#>         `MulticoreFuture-class.Rd` = "A multicore future is a future whose value will be resolved asynchronously in a parallel process", 
#>         `MultiprocessFuture-class.Rd` = "A multiprocess future is a future whose value will be resolved asynchronously in a parallel process", 
#>         `UniprocessFuture-class.Rd` = "An uniprocess future is a future whose value will be resolved synchronously in the current process", 
#>         as_lecyer_cmrg_seed.Rd = "Get a L'Ecuyer-CMRG seed either from an input seed or the current RNG state", 
#>         backtrace.Rd = "Back trace the expressions evaluated when an error was caught", 
#>         cluster.Rd = "Create a cluster future whose value will be resolved asynchronously in a parallel process", 
#>         clusterExportSticky.Rd = "Export globals to the sticky-globals environment of the cluster nodes", 
#>         find_references.Rd = "Get the first or all references of an <span style=\"R\">R</span> object", 
#>         future.Rd = "Create a future", future.options.Rd = "Options used for futures", 
#>         futureOf.Rd = "Get the future of a future variable", 
#>         futureSessionInfo.Rd = "Get session information specific to the future framework", 
#>         futures.Rd = "Get all futures in a container", getExpression.Rd = "Inject code for the next type of future to use for nested futures", 
#>         getGlobalsAndPackages.Rd = "Retrieves global variables of an expression and their associated packages", 
#>         `grapes-conditions-grapes.Rd` = "Control whether standard output should be captured or not", 
#>         `grapes-globals-grapes.Rd` = "Specify globals and packages for a future assignment", 
#>         `grapes-label-grapes.Rd` = "Specify label for a future assignment", 
#>         `grapes-lazy-grapes.Rd` = "Control lazy / eager evaluation for a future assignment", 
#>         `grapes-plan-grapes.Rd` = "Use a specific plan for a future assignment", 
#>         `grapes-seed-grapes.Rd` = "Set random seed for future assignment", 
#>         `grapes-stdout-grapes.Rd` = "Control whether standard output should be captured or not", 
#>         `grapes-tweak-grapes.Rd` = "Temporarily tweaks the arguments of the current strategy", 
#>         make_rng_seeds.Rd = "Produce Reproducible Seeds for Parallel Random Number Generation", 
#>         mandelbrot.Rd = "Mandelbrot convergence counts", multicore.Rd = "Create a multicore future whose value will be resolved asynchronously in a forked parallel process", 
#>         multiprocess.Rd = "Create a multiprocess future whose value will be resolved asynchronously using multicore or a multisession evaluation", 
#>         multisession.Rd = "Create a multisession future whose value will be resolved asynchronously in a parallel <span style=\"R\">R</span> session", 
#>         nbrOfWorkers.Rd = "Get the number of workers available", 
#>         nullcon.Rd = "Creates a connection to the system null device", 
#>         pid_exists.Rd = "Check whether a process PID exists or not", 
#>         plan.Rd = "Plan how to resolve a future", private_length.Rd = "Gets the length of an object without dispatching", 
#>         `re-exports.Rd` = "Functions Moved to 'parallelly'", 
#>         readImmediateConditions.Rd = "Read All 'immediateCondition' RDS Files", 
#>         remote.Rd = "Create a remote future whose value will be resolved asynchronously in a remote process", 
#>         requestCore.Rd = "Request a core for multicore processing", 
#>         resetWorkers.Rd = "Free up active background workers", 
#>         resolve.Rd = "Resolve one or more futures synchronously", 
#>         resolved.Rd = "Check whether a future is resolved or not", 
#>         result.Rd = "Get the results of a resolved future", run.Rd = "Run a future", 
#>         save_rds.Rd = "Robustly Saves an Object to RDS File Atomically", 
#>         sequential.Rd = "Create a sequential future whose value will be in the current <span style=\"R\">R</span> session", 
#>         sessionDetails.Rd = "Outputs details on the current <span style=\"R\">R</span> session", 
#>         signalConditions.Rd = "Signals Captured Conditions", 
#>         sticky_globals.Rd = "Place a sticky-globals environment immediately after the global environment", 
#>         tweak.Rd = "Tweak a future function by adjusting its default arguments", 
#>         usedCores.Rd = "Get number of cores currently used", 
#>         value.Rd = "The value of a future or the values of all elements in a container"
#>         ), rd = list(`ClusterFuture-class.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>             "\n", "% Please edit documentation in R/ClusterFuture-class.R,", 
#>             "\n", "%   R/MultisessionFuture-class.R", "\n", list(
#>                 "ClusterFuture-class"), "\n", list("ClusterFuture-class"), 
#>             "\n", list("ClusterFuture"), "\n", list("MultisessionFuture"), 
#>             "\n", list("MultisessionFuture-class"), "\n", list(
#>                 "A cluster future is a future whose value will be resolved asynchronously in a parallel process"), 
#>             "\n", list("\n", "ClusterFuture(\n", "  expr = NULL,\n", 
#>                 "  substitute = TRUE,\n", "  envir = parent.frame(),\n", 
#>                 "  globals = TRUE,\n", "  packages = NULL,\n", 
#>                 "  local = !persistent,\n", "  persistent = FALSE,\n", 
#>                 "  workers = NULL,\n", "  user = NULL,\n", "  master = NULL,\n", 
#>                 "  revtunnel = TRUE,\n", "  homogeneous = NULL,\n", 
#>                 "  ...\n", ")\n", "\n", "MultisessionFuture(\n", 
#>                 "  expr = NULL,\n", "  substitute = TRUE,\n", 
#>                 "  envir = parent.frame(),\n", "  persistent = FALSE,\n", 
#>                 "  workers = NULL,\n", "  ...\n", ")\n"), "\n", 
#>             list("\n", list(list("expr"), list("An ", list(), 
#>                 " ", list("expression"), ".")), "\n", "\n", list(
#>                 list("substitute"), list("If TRUE, argument ", 
#>                   list("expr"), " is\n", list(list("substitute"), 
#>                     "()"), ":ed, otherwise not.")), "\n", "\n", 
#>                 list(list("envir"), list("The ", list("environment"), 
#>                   " from where global objects should be\n", "identified.")), 
#>                 "\n", "\n", list(list("globals"), list("(optional) a logical, a character vector, or a named list\n", 
#>                   "to control how globals are handled.\n", "For details, see section 'Globals used by future expressions'\n", 
#>                   "in the help for ", list(list("future()")), 
#>                   ".")), "\n", "\n", list(list("packages"), list(
#>                   "(optional) a character vector specifying packages\n", 
#>                   "to be attached in the ", list(), " environment evaluating the future.")), 
#>                 "\n", "\n", list(list("local"), list("If TRUE, the expression is evaluated such that\n", 
#>                   "all assignments are done to local temporary environment, otherwise\n", 
#>                   "the assignments are done to the global environment of the ", 
#>                   list(), " process\n", "evaluating the future.")), 
#>                 "\n", "\n", list(list("persistent"), list("If FALSE, the evaluation environment is cleared\n", 
#>                   "from objects prior to the evaluation of the future.")), 
#>                 "\n", "\n", list(list("workers"), list("A ", 
#>                   list(list("cluster")), " object,\n", "a character vector of host names, a positive numeric scalar,\n", 
#>                   "or a function.\n", "If a character vector or a numeric scalar, a ", 
#>                   list("cluster"), " object\n", "is created using ", 
#>                   list(list("makeClusterPSOCK"), "(workers)"), 
#>                   ".\n", "If a function, it is called without arguments ", 
#>                   list("when the future\n", "is created"), " and its value is used to configure the workers.\n", 
#>                   "The function should return any of the above types.")), 
#>                 "\n", "\n", list(list("user"), list("(optional) The user name to be used when communicating\n", 
#>                   "with another host.")), "\n", "\n", list(list(
#>                   "master"), list("(optional) The hostname or IP address of the master\n", 
#>                   "machine running this node.")), "\n", "\n", 
#>                 list(list("revtunnel"), list("If TRUE, reverse SSH tunneling is used for the\n", 
#>                   "PSOCK cluster nodes to connect back to the master ", 
#>                   list(), " process.  This\n", "avoids the hassle of firewalls, port forwarding and having to know\n", 
#>                   "the internal / public IP address of the master ", 
#>                   list(), " session.")), "\n", "\n", list(list(
#>                   "homogeneous"), list("If TRUE, all cluster nodes is assumed to use the\n", 
#>                   "same path to ", list("Rscript"), " as the main ", 
#>                   list(), " session.  If FALSE, the\n", "it is assumed to be on the PATH for each node.\n", 
#>                   "If NULL, then ", list(list("parallelly::makeClusterPSOCK()")), 
#>                   " will decide on TRUE\n", "or FALSE depending on ", 
#>                   list("workers"), ".")), "\n", "\n", list(list(
#>                   "..."), list("Additional named elements passed to ", 
#>                   list(list("Future()")), ".")), "\n"), "\n", 
#>             list("\n", list("ClusterFuture()"), " returns an object of class ", 
#>                 list("ClusterFuture"), ".\n", "\n", list("MultisessionFuture()"), 
#>                 " returns an object of class\n", list("MultisessionFuture"), 
#>                 ", which inherits from ", list("ClusterFuture"), 
#>                 ".\n"), "\n", list("\n", "A cluster future is a future whose value will be resolved asynchronously in a parallel process\n"), 
#>             "\n", list("\n", "To evaluate an expression using \"cluster future\", see function\n", 
#>                 list(list("cluster()")), ".\n"), "\n", list("internal"), 
#>             "\n"), `ConstantFuture-class.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>             "\n", "% Please edit documentation in R/ConstantFuture-class.R", 
#>             "\n", list("ConstantFuture-class"), "\n", list("ConstantFuture-class"), 
#>             "\n", list("ConstantFuture"), "\n", list("A future with a constant value"), 
#>             "\n", list("\n", "ConstantFuture(..., globals = TRUE, envir = emptyenv())\n"), 
#>             "\n", list("\n", list(list("..."), list("Additional named elements of the future.")), 
#>                 "\n", "\n", list(list("globals"), list("(optional) a logical, a character vector, or a named list\n", 
#>                   "to control how globals are handled.\n", "For details, see section 'Globals used by future expressions'\n", 
#>                   "in the help for ", list(list("future()")), 
#>                   ".")), "\n", "\n", list(list("envir"), list(
#>                   "The ", list("environment"), " from where global objects should be\n", 
#>                   "identified.")), "\n"), "\n", list("\n", "An object of class ", 
#>                 list("ConstantFuture"), ".\n"), "\n", list("\n", 
#>                 "A constant future is a future whose expression is a constant\n", 
#>                 "and therefore by definition is already resolved upon creation.\n"), 
#>             "\n", list("internal"), "\n"), `Future-class.Rd` = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/Future-class.R", 
#>             "\n", list("Future-class"), "\n", list("Future-class"), 
#>             "\n", list("Future"), "\n", list("A future represents a value that will be available at some point in the future"), 
#>             "\n", list("\n", "Future(\n", "  expr = NULL,\n", 
#>                 "  envir = parent.frame(),\n", "  substitute = TRUE,\n", 
#>                 "  stdout = TRUE,\n", "  conditions = \"condition\",\n", 
#>                 "  globals = NULL,\n", "  packages = NULL,\n", 
#>                 "  seed = FALSE,\n", "  lazy = FALSE,\n", "  local = TRUE,\n", 
#>                 "  gc = FALSE,\n", "  earlySignal = FALSE,\n", 
#>                 "  label = NULL,\n", "  ...\n", ")\n"), "\n", 
#>             list("\n", list(list("expr"), list("An ", list(), 
#>                 " ", list("expression"), ".")), "\n", "\n", list(
#>                 list("envir"), list("The ", list("environment"), 
#>                   " from where global objects should be\n", "identified.")), 
#>                 "\n", "\n", list(list("substitute"), list("If TRUE, argument ", 
#>                   list("expr"), " is\n", list(list("substitute"), 
#>                     "()"), ":ed, otherwise not.")), "\n", "\n", 
#>                 list(list("stdout"), list("If TRUE (default), then the standard output is captured,\n", 
#>                   "and re-outputted when ", list("value()"), 
#>                   " is called.\n", "If FALSE, any output is silenced (by sinking it to the null device as\n", 
#>                   "it is outputted).\n", "If NA (not recommended), output is ", 
#>                   list("not"), " intercepted.")), "\n", "\n", 
#>                 list(list("conditions"), list("A character string of conditions classes to be captured\n", 
#>                   "and relayed.  The default is to relay messages and warnings.\n", 
#>                   "To not intercept any types of conditions, use ", 
#>                   list("conditions = NULL"), ".\n", "Attribute ", 
#>                   list("exclude"), " can be used to ignore specific classes, e.g.\n", 
#>                   list("conditions = structure(\"condition\", exclude = \"message\")"), 
#>                   " will capture\n", "all ", list("condition"), 
#>                   " classes except those that inherits from the ", 
#>                   list("message"), " class.\n", "Errors are always relayed.")), 
#>                 "\n", "\n", list(list("globals"), list("(optional) a logical, a character vector, or a named list\n", 
#>                   "to control how globals are handled.\n", "For details, see section 'Globals used by future expressions'\n", 
#>                   "in the help for ", list(list("future()")), 
#>                   ".")), "\n", "\n", list(list("packages"), list(
#>                   "(optional) a character vector specifying packages\n", 
#>                   "to be attached in the ", list(), " environment evaluating the future.")), 
#>                 "\n", "\n", list(list("seed"), list("(optional) If TRUE, the random seed, that is, the state of the\n", 
#>                   "random number generator (RNG) will be set such that statistically sound\n", 
#>                   "random numbers are produced (also during parallelization).\n", 
#>                   "If FALSE (default), it is assumed that the future expression does neither\n", 
#>                   "need nor use random numbers generation.\n", 
#>                   "To use a fixed random seed, specify a L'Ecuyer-CMRG seed (seven integer)\n", 
#>                   "or a regular RNG seed (a single integer).  If the latter, then a\n", 
#>                   "L'Ecuyer-CMRG seed will be automatically created based on the given seed.\n", 
#>                   "Furthermore, if FALSE, then the future will be monitored to make sure it\n", 
#>                   "does not use random numbers.  If it does and depending on the value of\n", 
#>                   "option ", list(list("future.rng.onMisuse")), 
#>                   ", the check is\n", "ignored, an informative warning, or error will be produced.\n", 
#>                   "If ", list("seed"), " is NULL, then the effect is as with ", 
#>                   list("seed = FALSE"), "\n", "but without the RNG check being performed.")), 
#>                 "\n", "\n", list(list("lazy"), list("If FALSE (default), the future is resolved\n", 
#>                   "eagerly (starting immediately), otherwise not.")), 
#>                 "\n", "\n", list(list("local"), list("If TRUE, the expression is evaluated such that\n", 
#>                   "all assignments are done to local temporary environment, otherwise\n", 
#>                   "the assignments are done to the global environment of the ", 
#>                   list(), " process\n", "evaluating the future.")), 
#>                 "\n", "\n", list(list("gc"), list("If TRUE, the garbage collector run (in the process that\n", 
#>                   "evaluated the future) only after the value of the future is collected.\n", 
#>                   "Exactly when the values are collected may depend on various factors such\n", 
#>                   "as number of free workers and whether ", list(
#>                     "earlySignal"), " is TRUE (more\n", "frequently) or FALSE (less frequently).\n", 
#>                   list("Some types of futures ignore this argument."))), 
#>                 "\n", "\n", list(list("earlySignal"), list("Specified whether conditions should be signaled as soon\n", 
#>                   "as possible or not.")), "\n", "\n", list(list(
#>                   "label"), list("An optional character string label attached to the future.")), 
#>                 "\n", "\n", list(list(list()), list("Additional named elements of the future.")), 
#>                 "\n"), "\n", list("\n", "An object of class ", 
#>                 list("Future"), ".\n"), "\n", list("\n", "A ", 
#>                 list("future"), " is an abstraction for a ", 
#>                 list("value"), " that may\n", "available at some point in the future.  A future can either be\n", 
#>                 list("unresolved"), " or ", list("resolved"), 
#>                 ", a state which can be checked\n", "with ", 
#>                 list(list("resolved()")), ".  As long as it is ", 
#>                 list("unresolved"), ", the\n", "value is not available.  As soon as it is ", 
#>                 list("resolved"), ", the value\n", "is available via ", 
#>                 list(list("value"), "()"), ".\n"), "\n", list(
#>                 "\n", "A Future object is itself an ", list("environment"), 
#>                 ".\n"), "\n", list("\n", "One function that creates a Future is ", 
#>                 list(list("future()")), ".\n", "It returns a Future that evaluates an ", 
#>                 list(), " expression in the future.\n", "An alternative approach is to use the ", 
#>                 list(list("%<-%")), " infix\n", "assignment operator, which creates a future from the\n", 
#>                 "right-hand-side (RHS) ", list(), " expression and assigns its future value\n", 
#>                 "to a variable as a ", list(list("promise")), 
#>                 ".\n"), "\n", list("internal"), "\n"), FutureCondition.Rd = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/FutureCondition-class.R", 
#>             "\n", list("FutureCondition"), "\n", list("FutureCondition"), 
#>             "\n", list("FutureMessage"), "\n", list("FutureWarning"), 
#>             "\n", list("FutureError"), "\n", list("RngFutureCondition"), 
#>             "\n", list("RngFutureWarning"), "\n", list("RngFutureError"), 
#>             "\n", list("UnexpectedFutureResultError"), "\n", 
#>             list("A condition (message, warning, or error) that occurred while orchestrating a future"), 
#>             "\n", list("\n", "FutureCondition(message, call = NULL, uuid = future$uuid, future = NULL)\n", 
#>                 "\n", "FutureMessage(message, call = NULL, uuid = future$uuid, future = NULL)\n", 
#>                 "\n", "FutureWarning(message, call = NULL, uuid = future$uuid, future = NULL)\n", 
#>                 "\n", "FutureError(message, call = NULL, uuid = future$uuid, future = NULL)\n", 
#>                 "\n", "RngFutureCondition(\n", "  message = NULL,\n", 
#>                 "  call = NULL,\n", "  uuid = future$uuid,\n", 
#>                 "  future = NULL\n", ")\n", "\n", "RngFutureWarning(...)\n", 
#>                 "\n", "RngFutureError(...)\n", "\n", "UnexpectedFutureResultError(future, hint = NULL)\n"), 
#>             "\n", list("\n", list(list("message"), list("A message condition.")), 
#>                 "\n", "\n", list(list("call"), list("The call stack that led up to the condition.")), 
#>                 "\n", "\n", list(list("uuid"), list("A universally unique identifier for the future associated with\n", 
#>                   "this FutureCondition.")), "\n", "\n", list(
#>                   list("future"), list("The ", list("Future"), 
#>                     " involved.")), "\n", "\n", list(list("hint"), 
#>                   list("(optional) A string with a suggestion on what might be wrong.")), 
#>                 "\n"), "\n", list("\n", "An object of class FutureCondition which inherits from class\n", 
#>                 list("condition"), " and FutureMessage, FutureWarning,\n", 
#>                 "and FutureError all inherits from FutureCondition.\n", 
#>                 "Moreover, a FutureError inherits from ", list(
#>                   "error"), ",\n", "a FutureWarning from ", list(
#>                   "warning"), ", and\n", "a FutureMessage from ", 
#>                 list("message"), ".\n"), "\n", list("\n", "While ", 
#>                 list("orchestrating"), " (creating, launching, querying, collection)\n", 
#>                 "futures, unexpected run-time errors (and other types of conditions) may\n", 
#>                 "occur.  Such conditions are coerced to a corresponding FutureCondition\n", 
#>                 "class to help distinguish them from conditions that occur due to the\n", 
#>                 list("evaluation"), " of the future.\n"), "\n", 
#>             list("internal"), "\n"), FutureGlobals.Rd = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/FutureGlobals-class.R", 
#>             "\n", list("FutureGlobals"), "\n", list("FutureGlobals"), 
#>             "\n", list("as.FutureGlobals"), "\n", list("as.FutureGlobals.FutureGlobals"), 
#>             "\n", list("as.FutureGlobals.Globals"), "\n", list(
#>                 "as.FutureGlobals.list"), "\n", list("[.FutureGlobals"), 
#>             "\n", list("c.FutureGlobals"), "\n", list("unique.FutureGlobals"), 
#>             "\n", list("A representation of a set of globals used with futures"), 
#>             "\n", list("\n", "FutureGlobals(object = list(), resolved = FALSE, total_size = NA_real_, ...)\n"), 
#>             "\n", list("\n", list(list("object"), list("A named list.")), 
#>                 "\n", "\n", list(list("resolved"), list("A logical indicating whether these globals\n", 
#>                   "have been scanned for and resolved futures or not.")), 
#>                 "\n", "\n", list(list("total_size"), list("The total size of all globals, if known.")), 
#>                 "\n", "\n", list(list(list()), list("Not used.")), 
#>                 "\n"), "\n", list("\n", "An object of class ", 
#>                 list("FutureGlobals"), ".\n"), "\n", list("\n", 
#>                 "A representation of a set of globals used with futures\n"), 
#>             "\n", list("\n", "This class extends the ", list(
#>                 "Globals"), " class by adding\n", "attributes ", 
#>                 list("resolved"), " and ", list("total_size"), 
#>                 ".\n"), "\n", list("internal"), "\n"), FutureResult.Rd = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/FutureResult-class.R", 
#>             "\n", list("FutureResult"), "\n", list("FutureResult"), 
#>             "\n", list("as.character.FutureResult"), "\n", list(
#>                 "print.FutureResult"), "\n", list("Results from resolving a future"), 
#>             "\n", list("\n", "FutureResult(\n", "  value = NULL,\n", 
#>                 "  visible = TRUE,\n", "  stdout = NULL,\n", 
#>                 "  conditions = NULL,\n", "  rng = FALSE,\n", 
#>                 "  ...,\n", "  started = .POSIXct(NA_real_),\n", 
#>                 "  finished = Sys.time(),\n", "  version = \"1.8\"\n", 
#>                 ")\n", "\n", list(list("as.character"), list(
#>                   "FutureResult")), "(x, ...)\n", "\n", list(
#>                   list("print"), list("FutureResult")), "(x, ...)\n"), 
#>             "\n", list("\n", list(list("value"), list("The value of the future expression.\n", 
#>                 "If the expression was not fully resolved (e.g. an error) occurred,\n", 
#>                 "the the value is ", list("NULL"), ".")), "\n", 
#>                 "\n", list(list("visible"), list("If TRUE, the value was visible, otherwise invisible.")), 
#>                 "\n", "\n", list(list("conditions"), list("A list of zero or more list elements each containing\n", 
#>                   "a captured ", list("condition"), " and possibly more meta data such as the\n", 
#>                   "call stack and a timestamp.")), "\n", "\n", 
#>                 list(list("rng"), list("If TRUE, the ", list(
#>                   ".Random.seed"), " was updated from resolving the\n", 
#>                   "future, otherwise not.")), "\n", "\n", list(
#>                   list(list()), list("(optional) Additional named results to be returned.")), 
#>                 "\n", "\n", list(list("started, finished"), list(
#>                   list("POSIXct"), " timestamps\n", "when the evaluation of the future expression was started and finished.")), 
#>                 "\n", "\n", list(list("version"), list("The version format of the results.")), 
#>                 "\n"), "\n", list("\n", "An object of class FutureResult.\n"), 
#>             "\n", list("\n", "Results from resolving a future\n"), 
#>             "\n", list("\n", "This function is only part of the ", 
#>                 list("backend"), " Future API.\n", "This function is ", 
#>                 list("not"), " part of the frontend Future API.\n"), 
#>             "\n", list(list("Note to developers"), list("\n", 
#>                 "\n", "The FutureResult structure is ", list(
#>                   "under development"), " and may change at anytime,\n", 
#>                 "e.g. elements may be renamed or removed.  Because of this, please avoid\n", 
#>                 "accessing the elements directly in code.  Feel free to reach out if you need\n", 
#>                 "to do so in your code.\n")), "\n", "\n", list(
#>                 "internal"), "\n"), `MulticoreFuture-class.Rd` = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/MulticoreFuture-class.R", 
#>             "\n", list("MulticoreFuture-class"), "\n", list("MulticoreFuture-class"), 
#>             "\n", list("MulticoreFuture"), "\n", list("A multicore future is a future whose value will be resolved asynchronously in a parallel process"), 
#>             "\n", list("\n", "MulticoreFuture(\n", "  expr = NULL,\n", 
#>                 "  substitute = TRUE,\n", "  envir = parent.frame(),\n", 
#>                 "  globals = TRUE,\n", "  lazy = FALSE,\n", "  ...\n", 
#>                 ")\n"), "\n", list("\n", list(list("expr"), list(
#>                 "An ", list(), " ", list("expression"), ".")), 
#>                 "\n", "\n", list(list("substitute"), list("If TRUE, argument ", 
#>                   list("expr"), " is\n", list(list("substitute"), 
#>                     "()"), ":ed, otherwise not.")), "\n", "\n", 
#>                 list(list("envir"), list("The ", list("environment"), 
#>                   " from where global objects should be\n", "identified.")), 
#>                 "\n", "\n", list(list("globals"), list("(optional) a logical, a character vector, or a named list\n", 
#>                   "to control how globals are handled.\n", "For details, see section 'Globals used by future expressions'\n", 
#>                   "in the help for ", list(list("future()")), 
#>                   ".")), "\n", "\n", list(list("lazy"), list(
#>                   "If FALSE (default), the future is resolved\n", 
#>                   "eagerly (starting immediately), otherwise not.")), 
#>                 "\n", "\n", list(list("..."), list("Additional named elements passed to ", 
#>                   list(list("Future()")), ".")), "\n"), "\n", 
#>             list("\n", "An object of class ", list("MulticoreFuture"), 
#>                 ".\n"), "\n", list("\n", "A multicore future is a future whose value will be resolved asynchronously in a parallel process\n"), 
#>             "\n", list("\n", "To evaluate an expression using \"multicore future\", see function\n", 
#>                 list(list("multicore()")), ".\n"), "\n", list(
#>                 "internal"), "\n"), `MultiprocessFuture-class.Rd` = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/MultiprocessFuture-class.R", 
#>             "\n", list("MultiprocessFuture-class"), "\n", list(
#>                 "MultiprocessFuture-class"), "\n", list("MultiprocessFuture"), 
#>             "\n", list("A multiprocess future is a future whose value will be resolved asynchronously in a parallel process"), 
#>             "\n", list("\n", "MultiprocessFuture(expr = NULL, substitute = TRUE, envir = parent.frame(), ...)\n"), 
#>             "\n", list("\n", list(list("expr"), list("An ", list(), 
#>                 " ", list("expression"), ".")), "\n", "\n", list(
#>                 list("substitute"), list("If TRUE, argument ", 
#>                   list("expr"), " is\n", list(list("substitute"), 
#>                     "()"), ":ed, otherwise not.")), "\n", "\n", 
#>                 list(list("envir"), list("The ", list("environment"), 
#>                   " from where global objects should be\n", "identified.")), 
#>                 "\n", "\n", list(list(list()), list("Additional named elements passed to ", 
#>                   list(list("Future()")), ".")), "\n"), "\n", 
#>             list("\n", "An object of class ", list("MultiprocessFuture"), 
#>                 ".\n"), "\n", list("\n", "A multiprocess future is a future whose value will be resolved asynchronously in a parallel process\n"), 
#>             "\n", list("\n", "To evaluate an expression using \"multiprocess future\", see function\n", 
#>                 list(list("multiprocess()")), ".\n"), "\n", list(
#>                 "internal"), "\n"), `UniprocessFuture-class.Rd` = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/UniprocessFuture-class.R", 
#>             "\n", list("UniprocessFuture-class"), "\n", list(
#>                 "UniprocessFuture-class"), "\n", list("UniprocessFuture"), 
#>             "\n", list("SequentialFuture"), "\n", list("TransparentFuture"), 
#>             "\n", list("An uniprocess future is a future whose value will be resolved synchronously in the current process"), 
#>             "\n", list("\n", "UniprocessFuture(\n", "  expr = NULL,\n", 
#>                 "  substitute = TRUE,\n", "  envir = parent.frame(),\n", 
#>                 "  globals = TRUE,\n", "  packages = NULL,\n", 
#>                 "  lazy = FALSE,\n", "  local = TRUE,\n", "  ...\n", 
#>                 ")\n", "\n", "SequentialFuture(\n", "  expr = NULL,\n", 
#>                 "  envir = parent.frame(),\n", "  substitute = TRUE,\n", 
#>                 "  lazy = FALSE,\n", "  globals = TRUE,\n", "  local = TRUE,\n", 
#>                 "  ...\n", ")\n", "\n", "TransparentFuture(\n", 
#>                 "  expr = NULL,\n", "  envir = parent.frame(),\n", 
#>                 "  substitute = TRUE,\n", "  lazy = FALSE,\n", 
#>                 "  globals = TRUE,\n", "  local = FALSE,\n", 
#>                 "  ...\n", ")\n"), "\n", list("\n", list(list(
#>                 "expr"), list("An ", list(), " ", list("expression"), 
#>                 ".")), "\n", "\n", list(list("substitute"), list(
#>                 "If TRUE, argument ", list("expr"), " is\n", 
#>                 list(list("substitute"), "()"), ":ed, otherwise not.")), 
#>                 "\n", "\n", list(list("envir"), list("The ", 
#>                   list("environment"), " from where global objects should be\n", 
#>                   "identified.")), "\n", "\n", list(list("globals"), 
#>                   list("(optional) a logical, a character vector, or a named list\n", 
#>                     "to control how globals are handled.\n", 
#>                     "For details, see section 'Globals used by future expressions'\n", 
#>                     "in the help for ", list(list("future()")), 
#>                     ".")), "\n", "\n", list(list("packages"), 
#>                   list("(optional) a character vector specifying packages\n", 
#>                     "to be attached in the ", list(), " environment evaluating the future.")), 
#>                 "\n", "\n", list(list("lazy"), list("If FALSE (default), the future is resolved\n", 
#>                   "eagerly (starting immediately), otherwise not.")), 
#>                 "\n", "\n", list(list("local"), list("If TRUE, the expression is evaluated such that\n", 
#>                   "all assignments are done to local temporary environment, otherwise\n", 
#>                   "the assignments are done to the global environment of the ", 
#>                   list(), " process\n", "evaluating the future.")), 
#>                 "\n", "\n", list(list(list()), list("Additional named elements passed to ", 
#>                   list(list("Future()")), ".")), "\n"), "\n", 
#>             list("\n", "An object of class ", list("UniprocessFuture"), 
#>                 ".\n"), "\n", list("\n", "An uniprocess future is a future whose value will be resolved synchronously in the current process\n"), 
#>             "\n", list("\n", "To evaluate an expression using \"uniprocess future\", see functions\n", 
#>                 list(list("uniprocess()")), ".\n"), "\n", list(
#>                 "internal"), "\n"), as_lecyer_cmrg_seed.Rd = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/rng.R", "\n", list(
#>                 "as_lecyer_cmrg_seed"), "\n", list("as_lecyer_cmrg_seed"), 
#>             "\n", list("is_lecyer_cmrg_seed"), "\n", list("Get a L'Ecuyer-CMRG seed either from an input seed or the current RNG state"), 
#>             "\n", list("\n", "as_lecyer_cmrg_seed(seed)\n", "\n", 
#>                 "is_lecyer_cmrg_seed(seed)\n"), "\n", list("\n", 
#>                 list(list("seed"), list("TRUE or NA, or a numeric vector of length one or seven.")), 
#>                 "\n"), "\n", list("\n", list("as_lecyer_cmrg_seed(seed)"), 
#>                 " returns a L'Ecuyer-CMRG seed, which is a\n", 
#>                 "7-digit integer vector, based on the input ", 
#>                 list("seed"), ".\n", "If already a L'Ecuyer-CMRG seed, then ", 
#>                 list("seed"), " is return as-is.\n", "If a scalar integer, then a random L'Ecuyer-CMRG seed is created based\n", 
#>                 "on this seed as the current RNG state.\n", "If ", 
#>                 list("seed = TRUE"), " and the current seed is already a L'Ecuyer-CMRG seed,\n", 
#>                 "then then current seed (", list(".Random.seed"), 
#>                 ") is return as-is.\n", "If ", list("seed = TRUE"), 
#>                 " and the current seed is ", list("not"), " of the 'L'Ecuyer-CMRG' kind,\n", 
#>                 "or ", list("seed = NA"), ", then a random one is created (based on the current RNG\n", 
#>                 "state).\n", "Any other values, including FALSE, is an error.\n", 
#>                 "\n", list("is_lecyer_cmrg_seed(seed)"), " returns TRUE if ", 
#>                 list("seed"), " is L'Ecuyer-CMRG seed,\n", "otherwise FALSE.\n"), 
#>             "\n", list("\n", "Get a L'Ecuyer-CMRG seed either from an input seed or the current RNG state\n"), 
#>             "\n", list("\n", "The ", list("as_lecyer_cmrg_seed()"), 
#>                 " function preserves the current RNG state, that\n", 
#>                 "is, it leaves ", list("globalenv()$.Random.seed"), 
#>                 " intact, which means it also leaved\n", "the RNG kind (", 
#>                 list("RNGkind()"), ") intact.\n", "\n", "Per ", 
#>                 list(list("base::RNGkind()")), ", a L'Ecuyer-CMRG seed comprise a length-seven integer\n", 
#>                 "vector of format ", list(".Random.seed <- c(rng.kind, n)"), 
#>                 " where ", list("length(n) == 6L"), " and ", 
#>                 list("rng.kind"), " fulfills ", list("rng.kind %% 10000L == 407L"), 
#>                 ".\n"), "\n", list("\n", "# The current RNG kind\n", 
#>                 "okind <- RNGkind()\n", "oseed <- globalenv()$.Random.seed\n", 
#>                 "\n", "# (a) A L'Ecuyer-CMRG seed based on a numeric-scalar seed\n", 
#>                 "seed1 <- future:::as_lecyer_cmrg_seed(42)\n", 
#>                 "str(seed1)\n", "## int [1:7] 10407 -2133391687 507561766 1260545903 1362917092 -1772566379 -1344458670\n", 
#>                 "# The RNG kind and the RNG state is preserved\n", 
#>                 "stopifnot(\n", "  future:::is_lecyer_cmrg_seed(seed1),\n", 
#>                 "  identical(RNGkind(), okind),\n", "  identical(globalenv()$.Random.seed, oseed)\n", 
#>                 ")\n", "\n", "# (b) A L'Ecuyer-CMRG seed based on a L'Ecuyer-CMRG seed\n", 
#>                 "seed2 <- future:::as_lecyer_cmrg_seed(seed1)\n", 
#>                 "str(seed2)\n", "## int [1:7] 10407 -2133391687 507561766 1260545903 1362917092 -1772566379 -1344458670\n", 
#>                 "# The input L'Ecuyer-CMRG seed is returned as-is\n", 
#>                 "stopifnot(identical(seed2, seed1))\n", "# The RNG kind and the RNG state is preserved\n", 
#>                 "stopifnot(\n", "  future:::is_lecyer_cmrg_seed(seed2),\n", 
#>                 "  identical(RNGkind(), okind),\n", "  identical(globalenv()$.Random.seed, oseed)\n", 
#>                 ")\n", "\n", "# (c) A L'Ecuyer-CMRG seed based on the current RNG state\n", 
#>                 "seed3 <- future:::as_lecyer_cmrg_seed(TRUE)\n", 
#>                 "str(seed3)\n", "## int [1:7] 10407 495333909 -1491719214 416071979 49340016 1956499377 899435966\n", 
#>                 "stopifnot(future:::is_lecyer_cmrg_seed(seed3))\n", 
#>                 "\n", "\n", "# All of the above calls preserve the RNG state including the RNG kind\n", 
#>                 "stopifnot(\n", "  identical(RNGkind(), okind),\n", 
#>                 "  identical(globalenv()$.Random.seed, oseed)\n", 
#>                 ")\n"), "\n", list("internal"), "\n"), backtrace.Rd = list(
#>             "% Generated by roxygen2: do not edit by hand", "\n", 
#>             "% Please edit documentation in R/backtrace.R", "\n", 
#>             list("backtrace"), "\n", list("backtrace"), "\n", 
#>             list("Back trace the expressions evaluated when an error was caught"), 
#>             "\n", list("\n", "backtrace(future, envir = parent.frame(), ...)\n"), 
#>             "\n", list("\n", list(list("future"), list("A future with a caught error.")), 
#>                 "\n", "\n", list(list("envir"), list("the environment where to locate the future.")), 
#>                 "\n", "\n", list(list(list()), list("Not used.")), 
#>                 "\n"), "\n", list("\n", "A list with the future's call stack that led up to the error.\n"), 
#>             "\n", list("\n", "Back trace the expressions evaluated when an error was caught\n"), 
#>             "\n", list("\n", "my_log <- function(x) log(x)\n", 
#>                 "foo <- function(...) my_log(...)\n", "\n", "f <- future({ foo(\"a\") })\n", 
#>                 "res <- tryCatch({\n", "  v <- value(f)\n", "}, error = function(ex) {\n", 
#>                 "  t <- backtrace(f)\n", "  print(t)\n", "})\n", 
#>                 list("\n", "## R CMD check: make sure any open connections are closed afterward\n", 
#>                   "if (!inherits(plan(\"next\"), \"sequential\")) plan(sequential)\n"), 
#>                 "\n", "\n"), "\n"), cluster.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>             "\n", "% Please edit documentation in R/cluster.R", 
#>             "\n", list("cluster"), "\n", list("cluster"), "\n", 
#>             list("Create a cluster future whose value will be resolved asynchronously in a parallel process"), 
#>             "\n", list("\n", "cluster(..., workers = availableWorkers(), envir = parent.frame())\n"), 
#>             "\n", list("\n", list(list(list()), list("Additional named elements passed to ", 
#>                 list(list("ClusterFuture()")), ".")), "\n", "\n", 
#>                 list(list("workers"), list("A ", list(list("cluster")), 
#>                   " object,\n", "a character vector of host names, a positive numeric scalar,\n", 
#>                   "or a function.\n", "If a character vector or a numeric scalar, a ", 
#>                   list("cluster"), " object\n", "is created using ", 
#>                   list(list("makeClusterPSOCK"), "(workers)"), 
#>                   ".\n", "If a function, it is called without arguments ", 
#>                   list("when the future\n", "is created"), " and its value is used to configure the workers.\n", 
#>                   "The function should return any of the above types.")), 
#>                 "\n", "\n", list(list("envir"), list("The ", 
#>                   list("environment"), " from where global objects should be\n", 
#>                   "identified.")), "\n"), "\n", list("\n", "A ", 
#>                 list("ClusterFuture"), ".\n"), "\n", list("\n", 
#>                 "A cluster future is a future that uses cluster evaluation,\n", 
#>                 "which means that its ", list("value is computed and resolved in\n", 
#>                   "parallel in another process"), ".\n"), "\n", 
#>             list("\n", "This function is ", list("not"), " meant to be called directly.  Instead, the\n", 
#>                 "typical usages are:", list(list("html"), list(
#>                   list("<div class=\"sourceCode r\">"))), list(
#>                   "# Evaluate futures via a single background R process on the local machine\n", 
#>                   "plan(cluster, workers = 1)\n", "\n", "# Evaluate futures via two background R processes on the local machine\n", 
#>                   "plan(cluster, workers = 2)\n", "\n", "# Evaluate futures via a single R process on another machine on on the\n", 
#>                   "# local area network (LAN)\n", "plan(cluster, workers = \"raspberry-pi\")\n", 
#>                   "\n", "# Evaluate futures via a single R process running on a remote machine\n", 
#>                   "plan(cluster, workers = \"pi.example.org\")\n", 
#>                   "\n", "# Evaluate futures via four R processes, one running on the local machine,\n", 
#>                   "# two running on LAN machine 'n1' and one on a remote machine\n", 
#>                   "plan(cluster, workers = c(\"localhost\", \"n1\", \"n1\", \"pi.example.org\")\n"), 
#>                 list(list("html"), list(list("</div>"))), "\n"), 
#>             "\n", list("\n", list("\n", "\n", "## Use cluster futures\n", 
#>                 "cl <- parallel::makeCluster(2, timeout = 60)\n", 
#>                 "plan(cluster, workers = cl)\n", "\n", "## A global variable\n", 
#>                 "a <- 0\n", "\n", "## Create future (explicitly)\n", 
#>                 "f <- future({\n", "  b <- 3\n", "  c <- 2\n", 
#>                 "  a * b * c\n", "})\n", "\n", "## A cluster future is evaluated in a separate process.\n", 
#>                 "## Regardless, changing the value of a global variable will\n", 
#>                 "## not affect the result of the future.\n", 
#>                 "a <- 7\n", "print(a)\n", "\n", "v <- value(f)\n", 
#>                 "print(v)\n", "stopifnot(v == 0)\n", "\n", "## CLEANUP\n", 
#>                 "parallel::stopCluster(cl)\n", "\n"), "\n"), 
#>             "\n"), clusterExportSticky.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>             "\n", "% Please edit documentation in R/sticky_globals.R", 
#>             "\n", list("clusterExportSticky"), "\n", list("clusterExportSticky"), 
#>             "\n", list("Export globals to the sticky-globals environment of the cluster nodes"), 
#>             "\n", list("\n", "clusterExportSticky(cl, globals)\n"), 
#>             "\n", list("\n", list(list("cl"), list("(cluster) A cluster object as returned by\n", 
#>                 list(list("parallel::makeCluster()")), ".")), 
#>                 "\n", "\n", list(list("globals"), list("(list) A named list of sticky globals to be exported.")), 
#>                 "\n"), "\n", list("\n", "(invisible; cluster) The cluster object.\n"), 
#>             "\n", list("\n", "Export globals to the sticky-globals environment of the cluster nodes\n"), 
#>             "\n", list("\n", "This requires that the ", list(
#>                 "future"), " package is installed on the cluster\n", 
#>                 "nodes.\n"), "\n", list("internals"), "\n"), 
#>             find_references.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/utils-marshalling.R", 
#>                 "\n", list("find_references"), "\n", list("find_references"), 
#>                 "\n", list("assert_no_references"), "\n", list(
#>                   "Get the first or all references of an ", list(), 
#>                   " object"), "\n", list("\n", "find_references(x, first_only = FALSE)\n", 
#>                   "\n", "assert_no_references(\n", "  x,\n", 
#>                   "  action = c(\"error\", \"warning\", \"message\", \"string\"),\n", 
#>                   "  source = c(\"globals\", \"value\")\n", ")\n"), 
#>                 "\n", list("\n", list(list("x"), list("The ", 
#>                   list(), " object to be checked.")), "\n", "\n", 
#>                   list(list("first_only"), list("If ", list("TRUE"), 
#>                     ", only the first reference is returned,\n", 
#>                     "otherwise all references.")), "\n", "\n", 
#>                   list(list("action"), list("Type of action to take if a reference is found.")), 
#>                   "\n", "\n", list(list("source"), list("Is the source of ", 
#>                     list("x"), " the globals or the value of the future?")), 
#>                   "\n"), "\n", list("\n", list("find_references()"), 
#>                   " returns a list of zero or more references\n", 
#>                   "identified.\n", "\n", "If a reference is detected, an informative error, warning, message,\n", 
#>                   "or a character string is produced, otherwise ", 
#>                   list("NULL"), " is returned\n", "invisibly.\n"), 
#>                 "\n", list("\n", "Get the first or all references of an ", 
#>                   list(), " object\n", "\n", "Assert that there are no references among the identified globals\n"), 
#>                 "\n", list("internal"), "\n"), future.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/future.R, R/futureAssign.R,", 
#>                 "\n", "%   R/futureAssign_OP.R, R/futureCall.R", 
#>                 "\n", list("future"), "\n", list("future"), "\n", 
#>                 list("futureCall"), "\n", list("futureAssign"), 
#>                 "\n", list("%<-%"), "\n", list("%->%"), "\n", 
#>                 list("Create a future"), "\n", list("\n", "future(\n", 
#>                   "  expr,\n", "  envir = parent.frame(),\n", 
#>                   "  substitute = TRUE,\n", "  lazy = FALSE,\n", 
#>                   "  seed = FALSE,\n", "  globals = TRUE,\n", 
#>                   "  packages = NULL,\n", "  stdout = TRUE,\n", 
#>                   "  conditions = \"condition\",\n", "  earlySignal = FALSE,\n", 
#>                   "  label = NULL,\n", "  gc = FALSE,\n", "  ...\n", 
#>                   ")\n", "\n", "futureAssign(\n", "  x,\n", "  value,\n", 
#>                   "  envir = parent.frame(),\n", "  substitute = TRUE,\n", 
#>                   "  lazy = FALSE,\n", "  seed = FALSE,\n", "  globals = TRUE,\n", 
#>                   "  packages = NULL,\n", "  stdout = TRUE,\n", 
#>                   "  conditions = \"condition\",\n", "  earlySignal = FALSE,\n", 
#>                   "  label = NULL,\n", "  gc = FALSE,\n", "  ...,\n", 
#>                   "  assign.env = envir\n", ")\n", "\n", "x %<-% value\n", 
#>                   "\n", "futureCall(\n", "  FUN,\n", "  args = list(),\n", 
#>                   "  envir = parent.frame(),\n", "  lazy = FALSE,\n", 
#>                   "  seed = FALSE,\n", "  globals = TRUE,\n", 
#>                   "  packages = NULL,\n", "  stdout = TRUE,\n", 
#>                   "  conditions = \"condition\",\n", "  earlySignal = FALSE,\n", 
#>                   "  label = NULL,\n", "  gc = FALSE,\n", "  ...\n", 
#>                   ")\n"), "\n", list("\n", list(list("expr, value"), 
#>                   list("An ", list(), " ", list("expression"), 
#>                     ".")), "\n", "\n", list(list("envir"), list(
#>                   "The ", list("environment"), " from where global objects should be\n", 
#>                   "identified.")), "\n", "\n", list(list("substitute"), 
#>                   list("If TRUE, argument ", list("expr"), " is\n", 
#>                     list(list("substitute"), "()"), ":ed, otherwise not.")), 
#>                   "\n", "\n", list(list("lazy"), list("If FALSE (default), the future is resolved\n", 
#>                     "eagerly (starting immediately), otherwise not.")), 
#>                   "\n", "\n", list(list("seed"), list("(optional) If TRUE, the random seed, that is, the state of the\n", 
#>                     "random number generator (RNG) will be set such that statistically sound\n", 
#>                     "random numbers are produced (also during parallelization).\n", 
#>                     "If FALSE (default), it is assumed that the future expression does neither\n", 
#>                     "need nor use random numbers generation.\n", 
#>                     "To use a fixed random seed, specify a L'Ecuyer-CMRG seed (seven integer)\n", 
#>                     "or a regular RNG seed (a single integer).  If the latter, then a\n", 
#>                     "L'Ecuyer-CMRG seed will be automatically created based on the given seed.\n", 
#>                     "Furthermore, if FALSE, then the future will be monitored to make sure it\n", 
#>                     "does not use random numbers.  If it does and depending on the value of\n", 
#>                     "option ", list(list("future.rng.onMisuse")), 
#>                     ", the check is\n", "ignored, an informative warning, or error will be produced.\n", 
#>                     "If ", list("seed"), " is NULL, then the effect is as with ", 
#>                     list("seed = FALSE"), "\n", "but without the RNG check being performed.")), 
#>                   "\n", "\n", list(list("globals"), list("(optional) a logical, a character vector, or a named list\n", 
#>                     "to control how globals are handled.\n", 
#>                     "For details, see section 'Globals used by future expressions'\n", 
#>                     "in the help for ", list(list("future()")), 
#>                     ".")), "\n", "\n", list(list("packages"), 
#>                     list("(optional) a character vector specifying packages\n", 
#>                       "to be attached in the ", list(), " environment evaluating the future.")), 
#>                   "\n", "\n", list(list("stdout"), list("If TRUE (default), then the standard output is captured,\n", 
#>                     "and re-outputted when ", list("value()"), 
#>                     " is called.\n", "If FALSE, any output is silenced (by sinking it to the null device as\n", 
#>                     "it is outputted).\n", "If NA (not recommended), output is ", 
#>                     list("not"), " intercepted.")), "\n", "\n", 
#>                   list(list("conditions"), list("A character string of conditions classes to be captured\n", 
#>                     "and relayed.  The default is to relay messages and warnings.\n", 
#>                     "To not intercept any types of conditions, use ", 
#>                     list("conditions = NULL"), ".\n", "Attribute ", 
#>                     list("exclude"), " can be used to ignore specific classes, e.g.\n", 
#>                     list("conditions = structure(\"condition\", exclude = \"message\")"), 
#>                     " will capture\n", "all ", list("condition"), 
#>                     " classes except those that inherits from the ", 
#>                     list("message"), " class.\n", "Errors are always relayed.")), 
#>                   "\n", "\n", list(list("earlySignal"), list(
#>                     "Specified whether conditions should be signaled as soon\n", 
#>                     "as possible or not.")), "\n", "\n", list(
#>                     list("label"), list("An optional character string label attached to the future.")), 
#>                   "\n", "\n", list(list("gc"), list("If TRUE, the garbage collector run (in the process that\n", 
#>                     "evaluated the future) only after the value of the future is collected.\n", 
#>                     "Exactly when the values are collected may depend on various factors such\n", 
#>                     "as number of free workers and whether ", 
#>                     list("earlySignal"), " is TRUE (more\n", 
#>                     "frequently) or FALSE (less frequently).\n", 
#>                     list("Some types of futures ignore this argument."))), 
#>                   "\n", "\n", list(list(list()), list("Additional arguments passed to ", 
#>                     list(list("Future()")), ".")), "\n", "\n", 
#>                   list(list("x"), list("the name of a future variable, which will hold the value\n", 
#>                     "of the future expression (as a promise).")), 
#>                   "\n", "\n", list(list("assign.env"), list("The ", 
#>                     list("environment"), " to which the variable\n", 
#>                     "should be assigned.")), "\n", "\n", list(
#>                     list("FUN"), list("A ", list("function"), 
#>                       " to be evaluated.")), "\n", "\n", list(
#>                     list("args"), list("A ", list("list"), " of arguments passed to function ", 
#>                       list("FUN"), ".")), "\n"), "\n", list("\n", 
#>                   list("f <- future(expr)"), " creates a ", list(
#>                     "Future"), " ", list("f"), " that evaluates expression ", 
#>                   list("expr"), ", the value of the future is retrieved using ", 
#>                   list("v <- value(f)"), ".\n", "\n", list("x %<-% value"), 
#>                   " (a future assignment) and\n", list("futureAssign(\"x\", value)"), 
#>                   " create a ", list("Future"), " that evaluates\n", 
#>                   "expression ", list("expr"), " and binds its value (as a\n", 
#>                   list("promise"), ") to\n", "a variable ", list(
#>                     "x"), ".  The value of the future is automatically retrieved\n", 
#>                   "when the assigned variable (promise) is queried.\n", 
#>                   "The future itself is returned invisibly, e.g.\n", 
#>                   list("f <- futureAssign(\"x\", expr)"), " and ", 
#>                   list("f <- (x %<-% expr)"), ".\n", "Alternatively, the future of a future variable ", 
#>                   list("x"), " can be retrieved\n", "without blocking using ", 
#>                   list("f <- ", list("futureOf"), "(x)"), ".\n", 
#>                   "Both the future and the variable (promise) are assigned to environment\n", 
#>                   list("assign.env"), " where the name of the future is ", 
#>                   list(".future_<name>"), ".\n", "\n", list("f <- futureCall(FUN, args)"), 
#>                   " creates a ", list("Future"), " ", list("f"), 
#>                   " that calls function ", list("FUN"), " with arguments ", 
#>                   list("args"), ", where the value of the future is retrieved using ", 
#>                   list("x <- value(f)"), ".\n"), "\n", list("\n", 
#>                   list(list("html"), list(list(list("logo.png"), 
#>                     list("options: align='right' alt='logo' width='120'")))), 
#>                   "\n", "Creates a future that evaluates an ", 
#>                   list(), " expression or\n", "a future that calls an ", 
#>                   list(), " function with a set of arguments.\n", 
#>                   "How, when, and where these futures are evaluated can be configured\n", 
#>                   "using ", list(list("plan()")), " such that it is evaluated in parallel on,\n", 
#>                   "for instance, the current machine, on a remote machine, or via a\n", 
#>                   "job queue on a compute cluster.\n", "Importantly, any ", 
#>                   list(), " code using futures remains the same regardless\n", 
#>                   "on these settings and there is no need to modify the code when\n", 
#>                   "switching from, say, sequential to parallel processing.\n"), 
#>                 "\n", list("\n", "The state of a future is either unresolved or resolved.\n", 
#>                   "The value of a future can be retrieved using ", 
#>                   list("v <- ", list("value"), "(f)"), ".\n", 
#>                   "Querying the value of a non-resolved future will ", 
#>                   list("block"), " the call\n", "until the future is resolved.\n", 
#>                   "It is possible to check whether a future is resolved or not\n", 
#>                   "without blocking by using ", list(list("resolved"), 
#>                     "(f)"), ".\n", "\n", "For a future created via a future assignment\n", 
#>                   "(", list("x %<-% value"), " or ", list("futureAssign(\"x\", value)"), 
#>                   "), the value\n", "is bound to a promise, which when queried will internally call\n", 
#>                   list(list("value()")), "  on the future and which will then be resolved\n", 
#>                   "into a regular variable bound to that value.  For example, with future\n", 
#>                   "assignment ", list("x %<-% value"), ", the first time variable ", 
#>                   list("x"), " is\n", "queried the call blocks if (and only if) the future is not yet resolved.\n", 
#>                   "As soon as it is resolved, and any succeeding queries, querying ", 
#>                   list("x"), "\n", "will immediately give the value.\n", 
#>                   "\n", "The future assignment construct ", list(
#>                     "x %<-% value"), " is not a formal\n", "assignment per se, but a binary infix operator on objects ", 
#>                   list("x"), "\n", "and expression ", list("value"), 
#>                   ".  However, by using non-standard evaluation,\n", 
#>                   "this constructs can emulate an assignment operator similar to\n", 
#>                   list("x <- value"), ". Due to ", list(), "'s precedence rules of operators,\n", 
#>                   "future expressions often need to be explicitly bracketed, e.g.\n", 
#>                   list("x %<-% { a + b }"), ".\n", "\n", "The ", 
#>                   list("futureCall()"), " function works analogously to\n", 
#>                   list(list("do.call"), "()"), ", which calls a function with a set of\n", 
#>                   "arguments.  The difference is that ", list(
#>                     "do.call()"), " returns the value of\n", 
#>                   "the call whereas ", list("futureCall()"), 
#>                   " returns a future.\n"), "\n", list(list("Eager or lazy evaluation"), 
#>                   list("\n", "\n", "By default, a future is resolved using ", 
#>                     list("eager"), " evaluation\n", "(", list(
#>                       "lazy = FALSE"), ").  This means that the expression starts to\n", 
#>                     "be evaluated as soon as the future is created.\n", 
#>                     "\n", "As an alternative, the future can be resolved using ", 
#>                     list("lazy"), "\n", "evaluation (", list(
#>                       "lazy = TRUE"), ").  This means that the expression\n", 
#>                     "will only be evaluated when the value of the future is requested.\n", 
#>                     list("Note that this means that the expression may not be evaluated\n", 
#>                       "at all - it is guaranteed to be evaluated if the value is requested"), 
#>                     ".\n", "\n", "For future assignments, lazy evaluation can be controlled via the\n", 
#>                     list("%lazy%"), " operator, e.g. ", list(
#>                       "x %<-% { expr } %lazy% TRUE"), ".\n")), 
#>                 "\n", "\n", list(list("Globals used by future expressions"), 
#>                   list("\n", "\n", "Global objects (short ", 
#>                     list("globals"), ") are objects (e.g. variables and\n", 
#>                     "functions) that are needed in order for the future expression to be\n", 
#>                     "evaluated while not being local objects that are defined by the future\n", 
#>                     "expression. For example, in\n", list("\n", 
#>                       "  a <- 42\n", "  f <- future({ b <- 2; a * b })\n"), 
#>                     "\n", "variable ", list("a"), " is a global of future assignment ", 
#>                     list("f"), " whereas\n", list("b"), " is a local variable.\n", 
#>                     "In order for the future to be resolved successfully (and correctly),\n", 
#>                     "all globals need to be gathered when the future is created such that\n", 
#>                     "they are available whenever and wherever the future is resolved.\n", 
#>                     "\n", "The default behavior (", list("globals = TRUE"), 
#>                     "),\n", "is that globals are automatically identified and gathered.\n", 
#>                     "More precisely, globals are identified via code inspection of the\n", 
#>                     "future expression ", list("expr"), " and their values are retrieved with\n", 
#>                     "environment ", list("envir"), " as the starting point (basically via\n", 
#>                     list("get(global, envir = envir, inherits = TRUE)"), 
#>                     ").\n", list("In most cases, such automatic collection of globals is sufficient\n", 
#>                       "and less tedious and error prone than if they are manually specified"), 
#>                     ".\n", "\n", "However, for full control, it is also possible to explicitly specify\n", 
#>                     "exactly which the globals are by providing their names as a character\n", 
#>                     "vector.\n", "In the above example, we could use\n", 
#>                     list("\n", "  a <- 42\n", "  f <- future({ b <- 2; a * b }, globals = \"a\")\n"), 
#>                     "\n", "\n", "Yet another alternative is to explicitly specify also their values\n", 
#>                     "using a named list as in\n", list("\n", 
#>                       "  a <- 42\n", "  f <- future({ b <- 2; a * b }, globals = list(a = a))\n"), 
#>                     "\n", "or\n", list("\n", "  f <- future({ b <- 2; a * b }, globals = list(a = 42))\n"), 
#>                     "\n", "\n", "Specifying globals explicitly avoids the overhead added from\n", 
#>                     "automatically identifying the globals and gathering their values.\n", 
#>                     "Furthermore, if we know that the future expression does not make use\n", 
#>                     "of any global variables, we can disable the automatic search for\n", 
#>                     "globals by using\n", list("\n", "  f <- future({ a <- 42; b <- 2; a * b }, globals = FALSE)\n"), 
#>                     "\n", "\n", "Future expressions often make use of functions from one or more packages.\n", 
#>                     "As long as these functions are part of the set of globals, the future\n", 
#>                     "package will make sure that those packages are attached when the future\n", 
#>                     "is resolved.  Because there is no need for such globals to be frozen\n", 
#>                     "or exported, the future package will not export them, which reduces\n", 
#>                     "the amount of transferred objects.\n", "For example, in\n", 
#>                     list("\n", "  x <- rnorm(1000)\n", "  f <- future({ median(x) })\n"), 
#>                     "\n", "variable ", list("x"), " and ", list(
#>                       "median()"), " are globals, but only ", 
#>                     list("x"), "\n", "is exported whereas ", 
#>                     list("median()"), ", which is part of the ", 
#>                     list("stats"), "\n", "package, is not exported.  Instead it is made sure that the ", 
#>                     list("stats"), "\n", "package is on the search path when the future expression is evaluated.\n", 
#>                     "Effectively, the above becomes\n", list(
#>                       "\n", "  x <- rnorm(1000)\n", "  f <- future({\n", 
#>                       "    library(\"stats\")\n", "    median(x)\n", 
#>                       "  })\n"), "\n", "To manually specify this, one can either do\n", 
#>                     list("\n", "  x <- rnorm(1000)\n", "  f <- future({\n", 
#>                       "    median(x)\n", "  }, globals = list(x = x, median = stats::median)\n"), 
#>                     "\n", "or\n", list("\n", "  x <- rnorm(1000)\n", 
#>                       "  f <- future({\n", "    library(\"stats\")\n", 
#>                       "    median(x)\n", "  }, globals = list(x = x))\n"), 
#>                     "\n", "Both are effectively the same.\n", 
#>                     "\n", "Although rarely needed, a combination of automatic identification and manual\n", 
#>                     "specification of globals is supported via attributes ", 
#>                     list("add"), " (to add\n", "false negatives) and ", 
#>                     list("ignore"), " (to ignore false positives) on value\n", 
#>                     list("TRUE"), ".  For example, with\n", list(
#>                       "globals = structure(TRUE, ignore = \"b\", add = \"a\")"), 
#>                     " any globals\n", "automatically identified except ", 
#>                     list("b"), " will be used in addition to\n", 
#>                     "global ", list("a"), ".\n", "\n", "When using future assignments, globals can be specified analogously\n", 
#>                     "using the ", list(list("%globals%")), " operator, e.g.\n", 
#>                     list("\n", "  x <- rnorm(1000)\n", "  y %<-% { median(x) } %globals% list(x = x, median = stats::median)\n"), 
#>                     "\n")), "\n", "\n", list("\n", "## Evaluate futures in parallel\n", 
#>                   "plan(multisession)\n", "\n", "## Data\n", 
#>                   "x <- rnorm(100)\n", "y <- 2 * x + 0.2 + rnorm(100)\n", 
#>                   "w <- 1 + x ^ 2\n", "\n", "\n", "## EXAMPLE: Regular assignments (evaluated sequentially)\n", 
#>                   "fitA <- lm(y ~ x, weights = w)      ## with offset\n", 
#>                   "fitB <- lm(y ~ x - 1, weights = w)  ## without offset\n", 
#>                   "fitC <- {\n", "  w <- 1 + abs(x)  ## Different weights\n", 
#>                   "  lm(y ~ x, weights = w)\n", "}\n", "print(fitA)\n", 
#>                   "print(fitB)\n", "print(fitC)\n", "\n", "\n", 
#>                   "## EXAMPLE: Future assignments (evaluated in parallel)\n", 
#>                   "fitA %<-% lm(y ~ x, weights = w)      ## with offset\n", 
#>                   "fitB %<-% lm(y ~ x - 1, weights = w)  ## without offset\n", 
#>                   "fitC %<-% {\n", "  w <- 1 + abs(x)\n", "  lm(y ~ x, weights = w)\n", 
#>                   "}\n", "print(fitA)\n", "print(fitB)\n", "print(fitC)\n", 
#>                   "\n", "\n", "## EXAMPLE: Explicitly create futures (evaluated in parallel)\n", 
#>                   "## and retrieve their values\n", "fA <- future( lm(y ~ x, weights = w) )\n", 
#>                   "fB <- future( lm(y ~ x - 1, weights = w) )\n", 
#>                   "fC <- future({\n", "  w <- 1 + abs(x)\n", 
#>                   "  lm(y ~ x, weights = w)\n", "})\n", "fitA <- value(fA)\n", 
#>                   "fitB <- value(fB)\n", "fitC <- value(fC)\n", 
#>                   "print(fitA)\n", "print(fitB)\n", "print(fitC)\n", 
#>                   "\n", list("\n", "## Make sure to \"close\" an multisession workers on Windows\n", 
#>                     "plan(sequential)\n"), "\n", "## EXAMPLE: futureCall() and do.call()\n", 
#>                   "x <- 1:100\n", "y0 <- do.call(sum, args = list(x))\n", 
#>                   "print(y0)\n", "\n", "f1 <- futureCall(sum, args = list(x))\n", 
#>                   "y1 <- value(f1)\n", "print(y1)\n"), "\n", 
#>                 list("\n", "How, when and where futures are resolved is given by the\n", 
#>                   list("future strategy"), ", which can be set by the end user using the\n", 
#>                   list(list("plan()")), " function.  The future strategy must not be\n", 
#>                   "set by the developer, e.g. it must not be called within a package.\n"), 
#>                 "\n", list("\n", "The future logo was designed by Dan LaBar and tweaked by Henrik Bengtsson.\n"), 
#>                 "\n"), future.options.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/options.R", 
#>                 "\n", list("future.options"), "\n", list("future.options"), 
#>                 "\n", list("future.cmdargs"), "\n", list(".future.R"), 
#>                 "\n", list("future.startup.script"), "\n", list(
#>                   "R_FUTURE_STARTUP_SCRIPT"), "\n", list("future.debug"), 
#>                 "\n", list("R_FUTURE_DEBUG"), "\n", list("future.demo.mandelbrot.region"), 
#>                 "\n", list("R_FUTURE_DEMO_MANDELBROT_REGION"), 
#>                 "\n", list("future.demo.mandelbrot.nrow"), "\n", 
#>                 list("R_FUTURE_DEMO_MANDELBROT_NROW"), "\n", 
#>                 list("future.fork.multithreading.enable"), "\n", 
#>                 list("R_FUTURE_FORK_MULTITHREADING_ENABLE"), 
#>                 "\n", list("future.globals.maxSize"), "\n", list(
#>                   "R_FUTURE_GLOBALS_MAXSIZE"), "\n", list("future.globals.method"), 
#>                 "\n", list("R_FUTURE_GLOBALS_METHOD"), "\n", 
#>                 list("future.globals.onMissing"), "\n", list(
#>                   "R_FUTURE_GLOBALS_ONMISSING"), "\n", list("future.globals.resolve"), 
#>                 "\n", list("R_FUTURE_GLOBALS_RESOLVE"), "\n", 
#>                 list("future.globals.onReference"), "\n", list(
#>                   "R_FUTURE_GLOBALS_ONREFERENCE"), "\n", list(
#>                   "future.plan"), "\n", list("R_FUTURE_PLAN"), 
#>                 "\n", list("future.resolve.recursive"), "\n", 
#>                 list("R_FUTURE_RNG_ONMISUSE"), "\n", list("future.wait.alpha"), 
#>                 "\n", list("R_FUTURE_WAIT_ALPHA"), "\n", list(
#>                   "future.wait.interval"), "\n", list("R_FUTURE_WAIT_INTERVAL"), 
#>                 "\n", list("future.wait.timeout"), "\n", list(
#>                   "R_FUTURE_WAIT_TIMEOUT"), "\n", list("R_FUTURE_RESOLVED_TIMEOUT"), 
#>                 "\n", list("future.output.windows.reencode"), 
#>                 "\n", list("R_FUTURE_OUTPUT_WINDOWS_REENCODE"), 
#>                 "\n", list("Options used for futures"), "\n", 
#>                 list("\n", "Below are the ", list(), " options and environment variables that are used by the\n", 
#>                   list("future"), " package and packages enhancing it.", 
#>                   list(), "\n", list(), "\n", list("WARNING: Note that the names and the default values of these options may\n", 
#>                     "change in future versions of the package.  Please use with care until\n", 
#>                     "further notice."), "\n"), "\n", list(list(
#>                   "Settings moved to the 'parallelly' package"), 
#>                   list("\n", "\n", "Several functions have been moved to the ", 
#>                     list("parallelly"), " package:\n", list("\n", 
#>                       list(), " ", list(list("parallelly::availableCores()")), 
#>                       "\n", list(), " ", list(list("parallelly::availableWorkers()")), 
#>                       "\n", list(), " ", list(list("parallelly::makeClusterMPI()")), 
#>                       "\n", list(), " ", list(list("parallelly::makeClusterPSOCK()")), 
#>                       "\n", list(), " ", list(list("parallelly::makeNodePSOCK()")), 
#>                       "\n", list(), " ", list(list("parallelly::supportsMulticore()")), 
#>                       "\n"), "\n", "\n", "The options and environment variables controlling those have been adjusted\n", 
#>                     "accordingly to have different prefixes.\n", 
#>                     "For example, option ", list("future.fork.enable"), 
#>                     " has been renamed to\n", list("parallelly.fork.enable"), 
#>                     " and the corresponding environment variable\n", 
#>                     list("R_FUTURE_FORK_ENABLE"), " has been renamed to\n", 
#>                     list("R_PARALLELLY_FORK_ENABLE"), ".\n", 
#>                     "For backward compatibility reasons, the ", 
#>                     list("parallelly"), " package will\n", "support both versions for a long foreseeable time.\n", 
#>                     "See the ", list("parallelly::parallelly.options"), 
#>                     " page for the settings.\n")), "\n", "\n", 
#>                 list(list("Options for controlling futures"), 
#>                   list("\n", "\n", list("\n", list(list(list(
#>                     "future.plan"), ":"), list("(character string or future function) Default future strategy plan used unless otherwise specified via ", 
#>                     list(list("plan()")), ". This will also be the future plan set when calling ", 
#>                     list("plan(\"default\")"), ".  If not specified, this option may be set when the ", 
#>                     list("future"), " package is ", list("loaded"), 
#>                     " if command-line option ", list("--parallel=ncores"), 
#>                     " (short ", list("-p ncores"), ") is specified; if ", 
#>                     list("ncores > 1"), ", then option ", list(
#>                       "future.plan"), " is set to ", list("multisession"), 
#>                     " otherwise ", list("sequential"), " (in addition to option ", 
#>                     list("mc.cores"), " being set to ", list(
#>                       "ncores"), ", if ", list("ncores >= 1"), 
#>                     "). (Default: ", list("sequential"), ")")), 
#>                     "\n", "\n", list(list(list("future.globals.maxSize"), 
#>                       ":"), list("(numeric) Maximum allowed total size (in bytes) of global variables identified. Used to prevent too large exports. If set of ", 
#>                       list("+Inf"), ", then the check for large globals is skipped. (Default: ", 
#>                       list("500 * 1024 ^ 2"), " = 500 MiB)")), 
#>                     "\n", "\n", list(list(list("future.globals.onReference"), 
#>                       ": (", list("beta feature - may change"), 
#>                       ")"), list("(character string) Controls whether the identified globals should be scanned for so called ", 
#>                       list("references"), " (e.g. external pointers and connections) or not.  It is unlikely that another ", 
#>                       list(), " process (\"worker\") can use a global that uses a internal reference of the master ", 
#>                       list(), " process - we call such objects ", 
#>                       list("non-exportable globals"), ".\n", 
#>                       "If this option is ", list("\"error\""), 
#>                       ", an informative error message is produced if a non-exportable global is detected.\n", 
#>                       "If ", list("\"warning\""), ", a warning is produced, but the processing will continue; it is likely that the future will be resolved with a run-time error unless processed in the master ", 
#>                       list(), " process (e.g. ", list("plan(sequential)"), 
#>                       " and ", list("plan(multicore)"), ").\n", 
#>                       "If ", list("\"ignore\""), ", no scan is performed.\n", 
#>                       "(Default: ", list("\"ignore\""), " but may change)\n")), 
#>                     "\n", "\n", list(list(list("future.resolve.recursive"), 
#>                       ":"), list("(integer) An integer specifying the maximum recursive depth to which futures should be resolved. If negative, nothing is resolved.  If ", 
#>                       list("0"), ", only the future itself is resolved.  If ", 
#>                       list("1"), ", the future and any of its elements that are futures are resolved, and so on. If ", 
#>                       list("+Inf"), ", infinite search depth is used. (Default: ", 
#>                       list("0"), ")")), "\n", "\n", list(list(
#>                       list("future.rng.onMisuse"), ": (", list(
#>                         "beta feature - may change"), ")"), list(
#>                       "(character string) If random numbers are used in futures, then parallel (L'Ecuyer-CMRG) RNG should be used in order to get statistical sound RNGs. The defaults in the future framework assume that ", 
#>                       list("no"), " random number generation (RNG) is taken place in the future expression because L'Ecuyer-CMRG RNGs come with an unnecessary overhead if not needed.  To protect against mistakes, the future framework attempts to detect when random numbers are used despite L'Ecuyer-CMRG RNGs are not in place.  If this is detected, and ", 
#>                       list("future.rng.onMisuse = \"error\""), 
#>                       ", then an informative error message is produced.  If ", 
#>                       list("\"warning\""), ", then a warning message is produced.  If ", 
#>                       list("\"ignore\""), ", no check is performed. (Default: ", 
#>                       list("\"warning\""), ")")), "\n", "\n", 
#>                     list(list(list("future.wait.timeout"), ":"), 
#>                       list("(numeric) Maximum waiting time (in seconds) for a free worker before a timeout error is generated. (Default: ", 
#>                         list("30 * 24 * 60 * 60"), " (= 30 days))")), 
#>                     "\n", "\n", list(list(list("future.wait.interval"), 
#>                       ":"), list("(numeric) Initial interval (in seconds) between polls. (Default: ", 
#>                       list("0.2"), " = 0.2 seconds)")), "\n", 
#>                     "\n", list(list(list("future.wait.alpha"), 
#>                       ":"), list("(numeric) Positive scale factor used to increase the interval after each poll. (Default: ", 
#>                       list("1.01"), ")")), "\n"), "\n")), "\n", 
#>                 "\n", list(list("Options for debugging futures"), 
#>                   list("\n", "\n", list("\n", list(list(list(
#>                     "future.debug"), ":"), list("(logical) If ", 
#>                     list("TRUE"), ", extensive debug messages are generated. (Default: ", 
#>                     list("FALSE"), ")")), "\n"), "\n")), "\n", 
#>                 "\n", list(list("Options for controlling package startup"), 
#>                   list("\n", "\n", list("\n", list(list(list(
#>                     "future.startup.script"), ":"), list("(character vector or a logical) Specifies zero of more future startup scripts to be sourced when the ", 
#>                     list("future"), " package is ", list("attached"), 
#>                     ". It is only the first existing script that is sourced. If none of the specified files exist, nothing is sourced - there will be neither a warning nor an error.\n", 
#>                     "If this option is not specified, environment variable ", 
#>                     list("R_FUTURE_STARTUP_SCRIPT"), " is considered, where multiple scripts may be separated by either a colon (", 
#>                     list(":"), ") or a semicolon (", list(";"), 
#>                     "). If neither is set, or either is set to ", 
#>                     list("TRUE"), ", the default is to look for a ", 
#>                     list(".future.R"), " script in the current directory and then in the user's home directory.  To disable future startup scripts, set the option or the environment variable to ", 
#>                     list("FALSE"), ".  ", list("Importantly"), 
#>                     ", this option is ", list("always"), " set to ", 
#>                     list("FALSE"), " if the ", list("future"), 
#>                     " package is loaded as part of a future expression being evaluated, e.g. in a background process. In order words, they are sourced in the main ", 
#>                     list(), " process but not in future processes. (Default: ", 
#>                     list("TRUE"), " in main ", list(), " process and ", 
#>                     list("FALSE"), " in future processes / during future evaluation)")), 
#>                     "\n", "\n", list(list(list("future.cmdargs"), 
#>                       ":"), list("(character vector) Overrides ", 
#>                       list(list("commandArgs"), "()"), " when the ", 
#>                       list("future"), " package is ", list("loaded"), 
#>                       ".")), "\n"), "\n")), "\n", "\n", list(
#>                   list("Options for configuring low-level system behaviors"), 
#>                   list("\n", "\n", "\n", list("\n", list(list(
#>                     list("future.fork.multithreading.enable"), 
#>                     " (", list("beta feature - may change"), 
#>                     "):"), list("(logical) Enable or disable ", 
#>                     list("multi-threading"), " while using ", 
#>                     list("forked"), " parallel processing.  If ", 
#>                     list("FALSE"), ", different multi-thread library settings are overridden such that they run in single-thread mode. Specifically, multi-threading will be disabled for OpenMP (which requires the ", 
#>                     list("RhpcBLASctl"), " package) and for ", 
#>                     list("RcppParallel"), ". If ", list("TRUE"), 
#>                     ", or not set (the default), multi-threading is allowed.  Parallelization via multi-threaded processing (done in native code by some packages and external libraries) while at the same time using forked (aka \"multicore\") parallel processing is known to unstable.  Note that this is not only true when using ", 
#>                     list("plan(multicore)"), " but also when using, for instance, ", 
#>                     list(list("mclapply"), "()"), " of the ", 
#>                     list("parallel"), " package. (Default: not set)")), 
#>                     "\n", "\n", list(list(list("future.output.windows.reencode"), 
#>                       " (", list("beta feature - may change"), 
#>                       "):"), list("(logical) Enable or disable re-encoding of UTF-8 symbols that were incorrectly encoded while captured.  On MS Windows, R cannot capture UTF-8 symbols as-is when they are captured from the standard output.  For examples, a UTF-8 check mark symbol (", 
#>                       list("\"\\u2713\""), ") would be relayed as ", 
#>                       list("\"<U+2713>\""), " (a string with eight ASCII characters).  This option will cause ", 
#>                       list("value()"), " to attempt to recover the intended UTF-8 symbols from ", 
#>                       list("<U+nnnn>"), " string components, if, and only if, the string was captured by a future resolved on MS Windows. (Default: ", 
#>                       list("TRUE"), ")")), "\n"), "\n", "\n", 
#>                     "See also ", list("parallelly::parallelly.options"), 
#>                     ".\n")), "\n", "\n", list(list("Options for demos"), 
#>                   list("\n", "\n", list("\n", list(list(list(
#>                     "future.demo.mandelbrot.region"), ":"), list(
#>                     "(integer) Either a named list of ", list(
#>                       list("mandelbrot()")), " arguments or an integer in {1, 2, 3} specifying a predefined Mandelbrot region. (Default: ", 
#>                     list("1L"), ")")), "\n", "\n", list(list(
#>                     list("future.demo.mandelbrot.nrow"), ":"), 
#>                     list("(integer) Number of rows and columns of tiles. (Default: ", 
#>                       list("3L"), ")")), "\n"), "\n")), "\n", 
#>                 "\n", list(list("Deprecated or for internal prototyping"), 
#>                   list("\n", "\n", "\n", "The following options exists only for troubleshooting purposes and must not\n", 
#>                     "be used in production.  If used, there is a risk that the results are\n", 
#>                     "non-reproducible if processed elsewhere.  To lower the risk of them being\n", 
#>                     "used by mistake, they are marked as deprecated and will produce warnings\n", 
#>                     "if set.\n", "\n", list("\n", list(list(list(
#>                       "future.globals.onMissing"), ":"), list(
#>                       "(character string) Action to take when non-existing global variables (\"globals\" or \"unknowns\") are identified when the future is created.  If ", 
#>                       list("\"error\""), ", an error is generated immediately.  If ", 
#>                       list("\"ignore\""), ", no action is taken and an attempt to evaluate the future expression will be made.  The latter is useful when there is a risk for false-positive globals being identified, e.g. when future expression contains non-standard evaluation (NSE).  (Default: ", 
#>                       list("\"ignore\""), ")")), "\n", "\n", 
#>                       list(list(list("future.globals.method"), 
#>                         ":"), list("(character string) Method used to identify globals. For details, see ", 
#>                         list(list("globalsOf"), "()"), ". (Default: ", 
#>                         list("\"ordered\""), ")")), "\n", "\n", 
#>                       list(list(list("future.globals.resolve"), 
#>                         ":"), list("(logical) If ", list("TRUE"), 
#>                         ", globals that are ", list(list("Future")), 
#>                         " objects (typically created as ", list(
#>                           "explicit"), " futures) will be resolved and have their values (using ", 
#>                         list("value()"), ") collected.  Because searching for unresolved futures among globals (including their content) can be expensive, the default is not to do it and instead leave it to the run-time checks that assert proper ownership when resolving futures and collecting their values. (Default: ", 
#>                         list("FALSE"), ")")), "\n"), "\n")), 
#>                 "\n", "\n", list(list("Environment variables that set R options"), 
#>                   list("\n", "\n", "All of the above ", list(), 
#>                     " ", list("future.*"), " options can be set by corresponding\n", 
#>                     "environment variable ", list("R_FUTURE_*"), 
#>                     " ", list("when the ", list("future"), " package is\n", 
#>                       "loaded"), ".\n", "For example, if ", list(
#>                       "R_FUTURE_RNG_ONMISUSE = \"ignore\""), 
#>                     ", then option\n", list("future.rng.onMisuse"), 
#>                     " is set to ", list("\"ignore\""), " (character string).\n", 
#>                     "Similarly, if ", list("R_FUTURE_GLOBALS_MAXSIZE = \"50000000\""), 
#>                     ", then option\n", list("future.globals.maxSize"), 
#>                     " is set to ", list("50000000"), " (numeric).\n")), 
#>                 "\n", "\n", list("\n", "# Allow at most 5 MB globals per futures\n", 
#>                   "options(future.globals.maxSize = 5e6)\n", 
#>                   "\n", "# Be strict; catch all RNG mistakes\n", 
#>                   "options(future.rng.onMisuse = \"error\")\n", 
#>                   "\n", "\n"), "\n", list("\n", "To set ", list(), 
#>                   " options or environment variables when ", 
#>                   list(), " starts (even before the ", list("future"), 
#>                   " package is loaded), see the ", list("Startup"), 
#>                   " help page.  The ", list(list("https://cran.r-project.org/package=startup"), 
#>                     list(list("startup"))), " package provides a friendly mechanism for configurating ", 
#>                   list(), "'s startup process.\n"), "\n", list(
#>                   "internal"), "\n"), futureOf.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/futureOf.R", 
#>                 "\n", list("futureOf"), "\n", list("futureOf"), 
#>                 "\n", list("Get the future of a future variable"), 
#>                 "\n", list("\n", "futureOf(\n", "  var = NULL,\n", 
#>                   "  envir = parent.frame(),\n", "  mustExist = TRUE,\n", 
#>                   "  default = NA,\n", "  drop = FALSE\n", ")\n"), 
#>                 "\n", list("\n", list(list("var"), list("the variable.  If NULL, all futures in the\n", 
#>                   "environment are returned.")), "\n", "\n", 
#>                   list(list("envir"), list("the environment where to search from.")), 
#>                   "\n", "\n", list(list("mustExist"), list("If TRUE and the variable does not exists, then\n", 
#>                     "an informative error is thrown, otherwise NA is returned.")), 
#>                   "\n", "\n", list(list("default"), list("the default value if future was not found.")), 
#>                   "\n", "\n", list(list("drop"), list("if TRUE and ", 
#>                     list("var"), " is NULL, then returned list\n", 
#>                     "only contains futures, otherwise also ", 
#>                     list("default"), " values.")), "\n"), "\n", 
#>                 list("\n", "A ", list("Future"), " (or ", list(
#>                   "default"), ").\n", "If ", list("var"), " is NULL, then a named list of Future:s are returned.\n"), 
#>                 "\n", list("\n", "Get the future of a future variable that has been created directly\n", 
#>                   "or indirectly via ", list(list("future()")), 
#>                   ".\n"), "\n", list("\n", "a %<-% { 1 }\n", 
#>                   "\n", "f <- futureOf(a)\n", "print(f)\n", "\n", 
#>                   "b %<-% { 2 }\n", "\n", "f <- futureOf(b)\n", 
#>                   "print(f)\n", "\n", "## All futures\n", "fs <- futureOf()\n", 
#>                   "print(fs)\n", "\n", "\n", "## Futures part of environment\n", 
#>                   "env <- new.env()\n", "env$c %<-% { 3 }\n", 
#>                   "\n", "f <- futureOf(env$c)\n", "print(f)\n", 
#>                   "\n", "f2 <- futureOf(c, envir = env)\n", "print(f2)\n", 
#>                   "\n", "f3 <- futureOf(\"c\", envir = env)\n", 
#>                   "print(f3)\n", "\n", "fs <- futureOf(envir = env)\n", 
#>                   "print(fs)\n"), "\n"), futureSessionInfo.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/futureSessionInfo.R", 
#>                 "\n", list("futureSessionInfo"), "\n", list("futureSessionInfo"), 
#>                 "\n", list("Get session information specific to the future framework"), 
#>                 "\n", list("\n", "futureSessionInfo(test = TRUE)\n"), 
#>                 "\n", list("\n", list(list("test"), list("If TRUE, one or more futures are created to query workers\n", 
#>                   "and validate their information.")), "\n"), 
#>                 "\n", list("\n", "Nothing.\n"), "\n", list("\n", 
#>                   "Get session information specific to the future framework\n"), 
#>                 "\n"), futures.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/futures.R", 
#>                 "\n", list("futures"), "\n", list("futures"), 
#>                 "\n", list("Get all futures in a container"), 
#>                 "\n", list("\n", "futures(x, ...)\n"), "\n", 
#>                 list("\n", list(list("x"), list("An environment, a list, or a list environment.")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "An object of same type as ", 
#>                   list("x"), " and with the same names\n", "and/or dimensions, if set.\n"), 
#>                 "\n", list("\n", "Gets all futures in an environment, a list, or a list environment\n", 
#>                   "and returns an object of the same class (and dimensions).\n", 
#>                   "Non-future elements are returned as is.\n"), 
#>                 "\n", list("\n", "This function is useful for retrieve futures that were created via\n", 
#>                   "future assignments (", list("%<-%"), ") and therefore stored as promises.\n", 
#>                   "This function turns such promises into standard ", 
#>                   list("Future"), "\n", "objects.\n"), "\n"), 
#>             getExpression.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/Future-class.R", 
#>                 "\n", list("getExpression"), "\n", list("getExpression"), 
#>                 "\n", list("getExpression.Future"), "\n", list(
#>                   "Inject code for the next type of future to use for nested futures"), 
#>                 "\n", list("\n", "getExpression(future, ...)\n"), 
#>                 "\n", list("\n", list(list("future"), list("Current future.")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "A future expression with code injected to set what\n", 
#>                   "type of future to use for nested futures, iff any.\n"), 
#>                 "\n", list("\n", "Inject code for the next type of future to use for nested futures\n"), 
#>                 "\n", list("\n", "If no next future strategy is specified, the default is to\n", 
#>                   "use ", list("sequential"), " futures.  This conservative approach protects\n", 
#>                   "against spawning off recursive futures by mistake, especially\n", 
#>                   list("multicore"), " and ", list("multisession"), 
#>                   " ones.\n", "The default will also set ", list(
#>                     "options(mc.cores = 1L)"), " (*) so that\n", 
#>                   "no parallel ", list(), " processes are spawned off by functions such as\n", 
#>                   list("parallel::mclapply()"), " and friends.\n", 
#>                   "\n", "Currently it is not possible to specify what type of nested\n", 
#>                   "futures to be used, meaning the above default will always be\n", 
#>                   "used.\n", "See ", list(list("https://github.com/HenrikBengtsson/future/issues/37"), 
#>                     list("Issue #37")), "\n", "for plans on adding support for custom nested future types.\n", 
#>                   "\n", "(*) Ideally we would set ", list("mc.cores = 0"), 
#>                   " but that will unfortunately\n", "cause ", 
#>                   list("mclapply()"), " and friends to generate an error saying\n", 
#>                   "\"'mc.cores' must be >= 1\".  Ideally those functions should\n", 
#>                   "fall back to using the non-multicore alternative in this\n", 
#>                   "case, e.g. ", list("mclapply(...)"), " => ", 
#>                   list("lapply(...)"), ".\n", "See ", list("https://github.com/HenrikBengtsson/Wishlist-for-R/issues/7"), 
#>                   "\n", "for a discussion on this.\n"), "\n", 
#>                 list("internal"), "\n"), getGlobalsAndPackages.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/globals.R", 
#>                 "\n", list("getGlobalsAndPackages"), "\n", list(
#>                   "getGlobalsAndPackages"), "\n", list("Retrieves global variables of an expression and their associated packages"), 
#>                 "\n", list("\n", "getGlobalsAndPackages(\n", 
#>                   "  expr,\n", "  envir = parent.frame(),\n", 
#>                   "  tweak = tweakExpression,\n", "  globals = TRUE,\n", 
#>                   "  resolve = getOption(\"future.globals.resolve\", NULL),\n", 
#>                   "  persistent = FALSE,\n", "  maxSize = getOption(\"future.globals.maxSize\", 500 * 1024^2),\n", 
#>                   "  ...\n", ")\n"), "\n", list("\n", list(list(
#>                   "expr"), list("An ", list(), " expression whose globals should be found.")), 
#>                   "\n", "\n", list(list("envir"), list("The environment from which globals should be searched.")), 
#>                   "\n", "\n", list(list("tweak"), list("(optional) A function that takes an expression and returned a modified one.")), 
#>                   "\n", "\n", list(list("globals"), list("(optional) a logical, a character vector, a named list, or a ", 
#>                     list("Globals"), " object.  If TRUE, globals are identified by code inspection based on ", 
#>                     list("expr"), " and ", list("tweak"), " searching from environment ", 
#>                     list("envir"), ".  If FALSE, no globals are used.  If a character vector, then globals are identified by lookup based their names ", 
#>                     list("globals"), " searching from environment ", 
#>                     list("envir"), ".  If a named list or a Globals object, the globals are used as is.")), 
#>                   "\n", "\n", list(list("resolve"), list("If TRUE, any future that is a global variables (or part of one) is resolved and replaced by a \"constant\" future.")), 
#>                   "\n", "\n", list(list("persistent"), list("If TRUE, non-existing globals (= identified in expression but not found in memory) are always silently ignored and assumed to be existing in the evaluation environment.  If FALSE, non-existing globals are by default ignore, but may also trigger an informative error if option ", 
#>                     list("future.globals.onMissing"), " in ", 
#>                     list("\"error\""), " (should only be used for troubleshooting).")), 
#>                   "\n", "\n", list(list("maxSize"), list("The maximum allowed total size (in bytes) of globals - for\n", 
#>                     "the purpose of preventing too large exports / transfers happening by\n", 
#>                     "mistake.  If the total size of the global objects are greater than this\n", 
#>                     "limit, an informative error message is produced. If\n", 
#>                     list("maxSize = +Inf"), ", then this assertion is skipped. (Default: 500 MiB).")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "A named list with elements ", 
#>                   list("expr"), " (the tweaked expression), ", 
#>                   list("globals"), " (a named list of class ", 
#>                   list("FutureGlobals"), ") and ", list("packages"), 
#>                   " (a character string).\n"), "\n", list("\n", 
#>                   "Retrieves global variables of an expression and their associated packages\n"), 
#>                 "\n", list("\n", "Internally, ", list(list("globalsOf"), 
#>                   "()"), " is used to identify globals and associated packages from the expression.\n"), 
#>                 "\n", list("internal"), "\n"), `grapes-conditions-grapes.Rd` = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/conditions_OP.R", 
#>                 "\n", list("%conditions%"), "\n", list("%conditions%"), 
#>                 "\n", list("Control whether standard output should be captured or not"), 
#>                 "\n", list("\n", "fassignment %conditions% capture\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("capture"), list(
#>                   "If TRUE, the standard output will be captured, otherwise not.")), 
#>                   "\n"), "\n", list("\n", "Control whether standard output should be captured or not\n"), 
#>                 "\n"), `grapes-globals-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/globals_OP.R", 
#>                 "\n", list("%globals%"), "\n", list("%globals%"), 
#>                 "\n", list("%packages%"), "\n", list("Specify globals and packages for a future assignment"), 
#>                 "\n", list("\n", "fassignment %globals% globals\n", 
#>                   "fassignment %packages% packages\n"), "\n", 
#>                 list("\n", list(list("fassignment"), list("The future assignment, e.g.\n", 
#>                   list("x %<-% { expr }"), ".")), "\n", "\n", 
#>                   list(list("globals"), list("(optional) a logical, a character vector, or a named list\n", 
#>                     "to control how globals are handled.\n", 
#>                     "For details, see section 'Globals used by future expressions'\n", 
#>                     "in the help for ", list(list("future()")), 
#>                     ".")), "\n", "\n", list(list("packages"), 
#>                     list("(optional) a character vector specifying packages\n", 
#>                       "to be attached in the ", list(), " environment evaluating the future.")), 
#>                   "\n"), "\n", list("\n", "Specify globals and packages for a future assignment\n"), 
#>                 "\n"), `grapes-label-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/label_OP.R", 
#>                 "\n", list("%label%"), "\n", list("%label%"), 
#>                 "\n", list("Specify label for a future assignment"), 
#>                 "\n", list("\n", "fassignment %label% label\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("label"), list(
#>                   "An optional character string label attached to the future.")), 
#>                   "\n"), "\n", list("\n", "Specify label for a future assignment\n"), 
#>                 "\n"), `grapes-lazy-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/lazy_OP.R", 
#>                 "\n", list("%lazy%"), "\n", list("%lazy%"), "\n", 
#>                 list("Control lazy / eager evaluation for a future assignment"), 
#>                 "\n", list("\n", "fassignment %lazy% lazy\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("lazy"), list(
#>                   "If FALSE (default), the future is resolved\n", 
#>                   "eagerly (starting immediately), otherwise not.")), 
#>                   "\n"), "\n", list("\n", "Control lazy / eager evaluation for a future assignment\n"), 
#>                 "\n"), `grapes-plan-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/plan_OP.R", 
#>                 "\n", list("%plan%"), "\n", list("%plan%"), "\n", 
#>                 list("Use a specific plan for a future assignment"), 
#>                 "\n", list("\n", "fassignment %plan% strategy\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("strategy"), list(
#>                   "The mechanism for how the future should be\n", 
#>                   "resolved. See ", list(list("plan()")), " for further details.")), 
#>                   "\n"), "\n", list("\n", "Use a specific plan for a future assignment\n"), 
#>                 "\n", list("\n", "The ", list(list("plan()")), 
#>                   " function sets the default plan for all futures.\n"), 
#>                 "\n"), `grapes-seed-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/seed_OP.R", 
#>                 "\n", list("%seed%"), "\n", list("%seed%"), "\n", 
#>                 list("Set random seed for future assignment"), 
#>                 "\n", list("\n", "fassignment %seed% seed\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("seed"), list(
#>                   "(optional) If TRUE, the random seed, that is, the state of the\n", 
#>                   "random number generator (RNG) will be set such that statistically sound\n", 
#>                   "random numbers are produced (also during parallelization).\n", 
#>                   "If FALSE (default), it is assumed that the future expression does neither\n", 
#>                   "need nor use random numbers generation.\n", 
#>                   "To use a fixed random seed, specify a L'Ecuyer-CMRG seed (seven integer)\n", 
#>                   "or a regular RNG seed (a single integer).  If the latter, then a\n", 
#>                   "L'Ecuyer-CMRG seed will be automatically created based on the given seed.\n", 
#>                   "Furthermore, if FALSE, then the future will be monitored to make sure it\n", 
#>                   "does not use random numbers.  If it does and depending on the value of\n", 
#>                   "option ", list(list("future.rng.onMisuse")), 
#>                   ", the check is\n", "ignored, an informative warning, or error will be produced.\n", 
#>                   "If ", list("seed"), " is NULL, then the effect is as with ", 
#>                   list("seed = FALSE"), "\n", "but without the RNG check being performed.")), 
#>                   "\n"), "\n", list("\n", "Set random seed for future assignment\n"), 
#>                 "\n"), `grapes-stdout-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/stdout_OP.R", 
#>                 "\n", list("%stdout%"), "\n", list("%stdout%"), 
#>                 "\n", list("Control whether standard output should be captured or not"), 
#>                 "\n", list("\n", "fassignment %stdout% capture\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("capture"), list(
#>                   "If TRUE, the standard output will be captured, otherwise not.")), 
#>                   "\n"), "\n", list("\n", "Control whether standard output should be captured or not\n"), 
#>                 "\n"), `grapes-tweak-grapes.Rd` = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/tweak_OP.R", 
#>                 "\n", list("%tweak%"), "\n", list("%tweak%"), 
#>                 "\n", list("Temporarily tweaks the arguments of the current strategy"), 
#>                 "\n", list("\n", "fassignment %tweak% tweaks\n"), 
#>                 "\n", list("\n", list(list("fassignment"), list(
#>                   "The future assignment, e.g.\n", list("x %<-% { expr }"), 
#>                   ".")), "\n", "\n", list(list("tweaks"), list(
#>                   "A named list (or vector) with arguments that\n", 
#>                   "should be changed relative to the current strategy.")), 
#>                   "\n"), "\n", list("\n", "Temporarily tweaks the arguments of the current strategy\n"), 
#>                 "\n"), make_rng_seeds.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/rng.R", 
#>                 "\n", list("make_rng_seeds"), "\n", list("make_rng_seeds"), 
#>                 "\n", list("Produce Reproducible Seeds for Parallel Random Number Generation"), 
#>                 "\n", list("\n", "make_rng_seeds(count, seed = FALSE, debug = getOption(\"future.debug\", FALSE))\n"), 
#>                 "\n", list("\n", list(list("count"), list("The number of RNG seeds to produce.")), 
#>                   "\n", "\n", list(list("seed"), list("A logical specifying whether RNG seeds should be generated\n", 
#>                     "or not.  (", list("seed = NULL"), " corresponds to ", 
#>                     list("seed = FALSE"), ").\n", "If a list, then it should be of length ", 
#>                     list("count"), " and each element should\n", 
#>                     "consist of a valid RNG seed.")), "\n", "\n", 
#>                   list(list("debug"), list("If ", list("TRUE"), 
#>                     ", debug output is produced, otherwise not.")), 
#>                   "\n"), "\n", list("\n", "Returns a non-named list of length ", 
#>                   list("count"), ", or ", list("NULL"), ".\n", 
#>                   "Any seed returned is a valid RNG seed.\n"), 
#>                 "\n", list("\n", "Produce Reproducible Seeds for Parallel Random Number Generation\n"), 
#>                 "\n", list("internal"), "\n"), mandelbrot.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/mandelbrot.R", 
#>                 "\n", list("mandelbrot"), "\n", list("mandelbrot"), 
#>                 "\n", list("as.raster.Mandelbrot"), "\n", list(
#>                   "plot.Mandelbrot"), "\n", list("mandelbrot_tiles"), 
#>                 "\n", list("Mandelbrot convergence counts"), 
#>                 "\n", list("\n", "mandelbrot(...)\n"), "\n", 
#>                 list("\n", list(list("Z"), list("A complex matrix for which convergence\n", 
#>                   "counts should be calculated.")), "\n", "\n", 
#>                   list(list("xmid, ymid, side, resolution"), 
#>                     list("Alternative specification of\n", "the complex plane ", 
#>                       list("Z"), ", where\n", list("mean(Re(Z)) == xmid"), 
#>                       ",\n", list("mean(Im(Z)) == ymid"), ",\n", 
#>                       list("diff(range(Re(Z))) == side"), ",\n", 
#>                       list("diff(range(Im(Z))) == side"), ", and\n", 
#>                       list("dim(Z) == c(resolution, resolution)"), 
#>                       ".")), "\n", "\n", list(list("maxIter"), 
#>                     list("Maximum number of iterations per bin.")), 
#>                   "\n", "\n", list(list("tau"), list("A threshold; the radius when calling\n", 
#>                     "divergence (Mod(z) > tau).")), "\n"), "\n", 
#>                 list("\n", "Returns an integer matrix (of class Mandelbrot) with\n", 
#>                   "non-negative counts.\n"), "\n", list("\n", 
#>                   "Mandelbrot convergence counts\n"), "\n", list(
#>                   "\n", "counts <- mandelbrot(xmid = -0.75, ymid = 0, side = 3)\n", 
#>                   "str(counts)\n", list("\n", "plot(counts)\n"), 
#>                   "\n", "\n", list("\n", "demo(\"mandelbrot\", package = \"future\", ask = FALSE)\n"), 
#>                   "\n", "\n"), "\n", list("\n", "The internal Mandelbrot algorithm was inspired by and\n", 
#>                   "adopted from similar GPL code of Martin Maechler available\n", 
#>                   "from ftp://stat.ethz.ch/U/maechler/R/ on 2005-02-18 (sic!).\n"), 
#>                 "\n", list("internal"), "\n"), multicore.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/multicore.R", 
#>                 "\n", list("multicore"), "\n", list("multicore"), 
#>                 "\n", list("Create a multicore future whose value will be resolved asynchronously in a forked parallel process"), 
#>                 "\n", list("\n", "multicore(\n", "  ...,\n", 
#>                   "  workers = availableCores(constraints = \"multicore\"),\n", 
#>                   "  envir = parent.frame()\n", ")\n"), "\n", 
#>                 list("\n", list(list("..."), list("Additional arguments passed to ", 
#>                   list(list("Future()")), ".")), "\n", "\n", 
#>                   list(list("workers"), list("A positive numeric scalar or a function specifying the\n", 
#>                     "maximum number of parallel futures that can be active at the same time\n", 
#>                     "before blocking.\n", "If a function, it is called without arguments ", 
#>                     list("when the future\n", "is created"), 
#>                     " and its value is used to configure the workers.\n", 
#>                     "The function should return a numeric scalar.")), 
#>                   "\n", "\n", list(list("envir"), list("The ", 
#>                     list("environment"), " from where global objects should be\n", 
#>                     "identified.")), "\n"), "\n", list("\n", 
#>                   "A ", list("MulticoreFuture"), "\n", "If ", 
#>                   list("workers == 1"), ", then all processing using done in the\n", 
#>                   "current/main ", list(), " session and we therefore fall back to using\n", 
#>                   "an sequential future.  This is also the case whenever multicore\n", 
#>                   "processing is not supported, e.g. on Windows.\n"), 
#>                 "\n", list("\n", "A multicore future is a future that uses multicore evaluation,\n", 
#>                   "which means that its ", list("value is computed and resolved in\n", 
#>                     "parallel in another process"), ".\n"), "\n", 
#>                 list("\n", "This function is ", list("not"), 
#>                   " meant to be called directly.  Instead, the\n", 
#>                   "typical usages are:", list(list("html"), list(
#>                     list("<div class=\"sourceCode r\">"))), list(
#>                     "# Evaluate futures in parallel on the local machine via as many forked\n", 
#>                     "# processes as available to the current R process\n", 
#>                     "plan(multicore)\n", "\n", "# Evaluate futures in parallel on the local machine via two forked processes\n", 
#>                     "plan(multicore, workers = 2)\n"), list(list(
#>                     "html"), list(list("</div>"))), "\n", "\n", 
#>                   "For the total number of cores available including the current/main\n", 
#>                   list(), " process, see ", list(list("parallelly::availableCores()")), 
#>                   ".\n", "\n", "Not all operating systems support process forking and thereby not multicore\n", 
#>                   "futures.  For instance, forking is not supported on Microsoft Windows.\n", 
#>                   "Moreover, process forking may break some R environments such as RStudio.\n", 
#>                   "Because of this, the future package disables process forking also in\n", 
#>                   "such cases.  See ", list(list("supportsMulticore()")), 
#>                   " for details.\n", "Trying to create multicore futures on non-supported systems or when\n", 
#>                   "forking is disabled will result in multicore futures falling back to\n", 
#>                   "becoming ", list("sequential"), " futures.\n"), 
#>                 "\n", list("\n", "## Use multicore futures\n", 
#>                   "plan(multicore)\n", "\n", "## A global variable\n", 
#>                   "a <- 0\n", "\n", "## Create future (explicitly)\n", 
#>                   "f <- future({\n", "  b <- 3\n", "  c <- 2\n", 
#>                   "  a * b * c\n", "})\n", "\n", "## A multicore future is evaluated in a separate forked\n", 
#>                   "## process.  Changing the value of a global variable\n", 
#>                   "## will not affect the result of the future.\n", 
#>                   "a <- 7\n", "print(a)\n", "\n", "v <- value(f)\n", 
#>                   "print(v)\n", "stopifnot(v == 0)\n"), "\n", 
#>                 list("\n", "For processing in multiple background ", 
#>                   list(), " sessions, see\n", list("multisession"), 
#>                   " futures.\n", "\n", "Use ", list(list("availableCores()")), 
#>                   " to see the total number of\n", "cores that are available for the current ", 
#>                   list(), " session.\n", "Use ", list(list("availableCores"), 
#>                     "(\"multicore\") > 1L"), " to check\n", "whether multicore futures are supported or not on the current\n", 
#>                   "system.\n"), "\n"), multiprocess.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/multiprocess.R", 
#>                 "\n", list("multiprocess"), "\n", list("multiprocess"), 
#>                 "\n", list("Create a multiprocess future whose value will be resolved asynchronously using multicore or a multisession evaluation"), 
#>                 "\n", list("\n", "multiprocess(..., workers = availableCores(), envir = parent.frame())\n"), 
#>                 "\n", list("\n", list(list(list()), list("Additional arguments passed to ", 
#>                   list(list("Future()")), ".")), "\n", "\n", 
#>                   list(list("workers"), list("A positive numeric scalar or a function specifying the\n", 
#>                     "maximum number of parallel futures that can be active at the same time\n", 
#>                     "before blocking.\n", "If a function, it is called without arguments ", 
#>                     list("when the future\n", "is created"), 
#>                     " and its value is used to configure the workers.\n", 
#>                     "The function should return a numeric scalar.")), 
#>                   "\n", "\n", list(list("envir"), list("The ", 
#>                     list("environment"), " from where global objects should be\n", 
#>                     "identified.")), "\n"), "\n", list("\n", 
#>                   "A ", list("MultiprocessFuture"), " implemented as either a\n", 
#>                   list("MulticoreFuture"), " or a ", list("MultisessionFuture"), 
#>                   ".\n"), "\n", list("\n", "A multiprocess future is a future that uses ", 
#>                   list("multicore"), " evaluation\n", "if supported, otherwise it uses ", 
#>                   list("multisession"), " evaluation.\n", "Regardless, its ", 
#>                   list("value is computed and resolved in\n", 
#>                     "parallel in another process"), ".", list(), 
#>                   "\n", list(), "\n", list("WARNING: Consider the 'multiprocess' future plan deprecated.\n", 
#>                     "Instead, explicitly specify 'multisession' or 'multicore'.  The former works\n", 
#>                     "everywhere and is the recommended one between the two. ", 
#>                     list("Forked processing"), ",\n", "which 'multicore' uses, is unstable in various environment and setups.\n", 
#>                     "The 'multiprocess' alias is therefore being phased out."), 
#>                   "\n"), "\n", list("\n", list("\n", "\n", "## Use multiprocess futures\n", 
#>                   "plan(multiprocess)\n", "\n", "## A global variable\n", 
#>                   "a <- 0\n", "\n", "## Create future (explicitly)\n", 
#>                   "f <- future({\n", "  b <- 3\n", "  c <- 2\n", 
#>                   "  a * b * c\n", "})\n", "\n", "## A multiprocess future is evaluated in a separate R process.\n", 
#>                   "## Changing the value of a global variable will not affect\n", 
#>                   "## the result of the future.\n", "a <- 7\n", 
#>                   "print(a)\n", "\n", "v <- value(f)\n", "print(v)\n", 
#>                   "stopifnot(v == 0)\n", "\n", "## Explicitly close multisession workers, if they were used\n", 
#>                   "plan(sequential)\n"), "\n"), "\n", list("\n", 
#>                   "Internally ", list(list("multicore()")), " and ", 
#>                   list(list("multisession()")), "\n", "are used.\n"), 
#>                 "\n", list("internal"), "\n"), multisession.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/multisession.R", 
#>                 "\n", list("multisession"), "\n", list("multisession"), 
#>                 "\n", list("Create a multisession future whose value will be resolved asynchronously in a parallel ", 
#>                   list(), " session"), "\n", list("\n", "multisession(\n", 
#>                   "  ...,\n", "  workers = availableCores(),\n", 
#>                   "  lazy = FALSE,\n", "  rscript_libs = .libPaths(),\n", 
#>                   "  envir = parent.frame()\n", ")\n"), "\n", 
#>                 list("\n", list(list("..."), list("Additional arguments passed to ", 
#>                   list(list("Future()")), ".")), "\n", "\n", 
#>                   list(list("workers"), list("A positive numeric scalar or a function specifying the\n", 
#>                     "maximum number of parallel futures that can be active at the same time\n", 
#>                     "before blocking.\n", "If a function, it is called without arguments ", 
#>                     list("when the future\n", "is created"), 
#>                     " and its value is used to configure the workers.\n", 
#>                     "The function should return a numeric scalar.")), 
#>                   "\n", "\n", list(list("lazy"), list("If FALSE (default), the future is resolved\n", 
#>                     "eagerly (starting immediately), otherwise not.")), 
#>                   "\n", "\n", list(list("rscript_libs"), list(
#>                     "A character vector of ", list(), " package library folders that\n", 
#>                     "the workers should use.  The default is ", 
#>                     list(".libPaths()"), " so that multisession\n", 
#>                     "workers inherits the same library path as the main ", 
#>                     list(), " session.\n", "To avoid this, use ", 
#>                     list("plan(multisession, ..., rscript_libs = NULL)"), 
#>                     ".\n", list("Important: Note that the library path is set on the workers when they are\n", 
#>                       "created, i.e. when ", list("plan(multisession)"), 
#>                       " is called.  Any changes to\n", list(".libPaths()"), 
#>                       " in the main R session after the workers have been created\n", 
#>                       "will have no effect."), "\n", "This is passed down as-is to ", 
#>                     list(list("parallelly::makeClusterPSOCK()")), 
#>                     ".")), "\n", "\n", list(list("envir"), list(
#>                     "The ", list("environment"), " from where global objects should be\n", 
#>                     "identified.")), "\n"), "\n", list("\n", 
#>                   "A ", list("MultisessionFuture"), ".\n", "If ", 
#>                   list("workers == 1"), ", then all processing using done in the\n", 
#>                   "current/main ", list(), " session and we therefore fall back to using\n", 
#>                   "a lazy future.\n"), "\n", list("\n", "A multisession future is a future that uses multisession evaluation,\n", 
#>                   "which means that its ", list("value is computed and resolved in\n", 
#>                     "parallel in another ", list(), " session"), 
#>                   ".\n"), "\n", list("\n", "This function is ", 
#>                   list("not"), " meant to be called directly.  Instead, the\n", 
#>                   "typical usages are:", list(list("html"), list(
#>                     list("<div class=\"sourceCode r\">"))), list(
#>                     "# Evaluate futures in parallel on the local machine via as many background\n", 
#>                     "# processes as available to the current R process\n", 
#>                     "plan(multisession)\n", "\n", "# Evaluate futures in parallel on the local machine via two background\n", 
#>                     "# processes\n", "plan(multisession, workers = 2)\n"), 
#>                   list(list("html"), list(list("</div>"))), "\n", 
#>                   "\n", "The background ", list(), " sessions (the \"workers\") are created using\n", 
#>                   list(list("makeClusterPSOCK()")), ".\n", "\n", 
#>                   "For the total number of\n", list(), " sessions available including the current/main ", 
#>                   list(), " process, see\n", list(list("parallelly::availableCores()")), 
#>                   ".\n", "\n", "A multisession future is a special type of cluster future.\n"), 
#>                 "\n", list("\n", list("\n", "\n", "## Use multisession futures\n", 
#>                   "plan(multisession)\n", "\n", "## A global variable\n", 
#>                   "a <- 0\n", "\n", "## Create future (explicitly)\n", 
#>                   "f <- future({\n", "  b <- 3\n", "  c <- 2\n", 
#>                   "  a * b * c\n", "})\n", "\n", "## A multisession future is evaluated in a separate R session.\n", 
#>                   "## Changing the value of a global variable will not affect\n", 
#>                   "## the result of the future.\n", "a <- 7\n", 
#>                   "print(a)\n", "\n", "v <- value(f)\n", "print(v)\n", 
#>                   "stopifnot(v == 0)\n", "\n", "## Explicitly close multisession workers by switching plan\n", 
#>                   "plan(sequential)\n"), "\n"), "\n", list("\n", 
#>                   "For processing in multiple forked ", list(), 
#>                   " sessions, see\n", list("multicore"), " futures.\n", 
#>                   "\n", "Use ", list(list("parallelly::availableCores()")), 
#>                   " to see the total number of\n", "cores that are available for the current ", 
#>                   list(), " session.\n"), "\n"), nbrOfWorkers.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/nbrOfWorkers.R", 
#>                 "\n", list("nbrOfWorkers"), "\n", list("nbrOfWorkers"), 
#>                 "\n", list("nbrOfFreeWorkers"), "\n", list("Get the number of workers available"), 
#>                 "\n", list("\n", "nbrOfWorkers(evaluator = NULL)\n", 
#>                   "\n", "nbrOfFreeWorkers(evaluator = NULL, background = FALSE, ...)\n"), 
#>                 "\n", list("\n", list(list("evaluator"), list(
#>                   "A future evaluator function.\n", "If NULL (default), the current evaluator as returned\n", 
#>                   "by ", list(list("plan()")), " is used.")), 
#>                   "\n", "\n", list(list("background"), list("If TRUE, only workers that can process a future in the\n", 
#>                     "background are considered.  If FALSE, also workers running in the main ", 
#>                     list(), "\n", "process are considered, e.g. when using the 'sequential' backend.")), 
#>                   "\n", "\n", list(list(list()), list("Not used; reserved for future use.")), 
#>                   "\n"), "\n", list("\n", list("nbrOfWorkers()"), 
#>                   " returns a positive number in ", list(list(
#>                     "{1, 2, 3, ...}")), ", which\n", "for some future backends may also be ", 
#>                   list("+Inf"), ".\n", "\n", list("nbrOfFreeWorkers()"), 
#>                   " returns a non-negative number in\n", list(
#>                     list("{0, 1, 2, 3, ...}")), " which is less than or equal to ", 
#>                   list("nbrOfWorkers()"), ".\n"), "\n", list(
#>                   "\n", "Get the number of workers available\n"), 
#>                 "\n", list("\n", "plan(multisession)\n", "nbrOfWorkers()  ## == availableCores()\n", 
#>                   "\n", "plan(sequential)\n", "nbrOfWorkers()  ## == 1\n"), 
#>                 "\n"), nullcon.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/utils.R", 
#>                 "\n", list("nullcon"), "\n", list("nullcon"), 
#>                 "\n", list("Creates a connection to the system null device"), 
#>                 "\n", list("\n", "nullcon()\n"), "\n", list("\n", 
#>                   "Returns a open, binary ", list(list("base::connection()")), 
#>                   ".\n"), "\n", list("\n", "Creates a connection to the system null device\n"), 
#>                 "\n", list("internal"), "\n"), pid_exists.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/utils.R", 
#>                 "\n", list("pid_exists"), "\n", list("pid_exists"), 
#>                 "\n", list("Check whether a process PID exists or not"), 
#>                 "\n", list("\n", "pid_exists(pid, debug = getOption(\"future.debug\", FALSE))\n"), 
#>                 "\n", list("\n", list(list("pid"), list("A positive integer.")), 
#>                   "\n"), "\n", list("\n", "Returns ", list("TRUE"), 
#>                   " if a process with the given PID exists,\n", 
#>                   list("FALSE"), " if a process with the given PID does not exists, and\n", 
#>                   list("NA"), " if it is not possible to check PIDs on the current system.\n"), 
#>                 "\n", list("\n", "Check whether a process PID exists or not\n"), 
#>                 "\n", list("\n", "There is no single go-to function in ", 
#>                   list(), " for testing whether a PID exists\n", 
#>                   "or not.  Instead, this function tries to identify a working one among\n", 
#>                   "multiple possible alternatives.  A method is considered working if the\n", 
#>                   "PID of the current process is successfully identified as being existing\n", 
#>                   "such that ", list("pid_exists(Sys.getpid())"), 
#>                   " is ", list("TRUE"), ".  If no working\n", 
#>                   "approach is found, ", list("pid_exists()"), 
#>                   " will always return ", list("NA"), "\n", "regardless of PID tested.\n", 
#>                   "On Unix, including macOS, alternatives ", 
#>                   list("tools::pskill(pid, signal = 0L)"), "\n", 
#>                   "and ", list("system2(\"ps\", args = pid)"), 
#>                   " are used.\n", "On Windows, various alternatives of ", 
#>                   list("system2(\"tasklist\", ...)"), " are used.\n"), 
#>                 "\n", list("\n", list("\n", list(), " The Open Group Base Specifications Issue 7, 2018 edition,\n", 
#>                   "IEEE Std 1003.1-2017 (Revision of IEEE Std 1003.1-2008)\n", 
#>                   list("https://pubs.opengroup.org/onlinepubs/9699919799/functions/kill.html"), 
#>                   "\n", list(), " Microsoft, tasklist, 2018-08-30,\n", 
#>                   list("https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/tasklist"), 
#>                   "\n", list(), " R-devel thread 'Detecting whether a process exists or not by its PID?',\n", 
#>                   "2018-08-30.\n", list("https://stat.ethz.ch/pipermail/r-devel/2018-August/076702.html"), 
#>                   "\n"), "\n"), "\n", list("\n", list(list("pskill"), 
#>                   "()"), " and ", list(list("system2"), "()"), 
#>                   ".\n"), "\n", list("internal"), "\n"), plan.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/zzz.plan.R", 
#>                 "\n", list("plan"), "\n", list("plan"), "\n", 
#>                 list("Plan how to resolve a future"), "\n", list(
#>                   "\n", "plan(\n", "  strategy = NULL,\n", "  ...,\n", 
#>                   "  substitute = TRUE,\n", "  .skip = FALSE,\n", 
#>                   "  .call = TRUE,\n", "  .cleanup = TRUE,\n", 
#>                   "  .init = TRUE\n", ")\n"), "\n", list("\n", 
#>                   list(list("strategy"), list("The evaluation function (or name of it) to use\n", 
#>                     "for resolving a future.  If NULL, then the current strategy is returned.")), 
#>                   "\n", "\n", list(list(list()), list("Additional arguments overriding the default arguments\n", 
#>                     "of the evaluation function.  Which additional arguments are supported\n", 
#>                     "depends on what evaluation function is used, e.g. several support\n", 
#>                     "argument ", list("workers"), " but not all.  For details, see the individual\n", 
#>                     "functions of which some are linked to below.")), 
#>                   "\n", "\n", list(list("substitute"), list("If TRUE, the ", 
#>                     list("strategy"), " expression is\n", list(
#>                       "substitute()"), ":d, otherwise not.")), 
#>                   "\n", "\n", list(list(".skip"), list("(internal) If ", 
#>                     list("TRUE"), ", then attempts to set a strategy\n", 
#>                     "that is the same as what is currently in use, will skipped.")), 
#>                   "\n", "\n", list(list(".call"), list("(internal) Used for recording the call to this function.")), 
#>                   "\n", "\n", list(list(".cleanup"), list("(internal) Used to stop implicitly started clusters.")), 
#>                   "\n", "\n", list(list(".init"), list("(internal) Used to initiate workers.")), 
#>                   "\n"), "\n", list("\n", "If a new strategy is chosen, then the previous one is returned\n", 
#>                   "(invisible), otherwise the current one is returned (visibly).\n"), 
#>                 "\n", list("\n", "This function allows ", list(
#>                   "the user"), " to plan the future, more specifically,\n", 
#>                   "it specifies how ", list(list("future()")), 
#>                   ":s are resolved,\n", "e.g. sequentially or in parallel.\n"), 
#>                 "\n", list("\n", "The default strategy is ", 
#>                   list(list("sequential")), ", but the default can be\n", 
#>                   "configured by option ", list("future.plan"), 
#>                   " and, if that is not set,\n", "system environment variable ", 
#>                   list("R_FUTURE_PLAN"), ".\n", "To reset the strategy back to the default, use ", 
#>                   list("plan(\"default\")"), ".\n"), "\n", list(
#>                   list("Implemented evaluation strategies"), 
#>                   list("\n", "\n", list("\n", list(), list(list(
#>                     list("sequential")), ":"), list("\n", "Resolves futures sequentially in the current ", 
#>                     list(), " process.\n"), "\n", list(), list(
#>                     list(list("multisession")), ":"), list("\n", 
#>                     "Resolves futures asynchronously (in parallel) in separate\n", 
#>                     list(), " sessions running in the background on the same machine.\n"), 
#>                     "\n", list(), list(list(list("multicore")), 
#>                       ":"), list("\n", "Resolves futures asynchronously (in parallel) in separate\n", 
#>                       list("forked"), " ", list(), " processes running in the background on\n", 
#>                       "the same machine.  Not supported on Windows.\n"), 
#>                     "\n", list(), list(list(list("multiprocess")), 
#>                       ":"), list("(DEPRECATED)\n", "If multicore evaluation is supported, that will be used,\n", 
#>                       "otherwise multisession evaluation will be used.\n"), 
#>                     "\n", list(), list(list(list("cluster")), 
#>                       ":"), list("\n", "Resolves futures asynchronously (in parallel) in separate\n", 
#>                       list(), " sessions running typically on one or more machines.\n"), 
#>                     "\n", list(), list(list(list("remote")), 
#>                       ":"), list("\n", "Resolves futures asynchronously in a separate ", 
#>                       list(), " session\n", "running on a separate machine, typically on a different\n", 
#>                       "network.\n"), "\n"), "\n", "\n", "Other package may provide additional evaluation strategies.\n", 
#>                     "Notably, the ", list("future.batchtools"), 
#>                     " package implements a\n", "type of futures that will be resolved via job schedulers\n", 
#>                     "that are typically available on high-performance compute\n", 
#>                     "(HPC) clusters, e.g. LSF, Slurm, TORQUE/PBS, Sun Grid Engine,\n", 
#>                     "and OpenLava.\n", "\n", "To \"close\" any background workers (e.g. ", 
#>                     list("multisession"), "), change\n", "the plan to something different; ", 
#>                     list("plan(sequential)"), " is recommended\n", 
#>                     "for this.\n")), "\n", "\n", list(list("For package developers"), 
#>                   list("\n", "\n", "Please refrain from modifying the future strategy inside your packages /\n", 
#>                     "functions, i.e. do not call ", list("plan()"), 
#>                     " in your code.  Instead, leave\n", "the control on what backend to use to the end user.  This idea is part of\n", 
#>                     "the core philosophy of the future framework - as a developer you can never\n", 
#>                     "know what future backends the user have access to.  Moreover, by not making\n", 
#>                     "any assumptions about what backends are available, your code will also work\n", 
#>                     "automatically with any new backends developed after you wrote your code.\n", 
#>                     "\n", "If you think it is necessary to modify the future strategy within a\n", 
#>                     "function, then make sure to undo the changes when exiting the function.\n", 
#>                     "This can be done using:\n", "\n", list("\n", 
#>                       "  oplan <- plan(new_set_of_strategies)\n", 
#>                       "  on.exit(plan(oplan), add = TRUE)\n", 
#>                       "  [...]\n"), "\n", "\n", "This is important because the end-user might have already set the future\n", 
#>                     "strategy elsewhere for other purposes and will most likely not known that\n", 
#>                     "calling your function will break their setup.\n", 
#>                     list("Remember, your package and its functions might be used in a greater\n", 
#>                       "context where multiple packages and functions are involved and those might\n", 
#>                       "also rely on the future framework, so it is important to avoid stepping on\n", 
#>                       "others' toes."), "\n")), "\n", "\n", list(
#>                   list("Using plan() in scripts and vignettes"), 
#>                   list("\n", "\n", "When writing scripts or vignettes that uses futures, try to place any\n", 
#>                     "call to ", list("plan()"), " as far up (as early on) in the code as possible.\n", 
#>                     "This will help users to quickly identify where the future plan is set up\n", 
#>                     "and allow them to modify it to their computational resources.\n", 
#>                     "Even better is to leave it to the user to set the ", 
#>                     list("plan()"), " prior to\n", list("source()"), 
#>                     ":ing the script or running the vignette.\n", 
#>                     "If a ", list(list(".future.R")), " exists in the current directory and / or in\n", 
#>                     "the user's home directory, it is sourced when the ", 
#>                     list("future"), " package is\n", list("loaded"), 
#>                     ".  Because of this, the ", list(".future.R"), 
#>                     " file provides a\n", "convenient place for users to set the ", 
#>                     list("plan()"), ".\n", "This behavior can be controlled via an ", 
#>                     list(), " option - see\n", list("future options"), 
#>                     " for more details.\n")), "\n", "\n", list(
#>                   "\n", "a <- b <- c <- NA_real_\n", "\n", "# An sequential future\n", 
#>                   "plan(sequential)\n", "f <- future({\n", "  a <- 7\n", 
#>                   "  b <- 3\n", "  c <- 2\n", "  a * b * c\n", 
#>                   "})\n", "y <- value(f)\n", "print(y)\n", "str(list(a = a, b = b, c = c)) ## All NAs\n", 
#>                   "\n", "\n", "# A sequential future with lazy evaluation\n", 
#>                   "plan(sequential)\n", "f <- future({\n", "  a <- 7\n", 
#>                   "  b <- 3\n", "  c <- 2\n", "  a * b * c\n", 
#>                   "}, lazy = TRUE)\n", "y <- value(f)\n", "print(y)\n", 
#>                   "str(list(a = a, b = b, c = c)) ## All NAs\n", 
#>                   "\n", "\n", "# A multicore future (specified as a string)\n", 
#>                   "plan(\"multicore\")\n", "f <- future({\n", 
#>                   "  a <- 7\n", "  b <- 3\n", "  c <- 2\n", "  a * b * c\n", 
#>                   "})\n", "y <- value(f)\n", "print(y)\n", "str(list(a = a, b = b, c = c)) ## All NAs\n", 
#>                   "\n", "\n", "## Multisession futures gives an error on R CMD check on\n", 
#>                   "## Windows (but not Linux or macOS) for unknown reasons.\n", 
#>                   "## The same code works in package tests.\n", 
#>                   list("\n", "\n", "# A multisession future (specified via a string variable)\n", 
#>                     "plan(\"future::multisession\")\n", "f <- future({\n", 
#>                     "  a <- 7\n", "  b <- 3\n", "  c <- 2\n", 
#>                     "  a * b * c\n", "})\n", "y <- value(f)\n", 
#>                     "print(y)\n", "str(list(a = a, b = b, c = c)) ## All NAs\n", 
#>                     "\n"), "\n", "\n", "## Explicitly close multisession workers by switching plan\n", 
#>                   "plan(sequential)\n"), "\n"), private_length.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/utils.R", 
#>                 "\n", list(".length"), "\n", list(".length"), 
#>                 "\n", list("Gets the length of an object without dispatching"), 
#>                 "\n", list("\n", ".length(x)\n"), "\n", list(
#>                   "\n", list(list("x"), list("Any ", list(), 
#>                     " object.")), "\n"), "\n", list("\n", "A non-negative integer.\n"), 
#>                 "\n", list("\n", "Gets the length of an object without dispatching\n"), 
#>                 "\n", list("\n", "This function returns ", list(
#>                   "length(unclass(x))"), ", but tries to avoid\n", 
#>                   "calling ", list("unclass(x)"), " unless necessary.\n"), 
#>                 "\n", list("\n", list(list(".subset"), "()"), 
#>                   " and ", list(list(".subset2"), "()"), ".\n"), 
#>                 "\n", list("internal"), "\n"), `re-exports.Rd` = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/000.re-exports.R", 
#>                 "\n", list("re-exports"), "\n", list("re-exports"), 
#>                 "\n", list("as.cluster"), "\n", list("autoStopCluster"), 
#>                 "\n", list("availableCores"), "\n", list("availableWorkers"), 
#>                 "\n", list("makeClusterMPI"), "\n", list("makeClusterPSOCK"), 
#>                 "\n", list("makeNodePSOCK"), "\n", list("supportsMulticore"), 
#>                 "\n", list("Functions Moved to 'parallelly'"), 
#>                 "\n", list("\n", "The following function used to be part of ", 
#>                   list("future"), " but has since\n", "been migrated to ", 
#>                   list("parallelly"), ".  The migration started with\n", 
#>                   list("future"), " 1.20.0 (November 2020).  They were moved because they\n", 
#>                   "are also useful outside of the ", list("future"), 
#>                   " framework.\n"), "\n", list("\n", list("\n", 
#>                   list(), " ", list(list("parallelly::as.cluster()")), 
#>                   "\n", list(), " ", list(list("parallelly::autoStopCluster()")), 
#>                   "\n", list(), " ", list(list("parallelly::availableCores()")), 
#>                   "\n", list(), " ", list(list("parallelly::availableWorkers()")), 
#>                   "\n", list(), " ", list(list("parallelly::makeClusterMPI()")), 
#>                   "\n", list(), " ", list(list("parallelly::makeClusterPSOCK()")), 
#>                   "\n", list(), " ", list(list("parallelly::makeNodePSOCK()")), 
#>                   "\n", list(), " ", list(list("parallelly::supportsMulticore()")), 
#>                   "\n"), "\n", "\n", "For backward-compatible reasons, these functions remain available as\n", 
#>                   "exact copies also from this package (as re-exports).  For example,", 
#>                   list(list("html"), list(list("<div class=\"sourceCode r\">"))), 
#>                   list("cl <- parallelly::makeClusterPSOCK(2)\n"), 
#>                   list(list("html"), list(list("</div>"))), "\n", 
#>                   "\n", "can still be accessed as:", list(list(
#>                     "html"), list(list("<div class=\"sourceCode r\">"))), 
#>                   list("cl <- future::makeClusterPSOCK(2)\n"), 
#>                   list(list("html"), list(list("</div>"))), "\n"), 
#>                 "\n"), readImmediateConditions.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/utils-immediateCondition.R", 
#>                 "\n", list("readImmediateConditions"), "\n", 
#>                 list("readImmediateConditions"), "\n", list("Read All 'immediateCondition' RDS Files"), 
#>                 "\n", list("\n", "readImmediateConditions(\n", 
#>                   "  path = immediateConditionsPath(),\n", "  pattern = \"[.]rds$\",\n", 
#>                   "  include = getOption(\"future.relay.immediate\", \"immediateCondition\"),\n", 
#>                   "  signal = FALSE,\n", "  remove = TRUE\n", 
#>                   ")\n"), "\n", list("\n", list(list("path"), 
#>                   list("(character string) The folder where the RDS files are.")), 
#>                   "\n", "\n", list(list("pattern"), list("(character string) A regular expression selecting\n", 
#>                     "the RDS files to be read.")), "\n", "\n", 
#>                   list(list("include"), list("(character vector) The class or classes of the objects\n", 
#>                     "to be kept.")), "\n", "\n", list(list("signal"), 
#>                     list("(logical) If TRUE, the condition read are signaled.")), 
#>                   "\n", "\n", list(list("remove"), list("(logical) If TRUE, the RDS files used are removed on exit.")), 
#>                   "\n"), "\n", list("\n", "Returns a ", list(
#>                   "base::list"), " of immediateCondition objects.\n"), 
#>                 "\n", list("\n", "Read All 'immediateCondition' RDS Files\n"), 
#>                 "\n", list("internal"), "\n"), remote.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/remote.R", 
#>                 "\n", list("remote"), "\n", list("remote"), "\n", 
#>                 list("Create a remote future whose value will be resolved asynchronously in a remote process"), 
#>                 "\n", list("\n", "remote(\n", "  ...,\n", "  workers = NULL,\n", 
#>                   "  revtunnel = TRUE,\n", "  myip = NULL,\n", 
#>                   "  persistent = TRUE,\n", "  homogeneous = TRUE,\n", 
#>                   "  envir = parent.frame()\n", ")\n"), "\n", 
#>                 list("\n", list(list("..."), list("Additional named elements passed to ", 
#>                   list(list("Future()")), ".")), "\n", "\n", 
#>                   list(list("workers"), list("A ", list(list(
#>                     "cluster")), " object,\n", "a character vector of host names, a positive numeric scalar,\n", 
#>                     "or a function.\n", "If a character vector or a numeric scalar, a ", 
#>                     list("cluster"), " object\n", "is created using ", 
#>                     list(list("makeClusterPSOCK"), "(workers)"), 
#>                     ".\n", "If a function, it is called without arguments ", 
#>                     list("when the future\n", "is created"), 
#>                     " and its value is used to configure the workers.\n", 
#>                     "The function should return any of the above types.")), 
#>                   "\n", "\n", list(list("revtunnel"), list("If TRUE, reverse SSH tunneling is used for the\n", 
#>                     "PSOCK cluster nodes to connect back to the master ", 
#>                     list(), " process.  This\n", "avoids the hassle of firewalls, port forwarding and having to know\n", 
#>                     "the internal / public IP address of the master ", 
#>                     list(), " session.")), "\n", "\n", list(list(
#>                     "myip"), list("The external IP address of this machine.\n", 
#>                     "If NULL, then it is inferred using an online service (default).")), 
#>                   "\n", "\n", list(list("persistent"), list("If FALSE, the evaluation environment is cleared\n", 
#>                     "from objects prior to the evaluation of the future.")), 
#>                   "\n", "\n", list(list("homogeneous"), list(
#>                     "If TRUE, all cluster nodes is assumed to use the\n", 
#>                     "same path to ", list("Rscript"), " as the main ", 
#>                     list(), " session.  If FALSE, the\n", "it is assumed to be on the PATH for each node.\n", 
#>                     "If NULL, then ", list(list("parallelly::makeClusterPSOCK()")), 
#>                     " will decide on TRUE\n", "or FALSE depending on ", 
#>                     list("workers"), ".")), "\n", "\n", list(
#>                     list("envir"), list("The ", list("environment"), 
#>                       " from where global objects should be\n", 
#>                       "identified.")), "\n"), "\n", list("\n", 
#>                   "A ", list("ClusterFuture"), ".\n"), "\n", 
#>                 list("\n", "A remote future is a future that uses remote cluster evaluation,\n", 
#>                   "which means that its ", list("value is computed and resolved\n", 
#>                     "remotely in another process"), ".\n"), "\n", 
#>                 list("\n", "This function is ", list("not"), 
#>                   " meant to be called directly.  Instead, the\n", 
#>                   "typical usages are:", list(list("html"), list(
#>                     list("<div class=\"sourceCode r\">"))), list(
#>                     "# Evaluate futures on remote machine 'server.example.org', and\n", 
#>                     "# any nested ones sequentially (default) on that remote machine\n", 
#>                     "plan(remote, workers = \"server.example.org\")\n", 
#>                     "\n", "# Evaluate futures on remote machine 'server.example.org', and\n", 
#>                     "# nested ones in parallel on that remote machine\n", 
#>                     "plan(list(\n", "   tweak(remote, workers = \"server.example.org\"),\n", 
#>                     "   multisession\n", "))\n", "\n", "# Evaluate futures on remote machine 'server.example.org', and\n", 
#>                     "# nested ones in parallel on the remote machines n1, n2, and n3.\n", 
#>                     "plan(list(\n", "  tweak(remote, workers = \"server.example.org\"),\n", 
#>                     "  tweak(cluster, workers = c(\"n1\", \"n2\", \"n3\"))\n", 
#>                     "))\n"), list(list("html"), list(list("</div>"))), 
#>                   "\n"), "\n", list(list("'remote' versus 'cluster'"), 
#>                   list("\n", "\n", "The ", list("remote"), " plan is a very similar to the ", 
#>                     list(list("cluster")), " plan, but provides\n", 
#>                     "more convenient default argument values when connecting to remote machines.  #' Specifically, ", 
#>                     list("remote"), " uses ", list("persistent = TRUE"), 
#>                     " by default, and it sets\n", list("homogeneous"), 
#>                     ", ", list("revtunnel"), ", and ", list("myip"), 
#>                     " \"wisely\" depending on the value of\n", 
#>                     list("workers"), ".\n", "' See below for example on how ", 
#>                     list("remote"), " and ", list("cluster"), 
#>                     " are related.\n")), "\n", "\n", list("\n", 
#>                   list("\\donttest{\n", "\n", "## Use a remote machine\n", 
#>                     "plan(remote, workers = \"remote.server.org\")\n", 
#>                     "\n", "## Evaluate expression remotely\n", 
#>                     "host %<-% { Sys.info()[[\"nodename\"]] }\n", 
#>                     "host\n", "[1] \"remote.server.org\"\n", 
#>                     "\n", "\n", "## The following setups are equivalent:\n", 
#>                     "plan(remote, workers = \"localhost\")\n", 
#>                     "plan(cluster, workers = \"localhost\", persistent = TRUE)\n", 
#>                     "plan(cluster, workers = 1, persistent = TRUE)\n", 
#>                     "plan(multisession, workers = 1, persistent = TRUE)\n", 
#>                     "\n", "## The following setups are equivalent:\n", 
#>                     "plan(remote, workers = \"remote.server.org\")\n", 
#>                     "plan(cluster, workers = \"remote.server.org\", persistent = TRUE, homogeneous = FALSE)\n", 
#>                     "\n", "## The following setups are equivalent:\n", 
#>                     "cl <- makeClusterPSOCK(\"remote.server.org\")\n", 
#>                     "plan(remote, workers = cl)\n", "plan(cluster, workers = cl, persistent = TRUE)\n", 
#>                     "\n", "}"), "\n"), "\n"), requestCore.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/multicore.R", 
#>                 "\n", list("requestCore"), "\n", list("requestCore"), 
#>                 "\n", list("Request a core for multicore processing"), 
#>                 "\n", list("\n", "requestCore(\n", "  await,\n", 
#>                   "  workers = availableCores(),\n", "  timeout = getOption(\"future.wait.timeout\", 30 * 24 * 60 * 60),\n", 
#>                   "  delta = getOption(\"future.wait.interval\", 0.2),\n", 
#>                   "  alpha = getOption(\"future.wait.alpha\", 1.01)\n", 
#>                   ")\n"), "\n", list("\n", list(list("await"), 
#>                   list("A function used to try to \"collect\"\n", 
#>                     "finished multicore subprocesses.")), "\n", 
#>                   "\n", list(list("workers"), list("Total number of workers available.")), 
#>                   "\n", "\n", list(list("timeout"), list("Maximum waiting time (in seconds) allowed\n", 
#>                     "before a timeout error is generated.")), 
#>                   "\n", "\n", list(list("delta"), list("Then base interval (in seconds) to wait\n", 
#>                     "between each try.")), "\n", "\n", list(list(
#>                     "alpha"), list("A multiplicative factor used to increase\n", 
#>                     "the wait interval after each try.")), "\n"), 
#>                 "\n", list("\n", "Invisible TRUE. If no cores are available after\n", 
#>                   "extensive waiting, then a timeout error is thrown.\n"), 
#>                 "\n", list("\n", "If no cores are available, the current process\n", 
#>                   "blocks until a core is available.\n"), "\n", 
#>                 list("internal"), "\n"), resetWorkers.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/zzz.plan.R", 
#>                 "\n", list("resetWorkers"), "\n", list("resetWorkers"), 
#>                 "\n", list("Free up active background workers"), 
#>                 "\n", list("\n", "resetWorkers(x, ...)\n"), "\n", 
#>                 list("\n", list(list("x"), list("A FutureStrategy.")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "Free up active background workers\n"), 
#>                 "\n", list("\n", "This function will resolve any active futures that is currently\n", 
#>                   "being evaluated on background workers.\n"), 
#>                 "\n", list("\n", "resetWorkers(plan())\n", "\n"), 
#>                 "\n", list("internal"), "\n"), resolve.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/resolve.R", 
#>                 "\n", list("resolve"), "\n", list("resolve"), 
#>                 "\n", list("Resolve one or more futures synchronously"), 
#>                 "\n", list("\n", "resolve(\n", "  x,\n", "  idxs = NULL,\n", 
#>                   "  recursive = 0,\n", "  result = FALSE,\n", 
#>                   "  stdout = FALSE,\n", "  signal = FALSE,\n", 
#>                   "  force = FALSE,\n", "  sleep = 1,\n", "  value = result,\n", 
#>                   "  ...\n", ")\n"), "\n", list("\n", list(list(
#>                   "x"), list("A ", list("Future"), " to be resolved, or a list, an environment, or a\n", 
#>                   "list environment of futures to be resolved.")), 
#>                   "\n", "\n", list(list("idxs"), list("(optional) integer or logical index specifying the subset of\n", 
#>                     "elements to check.")), "\n", "\n", list(
#>                     list("recursive"), list("A non-negative number specifying how deep of a recursion\n", 
#>                       "should be done.  If TRUE, an infinite recursion is used.  If FALSE or zero,\n", 
#>                       "no recursion is performed.")), "\n", "\n", 
#>                   list(list("result"), list("(internal) If TRUE, the results are retrieved, otherwise not.")), 
#>                   "\n", "\n", list(list("stdout"), list("(internal) If TRUE, captured standard output is relayed, otherwise note.")), 
#>                   "\n", "\n", list(list("signal"), list("(internal) If TRUE, captured ", 
#>                     list("conditions"), " are relayed,\n", "otherwise not.")), 
#>                   "\n", "\n", list(list("force"), list("(internal) If TRUE, captured standard output and captured\n", 
#>                     list("conditions"), " already relayed is relayed again, otherwise not.")), 
#>                   "\n", "\n", list(list("sleep"), list("Number of seconds to wait before checking if futures have been\n", 
#>                     "resolved since last time.")), "\n", "\n", 
#>                   list(list("value"), list("(DEFUNCT) Use argument ", 
#>                     list("result"), " instead.")), "\n", "\n", 
#>                   list(list(list()), list("Not used.")), "\n"), 
#>                 "\n", list("\n", "Returns ", list("x"), " (regardless of subsetting or not).\n", 
#>                   "If ", list("signal"), " is TRUE and one of the futures produces an error, then\n", 
#>                   "that error is produced.\n"), "\n", list("\n", 
#>                   "This function provides an efficient mechanism for waiting for multiple\n", 
#>                   "futures in a container (e.g. list or environment) to be resolved while in\n", 
#>                   "the meanwhile retrieving values of already resolved futures.\n"), 
#>                 "\n", list("\n", "This function is resolves synchronously, i.e. it blocks until ", 
#>                   list("x"), " and\n", "any containing futures are resolved.\n"), 
#>                 "\n", list("\n", "To resolve a future ", list(
#>                   "variable"), ", first retrieve its\n", list(
#>                   "Future"), " object using ", list(list("futureOf()")), 
#>                   ", e.g.\n", list("resolve(futureOf(x))"), ".\n"), 
#>                 "\n"), resolved.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/resolved.R", 
#>                 "\n", list("resolved"), "\n", list("resolved"), 
#>                 "\n", list("Check whether a future is resolved or not"), 
#>                 "\n", list("\n", "resolved(x, ...)\n"), "\n", 
#>                 list("\n", list(list("x"), list("A ", list("Future"), 
#>                   ", a list, or an environment (which also\n", 
#>                   "includes ", list("list environment"), ".")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "A logical of the same length and dimensions as ", 
#>                   list("x"), ".\n", "Each element is TRUE unless the corresponding element is a\n", 
#>                   "non-resolved future in case it is FALSE.\n"), 
#>                 "\n", list("\n", "Check whether a future is resolved or not\n"), 
#>                 "\n", list("\n", "This method needs to be implemented by the class that implement\n", 
#>                   "the Future API.  The implementation should return either TRUE or FALSE\n", 
#>                   "and must never throw an error (except for ", 
#>                   list("FutureError"), ":s which indicate\n", 
#>                   "significant, often unrecoverable infrastructure problems).\n", 
#>                   "It should also be possible to use the method for polling the\n", 
#>                   "future until it is resolved (without having to wait infinitely long),\n", 
#>                   "e.g. ", list("while (!resolved(future)) Sys.sleep(5)"), 
#>                   ".\n"), "\n"), result.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/Future-class.R", 
#>                 "\n", list("result.Future"), "\n", list("result.Future"), 
#>                 "\n", list("result"), "\n", list("Get the results of a resolved future"), 
#>                 "\n", list("\n", list(list("result"), list("Future")), 
#>                   "(future, ...)\n"), "\n", list("\n", list(list(
#>                   "future"), list("A ", list("Future"), ".")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "The ", list("FutureResult"), 
#>                   " object.\n"), "\n", list("\n", "Get the results of a resolved future\n"), 
#>                 "\n", list("\n", "This function is only part of the ", 
#>                   list("backend"), " Future API.\n", "This function is ", 
#>                   list("not"), " part of the frontend Future API.\n"), 
#>                 "\n", list("internal"), "\n"), run.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/Future-class.R", 
#>                 "\n", list("run.Future"), "\n", list("run.Future"), 
#>                 "\n", list("run"), "\n", list("Run a future"), 
#>                 "\n", list("\n", list(list("run"), list("Future")), 
#>                   "(future, ...)\n"), "\n", list("\n", list(list(
#>                   "future"), list("A ", list("Future"), ".")), 
#>                   "\n", "\n", list(list(list()), list("Not used.")), 
#>                   "\n"), "\n", list("\n", "The ", list("Future"), 
#>                   " object.\n"), "\n", list("\n", "Run a future\n"), 
#>                 "\n", list("\n", "This function can only be called once per future.\n", 
#>                   "Further calls will result in an informative error.\n", 
#>                   "If a future is not run when its value is queried,\n", 
#>                   "then it is run at that point.\n"), "\n", list(
#>                   "internal"), "\n"), save_rds.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/utils-immediateCondition.R", 
#>                 "\n", list("save_rds"), "\n", list("save_rds"), 
#>                 "\n", list("Robustly Saves an Object to RDS File Atomically"), 
#>                 "\n", list("\n", "save_rds(object, pathname, ...)\n"), 
#>                 "\n", list("\n", list(list("object"), list("The ", 
#>                   list(), " object to be save.")), "\n", "\n", 
#>                   list(list("pathname"), list("RDS file to written.")), 
#>                   "\n", "\n", list(list(list()), list("(optional) Additional arguments passed to ", 
#>                     list(list("base::saveRDS()")), ".")), "\n"), 
#>                 "\n", list("\n", "(invisible) The pathname of the RDS written.\n"), 
#>                 "\n", list("\n", "Robustly Saves an Object to RDS File Atomically\n"), 
#>                 "\n", list("\n", "Uses ", list("base::saveRDS"), 
#>                   " internally but writes the object atomically by first\n", 
#>                   "writing to a temporary file which is then renamed.\n"), 
#>                 "\n", list("internal"), "\n"), sequential.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/sequential.R", 
#>                 "\n", list("sequential"), "\n", list("sequential"), 
#>                 "\n", list("uniprocess"), "\n", list("transparent"), 
#>                 "\n", list("Create a sequential future whose value will be in the current ", 
#>                   list(), " session"), "\n", list("\n", "sequential(..., envir = parent.frame())\n", 
#>                   "\n", "transparent(..., envir = parent.frame())\n"), 
#>                 "\n", list("\n", list(list("..."), list("Additional arguments passed to ", 
#>                   list(list("Future()")), ".")), "\n", "\n", 
#>                   list(list("envir"), list("The ", list("environment"), 
#>                     " from where global objects should be\n", 
#>                     "identified.")), "\n"), "\n", list("\n", 
#>                   "A ", list("SequentialFuture"), ".\n"), "\n", 
#>                 list("\n", "A sequential future is a future that is evaluated sequentially in the\n", 
#>                   "current ", list(), " session similarly to how ", 
#>                   list(), " expressions are evaluated in ", list(), 
#>                   ".\n", "The only difference to ", list(), " itself is that globals are validated\n", 
#>                   "by default just as for all other types of futures in this package.\n"), 
#>                 "\n", list("\n", "This function is ", list("not"), 
#>                   " meant to be called directly.  Instead, the\n", 
#>                   "typical usages are:", list(list("html"), list(
#>                     list("<div class=\"sourceCode r\">"))), list(
#>                     "# Evaluate futures sequentially in the current R process\n", 
#>                     "plan(sequential)\n"), list(list("html"), 
#>                     list(list("</div>"))), "\n", "\n", "\n"), 
#>                 "\n", list(list("transparent futures (troubleshooting only)"), 
#>                   list("\n", "\n", "Transparent futures are sequential futures configured to emulate how R\n", 
#>                     "evaluates expressions as far as possible.  For instance, errors and\n", 
#>                     "warnings are signaled immediately and assignments are done to the\n", 
#>                     "calling environment (without ", list("local()"), 
#>                     " as default for all other\n", "types of futures).  This makes transparent futures useful for\n", 
#>                     "troubleshooting, especially when there are errors.  Having said that,\n", 
#>                     "using:", list(list("html"), list(list("<div class=\"sourceCode r\">"))), 
#>                     list("plan(sequential, split = TRUE)\n"), 
#>                     list(list("html"), list(list("</div>"))), 
#>                     "\n", "\n", "together with ", list("debug()"), 
#>                     " is often sufficient for troubleshooting.\n", 
#>                     "\n", list("WARNING: Transparent futures should only be used for debugging and\n", 
#>                       "troubleshooting.  They should not be used for production pipelines\n", 
#>                       "and must not be set within another package.  This is especially\n", 
#>                       "important since 'transparent' futures might be deprecated and replaced\n", 
#>                       "by better means of debugging in future releases."), 
#>                     "\n")), "\n", "\n", list("\n", "## Use sequential futures\n", 
#>                   "plan(sequential)\n", "\n", "## A global variable\n", 
#>                   "a <- 0\n", "\n", "## Create a sequential future\n", 
#>                   "f <- future({\n", "  b <- 3\n", "  c <- 2\n", 
#>                   "  a * b * c\n", "})\n", "\n", "## Since 'a' is a global variable in future 'f' which\n", 
#>                   "## is eagerly resolved (default), this global has already\n", 
#>                   "## been resolved / incorporated, and any changes to 'a'\n", 
#>                   "## at this point will _not_ affect the value of 'f'.\n", 
#>                   "a <- 7\n", "print(a)\n", "\n", "v <- value(f)\n", 
#>                   "print(v)\n", "stopifnot(v == 0)\n"), "\n"), 
#>             sessionDetails.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/sessionDetails.R", 
#>                 "\n", list("sessionDetails"), "\n", list("sessionDetails"), 
#>                 "\n", list("Outputs details on the current ", 
#>                   list(), " session"), "\n", list("\n", "sessionDetails(env = FALSE)\n"), 
#>                 "\n", list("\n", list(list("env"), list("If TRUE, ", 
#>                   list("Sys.getenv()"), " information is returned.")), 
#>                   "\n"), "\n", list("\n", "Invisibly a list of all details.\n"), 
#>                 "\n", list("\n", "Outputs details on the current ", 
#>                   list(), " session\n"), "\n", list("\n", "Note that remote futures use ", 
#>                   list("persistent = TRUE"), " by default.\n"), 
#>                 "\n", list("internal"), "\n"), signalConditions.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/signalConditions.R", 
#>                 "\n", list("signalConditions"), "\n", list("signalConditions"), 
#>                 "\n", list("Signals Captured Conditions"), "\n", 
#>                 list("\n", "signalConditions(\n", "  future,\n", 
#>                   "  include = \"condition\",\n", "  exclude = NULL,\n", 
#>                   "  resignal = TRUE,\n", "  ...\n", ")\n"), 
#>                 "\n", list("\n", list(list("future"), list("A resolved ", 
#>                   list("Future"), ".")), "\n", "\n", list(list(
#>                   "include"), list("A character string of ", 
#>                   list("condition"), "\n", "classes to signal.")), 
#>                   "\n", "\n", list(list("exclude"), list("A character string of ", 
#>                     list("condition"), "\n", "classes ", list(
#>                       "not"), " to signal.")), "\n", "\n", list(
#>                     list("resignal"), list("If TRUE, then already signaled conditions are signaled\n", 
#>                       "again, otherwise not.")), "\n", "\n", 
#>                   list(list(list()), list("Not used.")), "\n"), 
#>                 "\n", list("\n", "Returns the ", list("Future"), 
#>                   " where conditioned that were signaled\n", 
#>                   "have been flagged to have been signaled.\n"), 
#>                 "\n", list("\n", "Captured conditions that meet the ", 
#>                   list("include"), " and ", list("exclude"), 
#>                   "\n", "requirements are signaled ", list("in the order as they were captured"), 
#>                   ".\n"), "\n", list("\n", "Conditions are signaled by\n", 
#>                   list(list("signalCondition"), "()"), ".\n"), 
#>                 "\n"), sticky_globals.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/sticky_globals.R", 
#>                 "\n", list("sticky_globals"), "\n", list("sticky_globals"), 
#>                 "\n", list("Place a sticky-globals environment immediately after the global environment"), 
#>                 "\n", list("\n", "sticky_globals(erase = FALSE, name = \"future:sticky_globals\", pos = 2L)\n"), 
#>                 "\n", list("\n", list(list("erase"), list("(logical) If TRUE, the environment is erased, otherwise not.")), 
#>                   "\n", "\n", list(list("name"), list("(character) The name of the environment on the ", 
#>                     list("base::search"), "\n", "path.")), "\n", 
#>                   "\n", list(list("pos"), list("(integer) The position on the search path where the\n", 
#>                     "environment should be positioned.  If ", 
#>                     list("pos == 0L"), ", then the environment\n", 
#>                     "is detached, if it exists.")), "\n"), "\n", 
#>                 list("\n", "(invisible; environment) The environment.\n"), 
#>                 "\n", list("\n", "Place a sticky-globals environment immediately after the global environment\n"), 
#>                 "\n", list("internal"), "\n"), tweak.Rd = list(
#>                 "% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/tweak.R", 
#>                 "\n", list("tweak"), "\n", list("tweak"), "\n", 
#>                 list("Tweak a future function by adjusting its default arguments"), 
#>                 "\n", list("\n", "tweak(strategy, ..., penvir = parent.frame())\n"), 
#>                 "\n", list("\n", list(list("strategy"), list(
#>                   "An existing future function or the name of one.")), 
#>                   "\n", "\n", list(list(list()), list("Named arguments to replace the defaults of existing\n", 
#>                     "arguments.")), "\n", "\n", list(list("penvir"), 
#>                     list("The environment used when searching for a future\n", 
#>                       "function by its name.")), "\n"), "\n", 
#>                 list("\n", "a future function.\n"), "\n", list(
#>                   "\n", "Tweak a future function by adjusting its default arguments\n"), 
#>                 "\n", list("\n", "Use ", list(list("plan()")), 
#>                   " to set a future to become the\n", "new default strategy.\n"), 
#>                 "\n"), usedCores.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/multicore.R", 
#>                 "\n", list("usedCores"), "\n", list("usedCores"), 
#>                 "\n", list("Get number of cores currently used"), 
#>                 "\n", list("\n", "usedCores()\n"), "\n", list(
#>                   "\n", "A non-negative integer.\n"), "\n", list(
#>                   "\n", "Get number of children (and don't count the current process)\n", 
#>                   "used by the current ", list(), " session.  The number of children\n", 
#>                   "is the total number of subprocesses launched by this\n", 
#>                   "process that are still running and whose values have yet\n", 
#>                   "not been collected.\n"), "\n", list("internal"), 
#>                 "\n"), value.Rd = list("% Generated by roxygen2: do not edit by hand", 
#>                 "\n", "% Please edit documentation in R/value.R", 
#>                 "\n", list("value"), "\n", list("value"), "\n", 
#>                 list("values"), "\n", list("value.Future"), "\n", 
#>                 list("value.list"), "\n", list("value.listenv"), 
#>                 "\n", list("value.environment"), "\n", list("The value of a future or the values of all elements in a container"), 
#>                 "\n", list("\n", "value(...)\n", "\n", list(list(
#>                   "value"), list("Future")), "(future, stdout = TRUE, signal = TRUE, ...)\n", 
#>                   "\n", list(list("value"), list("list")), "(x, stdout = TRUE, signal = TRUE, ...)\n", 
#>                   "\n", list(list("value"), list("listenv")), 
#>                   "(x, stdout = TRUE, signal = TRUE, ...)\n", 
#>                   "\n", list(list("value"), list("environment")), 
#>                   "(x, stdout = TRUE, signal = TRUE, ...)\n"), 
#>                 "\n", list("\n", list(list(list()), list("All arguments used by the S3 methods.")), 
#>                   "\n", "\n", list(list("future, x"), list("A ", 
#>                     list("Future"), ", an environment, a list, or a list environment.")), 
#>                   "\n", "\n", list(list("stdout"), list("If TRUE, standard output captured while resolving futures\n", 
#>                     "is relayed, otherwise not.")), "\n", "\n", 
#>                   list(list("signal"), list("If TRUE, ", list(
#>                     "conditions"), " captured while resolving\n", 
#>                     "futures are relayed, otherwise not.")), 
#>                   "\n"), "\n", list("\n", list("value()"), " of a Future object returns the value of the future, which can\n", 
#>                   "be any type of ", list(), " object.\n", "\n", 
#>                   list("value()"), " of a list, an environment, or a list environment returns an\n", 
#>                   "object with the same number of elements and of the same class.\n", 
#>                   "Names and dimension attributes are preserved, if available.\n", 
#>                   "All future elements are replaced by their corresponding ", 
#>                   list("value()"), " values.\n", "For all other elements, the existing object is kept as-is.\n", 
#>                   "\n", "If ", list("signal"), " is TRUE and one of the futures produces an error, then\n", 
#>                   "that error is produced.\n"), "\n", list("\n", 
#>                   "Gets the value of a future or the values of all elements (including futures)\n", 
#>                   "in a container such as a list, an environment, or a list environment.\n", 
#>                   "If one or more futures is unresolved, then this function blocks until all\n", 
#>                   "queried futures are resolved.\n"), "\n")), 
#>         source = list(`ClusterFuture-class.Rd` = c("R/ClusterFuture-class.R", 
#>         "R/MultisessionFuture-class.R"), `ConstantFuture-class.Rd` = "R/ConstantFuture-class.R", 
#>             `Future-class.Rd` = "R/Future-class.R", FutureCondition.Rd = "R/FutureCondition-class.R", 
#>             FutureGlobals.Rd = "R/FutureGlobals-class.R", FutureResult.Rd = "R/FutureResult-class.R", 
#>             `MulticoreFuture-class.Rd` = "R/MulticoreFuture-class.R", 
#>             `MultiprocessFuture-class.Rd` = "R/MultiprocessFuture-class.R", 
#>             `UniprocessFuture-class.Rd` = "R/UniprocessFuture-class.R", 
#>             as_lecyer_cmrg_seed.Rd = "R/rng.R", backtrace.Rd = "R/backtrace.R", 
#>             cluster.Rd = "R/cluster.R", clusterExportSticky.Rd = "R/sticky_globals.R", 
#>             find_references.Rd = "R/utils-marshalling.R", future.Rd = c("R/future.R", 
#>             "R/futureAssign.R", "R/futureAssign_OP.R", "R/futureCall.R"
#>             ), future.options.Rd = "R/options.R", futureOf.Rd = "R/futureOf.R", 
#>             futureSessionInfo.Rd = "R/futureSessionInfo.R", futures.Rd = "R/futures.R", 
#>             getExpression.Rd = "R/Future-class.R", getGlobalsAndPackages.Rd = "R/globals.R", 
#>             `grapes-conditions-grapes.Rd` = "R/conditions_OP.R", 
#>             `grapes-globals-grapes.Rd` = "R/globals_OP.R", `grapes-label-grapes.Rd` = "R/label_OP.R", 
#>             `grapes-lazy-grapes.Rd` = "R/lazy_OP.R", `grapes-plan-grapes.Rd` = "R/plan_OP.R", 
#>             `grapes-seed-grapes.Rd` = "R/seed_OP.R", `grapes-stdout-grapes.Rd` = "R/stdout_OP.R", 
#>             `grapes-tweak-grapes.Rd` = "R/tweak_OP.R", make_rng_seeds.Rd = "R/rng.R", 
#>             mandelbrot.Rd = "R/mandelbrot.R", multicore.Rd = "R/multicore.R", 
#>             multiprocess.Rd = "R/multiprocess.R", multisession.Rd = "R/multisession.R", 
#>             nbrOfWorkers.Rd = "R/nbrOfWorkers.R", nullcon.Rd = "R/utils.R", 
#>             pid_exists.Rd = "R/utils.R", plan.Rd = "R/zzz.plan.R", 
#>             private_length.Rd = "R/utils.R", `re-exports.Rd` = "R/000.re-exports.R", 
#>             readImmediateConditions.Rd = "R/utils-immediateCondition.R", 
#>             remote.Rd = "R/remote.R", requestCore.Rd = "R/multicore.R", 
#>             resetWorkers.Rd = "R/zzz.plan.R", resolve.Rd = "R/resolve.R", 
#>             resolved.Rd = "R/resolved.R", result.Rd = "R/Future-class.R", 
#>             run.Rd = "R/Future-class.R", save_rds.Rd = "R/utils-immediateCondition.R", 
#>             sequential.Rd = "R/sequential.R", sessionDetails.Rd = "R/sessionDetails.R", 
#>             signalConditions.Rd = "R/signalConditions.R", sticky_globals.Rd = "R/sticky_globals.R", 
#>             tweak.Rd = "R/tweak.R", usedCores.Rd = "R/multicore.R", 
#>             value.Rd = "R/value.R"), keywords = list("internal", 
#>             "internal", "internal", "internal", "internal", "internal", 
#>             "internal", "internal", "internal", "internal", character(0), 
#>             character(0), "internals", "internal", character(0), 
#>             "internal", character(0), character(0), character(0), 
#>             "internal", "internal", character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), "internal", "internal", 
#>             character(0), "internal", character(0), character(0), 
#>             "internal", "internal", character(0), "internal", 
#>             character(0), "internal", character(0), "internal", 
#>             "internal", character(0), character(0), "internal", 
#>             "internal", "internal", character(0), "internal", 
#>             character(0), "internal", character(0), "internal", 
#>             character(0)), concepts = list(character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0), character(0), character(0), 
#>             character(0), character(0)), internal = c(TRUE, TRUE, 
#>         TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, 
#>         FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, 
#>         TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, 
#>         FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, 
#>         TRUE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, 
#>         FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, TRUE, 
#>         FALSE, TRUE, FALSE)), tutorials = list(name = character(0), 
#>         file_out = character(0), title = character(0), pagetitle = character(0), 
#>         url = character(0)), vignettes = list(name = c("future-1-overview", 
#>     "future-2-output", "future-3-topologies", "future-4-issues", 
#>     "future-4-non-exportable-objects", "future-5-startup", "future-6-future-api-backend-specification", 
#>     "future-7-for-package-developers", "future-8-how-future-is-validated"
#>     ), file_in = c("vignettes/future-1-overview.Rmd", "vignettes/future-2-output.Rmd", 
#>     "vignettes/future-3-topologies.Rmd", "vignettes/future-4-issues.Rmd", 
#>     "vignettes/future-4-non-exportable-objects.Rmd", "vignettes/future-5-startup.Rmd", 
#>     "vignettes/future-6-future-api-backend-specification.Rmd", 
#>     "vignettes/future-7-for-package-developers.Rmd", "vignettes/future-8-how-future-is-validated.Rmd"
#>     ), file_out = c("articles/future-1-overview.html", "articles/future-2-output.html", 
#>     "articles/future-3-topologies.html", "articles/future-4-issues.html", 
#>     "articles/future-4-non-exportable-objects.html", "articles/future-5-startup.html", 
#>     "articles/future-6-future-api-backend-specification.html", 
#>     "articles/future-7-for-package-developers.html", "articles/future-8-how-future-is-validated.html"
#>     ), title = c("A Future for R: A Comprehensive Overview", 
#>     "A Future for R: Text and Message Output", "A Future for R: Future Topologies", 
#>     "A Future for R: Common Issues with Solutions", "A Future for R: Non-Exportable Objects", 
#>     "A Future for R: Controlling Default Future Strategy", "A Future for R: Future API Backend Specification", 
#>     "A Future for R: Best Practices for Package Developers", 
#>     "A Future for R: How the Future Framework is Validated"), 
#>         description = c(NA_character_, NA_character_, NA_character_, 
#>         NA_character_, NA_character_, NA_character_, NA_character_, 
#>         NA_character_, NA_character_)))), examples = base::quote(TRUE), 
#>     run_dont_run = base::quote(FALSE), seed = base::quote(1014), 
#>     lazy = base::quote(FALSE), override = base::quote(list()), 
#>     install = base::quote(FALSE), preview = base::quote(FALSE), 
#>     new_process = base::quote(FALSE), devel = base::quote(FALSE), 
#>     crayon_enabled = base::quote(TRUE), crayon_colors = base::quote(16777216L), 
#>     pkgdown_internet = base::quote(TRUE))
#> 
#> [[13]]
#> pkgdown::build_site(...)
#> 
#> [[14]]
#> build_site_local(pkg = pkg, examples = examples, run_dont_run = run_dont_run, 
#>     seed = seed, lazy = lazy, override = override, preview = preview, 
#>     devel = devel)
#> 
#> [[15]]
#> build_reference(pkg, lazy = lazy, examples = examples, run_dont_run = run_dont_run, 
#>     seed = seed, override = override, preview = FALSE, devel = devel)
#> 
#> [[16]]
#> purrr::map(topics, build_reference_topic, pkg = pkg, lazy = lazy, 
#>     examples = examples, run_dont_run = run_dont_run)
#> 
#> [[17]]
#> .f(.x[[i]], ...)
#> 
#> [[18]]
#> withCallingHandlers(data_reference_topic(topic, pkg, examples = examples, 
#>     run_dont_run = run_dont_run), error = function(err) {
#>     msg <- c(paste0("Failed to parse Rd in ", topic$file_in), 
#>         i = err$message)
#>     abort(msg, parent = err)
#> })
#> 
#> [[19]]
#> data_reference_topic(topic, pkg, examples = examples, run_dont_run = run_dont_run)
#> 
#> [[20]]
#> run_examples(tags$tag_examples[[1]], env = new.env(parent = globalenv()), 
#>     topic = tools::file_path_sans_ext(topic$file_in), run_examples = examples, 
#>     run_dont_run = run_dont_run)
#> 
#> [[21]]
#> highlight_examples(code, topic, env = env)
#> 
#> [[22]]
#> downlit::evaluate_and_highlight(code, fig_save = fig_save_topic, 
#>     env = child_env(env))
#> 
#> [[23]]
#> evaluate::evaluate(code, child_env(env), new_device = TRUE, output_handler = output_handler)
#> 
#> [[24]]
#> evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos, 
#>     debug = debug, last = i == length(out), use_try = stop_on_error != 
#>         2L, keep_warning = keep_warning, keep_message = keep_message, 
#>     output_handler = output_handler, include_timing = include_timing)
#> 
#> [[25]]
#> timing_fn(handle(ev <- withCallingHandlers(withVisible(eval(expr, 
#>     envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)))
#> 
#> [[26]]
#> handle(ev <- withCallingHandlers(withVisible(eval(expr, envir, 
#>     enclos)), warning = wHandler, error = eHandler, message = mHandler))
#> 
#> [[27]]
#> try(f, silent = TRUE)
#> 
#> [[28]]
#> tryCatch(expr, error = function(e) {
#>     call <- conditionCall(e)
#>     if (!is.null(call)) {
#>         if (identical(call[[1L]], quote(doTryCatch))) 
#>             call <- sys.call(-4L)
#>         dcall <- deparse(call, nlines = 1L)
#>         prefix <- paste("Error in", dcall, ": ")
#>         LONG <- 75L
#>         sm <- strsplit(conditionMessage(e), "\n")[[1L]]
#>         w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
#>         if (is.na(w)) 
#>             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 
#>                 type = "b")
#>         if (w > LONG) 
#>             prefix <- paste0(prefix, "\n  ")
#>     }
#>     else prefix <- "Error : "
#>     msg <- paste0(prefix, conditionMessage(e), "\n")
#>     .Internal(seterrmessage(msg[1L]))
#>     if (!silent && isTRUE(getOption("show.error.messages"))) {
#>         cat(msg, file = outFile)
#>         .Internal(printDeferredWarnings())
#>     }
#>     invisible(structure(msg, class = "try-error", condition = e))
#> })
#> 
#> [[29]]
#> tryCatchList(expr, classes, parentenv, handlers)
#> 
#> [[30]]
#> tryCatchOne(expr, names, parentenv, handlers[[1L]])
#> 
#> [[31]]
#> doTryCatch(return(expr), name, parentenv, handler)
#> 
#> [[32]]
#> withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler, 
#>     error = eHandler, message = mHandler)
#> 
#> [[33]]
#> withVisible(eval(expr, envir, enclos))
#> 
#> [[34]]
#> eval(expr, envir, enclos)
#> 
#> [[35]]
#> eval(expr, envir, enclos)
#> 
#> [[36]]
#> future({
#>     foo("a")
#> })
#> 
#> [[37]]
#> Future(expr, substitute = FALSE, envir = envir, lazy = TRUE, 
#>     seed = seed, globals = globals, packages = packages, stdout = stdout, 
#>     conditions = conditions, earlySignal = earlySignal, label = label, 
#>     gc = gc, ...)
#> 
#> [[38]]
#> eval(quote({
#>     foo("a")
#> }), new.env())
#> 
#> [[39]]
#> foo("a")
#> 
#> [[40]]
#> function(...) my_log(...)
#> 
#> [[41]]
#> log(x)
#> 
# \dontshow{
## R CMD check: make sure any open connections are closed afterward
if (!inherits(plan("next"), "sequential")) plan(sequential)
# }