CRAN Package Check Results for Maintainer ‘Henrik Bengtsson <henrikb at braju.com>’

Last updated on 2020-01-22 16:48:17 CET.

Package ERROR NOTE OK
ACNE 13
aroma.affymetrix 8 5
aroma.apd 1 12
aroma.cn 2 11
aroma.core 13
calmate 13
dChipIO 13
doFuture 1 12
future 3 10
future.apply 13
future.BatchJobs 13
future.batchtools 13
future.callr 13
globals 13
listenv 13
matrixStats 8 5
profmem 13
PSCBS 13
R.cache 13
R.devices 1 12
R.filesets 13
R.huge 13
R.matlab 13
R.methodsS3 13
R.oo 13
R.rsp 2 11
R.utils 13
startup 2 11

Package ACNE

Current CRAN status: OK: 13

Package aroma.affymetrix

Current CRAN status: NOTE: 8, OK: 5

Version: 3.2.0
Check: installed package size
Result: NOTE
     installed size is 5.8Mb
     sub-directories of 1Mb or more:
     R 2.3Mb
     help 1.1Mb
     testScripts 1.3Mb
Flavors: r-devel-linux-x86_64-fedora-clang, r-devel-windows-ix86+x86_64, r-devel-windows-ix86+x86_64-gcc8, r-patched-solaris-x86, r-release-windows-ix86+x86_64, r-release-osx-x86_64, r-oldrel-windows-ix86+x86_64, r-oldrel-osx-x86_64

Version: 3.2.0
Check: package dependencies
Result: NOTE
    Package suggested but not available for checking: ‘AffymetrixDataTestFiles’
Flavors: r-release-osx-x86_64, r-oldrel-osx-x86_64

Package aroma.apd

Current CRAN status: NOTE: 1, OK: 12

Version: 0.6.0
Check: package dependencies
Result: NOTE
    Package suggested but not available for checking: ‘affxparser’
Flavor: r-release-osx-x86_64

Version: 0.6.0
Check: Rd cross-references
Result: NOTE
    Package unavailable to check Rd xrefs: ‘affxparser’
Flavor: r-release-osx-x86_64

Package aroma.cn

Current CRAN status: NOTE: 2, OK: 11

Version: 1.6.1
Check: package dependencies
Result: NOTE
    Package suggested but not available for checking: ‘GLAD’
Flavors: r-release-osx-x86_64, r-oldrel-osx-x86_64

Package aroma.core

Current CRAN status: NOTE: 13

Version: 3.2.0
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     'sfit', 'expectile', 'HaarSeg', 'mpcbs'
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-ix86+x86_64, r-devel-windows-ix86+x86_64-gcc8, r-patched-linux-x86_64, r-patched-solaris-x86, r-release-linux-x86_64, r-release-windows-ix86+x86_64

Version: 3.2.0
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     'GLAD', 'sfit', 'expectile', 'HaarSeg', 'mpcbs'
Flavor: r-release-osx-x86_64

Version: 3.2.0
Check: Rd cross-references
Result: NOTE
    Package unavailable to check Rd xrefs: ‘GLAD’
Flavors: r-release-osx-x86_64, r-oldrel-osx-x86_64

Version: 3.2.0
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     'sfit' 'expectile' 'HaarSeg' 'mpcbs'
Flavor: r-oldrel-windows-ix86+x86_64

Version: 3.2.0
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     ‘GLAD’ ‘sfit’ ‘expectile’ ‘HaarSeg’ ‘mpcbs’
Flavor: r-oldrel-osx-x86_64

Package calmate

Current CRAN status: OK: 13

Package dChipIO

Current CRAN status: OK: 13

Package doFuture

Current CRAN status: NOTE: 1, OK: 12

Version: 0.9.0
Check: package dependencies
Result: NOTE
    Suggests orphaned package: ‘doRNG’
Flavor: r-devel-linux-x86_64-fedora-clang

Package future

Current CRAN status: ERROR: 3, OK: 10

Version: 1.16.0
Check: tests
Result: ERROR
     Running '000.sessionDetails.R' [7s/8s]
     Running 'ClusterRegistry.R' [3s/55s]
     Running 'Future-class.R' [2s/20s]
     Running 'FutureError.R' [1s/1s]
     Running 'FutureGlobals.R' [1s/1s]
     Running 'FutureRegistry.R' [1s/1s]
     Running 'as.cluster.R' [1s/19s]
     Running 'availableCores.R' [1s/1s]
     Running 'availableWorkers.R' [1s/1s]
     Running 'backtrace.R' [1s/3s]
     Running 'cluster-missing-future-pkg.R' [1s/2s]
     Running 'cluster.R' [7s/121s]
     Running 'constant.R' [1s/1s]
     Running 'demo.R' [9s/28s]
     Running 'dotdotdot.R' [2s/19s]
     Running 'early-signaling.R' [2s/41s]
     Running 'future,labels.R' [1s/1s]
     Running 'future.R' [1s/1s]
     Running 'futureAssign.R' [2s/20s]
     Running 'futureAssign_OP.R' [3s/23s]
     Running 'futureAssign_OP_with_environment.R' [1s/1s]
     Running 'futureAssign_OP_with_listenv.R' [1s/1s]
     Running 'futureCall.R' [4s/30s]
     Running 'futureOf.R' [1s/1s]
     Running 'futureOf_with_environment.R' [1s/1s]
     Running 'futureOf_with_listenv.R' [1s/1s]
     Running 'futures.R' [19s/148s]
     Running 'globals,NSE.R' [1s/1s]
     Running 'globals,formulas.R' [4s/22s]
     Running 'globals,manual.R' [2s/2s]
     Running 'globals,resolve.R' [2s/18s]
     Running 'globals,subassignment.R' [3s/22s]
     Running 'globals,toolarge.R' [1s/18s]
     Running 'globals,tricky.R' [7s/27s]
     Running 'globals,tricky_recursive.R' [1s/1s]
     Running 'globalsOf,tweaks.R' [1s/1s]
     Running 'immediateCondition.R' [1s/2s]
     Running 'invalid-owner.R' [2s/19s]
     Running 'makeClusterPSOCK.R' [1s/9s]
     Running 'mandelbrot.R' [1s/1s]
     Running 'mpi.R' [1s/1s]
     Running 'multicore,multithreading.R' [1s/1s]
     Running 'multicore.R' [1s/1s]
     Running 'multiprocess.R' [2s/2s]
     Running 'multisession.R' [4s/55s]
     Running 'nbrOfWorkers.R' [5s/73s]
     Running 'nested_futures,mc.cores.R' [6s/122s]
     Running 'nested_futures.R' [1s/1s]
     Running 'non-exportable,connections.R' [1s/17s]
     Running 'objectSize.R' [1s/1s]
     Running 'plan.R' [6s/16s]
     Running 'relaying.R' [1s/2s]
     Running 'remote.R' [2s/19s]
     Running 'requestCore.R' [1s/3s]
     Running 'requestNode.R' [2s/32s]
     Running 'reserved-keyword-functions.R' [1s/1s]
     Running 'resolve.R' [2s/4s]
     Running 'resolved-non-blocking-test.R' [3s/73s]
     Running 'rng.R' [12s/33s]
     Running 'sequential.R' [1s/1s]
     Running 'sessionDetails.R' [1s/1s]
     Running 'startup.R' [2s/36s]
     Running 'stdout.R' [2s/21s]
     Running 'transparent.R' [1s/1s]
     Running 'tweak.R' [1s/1s]
     Running 'utils.R' [8s/9s]
     Running 'uuid.R' [1s/2s]
     Running 'whichIndex.R' [1s/1s]
    Running the tests in 'tests/multicore,multithreading.R' failed.
    Complete output:
     > source("incl/start.R")
     [23:21:35.325] plan(): Setting new future strategy stack:
     [23:21:35.327] List of future strategies:
     [23:21:35.327] 1. sequential:
     [23:21:35.327] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [23:21:35.327] - tweaked: FALSE
     [23:21:35.327] - call: future::plan("sequential")
     [23:21:35.329] plan(): nbrOfWorkers() = 1
     > library("listenv")
     > plan(multicore)
     [23:21:35.397] plan(): Setting new future strategy stack:
     [23:21:35.397] List of future strategies:
     [23:21:35.397] 1. multicore:
     [23:21:35.397] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [23:21:35.397] - tweaked: FALSE
     [23:21:35.397] - call: plan(multicore)
     [23:21:35.471] plan(): nbrOfWorkers() = 2
     >
     > message("*** multicore() and multi-threading ...")
     *** multicore() and multi-threading ...
     >
     > message("supportsMulticore(): ", sQuote(supportsMulticore()))
     supportsMulticore(): 'TRUE'
     > message("availableCores('multicore'): ", sQuote(availableCores("multicore")))
     availableCores('multicore'): '2'
     > message("supports_omp_threads(): ", sQuote(supports_omp_threads()))
     [23:21:35.678] supports_omp_threads() = TRUE
     supports_omp_threads(): 'TRUE'
     >
     > if (supportsMulticore() && availableCores("multicore") >=2 && supports_omp_threads()) {
     + for (enable in c(TRUE, FALSE)) {
     + options(future.fork.multithreading.enable = enable)
     +
     + message(sprintf("'future.fork.multithreading.enable' = %s ...", enable))
     +
     + f <- future(RhpcBLASctl::omp_get_max_threads())
     + nthreads <- value(f)
     + cat(sprintf("Number of OpenMP threads in %s future: %d\n", sQuote(class(f)[1]), nthreads))
     +
     + ## Assert that single-threading was set?
     + if (enable) {
     + stopifnot(enable && nthreads > 1L)
     + } else {
     + stopifnot(!enable && nthreads == 1L)
     + }
     +
     + message(sprintf("'future.fork.multithreading.enable' = %s ... DONE", enable))
     + } ## for (enable ...)
     + } ## if (requireNamespace("RhpcBLASctl", ...)) {
     [23:21:35.681] supports_omp_threads() = TRUE
     'future.fork.multithreading.enable' = TRUE ...
     [23:21:35.756] getGlobalsAndPackages() ...
     [23:21:35.756] Searching for globals...
     [23:21:35.783] - globals found: [1] '::'
     [23:21:35.784] Searching for globals ... DONE
     [23:21:35.784] Resolving globals: FALSE
     [23:21:35.786]
     [23:21:35.786]
     [23:21:35.786] getGlobalsAndPackages() ... DONE
     [23:21:35.792] Packages needed by the future expression (n = 0): <none>
     [23:21:35.792] Packages needed by future strategies (n = 0): <none>
     [23:21:35.816] {
     [23:21:35.816] {
     [23:21:35.816] ...future.startTime <- base::Sys.time()
     [23:21:35.816] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [23:21:35.816] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [23:21:35.816] future.globals.method = NULL, future.globals.onMissing = NULL,
     [23:21:35.816] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [23:21:35.816] future.resolve.recursive = NULL, width = 80L)
     [23:21:35.816] {
     [23:21:35.816] {
     [23:21:35.816] {
     [23:21:35.816] has_future <- base::requireNamespace("future",
     [23:21:35.816] quietly = TRUE)
     [23:21:35.816] version <- if (has_future)
     [23:21:35.816] utils::packageVersion("future")
     [23:21:35.816] else NULL
     [23:21:35.816] if (!has_future || version < "1.8.0") {
     [23:21:35.816] info <- base::c(r_version = base::gsub("R version ",
     [23:21:35.816] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [23:21:35.816] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [23:21:35.816] os = base::paste(base::Sys.info()[base::c("sysname",
     [23:21:35.816] "release", "version")], collapse = " "),
     [23:21:35.816] hostname = base::Sys.info()[["nodename"]])
     [23:21:35.816] info <- base::sprintf("%s: %s", base::names(info),
     [23:21:35.816] info)
     [23:21:35.816] info <- base::paste(info, collapse = "; ")
     [23:21:35.816] if (!has_future) {
     [23:21:35.816] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [23:21:35.816] info)
     [23:21:35.816] }
     [23:21:35.816] else {
     [23:21:35.816] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [23:21:35.816] info, version)
     [23:21:35.816] }
     [23:21:35.816] base::stop(msg)
     [23:21:35.816] }
     [23:21:35.816] }
     [23:21:35.816] ...future.mc.cores.old <- base::getOption("mc.cores")
     [23:21:35.816] base::options(mc.cores = 1L)
     [23:21:35.816] }
     [23:21:35.816] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [23:21:35.816] }
     [23:21:35.816] }
     [23:21:35.816] if (base::is.na(TRUE)) {
     [23:21:35.816] }
     [23:21:35.816] else {
     [23:21:35.816] if (TRUE) {
     [23:21:35.816] ...future.stdout <- base::rawConnection(base::raw(0L),
     [23:21:35.816] open = "w")
     [23:21:35.816] }
     [23:21:35.816] else {
     [23:21:35.816] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [23:21:35.816] windows = "NUL", "/dev/null"), open = "w")
     [23:21:35.816] }
     [23:21:35.816] base::sink(...future.stdout, type = "output", split = FALSE)
     [23:21:35.816] base::on.exit(if (!base::is.null(...future.stdout)) {
     [23:21:35.816] base::sink(type = "output", split = FALSE)
     [23:21:35.816] base::close(...future.stdout)
     [23:21:35.816] }, add = TRUE)
     [23:21:35.816] }
     [23:21:35.816] ...future.frame <- base::sys.nframe()
     [23:21:35.816] ...future.conditions <- base::list()
     [23:21:35.816] ...future.rng <- base::globalenv()$.Random.seed
     [23:21:35.816] ...future.result <- base::tryCatch({
     [23:21:35.816] base::withCallingHandlers({
     [23:21:35.816] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [23:21:35.816] future::FutureResult(value = ...future.value$value,
     [23:21:35.816] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [23:21:35.816] ...future.rng), started = ...future.startTime,
     [23:21:35.816] version = "1.8")
     [23:21:35.816] }, condition = base::local({
     [23:21:35.816] c <- base::c
     [23:21:35.816] inherits <- base::inherits
     [23:21:35.816] invokeRestart <- base::invokeRestart
     [23:21:35.816] length <- base::length
     [23:21:35.816] list <- base::list
     [23:21:35.816] seq.int <- base::seq.int
     [23:21:35.816] signalCondition <- base::signalCondition
     [23:21:35.816] sys.calls <- base::sys.calls
     [23:21:35.816] Sys.time <- base::Sys.time
     [23:21:35.816] `[[` <- base::`[[`
     [23:21:35.816] `+` <- base::`+`
     [23:21:35.816] `<<-` <- base::`<<-`
     [23:21:35.816] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [23:21:35.816] calls[seq.int(from = from + 12L, to = length(calls) -
     [23:21:35.816] 3L)]
     [23:21:35.816] }
     [23:21:35.816] function(cond) {
     [23:21:35.816] if (inherits(cond, "error")) {
     [23:21:35.816] ...future.conditions[[length(...future.conditions) +
     [23:21:35.816] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [23:21:35.816] cond$call), timestamp = Sys.time(), signaled = 0L)
     [23:21:35.816] signalCondition(cond)
     [23:21:35.816] }
     [23:21:35.816] else if (inherits(cond, "condition")) {
     [23:21:35.816] signal <- FALSE && inherits(cond, character(0))
     [23:21:35.816] ...future.conditions[[length(...future.conditions) +
     [23:21:35.816] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [23:21:35.816] if (!signal) {
     [23:21:35.816] muffleCondition <- function (cond)
     [23:21:35.816] {
     [23:21:35.816] inherits <- base::inherits
     [23:21:35.816] invokeRestart <- base::invokeRestart
     [23:21:35.816] muffled <- FALSE
     [23:21:35.816] if (inherits(cond, "message")) {
     [23:21:35.816] invokeRestart("muffleMessage")
     [23:21:35.816] muffled <- TRUE
     [23:21:35.816] }
     [23:21:35.816] else if (inherits(cond, "warning")) {
     [23:21:35.816] invokeRestart("muffleWarning")
     [23:21:35.816] muffled <- TRUE
     [23:21:35.816] }
     [23:21:35.816] else if (inherits(cond, "condition")) {
     [23:21:35.816] computeRestarts <- base::computeRestarts
     [23:21:35.816] grepl <- base::grepl
     [23:21:35.816] is.null <- base::is.null
     [23:21:35.816] restarts <- computeRestarts(cond)
     [23:21:35.816] for (restart in restarts) {
     [23:21:35.816] name <- restart$name
     [23:21:35.816] if (is.null(name))
     [23:21:35.816] next
     [23:21:35.816] if (!grepl("^muffle", name))
     [23:21:35.816] next
     [23:21:35.816] invokeRestart(restart)
     [23:21:35.816] muffled <- TRUE
     [23:21:35.816] break
     [23:21:35.816] }
     [23:21:35.816] }
     [23:21:35.816] invisible(muffled)
     [23:21:35.816] }
     [23:21:35.816] muffleCondition(cond)
     [23:21:35.816] }
     [23:21:35.816] }
     [23:21:35.816] }
     [23:21:35.816] }))
     [23:21:35.816] }, error = function(ex) {
     [23:21:35.816] base::structure(base::list(value = NULL, visible = NULL,
     [23:21:35.816] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [23:21:35.816] ...future.rng), version = "1.8"), class = "FutureResult")
     [23:21:35.816] }, finally = {
     [23:21:35.816] {
     [23:21:35.816] {
     [23:21:35.816] base::options(mc.cores = ...future.mc.cores.old)
     [23:21:35.816] }
     [23:21:35.816] future::plan(list(function (expr, envir = parent.frame(),
     [23:21:35.816] substitute = TRUE, lazy = FALSE, seed = NULL,
     [23:21:35.816] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [23:21:35.816] earlySignal = FALSE, label = NULL, ...)
     [23:21:35.816] {
     [23:21:35.816] if (substitute)
     [23:21:35.816] expr <- substitute(expr)
     [23:21:35.816] if (is.function(workers))
     [23:21:35.816] workers <- workers()
     [23:21:35.816] workers <- as.integer(workers)
     [23:21:35.816] stop_if_not(is.finite(workers), workers >= 1L)
     [23:21:35.816] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [23:21:35.816] return(sequential(expr, envir = envir, substitute = FALSE,
     [23:21:35.816] lazy = lazy, seed = seed, globals = globals,
     [23:21:35.816] local = TRUE, label = label, ...))
     [23:21:35.816] }
     [23:21:35.816] oopts <- options(mc.cores = workers)
     [23:21:35.816] on.exit(options(oopts))
     [23:21:35.816] future <- MulticoreFuture(expr = expr, envir = envir,
     [23:21:35.816] substitute = FALSE, lazy = lazy, seed = seed,
     [23:21:35.816] globals = globals, workers = workers, earlySignal = earlySignal,
     [23:21:35.816] label = label, ...)
     [23:21:35.816] if (!future$lazy)
     [23:21:35.816] future <- run(future)
     [23:21:35.816] invisible(future)
     [23:21:35.816] }), .cleanup = FALSE, .init = FALSE)
     [23:21:35.816] }
     [23:21:35.816] base::options(...future.oldOptions)
     [23:21:35.816] })
     [23:21:35.816] Sys.time
     [23:21:35.816] if (base::is.na(TRUE)) {
     [23:21:35.816] }
     [23:21:35.816] else {
     [23:21:35.816] base::sink(type = "output", split = FALSE)
     [23:21:35.816] if (TRUE) {
     [23:21:35.816] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [23:21:35.816] }
     [23:21:35.816] else {
     [23:21:35.816] ...future.result["stdout"] <- base::list(NULL)
     [23:21:35.816] }
     [23:21:35.816] base::close(...future.stdout)
     [23:21:35.816] ...future.stdout <- NULL
     [23:21:35.816] }
     [23:21:35.816] ...future.result$conditions <- ...future.conditions
     [23:21:35.816] ...future.result
     [23:21:35.816] }
     [23:21:35.820] requestCore(): workers = 2
     [23:21:35.825] MulticoreFuture started
     [23:21:35.847] plan(): Setting new future strategy stack:
     [23:21:35.848] List of future strategies:
     [23:21:35.848] 1. sequential:
     [23:21:35.848] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [23:21:35.848] - tweaked: FALSE
     [23:21:35.848] - call: NULL
     [23:21:35.849] plan(): nbrOfWorkers() = 1
     [23:21:35.852] plan(): Setting new future strategy stack:
     [23:21:35.853] List of future strategies:
     [23:21:35.853] 1. multicore:
     [23:21:35.853] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [23:21:35.853] - tweaked: FALSE
     [23:21:35.853] - call: plan(multicore)
     [23:21:35.855] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 3
     'future.fork.multithreading.enable' = TRUE ... DONE
     'future.fork.multithreading.enable' = FALSE ...
     [23:21:35.869] getGlobalsAndPackages() ...
     [23:21:35.870] Searching for globals...
     [23:21:35.885] - globals found: [1] '::'
     [23:21:35.886] Searching for globals ... DONE
     [23:21:35.886] Resolving globals: FALSE
     [23:21:35.887]
     [23:21:35.887]
     [23:21:35.888] getGlobalsAndPackages() ... DONE
     [23:21:35.889] - Evaluate future in single-threaded mode ...
     [23:21:35.889] supports_omp_threads() = TRUE
     [23:21:35.889] - Force single-threaded processing for OpenMP
     [23:21:35.890] - Evaluate future in single-threaded mode ... DONE
     [23:21:35.893] Packages needed by the future expression (n = 0): <none>
     [23:21:35.893] Packages needed by future strategies (n = 0): <none>
     [23:21:35.916] {
     [23:21:35.916] {
     [23:21:35.916] ...future.startTime <- base::Sys.time()
     [23:21:35.916] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [23:21:35.916] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [23:21:35.916] future.globals.method = NULL, future.globals.onMissing = NULL,
     [23:21:35.916] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [23:21:35.916] future.resolve.recursive = NULL, width = 80L)
     [23:21:35.916] {
     [23:21:35.916] {
     [23:21:35.916] {
     [23:21:35.916] has_future <- base::requireNamespace("future",
     [23:21:35.916] quietly = TRUE)
     [23:21:35.916] version <- if (has_future)
     [23:21:35.916] utils::packageVersion("future")
     [23:21:35.916] else NULL
     [23:21:35.916] if (!has_future || version < "1.8.0") {
     [23:21:35.916] info <- base::c(r_version = base::gsub("R version ",
     [23:21:35.916] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [23:21:35.916] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [23:21:35.916] os = base::paste(base::Sys.info()[base::c("sysname",
     [23:21:35.916] "release", "version")], collapse = " "),
     [23:21:35.916] hostname = base::Sys.info()[["nodename"]])
     [23:21:35.916] info <- base::sprintf("%s: %s", base::names(info),
     [23:21:35.916] info)
     [23:21:35.916] info <- base::paste(info, collapse = "; ")
     [23:21:35.916] if (!has_future) {
     [23:21:35.916] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [23:21:35.916] info)
     [23:21:35.916] }
     [23:21:35.916] else {
     [23:21:35.916] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [23:21:35.916] info, version)
     [23:21:35.916] }
     [23:21:35.916] base::stop(msg)
     [23:21:35.916] }
     [23:21:35.916] }
     [23:21:35.916] ...future.mc.cores.old <- base::getOption("mc.cores")
     [23:21:35.916] base::options(mc.cores = 1L)
     [23:21:35.916] }
     [23:21:35.916] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [23:21:35.916] }
     [23:21:35.916] }
     [23:21:35.916] if (base::is.na(TRUE)) {
     [23:21:35.916] }
     [23:21:35.916] else {
     [23:21:35.916] if (TRUE) {
     [23:21:35.916] ...future.stdout <- base::rawConnection(base::raw(0L),
     [23:21:35.916] open = "w")
     [23:21:35.916] }
     [23:21:35.916] else {
     [23:21:35.916] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [23:21:35.916] windows = "NUL", "/dev/null"), open = "w")
     [23:21:35.916] }
     [23:21:35.916] base::sink(...future.stdout, type = "output", split = FALSE)
     [23:21:35.916] base::on.exit(if (!base::is.null(...future.stdout)) {
     [23:21:35.916] base::sink(type = "output", split = FALSE)
     [23:21:35.916] base::close(...future.stdout)
     [23:21:35.916] }, add = TRUE)
     [23:21:35.916] }
     [23:21:35.916] ...future.frame <- base::sys.nframe()
     [23:21:35.916] ...future.conditions <- base::list()
     [23:21:35.916] ...future.rng <- base::globalenv()$.Random.seed
     [23:21:35.916] ...future.result <- base::tryCatch({
     [23:21:35.916] base::withCallingHandlers({
     [23:21:35.916] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [23:21:35.916] future::FutureResult(value = ...future.value$value,
     [23:21:35.916] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [23:21:35.916] ...future.rng), started = ...future.startTime,
     [23:21:35.916] version = "1.8")
     [23:21:35.916] }, condition = base::local({
     [23:21:35.916] c <- base::c
     [23:21:35.916] inherits <- base::inherits
     [23:21:35.916] invokeRestart <- base::invokeRestart
     [23:21:35.916] length <- base::length
     [23:21:35.916] list <- base::list
     [23:21:35.916] seq.int <- base::seq.int
     [23:21:35.916] signalCondition <- base::signalCondition
     [23:21:35.916] sys.calls <- base::sys.calls
     [23:21:35.916] Sys.time <- base::Sys.time
     [23:21:35.916] `[[` <- base::`[[`
     [23:21:35.916] `+` <- base::`+`
     [23:21:35.916] `<<-` <- base::`<<-`
     [23:21:35.916] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [23:21:35.916] calls[seq.int(from = from + 12L, to = length(calls) -
     [23:21:35.916] 3L)]
     [23:21:35.916] }
     [23:21:35.916] function(cond) {
     [23:21:35.916] if (inherits(cond, "error")) {
     [23:21:35.916] ...future.conditions[[length(...future.conditions) +
     [23:21:35.916] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [23:21:35.916] cond$call), timestamp = Sys.time(), signaled = 0L)
     [23:21:35.916] signalCondition(cond)
     [23:21:35.916] }
     [23:21:35.916] else if (inherits(cond, "condition")) {
     [23:21:35.916] signal <- FALSE && inherits(cond, character(0))
     [23:21:35.916] ...future.conditions[[length(...future.conditions) +
     [23:21:35.916] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [23:21:35.916] if (!signal) {
     [23:21:35.916] muffleCondition <- function (cond)
     [23:21:35.916] {
     [23:21:35.916] inherits <- base::inherits
     [23:21:35.916] invokeRestart <- base::invokeRestart
     [23:21:35.916] muffled <- FALSE
     [23:21:35.916] if (inherits(cond, "message")) {
     [23:21:35.916] invokeRestart("muffleMessage")
     [23:21:35.916] muffled <- TRUE
     [23:21:35.916] }
     [23:21:35.916] else if (inherits(cond, "warning")) {
     [23:21:35.916] invokeRestart("muffleWarning")
     [23:21:35.916] muffled <- TRUE
     [23:21:35.916] }
     [23:21:35.916] else if (inherits(cond, "condition")) {
     [23:21:35.916] computeRestarts <- base::computeRestarts
     [23:21:35.916] grepl <- base::grepl
     [23:21:35.916] is.null <- base::is.null
     [23:21:35.916] restarts <- computeRestarts(cond)
     [23:21:35.916] for (restart in restarts) {
     [23:21:35.916] name <- restart$name
     [23:21:35.916] if (is.null(name))
     [23:21:35.916] next
     [23:21:35.916] if (!grepl("^muffle", name))
     [23:21:35.916] next
     [23:21:35.916] invokeRestart(restart)
     [23:21:35.916] muffled <- TRUE
     [23:21:35.916] break
     [23:21:35.916] }
     [23:21:35.916] }
     [23:21:35.916] invisible(muffled)
     [23:21:35.916] }
     [23:21:35.916] muffleCondition(cond)
     [23:21:35.916] }
     [23:21:35.916] }
     [23:21:35.916] }
     [23:21:35.916] }))
     [23:21:35.916] }, error = function(ex) {
     [23:21:35.916] base::structure(base::list(value = NULL, visible = NULL,
     [23:21:35.916] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [23:21:35.916] ...future.rng), version = "1.8"), class = "FutureResult")
     [23:21:35.916] }, finally = {
     [23:21:35.916] {
     [23:21:35.916] {
     [23:21:35.916] base::options(mc.cores = ...future.mc.cores.old)
     [23:21:35.916] }
     [23:21:35.916] future::plan(list(function (expr, envir = parent.frame(),
     [23:21:35.916] substitute = TRUE, lazy = FALSE, seed = NULL,
     [23:21:35.916] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [23:21:35.916] earlySignal = FALSE, label = NULL, ...)
     [23:21:35.916] {
     [23:21:35.916] if (substitute)
     [23:21:35.916] expr <- substitute(expr)
     [23:21:35.916] if (is.function(workers))
     [23:21:35.916] workers <- workers()
     [23:21:35.916] workers <- as.integer(workers)
     [23:21:35.916] stop_if_not(is.finite(workers), workers >= 1L)
     [23:21:35.916] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [23:21:35.916] return(sequential(expr, envir = envir, substitute = FALSE,
     [23:21:35.916] lazy = lazy, seed = seed, globals = globals,
     [23:21:35.916] local = TRUE, label = label, ...))
     [23:21:35.916] }
     [23:21:35.916] oopts <- options(mc.cores = workers)
     [23:21:35.916] on.exit(options(oopts))
     [23:21:35.916] future <- MulticoreFuture(expr = expr, envir = envir,
     [23:21:35.916] substitute = FALSE, lazy = lazy, seed = seed,
     [23:21:35.916] globals = globals, workers = workers, earlySignal = earlySignal,
     [23:21:35.916] label = label, ...)
     [23:21:35.916] if (!future$lazy)
     [23:21:35.916] future <- run(future)
     [23:21:35.916] invisible(future)
     [23:21:35.916] }), .cleanup = FALSE, .init = FALSE)
     [23:21:35.916] }
     [23:21:35.916] base::options(...future.oldOptions)
     [23:21:35.916] })
     [23:21:35.916] Sys.time
     [23:21:35.916] if (base::is.na(TRUE)) {
     [23:21:35.916] }
     [23:21:35.916] else {
     [23:21:35.916] base::sink(type = "output", split = FALSE)
     [23:21:35.916] if (TRUE) {
     [23:21:35.916] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [23:21:35.916] }
     [23:21:35.916] else {
     [23:21:35.916] ...future.result["stdout"] <- base::list(NULL)
     [23:21:35.916] }
     [23:21:35.916] base::close(...future.stdout)
     [23:21:35.916] ...future.stdout <- NULL
     [23:21:35.916] }
     [23:21:35.916] ...future.result$conditions <- ...future.conditions
     [23:21:35.916] ...future.result
     [23:21:35.916] }
     [23:21:35.920] requestCore(): workers = 2
     [23:21:35.924] MulticoreFuture started
     [23:21:35.939] plan(): Setting new future strategy stack:
     [23:21:35.940] List of future strategies:
     [23:21:35.940] 1. sequential:
     [23:21:35.940] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [23:21:35.940] - tweaked: FALSE
     [23:21:35.940] - call: NULL
     [23:21:35.942] plan(): nbrOfWorkers() = 1
     [23:21:35.977] plan(): Setting new future strategy stack:
     [23:21:35.977] List of future strategies:
     [23:21:35.977] 1. multicore:
     [23:21:35.977] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [23:21:35.977] - tweaked: FALSE
     [23:21:35.977] - call: plan(multicore)
     [23:21:35.992] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 3
     Error: !enable && nthreads == 1L is not TRUE
     Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 1.16.0
Check: tests
Result: ERROR
     Running ‘000.sessionDetails.R’ [9s/10s]
     Running ‘ClusterRegistry.R’ [4s/63s]
     Running ‘Future-class.R’ [2s/25s]
     Running ‘FutureError.R’
     Running ‘FutureGlobals.R’
     Running ‘FutureRegistry.R’
     Running ‘as.cluster.R’ [2s/22s]
     Running ‘availableCores.R’
     Running ‘availableWorkers.R’
     Running ‘backtrace.R’
     Running ‘cluster-missing-future-pkg.R’
     Running ‘cluster.R’ [9s/143s]
     Running ‘constant.R’
     Running ‘demo.R’ [12s/43s]
     Running ‘dotdotdot.R’ [2s/26s]
     Running ‘early-signaling.R’ [3s/48s]
     Running ‘future,labels.R’
     Running ‘future.R’
     Running ‘futureAssign.R’ [3s/23s]
     Running ‘futureAssign_OP.R’ [4s/27s]
     Running ‘futureAssign_OP_with_environment.R’
     Running ‘futureAssign_OP_with_listenv.R’
     Running ‘futureCall.R’ [5s/38s]
     Running ‘futureOf.R’
     Running ‘futureOf_with_environment.R’
     Running ‘futureOf_with_listenv.R’
     Running ‘futures.R’ [23s/189s]
     Running ‘globals,NSE.R’
     Running ‘globals,formulas.R’ [5s/26s]
     Running ‘globals,manual.R’
     Running ‘globals,resolve.R’ [2s/24s]
     Running ‘globals,subassignment.R’ [4s/26s]
     Running ‘globals,toolarge.R’ [2s/25s]
     Running ‘globals,tricky.R’ [9s/35s]
     Running ‘globals,tricky_recursive.R’
     Running ‘globalsOf,tweaks.R’
     Running ‘immediateCondition.R’
     Running ‘invalid-owner.R’ [2s/24s]
     Running ‘makeClusterPSOCK.R’ [1s/11s]
     Running ‘mandelbrot.R’
     Running ‘mpi.R’
     Running ‘multicore,multithreading.R’
     Running ‘multicore.R’
     Running ‘multiprocess.R’
     Running ‘multisession.R’ [6s/70s]
     Running ‘nbrOfWorkers.R’ [6s/85s]
     Running ‘nested_futures,mc.cores.R’ [7s/148s]
     Running ‘nested_futures.R’
     Running ‘non-exportable,connections.R’ [2s/22s]
     Running ‘objectSize.R’
     Running ‘plan.R’ [9s/22s]
     Running ‘relaying.R’
     Running ‘remote.R’ [2s/22s]
     Running ‘requestCore.R’
     Running ‘requestNode.R’ [2s/37s]
     Running ‘reserved-keyword-functions.R’
     Running ‘resolve.R’
     Running ‘resolved-non-blocking-test.R’ [4s/82s]
     Running ‘rng.R’ [14s/42s]
     Running ‘sequential.R’
     Running ‘sessionDetails.R’
     Running ‘startup.R’ [3s/46s]
     Running ‘stdout.R’ [3s/26s]
     Running ‘transparent.R’
     Running ‘tweak.R’
     Running ‘utils.R’ [9s/13s]
     Running ‘uuid.R’
     Running ‘whichIndex.R’
    Running the tests in ‘tests/multicore,multithreading.R’ failed.
    Complete output:
     > source("incl/start.R")
     [16:30:12.477] plan(): Setting new future strategy stack:
     [16:30:12.479] List of future strategies:
     [16:30:12.479] 1. sequential:
     [16:30:12.479] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [16:30:12.479] - tweaked: FALSE
     [16:30:12.479] - call: future::plan("sequential")
     [16:30:12.481] plan(): nbrOfWorkers() = 1
     > library("listenv")
     > plan(multicore)
     [16:30:12.529] plan(): Setting new future strategy stack:
     [16:30:12.530] List of future strategies:
     [16:30:12.530] 1. multicore:
     [16:30:12.530] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [16:30:12.530] - tweaked: FALSE
     [16:30:12.530] - call: plan(multicore)
     [16:30:12.628] plan(): nbrOfWorkers() = 2
     >
     > message("*** multicore() and multi-threading ...")
     *** multicore() and multi-threading ...
     >
     > message("supportsMulticore(): ", sQuote(supportsMulticore()))
     supportsMulticore(): 'TRUE'
     > message("availableCores('multicore'): ", sQuote(availableCores("multicore")))
     availableCores('multicore'): '2'
     > message("supports_omp_threads(): ", sQuote(supports_omp_threads()))
     [16:30:12.700] supports_omp_threads() = TRUE
     supports_omp_threads(): 'TRUE'
     >
     > if (supportsMulticore() && availableCores("multicore") >=2 && supports_omp_threads()) {
     + for (enable in c(TRUE, FALSE)) {
     + options(future.fork.multithreading.enable = enable)
     +
     + message(sprintf("'future.fork.multithreading.enable' = %s ...", enable))
     +
     + f <- future(RhpcBLASctl::omp_get_max_threads())
     + nthreads <- value(f)
     + cat(sprintf("Number of OpenMP threads in %s future: %d\n", sQuote(class(f)[1]), nthreads))
     +
     + ## Assert that single-threading was set?
     + if (enable) {
     + stopifnot(enable && nthreads > 1L)
     + } else {
     + stopifnot(!enable && nthreads == 1L)
     + }
     +
     + message(sprintf("'future.fork.multithreading.enable' = %s ... DONE", enable))
     + } ## for (enable ...)
     + } ## if (requireNamespace("RhpcBLASctl", ...)) {
     [16:30:12.704] supports_omp_threads() = TRUE
     'future.fork.multithreading.enable' = TRUE ...
     [16:30:12.764] getGlobalsAndPackages() ...
     [16:30:12.764] Searching for globals...
     [16:30:12.789] - globals found: [1] '::'
     [16:30:12.789] Searching for globals ... DONE
     [16:30:12.790] Resolving globals: FALSE
     [16:30:12.791]
     [16:30:12.792]
     [16:30:12.792] getGlobalsAndPackages() ... DONE
     [16:30:12.807] Packages needed by the future expression (n = 0): <none>
     [16:30:12.808] Packages needed by future strategies (n = 0): <none>
     [16:30:12.815] {
     [16:30:12.815] {
     [16:30:12.815] ...future.startTime <- base::Sys.time()
     [16:30:12.815] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [16:30:12.815] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [16:30:12.815] future.globals.method = NULL, future.globals.onMissing = NULL,
     [16:30:12.815] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [16:30:12.815] future.resolve.recursive = NULL, width = 80L)
     [16:30:12.815] {
     [16:30:12.815] {
     [16:30:12.815] {
     [16:30:12.815] has_future <- base::requireNamespace("future",
     [16:30:12.815] quietly = TRUE)
     [16:30:12.815] version <- if (has_future)
     [16:30:12.815] utils::packageVersion("future")
     [16:30:12.815] else NULL
     [16:30:12.815] if (!has_future || version < "1.8.0") {
     [16:30:12.815] info <- base::c(r_version = base::gsub("R version ",
     [16:30:12.815] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [16:30:12.815] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [16:30:12.815] os = base::paste(base::Sys.info()[base::c("sysname",
     [16:30:12.815] "release", "version")], collapse = " "),
     [16:30:12.815] hostname = base::Sys.info()[["nodename"]])
     [16:30:12.815] info <- base::sprintf("%s: %s", base::names(info),
     [16:30:12.815] info)
     [16:30:12.815] info <- base::paste(info, collapse = "; ")
     [16:30:12.815] if (!has_future) {
     [16:30:12.815] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [16:30:12.815] info)
     [16:30:12.815] }
     [16:30:12.815] else {
     [16:30:12.815] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [16:30:12.815] info, version)
     [16:30:12.815] }
     [16:30:12.815] base::stop(msg)
     [16:30:12.815] }
     [16:30:12.815] }
     [16:30:12.815] ...future.mc.cores.old <- base::getOption("mc.cores")
     [16:30:12.815] base::options(mc.cores = 1L)
     [16:30:12.815] }
     [16:30:12.815] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [16:30:12.815] }
     [16:30:12.815] }
     [16:30:12.815] if (base::is.na(TRUE)) {
     [16:30:12.815] }
     [16:30:12.815] else {
     [16:30:12.815] if (TRUE) {
     [16:30:12.815] ...future.stdout <- base::rawConnection(base::raw(0L),
     [16:30:12.815] open = "w")
     [16:30:12.815] }
     [16:30:12.815] else {
     [16:30:12.815] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [16:30:12.815] windows = "NUL", "/dev/null"), open = "w")
     [16:30:12.815] }
     [16:30:12.815] base::sink(...future.stdout, type = "output", split = FALSE)
     [16:30:12.815] base::on.exit(if (!base::is.null(...future.stdout)) {
     [16:30:12.815] base::sink(type = "output", split = FALSE)
     [16:30:12.815] base::close(...future.stdout)
     [16:30:12.815] }, add = TRUE)
     [16:30:12.815] }
     [16:30:12.815] ...future.frame <- base::sys.nframe()
     [16:30:12.815] ...future.conditions <- base::list()
     [16:30:12.815] ...future.rng <- base::globalenv()$.Random.seed
     [16:30:12.815] ...future.result <- base::tryCatch({
     [16:30:12.815] base::withCallingHandlers({
     [16:30:12.815] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [16:30:12.815] future::FutureResult(value = ...future.value$value,
     [16:30:12.815] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [16:30:12.815] ...future.rng), started = ...future.startTime,
     [16:30:12.815] version = "1.8")
     [16:30:12.815] }, condition = base::local({
     [16:30:12.815] c <- base::c
     [16:30:12.815] inherits <- base::inherits
     [16:30:12.815] invokeRestart <- base::invokeRestart
     [16:30:12.815] length <- base::length
     [16:30:12.815] list <- base::list
     [16:30:12.815] seq.int <- base::seq.int
     [16:30:12.815] signalCondition <- base::signalCondition
     [16:30:12.815] sys.calls <- base::sys.calls
     [16:30:12.815] Sys.time <- base::Sys.time
     [16:30:12.815] `[[` <- base::`[[`
     [16:30:12.815] `+` <- base::`+`
     [16:30:12.815] `<<-` <- base::`<<-`
     [16:30:12.815] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [16:30:12.815] calls[seq.int(from = from + 12L, to = length(calls) -
     [16:30:12.815] 3L)]
     [16:30:12.815] }
     [16:30:12.815] function(cond) {
     [16:30:12.815] if (inherits(cond, "error")) {
     [16:30:12.815] ...future.conditions[[length(...future.conditions) +
     [16:30:12.815] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [16:30:12.815] cond$call), timestamp = Sys.time(), signaled = 0L)
     [16:30:12.815] signalCondition(cond)
     [16:30:12.815] }
     [16:30:12.815] else if (inherits(cond, "condition")) {
     [16:30:12.815] signal <- FALSE && inherits(cond, character(0))
     [16:30:12.815] ...future.conditions[[length(...future.conditions) +
     [16:30:12.815] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [16:30:12.815] if (!signal) {
     [16:30:12.815] muffleCondition <- function (cond)
     [16:30:12.815] {
     [16:30:12.815] inherits <- base::inherits
     [16:30:12.815] invokeRestart <- base::invokeRestart
     [16:30:12.815] muffled <- FALSE
     [16:30:12.815] if (inherits(cond, "message")) {
     [16:30:12.815] invokeRestart("muffleMessage")
     [16:30:12.815] muffled <- TRUE
     [16:30:12.815] }
     [16:30:12.815] else if (inherits(cond, "warning")) {
     [16:30:12.815] invokeRestart("muffleWarning")
     [16:30:12.815] muffled <- TRUE
     [16:30:12.815] }
     [16:30:12.815] else if (inherits(cond, "condition")) {
     [16:30:12.815] computeRestarts <- base::computeRestarts
     [16:30:12.815] grepl <- base::grepl
     [16:30:12.815] is.null <- base::is.null
     [16:30:12.815] restarts <- computeRestarts(cond)
     [16:30:12.815] for (restart in restarts) {
     [16:30:12.815] name <- restart$name
     [16:30:12.815] if (is.null(name))
     [16:30:12.815] next
     [16:30:12.815] if (!grepl("^muffle", name))
     [16:30:12.815] next
     [16:30:12.815] invokeRestart(restart)
     [16:30:12.815] muffled <- TRUE
     [16:30:12.815] break
     [16:30:12.815] }
     [16:30:12.815] }
     [16:30:12.815] invisible(muffled)
     [16:30:12.815] }
     [16:30:12.815] muffleCondition(cond)
     [16:30:12.815] }
     [16:30:12.815] }
     [16:30:12.815] }
     [16:30:12.815] }))
     [16:30:12.815] }, error = function(ex) {
     [16:30:12.815] base::structure(base::list(value = NULL, visible = NULL,
     [16:30:12.815] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [16:30:12.815] ...future.rng), version = "1.8"), class = "FutureResult")
     [16:30:12.815] }, finally = {
     [16:30:12.815] {
     [16:30:12.815] {
     [16:30:12.815] base::options(mc.cores = ...future.mc.cores.old)
     [16:30:12.815] }
     [16:30:12.815] future::plan(list(function (expr, envir = parent.frame(),
     [16:30:12.815] substitute = TRUE, lazy = FALSE, seed = NULL,
     [16:30:12.815] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [16:30:12.815] earlySignal = FALSE, label = NULL, ...)
     [16:30:12.815] {
     [16:30:12.815] if (substitute)
     [16:30:12.815] expr <- substitute(expr)
     [16:30:12.815] if (is.function(workers))
     [16:30:12.815] workers <- workers()
     [16:30:12.815] workers <- as.integer(workers)
     [16:30:12.815] stop_if_not(is.finite(workers), workers >= 1L)
     [16:30:12.815] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [16:30:12.815] return(sequential(expr, envir = envir, substitute = FALSE,
     [16:30:12.815] lazy = lazy, seed = seed, globals = globals,
     [16:30:12.815] local = TRUE, label = label, ...))
     [16:30:12.815] }
     [16:30:12.815] oopts <- options(mc.cores = workers)
     [16:30:12.815] on.exit(options(oopts))
     [16:30:12.815] future <- MulticoreFuture(expr = expr, envir = envir,
     [16:30:12.815] substitute = FALSE, lazy = lazy, seed = seed,
     [16:30:12.815] globals = globals, workers = workers, earlySignal = earlySignal,
     [16:30:12.815] label = label, ...)
     [16:30:12.815] if (!future$lazy)
     [16:30:12.815] future <- run(future)
     [16:30:12.815] invisible(future)
     [16:30:12.815] }), .cleanup = FALSE, .init = FALSE)
     [16:30:12.815] }
     [16:30:12.815] base::options(...future.oldOptions)
     [16:30:12.815] })
     [16:30:12.815] Sys.time
     [16:30:12.815] if (base::is.na(TRUE)) {
     [16:30:12.815] }
     [16:30:12.815] else {
     [16:30:12.815] base::sink(type = "output", split = FALSE)
     [16:30:12.815] if (TRUE) {
     [16:30:12.815] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [16:30:12.815] }
     [16:30:12.815] else {
     [16:30:12.815] ...future.result["stdout"] <- base::list(NULL)
     [16:30:12.815] }
     [16:30:12.815] base::close(...future.stdout)
     [16:30:12.815] ...future.stdout <- NULL
     [16:30:12.815] }
     [16:30:12.815] ...future.result$conditions <- ...future.conditions
     [16:30:12.815] ...future.result
     [16:30:12.815] }
     [16:30:12.821] requestCore(): workers = 2
     [16:30:12.831] MulticoreFuture started
     [16:30:12.858] plan(): Setting new future strategy stack:
     [16:30:12.859] List of future strategies:
     [16:30:12.859] 1. sequential:
     [16:30:12.859] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [16:30:12.859] - tweaked: FALSE
     [16:30:12.859] - call: NULL
     [16:30:12.861] plan(): nbrOfWorkers() = 1
     [16:30:12.867] plan(): Setting new future strategy stack:
     [16:30:12.868] List of future strategies:
     [16:30:12.868] 1. multicore:
     [16:30:12.868] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [16:30:12.868] - tweaked: FALSE
     [16:30:12.868] - call: plan(multicore)
     [16:30:12.871] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 24
     'future.fork.multithreading.enable' = TRUE ... DONE
     'future.fork.multithreading.enable' = FALSE ...
     [16:30:12.889] getGlobalsAndPackages() ...
     [16:30:12.889] Searching for globals...
     [16:30:12.892] - globals found: [1] '::'
     [16:30:12.892] Searching for globals ... DONE
     [16:30:12.892] Resolving globals: FALSE
     [16:30:12.893]
     [16:30:12.894]
     [16:30:12.894] getGlobalsAndPackages() ... DONE
     [16:30:12.895] - Evaluate future in single-threaded mode ...
     [16:30:12.895] supports_omp_threads() = TRUE
     [16:30:12.896] - Force single-threaded processing for OpenMP
     [16:30:12.896] - Evaluate future in single-threaded mode ... DONE
     [16:30:12.899] Packages needed by the future expression (n = 0): <none>
     [16:30:12.900] Packages needed by future strategies (n = 0): <none>
     [16:30:12.907] {
     [16:30:12.907] {
     [16:30:12.907] ...future.startTime <- base::Sys.time()
     [16:30:12.907] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [16:30:12.907] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [16:30:12.907] future.globals.method = NULL, future.globals.onMissing = NULL,
     [16:30:12.907] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [16:30:12.907] future.resolve.recursive = NULL, width = 80L)
     [16:30:12.907] {
     [16:30:12.907] {
     [16:30:12.907] {
     [16:30:12.907] has_future <- base::requireNamespace("future",
     [16:30:12.907] quietly = TRUE)
     [16:30:12.907] version <- if (has_future)
     [16:30:12.907] utils::packageVersion("future")
     [16:30:12.907] else NULL
     [16:30:12.907] if (!has_future || version < "1.8.0") {
     [16:30:12.907] info <- base::c(r_version = base::gsub("R version ",
     [16:30:12.907] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [16:30:12.907] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [16:30:12.907] os = base::paste(base::Sys.info()[base::c("sysname",
     [16:30:12.907] "release", "version")], collapse = " "),
     [16:30:12.907] hostname = base::Sys.info()[["nodename"]])
     [16:30:12.907] info <- base::sprintf("%s: %s", base::names(info),
     [16:30:12.907] info)
     [16:30:12.907] info <- base::paste(info, collapse = "; ")
     [16:30:12.907] if (!has_future) {
     [16:30:12.907] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [16:30:12.907] info)
     [16:30:12.907] }
     [16:30:12.907] else {
     [16:30:12.907] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [16:30:12.907] info, version)
     [16:30:12.907] }
     [16:30:12.907] base::stop(msg)
     [16:30:12.907] }
     [16:30:12.907] }
     [16:30:12.907] ...future.mc.cores.old <- base::getOption("mc.cores")
     [16:30:12.907] base::options(mc.cores = 1L)
     [16:30:12.907] }
     [16:30:12.907] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [16:30:12.907] }
     [16:30:12.907] }
     [16:30:12.907] if (base::is.na(TRUE)) {
     [16:30:12.907] }
     [16:30:12.907] else {
     [16:30:12.907] if (TRUE) {
     [16:30:12.907] ...future.stdout <- base::rawConnection(base::raw(0L),
     [16:30:12.907] open = "w")
     [16:30:12.907] }
     [16:30:12.907] else {
     [16:30:12.907] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [16:30:12.907] windows = "NUL", "/dev/null"), open = "w")
     [16:30:12.907] }
     [16:30:12.907] base::sink(...future.stdout, type = "output", split = FALSE)
     [16:30:12.907] base::on.exit(if (!base::is.null(...future.stdout)) {
     [16:30:12.907] base::sink(type = "output", split = FALSE)
     [16:30:12.907] base::close(...future.stdout)
     [16:30:12.907] }, add = TRUE)
     [16:30:12.907] }
     [16:30:12.907] ...future.frame <- base::sys.nframe()
     [16:30:12.907] ...future.conditions <- base::list()
     [16:30:12.907] ...future.rng <- base::globalenv()$.Random.seed
     [16:30:12.907] ...future.result <- base::tryCatch({
     [16:30:12.907] base::withCallingHandlers({
     [16:30:12.907] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [16:30:12.907] future::FutureResult(value = ...future.value$value,
     [16:30:12.907] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [16:30:12.907] ...future.rng), started = ...future.startTime,
     [16:30:12.907] version = "1.8")
     [16:30:12.907] }, condition = base::local({
     [16:30:12.907] c <- base::c
     [16:30:12.907] inherits <- base::inherits
     [16:30:12.907] invokeRestart <- base::invokeRestart
     [16:30:12.907] length <- base::length
     [16:30:12.907] list <- base::list
     [16:30:12.907] seq.int <- base::seq.int
     [16:30:12.907] signalCondition <- base::signalCondition
     [16:30:12.907] sys.calls <- base::sys.calls
     [16:30:12.907] Sys.time <- base::Sys.time
     [16:30:12.907] `[[` <- base::`[[`
     [16:30:12.907] `+` <- base::`+`
     [16:30:12.907] `<<-` <- base::`<<-`
     [16:30:12.907] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [16:30:12.907] calls[seq.int(from = from + 12L, to = length(calls) -
     [16:30:12.907] 3L)]
     [16:30:12.907] }
     [16:30:12.907] function(cond) {
     [16:30:12.907] if (inherits(cond, "error")) {
     [16:30:12.907] ...future.conditions[[length(...future.conditions) +
     [16:30:12.907] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [16:30:12.907] cond$call), timestamp = Sys.time(), signaled = 0L)
     [16:30:12.907] signalCondition(cond)
     [16:30:12.907] }
     [16:30:12.907] else if (inherits(cond, "condition")) {
     [16:30:12.907] signal <- FALSE && inherits(cond, character(0))
     [16:30:12.907] ...future.conditions[[length(...future.conditions) +
     [16:30:12.907] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [16:30:12.907] if (!signal) {
     [16:30:12.907] muffleCondition <- function (cond)
     [16:30:12.907] {
     [16:30:12.907] inherits <- base::inherits
     [16:30:12.907] invokeRestart <- base::invokeRestart
     [16:30:12.907] muffled <- FALSE
     [16:30:12.907] if (inherits(cond, "message")) {
     [16:30:12.907] invokeRestart("muffleMessage")
     [16:30:12.907] muffled <- TRUE
     [16:30:12.907] }
     [16:30:12.907] else if (inherits(cond, "warning")) {
     [16:30:12.907] invokeRestart("muffleWarning")
     [16:30:12.907] muffled <- TRUE
     [16:30:12.907] }
     [16:30:12.907] else if (inherits(cond, "condition")) {
     [16:30:12.907] computeRestarts <- base::computeRestarts
     [16:30:12.907] grepl <- base::grepl
     [16:30:12.907] is.null <- base::is.null
     [16:30:12.907] restarts <- computeRestarts(cond)
     [16:30:12.907] for (restart in restarts) {
     [16:30:12.907] name <- restart$name
     [16:30:12.907] if (is.null(name))
     [16:30:12.907] next
     [16:30:12.907] if (!grepl("^muffle", name))
     [16:30:12.907] next
     [16:30:12.907] invokeRestart(restart)
     [16:30:12.907] muffled <- TRUE
     [16:30:12.907] break
     [16:30:12.907] }
     [16:30:12.907] }
     [16:30:12.907] invisible(muffled)
     [16:30:12.907] }
     [16:30:12.907] muffleCondition(cond)
     [16:30:12.907] }
     [16:30:12.907] }
     [16:30:12.907] }
     [16:30:12.907] }))
     [16:30:12.907] }, error = function(ex) {
     [16:30:12.907] base::structure(base::list(value = NULL, visible = NULL,
     [16:30:12.907] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [16:30:12.907] ...future.rng), version = "1.8"), class = "FutureResult")
     [16:30:12.907] }, finally = {
     [16:30:12.907] {
     [16:30:12.907] {
     [16:30:12.907] base::options(mc.cores = ...future.mc.cores.old)
     [16:30:12.907] }
     [16:30:12.907] future::plan(list(function (expr, envir = parent.frame(),
     [16:30:12.907] substitute = TRUE, lazy = FALSE, seed = NULL,
     [16:30:12.907] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [16:30:12.907] earlySignal = FALSE, label = NULL, ...)
     [16:30:12.907] {
     [16:30:12.907] if (substitute)
     [16:30:12.907] expr <- substitute(expr)
     [16:30:12.907] if (is.function(workers))
     [16:30:12.907] workers <- workers()
     [16:30:12.907] workers <- as.integer(workers)
     [16:30:12.907] stop_if_not(is.finite(workers), workers >= 1L)
     [16:30:12.907] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [16:30:12.907] return(sequential(expr, envir = envir, substitute = FALSE,
     [16:30:12.907] lazy = lazy, seed = seed, globals = globals,
     [16:30:12.907] local = TRUE, label = label, ...))
     [16:30:12.907] }
     [16:30:12.907] oopts <- options(mc.cores = workers)
     [16:30:12.907] on.exit(options(oopts))
     [16:30:12.907] future <- MulticoreFuture(expr = expr, envir = envir,
     [16:30:12.907] substitute = FALSE, lazy = lazy, seed = seed,
     [16:30:12.907] globals = globals, workers = workers, earlySignal = earlySignal,
     [16:30:12.907] label = label, ...)
     [16:30:12.907] if (!future$lazy)
     [16:30:12.907] future <- run(future)
     [16:30:12.907] invisible(future)
     [16:30:12.907] }), .cleanup = FALSE, .init = FALSE)
     [16:30:12.907] }
     [16:30:12.907] base::options(...future.oldOptions)
     [16:30:12.907] })
     [16:30:12.907] Sys.time
     [16:30:12.907] if (base::is.na(TRUE)) {
     [16:30:12.907] }
     [16:30:12.907] else {
     [16:30:12.907] base::sink(type = "output", split = FALSE)
     [16:30:12.907] if (TRUE) {
     [16:30:12.907] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [16:30:12.907] }
     [16:30:12.907] else {
     [16:30:12.907] ...future.result["stdout"] <- base::list(NULL)
     [16:30:12.907] }
     [16:30:12.907] base::close(...future.stdout)
     [16:30:12.907] ...future.stdout <- NULL
     [16:30:12.907] }
     [16:30:12.907] ...future.result$conditions <- ...future.conditions
     [16:30:12.907] ...future.result
     [16:30:12.907] }
     [16:30:12.913] requestCore(): workers = 2
     [16:30:12.918] MulticoreFuture started
     [16:30:12.932] plan(): Setting new future strategy stack:
     [16:30:12.933] List of future strategies:
     [16:30:12.933] 1. sequential:
     [16:30:12.933] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [16:30:12.933] - tweaked: FALSE
     [16:30:12.933] - call: NULL
     [16:30:12.935] plan(): nbrOfWorkers() = 1
     [16:30:12.960] plan(): Setting new future strategy stack:
     [16:30:12.961] List of future strategies:
     [16:30:12.961] 1. multicore:
     [16:30:12.961] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [16:30:12.961] - tweaked: FALSE
     [16:30:12.961] - call: plan(multicore)
     [16:30:12.964] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 24
     Error: !enable && nthreads == 1L is not TRUE
     Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang

Version: 1.16.0
Check: tests
Result: ERROR
     Running ‘000.sessionDetails.R’ [7s/8s]
     Running ‘ClusterRegistry.R’ [3s/49s]
     Running ‘Future-class.R’ [2s/17s]
     Running ‘FutureError.R’ [1s/1s]
     Running ‘FutureGlobals.R’ [1s/1s]
     Running ‘FutureRegistry.R’ [1s/2s]
     Running ‘as.cluster.R’ [1s/18s]
     Running ‘availableCores.R’ [1s/1s]
     Running ‘availableWorkers.R’ [1s/1s]
     Running ‘backtrace.R’ [1s/3s]
     Running ‘cluster-missing-future-pkg.R’ [1s/2s]
     Running ‘cluster.R’ [7s/111s]
     Running ‘constant.R’ [1s/1s]
     Running ‘demo.R’ [9s/27s]
     Running ‘dotdotdot.R’ [2s/18s]
     Running ‘early-signaling.R’ [2s/36s]
     Running ‘future,labels.R’ [1s/1s]
     Running ‘future.R’ [1s/1s]
     Running ‘futureAssign.R’ [2s/18s]
     Running ‘futureAssign_OP.R’ [3s/20s]
     Running ‘futureAssign_OP_with_environment.R’ [1s/1s]
     Running ‘futureAssign_OP_with_listenv.R’ [1s/1s]
     Running ‘futureCall.R’ [4s/28s]
     Running ‘futureOf.R’ [1s/1s]
     Running ‘futureOf_with_environment.R’ [1s/1s]
     Running ‘futureOf_with_listenv.R’ [1s/1s]
     Running ‘futures.R’ [18s/137s]
     Running ‘globals,NSE.R’ [1s/1s]
     Running ‘globals,formulas.R’ [2s/4s]
     Running ‘globals,manual.R’ [2s/2s]
     Running ‘globals,resolve.R’ [1s/17s]
     Running ‘globals,subassignment.R’ [3s/20s]
     Running ‘globals,toolarge.R’ [1s/17s]
     Running ‘globals,tricky.R’ [7s/25s]
     Running ‘globals,tricky_recursive.R’ [1s/1s]
     Running ‘globalsOf,tweaks.R’ [1s/1s]
     Running ‘immediateCondition.R’ [1s/2s]
     Running ‘invalid-owner.R’ [2s/19s]
     Running ‘makeClusterPSOCK.R’ [1s/9s]
     Running ‘mandelbrot.R’ [1s/1s]
     Running ‘mpi.R’ [1s/1s]
     Running ‘multicore,multithreading.R’ [1s/1s]
     Running ‘multicore.R’ [1s/2s]
     Running ‘multiprocess.R’ [2s/2s]
     Running ‘multisession.R’ [4s/54s]
     Running ‘nbrOfWorkers.R’ [4s/67s]
     Running ‘nested_futures,mc.cores.R’ [5s/114s]
     Running ‘nested_futures.R’ [1s/1s]
     Running ‘non-exportable,connections.R’ [1s/18s]
     Running ‘objectSize.R’ [1s/1s]
     Running ‘plan.R’ [6s/16s]
     Running ‘relaying.R’ [1s/3s]
     Running ‘remote.R’ [1s/19s]
     Running ‘requestCore.R’ [1s/3s]
     Running ‘requestNode.R’ [2s/29s]
     Running ‘reserved-keyword-functions.R’ [1s/1s]
     Running ‘resolve.R’ [2s/4s]
     Running ‘resolved-non-blocking-test.R’ [3s/67s]
     Running ‘rng.R’ [11s/32s]
     Running ‘sequential.R’ [1s/1s]
     Running ‘sessionDetails.R’ [1s/1s]
     Running ‘startup.R’ [2s/35s]
     Running ‘stdout.R’ [2s/18s]
     Running ‘transparent.R’ [1s/1s]
     Running ‘tweak.R’ [1s/1s]
     Running ‘utils.R’ [7s/8s]
     Running ‘uuid.R’ [1s/1s]
     Running ‘whichIndex.R’ [1s/1s]
    Running the tests in ‘tests/globals,formulas.R’ failed.
    Complete output:
     > source("incl/start.R")
     [14:16:47.406] plan(): Setting new future strategy stack:
     [14:16:47.407] List of future strategies:
     [14:16:47.407] 1. sequential:
     [14:16:47.407] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.407] - tweaked: FALSE
     [14:16:47.407] - call: future::plan("sequential")
     [14:16:47.409] plan(): nbrOfWorkers() = 1
     >
     > library("datasets") ## cars data set
     > library("stats") ## lm(), poly(), xtabs()
     >
     > message("*** Globals - formulas ...")
     *** Globals - formulas ...
     >
     > ## (i) lm(<formula>):
     > ## From example("lm", package = "stats")
     > ctl <- c(4.17, 5.58, 5.18, 6.11, 4.50, 4.61, 5.17, 4.53, 5.33, 5.14)
     > trt <- c(4.81, 4.17, 4.41, 3.59, 5.87, 3.83, 6.03, 4.89, 4.32, 4.69)
     > group <- gl(2, 10, 20, labels = c("Ctl", "Trt"))
     > weight <- c(ctl, trt)
     > ctl <- trt <- NULL
     > ## Truth:
     > fit_i <- lm(weight ~ group - 1)
     > print(fit_i)
    
     Call:
     lm(formula = weight ~ group - 1)
    
     Coefficients:
     groupCtl groupTrt
     5.032 4.661
    
     >
     > ## (ii) xtabs(~ x):
     > x <- c(1, 1, 2, 2, 2)
     > ## Truth:
     > tbl_ii <- xtabs(~ x)
     > print(tbl_ii)
     x
     1 2
     2 3
     >
     > ## (iii) lm(<formula>, data = cars):
     > exprs <- list(
     + # "remove-intercept-term" form of no-intercept
     + a = substitute({ lm(dist ~ . -1, data = cars) }),
     + # "make-intercept-zero" form of no-intercept
     + b = substitute({ lm(dist ~ . +0, data = cars) }),
     + # doesn't do what we want here
     + c = substitute({ lm(dist ~ speed + speed ^ 2, data = cars) }),
     + # gets us a quadratic term
     + d = substitute({ lm(dist ~ speed + I(speed ^ 2), data = cars) }),
     + # avoid potential multicollinearity
     + e = substitute({ lm(dist ~ poly(speed, 2), data = cars) })
     + )
     >
     > ## (iv) Globals - map(x, ~ expr):
     > ## A fake purrr::map() function with limited functionality
     > map <- function(.x, .f, ...) {
     + if (inherits(.f, "formula")) {
     + expr <- .f[[-1]]
     + .f <- eval(bquote(function(...) {
     + .(expr)
     + }))
     + }
     + eval(lapply(.x, FUN = .f, ...))
     + }
     >
     > inner_function <- function(x) { x + 1 }
     >
     > outer_function <- function(x) {
     + map(1:2, ~ inner_function(.x))
     + }
     >
     > y_iv <- outer_function(1L)
     > str(y_iv)
     List of 2
     $ : num [1:2] 2 3
     $ : num [1:2] 2 3
     >
     >
     > for (cores in 1:availCores) {
     + ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
     + if (!fullTest && isWin32) next
     +
     + message(sprintf("Testing with %d cores ...", cores))
     + options(mc.cores = cores)
     +
     + message("availableCores(): ", availableCores())
     +
     + for (strategy in supportedStrategies(cores)) {
     + message(sprintf("- plan('%s') ...", strategy))
     + plan(strategy)
     +
     + message("- lm(<formula>) ...")
     +
     + ## Explicit future
     + f <- future({ lm(weight ~ group - 1) })
     + fit <- value(f)
     + print(fit)
     + stopifnot(all.equal(fit, fit_i))
     +
     + ## Explicit future (lazy)
     + f <- future({ lm(weight ~ group - 1) }, lazy = TRUE)
     + fit <- value(f)
     + print(fit)
     + stopifnot(all.equal(fit, fit_i))
     +
     + ## Future assignment
     + fit %<-% { lm(weight ~ group - 1) }
     + print(fit)
     + stopifnot(all.equal(fit, fit_i))
     +
     + ## Future assignment (non-lazy)
     + fit %<-% { lm(weight ~ group - 1) } %lazy% FALSE
     + print(fit)
     + stopifnot(all.equal(fit, fit_i))
     +
     + ## Future assignment (lazy)
     + fit %<-% { lm(weight ~ group - 1) } %lazy% TRUE
     + print(fit)
     + stopifnot(all.equal(fit, fit_i))
     +
     + message("- Globals - one-side formulas, e.g. xtabs(~ x) ...")
     + ## Explicit future
     + f <- future({ xtabs(~ x) })
     + tbl <- value(f)
     + print(tbl)
     + stopifnot(all.equal(tbl, tbl_ii))
     +
     + ## Future assignment
     + tbl %<-% { xtabs(~ x) }
     + print(tbl)
     + stopifnot(all.equal(tbl, tbl_ii))
     +
     + message("- Globals - lm(<formula>, data = cars) ...")
     + for (kk in seq_along(exprs)) {
     + expr <- exprs[[kk]]
     + name <- names(exprs)[kk]
     + message(sprintf("- Globals - lm(<formula #%d (%s)>, data = cars) ...",
     + kk, sQuote(name)))
     +
     + fit_iii <- eval(expr)
     + print(fit_iii)
     +
     + f <- future(expr, substitute = FALSE)
     + fit <- value(f)
     + print(fit)
     +
     + stopifnot(all.equal(fit, fit_iii))
     + } ## for (kk ...)
     +
     + message("- Globals - map(x, ~ expr) ...")
     + f <- future({ outer_function(1L) })
     + y <- value(f)
     + str(y)
     + stopifnot(all.equal(y, y_iv))
     +
     + y %<-% { outer_function(1L) }
     + str(y)
     + stopifnot(all.equal(y, y_iv))
     + } ## for (strategy ...)
     + message(sprintf("Testing with %d cores ... DONE", cores))
     + } ## for (cores ...)
     Testing with 1 cores ...
     availableCores(): 1
     - plan('sequential') ...
     [14:16:47.595] plan(): Setting new future strategy stack:
     [14:16:47.596] List of future strategies:
     [14:16:47.596] 1. sequential:
     [14:16:47.596] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.596] - tweaked: FALSE
     [14:16:47.596] - call: plan(strategy)
     [14:16:47.625] plan(): nbrOfWorkers() = 1
     - lm(<formula>) ...
     [14:16:47.627] getGlobalsAndPackages() ...
     [14:16:47.627] Searching for globals...
     [14:16:47.637] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
     [14:16:47.638] Searching for globals ... DONE
     [14:16:47.638] Resolving globals: FALSE
     [14:16:47.641] The total size of the 2 globals is 896 bytes (896 bytes)
     [14:16:47.641] - globals: [2] 'weight', 'group'
     [14:16:47.641] - packages: [1] 'stats'
     [14:16:47.642] getGlobalsAndPackages() ... DONE
     [14:16:47.645] Packages needed by the future expression (n = 0): <none>
     [14:16:47.645] Packages needed by future strategies (n = 0): <none>
     [14:16:47.651] {
     [14:16:47.651] {
     [14:16:47.651] ...future.startTime <- base::Sys.time()
     [14:16:47.651] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:47.651] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:47.651] future.globals.method = NULL, future.globals.onMissing = NULL,
     [14:16:47.651] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:47.651] future.resolve.recursive = NULL, width = 80L)
     [14:16:47.651] {
     [14:16:47.651] {
     [14:16:47.651] has_future <- base::requireNamespace("future",
     [14:16:47.651] quietly = TRUE)
     [14:16:47.651] version <- if (has_future)
     [14:16:47.651] utils::packageVersion("future")
     [14:16:47.651] else NULL
     [14:16:47.651] if (!has_future || version < "1.8.0") {
     [14:16:47.651] info <- base::c(r_version = base::gsub("R version ",
     [14:16:47.651] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:47.651] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:47.651] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:47.651] "release", "version")], collapse = " "),
     [14:16:47.651] hostname = base::Sys.info()[["nodename"]])
     [14:16:47.651] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:47.651] info)
     [14:16:47.651] info <- base::paste(info, collapse = "; ")
     [14:16:47.651] if (!has_future) {
     [14:16:47.651] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:47.651] info)
     [14:16:47.651] }
     [14:16:47.651] else {
     [14:16:47.651] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:47.651] info, version)
     [14:16:47.651] }
     [14:16:47.651] base::stop(msg)
     [14:16:47.651] }
     [14:16:47.651] }
     [14:16:47.651] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:47.651] }
     [14:16:47.651] }
     [14:16:47.651] if (base::is.na(TRUE)) {
     [14:16:47.651] }
     [14:16:47.651] else {
     [14:16:47.651] if (TRUE) {
     [14:16:47.651] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:47.651] open = "w")
     [14:16:47.651] }
     [14:16:47.651] else {
     [14:16:47.651] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:47.651] windows = "NUL", "/dev/null"), open = "w")
     [14:16:47.651] }
     [14:16:47.651] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:47.651] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:47.651] base::sink(type = "output", split = FALSE)
     [14:16:47.651] base::close(...future.stdout)
     [14:16:47.651] }, add = TRUE)
     [14:16:47.651] }
     [14:16:47.651] ...future.frame <- base::sys.nframe()
     [14:16:47.651] ...future.conditions <- base::list()
     [14:16:47.651] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:47.651] ...future.result <- base::tryCatch({
     [14:16:47.651] base::withCallingHandlers({
     [14:16:47.651] ...future.value <- base::withVisible(base::local({
     [14:16:47.651] lm(weight ~ group - 1)
     [14:16:47.651] }))
     [14:16:47.651] future::FutureResult(value = ...future.value$value,
     [14:16:47.651] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.651] ...future.rng), started = ...future.startTime,
     [14:16:47.651] version = "1.8")
     [14:16:47.651] }, condition = base::local({
     [14:16:47.651] c <- base::c
     [14:16:47.651] inherits <- base::inherits
     [14:16:47.651] invokeRestart <- base::invokeRestart
     [14:16:47.651] length <- base::length
     [14:16:47.651] list <- base::list
     [14:16:47.651] seq.int <- base::seq.int
     [14:16:47.651] signalCondition <- base::signalCondition
     [14:16:47.651] sys.calls <- base::sys.calls
     [14:16:47.651] Sys.time <- base::Sys.time
     [14:16:47.651] `[[` <- base::`[[`
     [14:16:47.651] `+` <- base::`+`
     [14:16:47.651] `<<-` <- base::`<<-`
     [14:16:47.651] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:47.651] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:47.651] 3L)]
     [14:16:47.651] }
     [14:16:47.651] function(cond) {
     [14:16:47.651] if (inherits(cond, "error")) {
     [14:16:47.651] ...future.conditions[[length(...future.conditions) +
     [14:16:47.651] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:47.651] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:47.651] signalCondition(cond)
     [14:16:47.651] }
     [14:16:47.651] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:47.651] ))) {
     [14:16:47.651] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:47.651] ...future.conditions[[length(...future.conditions) +
     [14:16:47.651] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:47.651] if (!signal) {
     [14:16:47.651] muffleCondition <- function (cond)
     [14:16:47.651] {
     [14:16:47.651] inherits <- base::inherits
     [14:16:47.651] invokeRestart <- base::invokeRestart
     [14:16:47.651] muffled <- FALSE
     [14:16:47.651] if (inherits(cond, "message")) {
     [14:16:47.651] invokeRestart("muffleMessage")
     [14:16:47.651] muffled <- TRUE
     [14:16:47.651] }
     [14:16:47.651] else if (inherits(cond, "warning")) {
     [14:16:47.651] invokeRestart("muffleWarning")
     [14:16:47.651] muffled <- TRUE
     [14:16:47.651] }
     [14:16:47.651] else if (inherits(cond, "condition")) {
     [14:16:47.651] computeRestarts <- base::computeRestarts
     [14:16:47.651] grepl <- base::grepl
     [14:16:47.651] is.null <- base::is.null
     [14:16:47.651] restarts <- computeRestarts(cond)
     [14:16:47.651] for (restart in restarts) {
     [14:16:47.651] name <- restart$name
     [14:16:47.651] if (is.null(name))
     [14:16:47.651] next
     [14:16:47.651] if (!grepl("^muffle", name))
     [14:16:47.651] next
     [14:16:47.651] invokeRestart(restart)
     [14:16:47.651] muffled <- TRUE
     [14:16:47.651] break
     [14:16:47.651] }
     [14:16:47.651] }
     [14:16:47.651] invisible(muffled)
     [14:16:47.651] }
     [14:16:47.651] muffleCondition(cond)
     [14:16:47.651] }
     [14:16:47.651] }
     [14:16:47.651] }
     [14:16:47.651] }))
     [14:16:47.651] }, error = function(ex) {
     [14:16:47.651] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:47.651] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.651] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:47.651] }, finally = {
     [14:16:47.651] {
     [14:16:47.651] NULL
     [14:16:47.651] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:47.651] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:47.651] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:47.651] label = NULL, ...)
     [14:16:47.651] {
     [14:16:47.651] if (substitute)
     [14:16:47.651] expr <- substitute(expr)
     [14:16:47.651] local <- as.logical(local)
     [14:16:47.651] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:47.651] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:47.651] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:47.651] label = label, ...)
     [14:16:47.651] if (!future$lazy)
     [14:16:47.651] future <- run(future)
     [14:16:47.651] invisible(future)
     [14:16:47.651] }), .cleanup = FALSE, .init = FALSE)
     [14:16:47.651] }
     [14:16:47.651] base::options(...future.oldOptions)
     [14:16:47.651] })
     [14:16:47.651] Sys.time
     [14:16:47.651] if (base::is.na(TRUE)) {
     [14:16:47.651] }
     [14:16:47.651] else {
     [14:16:47.651] base::sink(type = "output", split = FALSE)
     [14:16:47.651] if (TRUE) {
     [14:16:47.651] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:47.651] }
     [14:16:47.651] else {
     [14:16:47.651] ...future.result["stdout"] <- base::list(NULL)
     [14:16:47.651] }
     [14:16:47.651] base::close(...future.stdout)
     [14:16:47.651] ...future.stdout <- NULL
     [14:16:47.651] }
     [14:16:47.651] ...future.result$conditions <- ...future.conditions
     [14:16:47.651] ...future.result
     [14:16:47.651] }
     [14:16:47.656] plan(): Setting new future strategy stack:
     [14:16:47.656] List of future strategies:
     [14:16:47.656] 1. sequential:
     [14:16:47.656] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.656] - tweaked: FALSE
     [14:16:47.656] - call: NULL
     [14:16:47.657] plan(): nbrOfWorkers() = 1
     [14:16:47.661] plan(): Setting new future strategy stack:
     [14:16:47.661] List of future strategies:
     [14:16:47.661] 1. sequential:
     [14:16:47.661] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.661] - tweaked: FALSE
     [14:16:47.661] - call: plan(strategy)
     [14:16:47.662] plan(): nbrOfWorkers() = 1
     [14:16:47.663] SequentialFuture started (and completed)
    
     Call:
     lm(formula = weight ~ group - 1)
    
     Coefficients:
     groupCtl groupTrt
     5.032 4.661
    
     [14:16:47.670] getGlobalsAndPackages() ...
     [14:16:47.670] Searching for globals...
     [14:16:47.679] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
     [14:16:47.679] Searching for globals ... DONE
     [14:16:47.679] Resolving globals: FALSE
     [14:16:47.681] The total size of the 2 globals is 896 bytes (896 bytes)
     [14:16:47.681] - globals: [2] 'weight', 'group'
     [14:16:47.681] - packages: [1] 'stats'
     [14:16:47.682] getGlobalsAndPackages() ... DONE
     [14:16:47.684] Packages needed by the future expression (n = 1): 'stats'
     [14:16:47.684] Packages needed by future strategies (n = 0): <none>
     [14:16:47.690] {
     [14:16:47.690] {
     [14:16:47.690] ...future.startTime <- base::Sys.time()
     [14:16:47.690] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:47.690] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:47.690] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:47.690] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:47.690] future.resolve.recursive = NULL, width = 80L)
     [14:16:47.690] {
     [14:16:47.690] {
     [14:16:47.690] {
     [14:16:47.690] has_future <- base::requireNamespace("future",
     [14:16:47.690] quietly = TRUE)
     [14:16:47.690] version <- if (has_future)
     [14:16:47.690] utils::packageVersion("future")
     [14:16:47.690] else NULL
     [14:16:47.690] if (!has_future || version < "1.8.0") {
     [14:16:47.690] info <- base::c(r_version = base::gsub("R version ",
     [14:16:47.690] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:47.690] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:47.690] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:47.690] "release", "version")], collapse = " "),
     [14:16:47.690] hostname = base::Sys.info()[["nodename"]])
     [14:16:47.690] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:47.690] info)
     [14:16:47.690] info <- base::paste(info, collapse = "; ")
     [14:16:47.690] if (!has_future) {
     [14:16:47.690] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:47.690] info)
     [14:16:47.690] }
     [14:16:47.690] else {
     [14:16:47.690] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:47.690] info, version)
     [14:16:47.690] }
     [14:16:47.690] base::stop(msg)
     [14:16:47.690] }
     [14:16:47.690] }
     [14:16:47.690] base::local({
     [14:16:47.690] for (pkg in "stats") {
     [14:16:47.690] base::loadNamespace(pkg)
     [14:16:47.690] base::library(pkg, character.only = TRUE)
     [14:16:47.690] }
     [14:16:47.690] })
     [14:16:47.690] }
     [14:16:47.690] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:47.690] }
     [14:16:47.690] }
     [14:16:47.690] if (base::is.na(TRUE)) {
     [14:16:47.690] }
     [14:16:47.690] else {
     [14:16:47.690] if (TRUE) {
     [14:16:47.690] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:47.690] open = "w")
     [14:16:47.690] }
     [14:16:47.690] else {
     [14:16:47.690] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:47.690] windows = "NUL", "/dev/null"), open = "w")
     [14:16:47.690] }
     [14:16:47.690] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:47.690] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:47.690] base::sink(type = "output", split = FALSE)
     [14:16:47.690] base::close(...future.stdout)
     [14:16:47.690] }, add = TRUE)
     [14:16:47.690] }
     [14:16:47.690] ...future.frame <- base::sys.nframe()
     [14:16:47.690] ...future.conditions <- base::list()
     [14:16:47.690] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:47.690] ...future.result <- base::tryCatch({
     [14:16:47.690] base::withCallingHandlers({
     [14:16:47.690] ...future.value <- base::withVisible(base::local({
     [14:16:47.690] lm(weight ~ group - 1)
     [14:16:47.690] }))
     [14:16:47.690] future::FutureResult(value = ...future.value$value,
     [14:16:47.690] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.690] ...future.rng), started = ...future.startTime,
     [14:16:47.690] version = "1.8")
     [14:16:47.690] }, condition = base::local({
     [14:16:47.690] c <- base::c
     [14:16:47.690] inherits <- base::inherits
     [14:16:47.690] invokeRestart <- base::invokeRestart
     [14:16:47.690] length <- base::length
     [14:16:47.690] list <- base::list
     [14:16:47.690] seq.int <- base::seq.int
     [14:16:47.690] signalCondition <- base::signalCondition
     [14:16:47.690] sys.calls <- base::sys.calls
     [14:16:47.690] Sys.time <- base::Sys.time
     [14:16:47.690] `[[` <- base::`[[`
     [14:16:47.690] `+` <- base::`+`
     [14:16:47.690] `<<-` <- base::`<<-`
     [14:16:47.690] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:47.690] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:47.690] 3L)]
     [14:16:47.690] }
     [14:16:47.690] function(cond) {
     [14:16:47.690] if (inherits(cond, "error")) {
     [14:16:47.690] ...future.conditions[[length(...future.conditions) +
     [14:16:47.690] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:47.690] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:47.690] signalCondition(cond)
     [14:16:47.690] }
     [14:16:47.690] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:47.690] ))) {
     [14:16:47.690] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:47.690] ...future.conditions[[length(...future.conditions) +
     [14:16:47.690] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:47.690] if (!signal) {
     [14:16:47.690] muffleCondition <- function (cond)
     [14:16:47.690] {
     [14:16:47.690] inherits <- base::inherits
     [14:16:47.690] invokeRestart <- base::invokeRestart
     [14:16:47.690] muffled <- FALSE
     [14:16:47.690] if (inherits(cond, "message")) {
     [14:16:47.690] invokeRestart("muffleMessage")
     [14:16:47.690] muffled <- TRUE
     [14:16:47.690] }
     [14:16:47.690] else if (inherits(cond, "warning")) {
     [14:16:47.690] invokeRestart("muffleWarning")
     [14:16:47.690] muffled <- TRUE
     [14:16:47.690] }
     [14:16:47.690] else if (inherits(cond, "condition")) {
     [14:16:47.690] computeRestarts <- base::computeRestarts
     [14:16:47.690] grepl <- base::grepl
     [14:16:47.690] is.null <- base::is.null
     [14:16:47.690] restarts <- computeRestarts(cond)
     [14:16:47.690] for (restart in restarts) {
     [14:16:47.690] name <- restart$name
     [14:16:47.690] if (is.null(name))
     [14:16:47.690] next
     [14:16:47.690] if (!grepl("^muffle", name))
     [14:16:47.690] next
     [14:16:47.690] invokeRestart(restart)
     [14:16:47.690] muffled <- TRUE
     [14:16:47.690] break
     [14:16:47.690] }
     [14:16:47.690] }
     [14:16:47.690] invisible(muffled)
     [14:16:47.690] }
     [14:16:47.690] muffleCondition(cond)
     [14:16:47.690] }
     [14:16:47.690] }
     [14:16:47.690] }
     [14:16:47.690] }))
     [14:16:47.690] }, error = function(ex) {
     [14:16:47.690] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:47.690] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.690] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:47.690] }, finally = {
     [14:16:47.690] {
     [14:16:47.690] NULL
     [14:16:47.690] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:47.690] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:47.690] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:47.690] label = NULL, ...)
     [14:16:47.690] {
     [14:16:47.690] if (substitute)
     [14:16:47.690] expr <- substitute(expr)
     [14:16:47.690] local <- as.logical(local)
     [14:16:47.690] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:47.690] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:47.690] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:47.690] label = label, ...)
     [14:16:47.690] if (!future$lazy)
     [14:16:47.690] future <- run(future)
     [14:16:47.690] invisible(future)
     [14:16:47.690] }), .cleanup = FALSE, .init = FALSE)
     [14:16:47.690] }
     [14:16:47.690] base::options(...future.oldOptions)
     [14:16:47.690] })
     [14:16:47.690] Sys.time
     [14:16:47.690] if (base::is.na(TRUE)) {
     [14:16:47.690] }
     [14:16:47.690] else {
     [14:16:47.690] base::sink(type = "output", split = FALSE)
     [14:16:47.690] if (TRUE) {
     [14:16:47.690] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:47.690] }
     [14:16:47.690] else {
     [14:16:47.690] ...future.result["stdout"] <- base::list(NULL)
     [14:16:47.690] }
     [14:16:47.690] base::close(...future.stdout)
     [14:16:47.690] ...future.stdout <- NULL
     [14:16:47.690] }
     [14:16:47.690] ...future.result$conditions <- ...future.conditions
     [14:16:47.690] ...future.result
     [14:16:47.690] }
     [14:16:47.695] plan(): Setting new future strategy stack:
     [14:16:47.696] List of future strategies:
     [14:16:47.696] 1. sequential:
     [14:16:47.696] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.696] - tweaked: FALSE
     [14:16:47.696] - call: NULL
     [14:16:47.697] plan(): nbrOfWorkers() = 1
     [14:16:47.700] plan(): Setting new future strategy stack:
     [14:16:47.700] List of future strategies:
     [14:16:47.700] 1. sequential:
     [14:16:47.700] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.700] - tweaked: FALSE
     [14:16:47.700] - call: plan(strategy)
     [14:16:47.701] plan(): nbrOfWorkers() = 1
     [14:16:47.702] SequentialFuture started (and completed)
    
     Call:
     lm(formula = weight ~ group - 1)
    
     Coefficients:
     groupCtl groupTrt
     5.032 4.661
    
     [14:16:47.709] getGlobalsAndPackages() ...
     [14:16:47.709] Searching for globals...
     [14:16:47.713] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
     [14:16:47.713] Searching for globals ... DONE
     [14:16:47.714] Resolving globals: FALSE
     [14:16:47.715] The total size of the 2 globals is 896 bytes (896 bytes)
     [14:16:47.715] - globals: [2] 'weight', 'group'
     [14:16:47.716] - packages: [1] 'stats'
     [14:16:47.716] getGlobalsAndPackages() ... DONE
     [14:16:47.718] Packages needed by the future expression (n = 0): <none>
     [14:16:47.719] Packages needed by future strategies (n = 0): <none>
     [14:16:47.724] {
     [14:16:47.724] {
     [14:16:47.724] ...future.startTime <- base::Sys.time()
     [14:16:47.724] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:47.724] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:47.724] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:47.724] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:47.724] future.resolve.recursive = NULL, width = 80L)
     [14:16:47.724] {
     [14:16:47.724] {
     [14:16:47.724] has_future <- base::requireNamespace("future",
     [14:16:47.724] quietly = TRUE)
     [14:16:47.724] version <- if (has_future)
     [14:16:47.724] utils::packageVersion("future")
     [14:16:47.724] else NULL
     [14:16:47.724] if (!has_future || version < "1.8.0") {
     [14:16:47.724] info <- base::c(r_version = base::gsub("R version ",
     [14:16:47.724] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:47.724] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:47.724] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:47.724] "release", "version")], collapse = " "),
     [14:16:47.724] hostname = base::Sys.info()[["nodename"]])
     [14:16:47.724] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:47.724] info)
     [14:16:47.724] info <- base::paste(info, collapse = "; ")
     [14:16:47.724] if (!has_future) {
     [14:16:47.724] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:47.724] info)
     [14:16:47.724] }
     [14:16:47.724] else {
     [14:16:47.724] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:47.724] info, version)
     [14:16:47.724] }
     [14:16:47.724] base::stop(msg)
     [14:16:47.724] }
     [14:16:47.724] }
     [14:16:47.724] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:47.724] }
     [14:16:47.724] }
     [14:16:47.724] if (base::is.na(TRUE)) {
     [14:16:47.724] }
     [14:16:47.724] else {
     [14:16:47.724] if (TRUE) {
     [14:16:47.724] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:47.724] open = "w")
     [14:16:47.724] }
     [14:16:47.724] else {
     [14:16:47.724] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:47.724] windows = "NUL", "/dev/null"), open = "w")
     [14:16:47.724] }
     [14:16:47.724] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:47.724] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:47.724] base::sink(type = "output", split = FALSE)
     [14:16:47.724] base::close(...future.stdout)
     [14:16:47.724] }, add = TRUE)
     [14:16:47.724] }
     [14:16:47.724] ...future.frame <- base::sys.nframe()
     [14:16:47.724] ...future.conditions <- base::list()
     [14:16:47.724] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:47.724] ...future.result <- base::tryCatch({
     [14:16:47.724] base::withCallingHandlers({
     [14:16:47.724] ...future.value <- base::withVisible(base::local({
     [14:16:47.724] lm(weight ~ group - 1)
     [14:16:47.724] }))
     [14:16:47.724] future::FutureResult(value = ...future.value$value,
     [14:16:47.724] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.724] ...future.rng), started = ...future.startTime,
     [14:16:47.724] version = "1.8")
     [14:16:47.724] }, condition = base::local({
     [14:16:47.724] c <- base::c
     [14:16:47.724] inherits <- base::inherits
     [14:16:47.724] invokeRestart <- base::invokeRestart
     [14:16:47.724] length <- base::length
     [14:16:47.724] list <- base::list
     [14:16:47.724] seq.int <- base::seq.int
     [14:16:47.724] signalCondition <- base::signalCondition
     [14:16:47.724] sys.calls <- base::sys.calls
     [14:16:47.724] Sys.time <- base::Sys.time
     [14:16:47.724] `[[` <- base::`[[`
     [14:16:47.724] `+` <- base::`+`
     [14:16:47.724] `<<-` <- base::`<<-`
     [14:16:47.724] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:47.724] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:47.724] 3L)]
     [14:16:47.724] }
     [14:16:47.724] function(cond) {
     [14:16:47.724] if (inherits(cond, "error")) {
     [14:16:47.724] ...future.conditions[[length(...future.conditions) +
     [14:16:47.724] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:47.724] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:47.724] signalCondition(cond)
     [14:16:47.724] }
     [14:16:47.724] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:47.724] ))) {
     [14:16:47.724] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:47.724] ...future.conditions[[length(...future.conditions) +
     [14:16:47.724] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:47.724] if (!signal) {
     [14:16:47.724] muffleCondition <- function (cond)
     [14:16:47.724] {
     [14:16:47.724] inherits <- base::inherits
     [14:16:47.724] invokeRestart <- base::invokeRestart
     [14:16:47.724] muffled <- FALSE
     [14:16:47.724] if (inherits(cond, "message")) {
     [14:16:47.724] invokeRestart("muffleMessage")
     [14:16:47.724] muffled <- TRUE
     [14:16:47.724] }
     [14:16:47.724] else if (inherits(cond, "warning")) {
     [14:16:47.724] invokeRestart("muffleWarning")
     [14:16:47.724] muffled <- TRUE
     [14:16:47.724] }
     [14:16:47.724] else if (inherits(cond, "condition")) {
     [14:16:47.724] computeRestarts <- base::computeRestarts
     [14:16:47.724] grepl <- base::grepl
     [14:16:47.724] is.null <- base::is.null
     [14:16:47.724] restarts <- computeRestarts(cond)
     [14:16:47.724] for (restart in restarts) {
     [14:16:47.724] name <- restart$name
     [14:16:47.724] if (is.null(name))
     [14:16:47.724] next
     [14:16:47.724] if (!grepl("^muffle", name))
     [14:16:47.724] next
     [14:16:47.724] invokeRestart(restart)
     [14:16:47.724] muffled <- TRUE
     [14:16:47.724] break
     [14:16:47.724] }
     [14:16:47.724] }
     [14:16:47.724] invisible(muffled)
     [14:16:47.724] }
     [14:16:47.724] muffleCondition(cond)
     [14:16:47.724] }
     [14:16:47.724] }
     [14:16:47.724] }
     [14:16:47.724] }))
     [14:16:47.724] }, error = function(ex) {
     [14:16:47.724] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:47.724] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.724] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:47.724] }, finally = {
     [14:16:47.724] {
     [14:16:47.724] NULL
     [14:16:47.724] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:47.724] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:47.724] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:47.724] label = NULL, ...)
     [14:16:47.724] {
     [14:16:47.724] if (substitute)
     [14:16:47.724] expr <- substitute(expr)
     [14:16:47.724] local <- as.logical(local)
     [14:16:47.724] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:47.724] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:47.724] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:47.724] label = label, ...)
     [14:16:47.724] if (!future$lazy)
     [14:16:47.724] future <- run(future)
     [14:16:47.724] invisible(future)
     [14:16:47.724] }), .cleanup = FALSE, .init = FALSE)
     [14:16:47.724] }
     [14:16:47.724] base::options(...future.oldOptions)
     [14:16:47.724] })
     [14:16:47.724] Sys.time
     [14:16:47.724] if (base::is.na(TRUE)) {
     [14:16:47.724] }
     [14:16:47.724] else {
     [14:16:47.724] base::sink(type = "output", split = FALSE)
     [14:16:47.724] if (TRUE) {
     [14:16:47.724] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:47.724] }
     [14:16:47.724] else {
     [14:16:47.724] ...future.result["stdout"] <- base::list(NULL)
     [14:16:47.724] }
     [14:16:47.724] base::close(...future.stdout)
     [14:16:47.724] ...future.stdout <- NULL
     [14:16:47.724] }
     [14:16:47.724] ...future.result$conditions <- ...future.conditions
     [14:16:47.724] ...future.result
     [14:16:47.724] }
     [14:16:47.729] plan(): Setting new future strategy stack:
     [14:16:47.729] List of future strategies:
     [14:16:47.729] 1. sequential:
     [14:16:47.729] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.729] - tweaked: FALSE
     [14:16:47.729] - call: NULL
     [14:16:47.730] plan(): nbrOfWorkers() = 1
     [14:16:47.733] plan(): Setting new future strategy stack:
     [14:16:47.733] List of future strategies:
     [14:16:47.733] 1. sequential:
     [14:16:47.733] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.733] - tweaked: FALSE
     [14:16:47.733] - call: plan(strategy)
     [14:16:47.734] plan(): nbrOfWorkers() = 1
     [14:16:47.735] SequentialFuture started (and completed)
    
     Call:
     lm(formula = weight ~ group - 1)
    
     Coefficients:
     groupCtl groupTrt
     5.032 4.661
    
     [14:16:47.740] getGlobalsAndPackages() ...
     [14:16:47.740] Searching for globals...
     [14:16:47.743] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
     [14:16:47.744] Searching for globals ... DONE
     [14:16:47.744] Resolving globals: FALSE
     [14:16:47.746] The total size of the 2 globals is 896 bytes (896 bytes)
     [14:16:47.746] - globals: [2] 'weight', 'group'
     [14:16:47.747] - packages: [1] 'stats'
     [14:16:47.747] getGlobalsAndPackages() ... DONE
     [14:16:47.752] Packages needed by the future expression (n = 0): <none>
     [14:16:47.753] Packages needed by future strategies (n = 0): <none>
     [14:16:47.758] {
     [14:16:47.758] {
     [14:16:47.758] ...future.startTime <- base::Sys.time()
     [14:16:47.758] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:47.758] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:47.758] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:47.758] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:47.758] future.resolve.recursive = NULL, width = 80L)
     [14:16:47.758] {
     [14:16:47.758] {
     [14:16:47.758] has_future <- base::requireNamespace("future",
     [14:16:47.758] quietly = TRUE)
     [14:16:47.758] version <- if (has_future)
     [14:16:47.758] utils::packageVersion("future")
     [14:16:47.758] else NULL
     [14:16:47.758] if (!has_future || version < "1.8.0") {
     [14:16:47.758] info <- base::c(r_version = base::gsub("R version ",
     [14:16:47.758] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:47.758] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:47.758] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:47.758] "release", "version")], collapse = " "),
     [14:16:47.758] hostname = base::Sys.info()[["nodename"]])
     [14:16:47.758] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:47.758] info)
     [14:16:47.758] info <- base::paste(info, collapse = "; ")
     [14:16:47.758] if (!has_future) {
     [14:16:47.758] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:47.758] info)
     [14:16:47.758] }
     [14:16:47.758] else {
     [14:16:47.758] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:47.758] info, version)
     [14:16:47.758] }
     [14:16:47.758] base::stop(msg)
     [14:16:47.758] }
     [14:16:47.758] }
     [14:16:47.758] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:47.758] }
     [14:16:47.758] }
     [14:16:47.758] if (base::is.na(TRUE)) {
     [14:16:47.758] }
     [14:16:47.758] else {
     [14:16:47.758] if (TRUE) {
     [14:16:47.758] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:47.758] open = "w")
     [14:16:47.758] }
     [14:16:47.758] else {
     [14:16:47.758] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:47.758] windows = "NUL", "/dev/null"), open = "w")
     [14:16:47.758] }
     [14:16:47.758] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:47.758] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:47.758] base::sink(type = "output", split = FALSE)
     [14:16:47.758] base::close(...future.stdout)
     [14:16:47.758] }, add = TRUE)
     [14:16:47.758] }
     [14:16:47.758] ...future.frame <- base::sys.nframe()
     [14:16:47.758] ...future.conditions <- base::list()
     [14:16:47.758] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:47.758] ...future.result <- base::tryCatch({
     [14:16:47.758] base::withCallingHandlers({
     [14:16:47.758] ...future.value <- base::withVisible(base::local({
     [14:16:47.758] lm(weight ~ group - 1)
     [14:16:47.758] }))
     [14:16:47.758] future::FutureResult(value = ...future.value$value,
     [14:16:47.758] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.758] ...future.rng), started = ...future.startTime,
     [14:16:47.758] version = "1.8")
     [14:16:47.758] }, condition = base::local({
     [14:16:47.758] c <- base::c
     [14:16:47.758] inherits <- base::inherits
     [14:16:47.758] invokeRestart <- base::invokeRestart
     [14:16:47.758] length <- base::length
     [14:16:47.758] list <- base::list
     [14:16:47.758] seq.int <- base::seq.int
     [14:16:47.758] signalCondition <- base::signalCondition
     [14:16:47.758] sys.calls <- base::sys.calls
     [14:16:47.758] Sys.time <- base::Sys.time
     [14:16:47.758] `[[` <- base::`[[`
     [14:16:47.758] `+` <- base::`+`
     [14:16:47.758] `<<-` <- base::`<<-`
     [14:16:47.758] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:47.758] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:47.758] 3L)]
     [14:16:47.758] }
     [14:16:47.758] function(cond) {
     [14:16:47.758] if (inherits(cond, "error")) {
     [14:16:47.758] ...future.conditions[[length(...future.conditions) +
     [14:16:47.758] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:47.758] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:47.758] signalCondition(cond)
     [14:16:47.758] }
     [14:16:47.758] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:47.758] ))) {
     [14:16:47.758] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:47.758] ...future.conditions[[length(...future.conditions) +
     [14:16:47.758] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:47.758] if (!signal) {
     [14:16:47.758] muffleCondition <- function (cond)
     [14:16:47.758] {
     [14:16:47.758] inherits <- base::inherits
     [14:16:47.758] invokeRestart <- base::invokeRestart
     [14:16:47.758] muffled <- FALSE
     [14:16:47.758] if (inherits(cond, "message")) {
     [14:16:47.758] invokeRestart("muffleMessage")
     [14:16:47.758] muffled <- TRUE
     [14:16:47.758] }
     [14:16:47.758] else if (inherits(cond, "warning")) {
     [14:16:47.758] invokeRestart("muffleWarning")
     [14:16:47.758] muffled <- TRUE
     [14:16:47.758] }
     [14:16:47.758] else if (inherits(cond, "condition")) {
     [14:16:47.758] computeRestarts <- base::computeRestarts
     [14:16:47.758] grepl <- base::grepl
     [14:16:47.758] is.null <- base::is.null
     [14:16:47.758] restarts <- computeRestarts(cond)
     [14:16:47.758] for (restart in restarts) {
     [14:16:47.758] name <- restart$name
     [14:16:47.758] if (is.null(name))
     [14:16:47.758] next
     [14:16:47.758] if (!grepl("^muffle", name))
     [14:16:47.758] next
     [14:16:47.758] invokeRestart(restart)
     [14:16:47.758] muffled <- TRUE
     [14:16:47.758] break
     [14:16:47.758] }
     [14:16:47.758] }
     [14:16:47.758] invisible(muffled)
     [14:16:47.758] }
     [14:16:47.758] muffleCondition(cond)
     [14:16:47.758] }
     [14:16:47.758] }
     [14:16:47.758] }
     [14:16:47.758] }))
     [14:16:47.758] }, error = function(ex) {
     [14:16:47.758] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:47.758] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.758] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:47.758] }, finally = {
     [14:16:47.758] {
     [14:16:47.758] NULL
     [14:16:47.758] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:47.758] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:47.758] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:47.758] label = NULL, ...)
     [14:16:47.758] {
     [14:16:47.758] if (substitute)
     [14:16:47.758] expr <- substitute(expr)
     [14:16:47.758] local <- as.logical(local)
     [14:16:47.758] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:47.758] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:47.758] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:47.758] label = label, ...)
     [14:16:47.758] if (!future$lazy)
     [14:16:47.758] future <- run(future)
     [14:16:47.758] invisible(future)
     [14:16:47.758] }), .cleanup = FALSE, .init = FALSE)
     [14:16:47.758] }
     [14:16:47.758] base::options(...future.oldOptions)
     [14:16:47.758] })
     [14:16:47.758] Sys.time
     [14:16:47.758] if (base::is.na(TRUE)) {
     [14:16:47.758] }
     [14:16:47.758] else {
     [14:16:47.758] base::sink(type = "output", split = FALSE)
     [14:16:47.758] if (TRUE) {
     [14:16:47.758] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:47.758] }
     [14:16:47.758] else {
     [14:16:47.758] ...future.result["stdout"] <- base::list(NULL)
     [14:16:47.758] }
     [14:16:47.758] base::close(...future.stdout)
     [14:16:47.758] ...future.stdout <- NULL
     [14:16:47.758] }
     [14:16:47.758] ...future.result$conditions <- ...future.conditions
     [14:16:47.758] ...future.result
     [14:16:47.758] }
     [14:16:47.763] plan(): Setting new future strategy stack:
     [14:16:47.763] List of future strategies:
     [14:16:47.763] 1. sequential:
     [14:16:47.763] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.763] - tweaked: FALSE
     [14:16:47.763] - call: NULL
     [14:16:47.764] plan(): nbrOfWorkers() = 1
     [14:16:47.768] plan(): Setting new future strategy stack:
     [14:16:47.768] List of future strategies:
     [14:16:47.768] 1. sequential:
     [14:16:47.768] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.768] - tweaked: FALSE
     [14:16:47.768] - call: plan(strategy)
     [14:16:47.769] plan(): nbrOfWorkers() = 1
     [14:16:47.770] SequentialFuture started (and completed)
    
     Call:
     lm(formula = weight ~ group - 1)
    
     Coefficients:
     groupCtl groupTrt
     5.032 4.661
    
     [14:16:47.775] getGlobalsAndPackages() ...
     [14:16:47.776] Searching for globals...
     [14:16:47.779] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
     [14:16:47.780] Searching for globals ... DONE
     [14:16:47.780] Resolving globals: FALSE
     [14:16:47.781] The total size of the 2 globals is 896 bytes (896 bytes)
     [14:16:47.782] - globals: [2] 'weight', 'group'
     [14:16:47.782] - packages: [1] 'stats'
     [14:16:47.783] getGlobalsAndPackages() ... DONE
     [14:16:47.785] Packages needed by the future expression (n = 1): 'stats'
     [14:16:47.786] Packages needed by future strategies (n = 0): <none>
     [14:16:47.791] {
     [14:16:47.791] {
     [14:16:47.791] ...future.startTime <- base::Sys.time()
     [14:16:47.791] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:47.791] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:47.791] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:47.791] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:47.791] future.resolve.recursive = NULL, width = 80L)
     [14:16:47.791] {
     [14:16:47.791] {
     [14:16:47.791] {
     [14:16:47.791] has_future <- base::requireNamespace("future",
     [14:16:47.791] quietly = TRUE)
     [14:16:47.791] version <- if (has_future)
     [14:16:47.791] utils::packageVersion("future")
     [14:16:47.791] else NULL
     [14:16:47.791] if (!has_future || version < "1.8.0") {
     [14:16:47.791] info <- base::c(r_version = base::gsub("R version ",
     [14:16:47.791] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:47.791] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:47.791] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:47.791] "release", "version")], collapse = " "),
     [14:16:47.791] hostname = base::Sys.info()[["nodename"]])
     [14:16:47.791] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:47.791] info)
     [14:16:47.791] info <- base::paste(info, collapse = "; ")
     [14:16:47.791] if (!has_future) {
     [14:16:47.791] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:47.791] info)
     [14:16:47.791] }
     [14:16:47.791] else {
     [14:16:47.791] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:47.791] info, version)
     [14:16:47.791] }
     [14:16:47.791] base::stop(msg)
     [14:16:47.791] }
     [14:16:47.791] }
     [14:16:47.791] base::local({
     [14:16:47.791] for (pkg in "stats") {
     [14:16:47.791] base::loadNamespace(pkg)
     [14:16:47.791] base::library(pkg, character.only = TRUE)
     [14:16:47.791] }
     [14:16:47.791] })
     [14:16:47.791] }
     [14:16:47.791] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:47.791] }
     [14:16:47.791] }
     [14:16:47.791] if (base::is.na(TRUE)) {
     [14:16:47.791] }
     [14:16:47.791] else {
     [14:16:47.791] if (TRUE) {
     [14:16:47.791] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:47.791] open = "w")
     [14:16:47.791] }
     [14:16:47.791] else {
     [14:16:47.791] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:47.791] windows = "NUL", "/dev/null"), open = "w")
     [14:16:47.791] }
     [14:16:47.791] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:47.791] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:47.791] base::sink(type = "output", split = FALSE)
     [14:16:47.791] base::close(...future.stdout)
     [14:16:47.791] }, add = TRUE)
     [14:16:47.791] }
     [14:16:47.791] ...future.frame <- base::sys.nframe()
     [14:16:47.791] ...future.conditions <- base::list()
     [14:16:47.791] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:47.791] ...future.result <- base::tryCatch({
     [14:16:47.791] base::withCallingHandlers({
     [14:16:47.791] ...future.value <- base::withVisible(base::local({
     [14:16:47.791] lm(weight ~ group - 1)
     [14:16:47.791] }))
     [14:16:47.791] future::FutureResult(value = ...future.value$value,
     [14:16:47.791] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.791] ...future.rng), started = ...future.startTime,
     [14:16:47.791] version = "1.8")
     [14:16:47.791] }, condition = base::local({
     [14:16:47.791] c <- base::c
     [14:16:47.791] inherits <- base::inherits
     [14:16:47.791] invokeRestart <- base::invokeRestart
     [14:16:47.791] length <- base::length
     [14:16:47.791] list <- base::list
     [14:16:47.791] seq.int <- base::seq.int
     [14:16:47.791] signalCondition <- base::signalCondition
     [14:16:47.791] sys.calls <- base::sys.calls
     [14:16:47.791] Sys.time <- base::Sys.time
     [14:16:47.791] `[[` <- base::`[[`
     [14:16:47.791] `+` <- base::`+`
     [14:16:47.791] `<<-` <- base::`<<-`
     [14:16:47.791] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:47.791] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:47.791] 3L)]
     [14:16:47.791] }
     [14:16:47.791] function(cond) {
     [14:16:47.791] if (inherits(cond, "error")) {
     [14:16:47.791] ...future.conditions[[length(...future.conditions) +
     [14:16:47.791] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:47.791] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:47.791] signalCondition(cond)
     [14:16:47.791] }
     [14:16:47.791] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:47.791] ))) {
     [14:16:47.791] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:47.791] ...future.conditions[[length(...future.conditions) +
     [14:16:47.791] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:47.791] if (!signal) {
     [14:16:47.791] muffleCondition <- function (cond)
     [14:16:47.791] {
     [14:16:47.791] inherits <- base::inherits
     [14:16:47.791] invokeRestart <- base::invokeRestart
     [14:16:47.791] muffled <- FALSE
     [14:16:47.791] if (inherits(cond, "message")) {
     [14:16:47.791] invokeRestart("muffleMessage")
     [14:16:47.791] muffled <- TRUE
     [14:16:47.791] }
     [14:16:47.791] else if (inherits(cond, "warning")) {
     [14:16:47.791] invokeRestart("muffleWarning")
     [14:16:47.791] muffled <- TRUE
     [14:16:47.791] }
     [14:16:47.791] else if (inherits(cond, "condition")) {
     [14:16:47.791] computeRestarts <- base::computeRestarts
     [14:16:47.791] grepl <- base::grepl
     [14:16:47.791] is.null <- base::is.null
     [14:16:47.791] restarts <- computeRestarts(cond)
     [14:16:47.791] for (restart in restarts) {
     [14:16:47.791] name <- restart$name
     [14:16:47.791] if (is.null(name))
     [14:16:47.791] next
     [14:16:47.791] if (!grepl("^muffle", name))
     [14:16:47.791] next
     [14:16:47.791] invokeRestart(restart)
     [14:16:47.791] muffled <- TRUE
     [14:16:47.791] break
     [14:16:47.791] }
     [14:16:47.791] }
     [14:16:47.791] invisible(muffled)
     [14:16:47.791] }
     [14:16:47.791] muffleCondition(cond)
     [14:16:47.791] }
     [14:16:47.791] }
     [14:16:47.791] }
     [14:16:47.791] }))
     [14:16:47.791] }, error = function(ex) {
     [14:16:47.791] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:47.791] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.791] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:47.791] }, finally = {
     [14:16:47.791] {
     [14:16:47.791] NULL
     [14:16:47.791] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:47.791] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:47.791] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:47.791] label = NULL, ...)
     [14:16:47.791] {
     [14:16:47.791] if (substitute)
     [14:16:47.791] expr <- substitute(expr)
     [14:16:47.791] local <- as.logical(local)
     [14:16:47.791] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:47.791] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:47.791] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:47.791] label = label, ...)
     [14:16:47.791] if (!future$lazy)
     [14:16:47.791] future <- run(future)
     [14:16:47.791] invisible(future)
     [14:16:47.791] }), .cleanup = FALSE, .init = FALSE)
     [14:16:47.791] }
     [14:16:47.791] base::options(...future.oldOptions)
     [14:16:47.791] })
     [14:16:47.791] Sys.time
     [14:16:47.791] if (base::is.na(TRUE)) {
     [14:16:47.791] }
     [14:16:47.791] else {
     [14:16:47.791] base::sink(type = "output", split = FALSE)
     [14:16:47.791] if (TRUE) {
     [14:16:47.791] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:47.791] }
     [14:16:47.791] else {
     [14:16:47.791] ...future.result["stdout"] <- base::list(NULL)
     [14:16:47.791] }
     [14:16:47.791] base::close(...future.stdout)
     [14:16:47.791] ...future.stdout <- NULL
     [14:16:47.791] }
     [14:16:47.791] ...future.result$conditions <- ...future.conditions
     [14:16:47.791] ...future.result
     [14:16:47.791] }
     [14:16:47.797] plan(): Setting new future strategy stack:
     [14:16:47.797] List of future strategies:
     [14:16:47.797] 1. sequential:
     [14:16:47.797] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.797] - tweaked: FALSE
     [14:16:47.797] - call: NULL
     [14:16:47.798] plan(): nbrOfWorkers() = 1
     [14:16:47.801] plan(): Setting new future strategy stack:
     [14:16:47.801] List of future strategies:
     [14:16:47.801] 1. sequential:
     [14:16:47.801] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.801] - tweaked: FALSE
     [14:16:47.801] - call: plan(strategy)
     [14:16:47.802] plan(): nbrOfWorkers() = 1
     [14:16:47.803] SequentialFuture started (and completed)
    
     Call:
     lm(formula = weight ~ group - 1)
    
     Coefficients:
     groupCtl groupTrt
     5.032 4.661
    
     - Globals - one-side formulas, e.g. xtabs(~ x) ...
     [14:16:47.808] getGlobalsAndPackages() ...
     [14:16:47.808] Searching for globals...
     [14:16:47.811] - globals found: [4] '{', 'xtabs', 'x', '~'
     [14:16:47.811] Searching for globals ... DONE
     [14:16:47.811] Resolving globals: FALSE
     [14:16:47.812] The total size of the 1 globals is 96 bytes (96 bytes)
     [14:16:47.813] - globals: [1] 'x'
     [14:16:47.813] - packages: [1] 'stats'
     [14:16:47.813] getGlobalsAndPackages() ... DONE
     [14:16:47.816] Packages needed by the future expression (n = 0): <none>
     [14:16:47.816] Packages needed by future strategies (n = 0): <none>
     [14:16:47.824] {
     [14:16:47.824] {
     [14:16:47.824] ...future.startTime <- base::Sys.time()
     [14:16:47.824] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:47.824] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:47.824] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:47.824] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:47.824] future.resolve.recursive = NULL, width = 80L)
     [14:16:47.824] {
     [14:16:47.824] {
     [14:16:47.824] has_future <- base::requireNamespace("future",
     [14:16:47.824] quietly = TRUE)
     [14:16:47.824] version <- if (has_future)
     [14:16:47.824] utils::packageVersion("future")
     [14:16:47.824] else NULL
     [14:16:47.824] if (!has_future || version < "1.8.0") {
     [14:16:47.824] info <- base::c(r_version = base::gsub("R version ",
     [14:16:47.824] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:47.824] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:47.824] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:47.824] "release", "version")], collapse = " "),
     [14:16:47.824] hostname = base::Sys.info()[["nodename"]])
     [14:16:47.824] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:47.824] info)
     [14:16:47.824] info <- base::paste(info, collapse = "; ")
     [14:16:47.824] if (!has_future) {
     [14:16:47.824] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:47.824] info)
     [14:16:47.824] }
     [14:16:47.824] else {
     [14:16:47.824] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:47.824] info, version)
     [14:16:47.824] }
     [14:16:47.824] base::stop(msg)
     [14:16:47.824] }
     [14:16:47.824] }
     [14:16:47.824] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:47.824] }
     [14:16:47.824] }
     [14:16:47.824] if (base::is.na(TRUE)) {
     [14:16:47.824] }
     [14:16:47.824] else {
     [14:16:47.824] if (TRUE) {
     [14:16:47.824] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:47.824] open = "w")
     [14:16:47.824] }
     [14:16:47.824] else {
     [14:16:47.824] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:47.824] windows = "NUL", "/dev/null"), open = "w")
     [14:16:47.824] }
     [14:16:47.824] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:47.824] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:47.824] base::sink(type = "output", split = FALSE)
     [14:16:47.824] base::close(...future.stdout)
     [14:16:47.824] }, add = TRUE)
     [14:16:47.824] }
     [14:16:47.824] ...future.frame <- base::sys.nframe()
     [14:16:47.824] ...future.conditions <- base::list()
     [14:16:47.824] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:47.824] ...future.result <- base::tryCatch({
     [14:16:47.824] base::withCallingHandlers({
     [14:16:47.824] ...future.value <- base::withVisible(base::local({
     [14:16:47.824] xtabs(~x)
     [14:16:47.824] }))
     [14:16:47.824] future::FutureResult(value = ...future.value$value,
     [14:16:47.824] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.824] ...future.rng), started = ...future.startTime,
     [14:16:47.824] version = "1.8")
     [14:16:47.824] }, condition = base::local({
     [14:16:47.824] c <- base::c
     [14:16:47.824] inherits <- base::inherits
     [14:16:47.824] invokeRestart <- base::invokeRestart
     [14:16:47.824] length <- base::length
     [14:16:47.824] list <- base::list
     [14:16:47.824] seq.int <- base::seq.int
     [14:16:47.824] signalCondition <- base::signalCondition
     [14:16:47.824] sys.calls <- base::sys.calls
     [14:16:47.824] Sys.time <- base::Sys.time
     [14:16:47.824] `[[` <- base::`[[`
     [14:16:47.824] `+` <- base::`+`
     [14:16:47.824] `<<-` <- base::`<<-`
     [14:16:47.824] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:47.824] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:47.824] 3L)]
     [14:16:47.824] }
     [14:16:47.824] function(cond) {
     [14:16:47.824] if (inherits(cond, "error")) {
     [14:16:47.824] ...future.conditions[[length(...future.conditions) +
     [14:16:47.824] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:47.824] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:47.824] signalCondition(cond)
     [14:16:47.824] }
     [14:16:47.824] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:47.824] ))) {
     [14:16:47.824] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:47.824] ...future.conditions[[length(...future.conditions) +
     [14:16:47.824] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:47.824] if (!signal) {
     [14:16:47.824] muffleCondition <- function (cond)
     [14:16:47.824] {
     [14:16:47.824] inherits <- base::inherits
     [14:16:47.824] invokeRestart <- base::invokeRestart
     [14:16:47.824] muffled <- FALSE
     [14:16:47.824] if (inherits(cond, "message")) {
     [14:16:47.824] invokeRestart("muffleMessage")
     [14:16:47.824] muffled <- TRUE
     [14:16:47.824] }
     [14:16:47.824] else if (inherits(cond, "warning")) {
     [14:16:47.824] invokeRestart("muffleWarning")
     [14:16:47.824] muffled <- TRUE
     [14:16:47.824] }
     [14:16:47.824] else if (inherits(cond, "condition")) {
     [14:16:47.824] computeRestarts <- base::computeRestarts
     [14:16:47.824] grepl <- base::grepl
     [14:16:47.824] is.null <- base::is.null
     [14:16:47.824] restarts <- computeRestarts(cond)
     [14:16:47.824] for (restart in restarts) {
     [14:16:47.824] name <- restart$name
     [14:16:47.824] if (is.null(name))
     [14:16:47.824] next
     [14:16:47.824] if (!grepl("^muffle", name))
     [14:16:47.824] next
     [14:16:47.824] invokeRestart(restart)
     [14:16:47.824] muffled <- TRUE
     [14:16:47.824] break
     [14:16:47.824] }
     [14:16:47.824] }
     [14:16:47.824] invisible(muffled)
     [14:16:47.824] }
     [14:16:47.824] muffleCondition(cond)
     [14:16:47.824] }
     [14:16:47.824] }
     [14:16:47.824] }
     [14:16:47.824] }))
     [14:16:47.824] }, error = function(ex) {
     [14:16:47.824] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:47.824] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.824] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:47.824] }, finally = {
     [14:16:47.824] {
     [14:16:47.824] NULL
     [14:16:47.824] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:47.824] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:47.824] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:47.824] label = NULL, ...)
     [14:16:47.824] {
     [14:16:47.824] if (substitute)
     [14:16:47.824] expr <- substitute(expr)
     [14:16:47.824] local <- as.logical(local)
     [14:16:47.824] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:47.824] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:47.824] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:47.824] label = label, ...)
     [14:16:47.824] if (!future$lazy)
     [14:16:47.824] future <- run(future)
     [14:16:47.824] invisible(future)
     [14:16:47.824] }), .cleanup = FALSE, .init = FALSE)
     [14:16:47.824] }
     [14:16:47.824] base::options(...future.oldOptions)
     [14:16:47.824] })
     [14:16:47.824] Sys.time
     [14:16:47.824] if (base::is.na(TRUE)) {
     [14:16:47.824] }
     [14:16:47.824] else {
     [14:16:47.824] base::sink(type = "output", split = FALSE)
     [14:16:47.824] if (TRUE) {
     [14:16:47.824] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:47.824] }
     [14:16:47.824] else {
     [14:16:47.824] ...future.result["stdout"] <- base::list(NULL)
     [14:16:47.824] }
     [14:16:47.824] base::close(...future.stdout)
     [14:16:47.824] ...future.stdout <- NULL
     [14:16:47.824] }
     [14:16:47.824] ...future.result$conditions <- ...future.conditions
     [14:16:47.824] ...future.result
     [14:16:47.824] }
     [14:16:47.829] plan(): Setting new future strategy stack:
     [14:16:47.830] List of future strategies:
     [14:16:47.830] 1. sequential:
     [14:16:47.830] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.830] - tweaked: FALSE
     [14:16:47.830] - call: NULL
     [14:16:47.831] plan(): nbrOfWorkers() = 1
     [14:16:47.833] plan(): Setting new future strategy stack:
     [14:16:47.833] List of future strategies:
     [14:16:47.833] 1. sequential:
     [14:16:47.833] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.833] - tweaked: FALSE
     [14:16:47.833] - call: plan(strategy)
     [14:16:47.834] plan(): nbrOfWorkers() = 1
     [14:16:47.835] SequentialFuture started (and completed)
     x
     1 2
     2 3
     [14:16:47.837] getGlobalsAndPackages() ...
     [14:16:47.837] Searching for globals...
     [14:16:47.840] - globals found: [4] '{', 'xtabs', 'x', '~'
     [14:16:47.840] Searching for globals ... DONE
     [14:16:47.841] Resolving globals: FALSE
     [14:16:47.842] The total size of the 1 globals is 96 bytes (96 bytes)
     [14:16:47.842] - globals: [1] 'x'
     [14:16:47.843] - packages: [1] 'stats'
     [14:16:47.843] getGlobalsAndPackages() ... DONE
     [14:16:47.845] Packages needed by the future expression (n = 0): <none>
     [14:16:47.845] Packages needed by future strategies (n = 0): <none>
     [14:16:47.851] {
     [14:16:47.851] {
     [14:16:47.851] ...future.startTime <- base::Sys.time()
     [14:16:47.851] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:47.851] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:47.851] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:47.851] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:47.851] future.resolve.recursive = NULL, width = 80L)
     [14:16:47.851] {
     [14:16:47.851] {
     [14:16:47.851] has_future <- base::requireNamespace("future",
     [14:16:47.851] quietly = TRUE)
     [14:16:47.851] version <- if (has_future)
     [14:16:47.851] utils::packageVersion("future")
     [14:16:47.851] else NULL
     [14:16:47.851] if (!has_future || version < "1.8.0") {
     [14:16:47.851] info <- base::c(r_version = base::gsub("R version ",
     [14:16:47.851] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:47.851] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:47.851] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:47.851] "release", "version")], collapse = " "),
     [14:16:47.851] hostname = base::Sys.info()[["nodename"]])
     [14:16:47.851] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:47.851] info)
     [14:16:47.851] info <- base::paste(info, collapse = "; ")
     [14:16:47.851] if (!has_future) {
     [14:16:47.851] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:47.851] info)
     [14:16:47.851] }
     [14:16:47.851] else {
     [14:16:47.851] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:47.851] info, version)
     [14:16:47.851] }
     [14:16:47.851] base::stop(msg)
     [14:16:47.851] }
     [14:16:47.851] }
     [14:16:47.851] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:47.851] }
     [14:16:47.851] }
     [14:16:47.851] if (base::is.na(TRUE)) {
     [14:16:47.851] }
     [14:16:47.851] else {
     [14:16:47.851] if (TRUE) {
     [14:16:47.851] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:47.851] open = "w")
     [14:16:47.851] }
     [14:16:47.851] else {
     [14:16:47.851] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:47.851] windows = "NUL", "/dev/null"), open = "w")
     [14:16:47.851] }
     [14:16:47.851] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:47.851] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:47.851] base::sink(type = "output", split = FALSE)
     [14:16:47.851] base::close(...future.stdout)
     [14:16:47.851] }, add = TRUE)
     [14:16:47.851] }
     [14:16:47.851] ...future.frame <- base::sys.nframe()
     [14:16:47.851] ...future.conditions <- base::list()
     [14:16:47.851] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:47.851] ...future.result <- base::tryCatch({
     [14:16:47.851] base::withCallingHandlers({
     [14:16:47.851] ...future.value <- base::withVisible(base::local({
     [14:16:47.851] xtabs(~x)
     [14:16:47.851] }))
     [14:16:47.851] future::FutureResult(value = ...future.value$value,
     [14:16:47.851] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.851] ...future.rng), started = ...future.startTime,
     [14:16:47.851] version = "1.8")
     [14:16:47.851] }, condition = base::local({
     [14:16:47.851] c <- base::c
     [14:16:47.851] inherits <- base::inherits
     [14:16:47.851] invokeRestart <- base::invokeRestart
     [14:16:47.851] length <- base::length
     [14:16:47.851] list <- base::list
     [14:16:47.851] seq.int <- base::seq.int
     [14:16:47.851] signalCondition <- base::signalCondition
     [14:16:47.851] sys.calls <- base::sys.calls
     [14:16:47.851] Sys.time <- base::Sys.time
     [14:16:47.851] `[[` <- base::`[[`
     [14:16:47.851] `+` <- base::`+`
     [14:16:47.851] `<<-` <- base::`<<-`
     [14:16:47.851] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:47.851] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:47.851] 3L)]
     [14:16:47.851] }
     [14:16:47.851] function(cond) {
     [14:16:47.851] if (inherits(cond, "error")) {
     [14:16:47.851] ...future.conditions[[length(...future.conditions) +
     [14:16:47.851] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:47.851] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:47.851] signalCondition(cond)
     [14:16:47.851] }
     [14:16:47.851] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:47.851] ))) {
     [14:16:47.851] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:47.851] ...future.conditions[[length(...future.conditions) +
     [14:16:47.851] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:47.851] if (!signal) {
     [14:16:47.851] muffleCondition <- function (cond)
     [14:16:47.851] {
     [14:16:47.851] inherits <- base::inherits
     [14:16:47.851] invokeRestart <- base::invokeRestart
     [14:16:47.851] muffled <- FALSE
     [14:16:47.851] if (inherits(cond, "message")) {
     [14:16:47.851] invokeRestart("muffleMessage")
     [14:16:47.851] muffled <- TRUE
     [14:16:47.851] }
     [14:16:47.851] else if (inherits(cond, "warning")) {
     [14:16:47.851] invokeRestart("muffleWarning")
     [14:16:47.851] muffled <- TRUE
     [14:16:47.851] }
     [14:16:47.851] else if (inherits(cond, "condition")) {
     [14:16:47.851] computeRestarts <- base::computeRestarts
     [14:16:47.851] grepl <- base::grepl
     [14:16:47.851] is.null <- base::is.null
     [14:16:47.851] restarts <- computeRestarts(cond)
     [14:16:47.851] for (restart in restarts) {
     [14:16:47.851] name <- restart$name
     [14:16:47.851] if (is.null(name))
     [14:16:47.851] next
     [14:16:47.851] if (!grepl("^muffle", name))
     [14:16:47.851] next
     [14:16:47.851] invokeRestart(restart)
     [14:16:47.851] muffled <- TRUE
     [14:16:47.851] break
     [14:16:47.851] }
     [14:16:47.851] }
     [14:16:47.851] invisible(muffled)
     [14:16:47.851] }
     [14:16:47.851] muffleCondition(cond)
     [14:16:47.851] }
     [14:16:47.851] }
     [14:16:47.851] }
     [14:16:47.851] }))
     [14:16:47.851] }, error = function(ex) {
     [14:16:47.851] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:47.851] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.851] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:47.851] }, finally = {
     [14:16:47.851] {
     [14:16:47.851] NULL
     [14:16:47.851] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:47.851] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:47.851] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:47.851] label = NULL, ...)
     [14:16:47.851] {
     [14:16:47.851] if (substitute)
     [14:16:47.851] expr <- substitute(expr)
     [14:16:47.851] local <- as.logical(local)
     [14:16:47.851] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:47.851] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:47.851] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:47.851] label = label, ...)
     [14:16:47.851] if (!future$lazy)
     [14:16:47.851] future <- run(future)
     [14:16:47.851] invisible(future)
     [14:16:47.851] }), .cleanup = FALSE, .init = FALSE)
     [14:16:47.851] }
     [14:16:47.851] base::options(...future.oldOptions)
     [14:16:47.851] })
     [14:16:47.851] Sys.time
     [14:16:47.851] if (base::is.na(TRUE)) {
     [14:16:47.851] }
     [14:16:47.851] else {
     [14:16:47.851] base::sink(type = "output", split = FALSE)
     [14:16:47.851] if (TRUE) {
     [14:16:47.851] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:47.851] }
     [14:16:47.851] else {
     [14:16:47.851] ...future.result["stdout"] <- base::list(NULL)
     [14:16:47.851] }
     [14:16:47.851] base::close(...future.stdout)
     [14:16:47.851] ...future.stdout <- NULL
     [14:16:47.851] }
     [14:16:47.851] ...future.result$conditions <- ...future.conditions
     [14:16:47.851] ...future.result
     [14:16:47.851] }
     [14:16:47.856] plan(): Setting new future strategy stack:
     [14:16:47.856] List of future strategies:
     [14:16:47.856] 1. sequential:
     [14:16:47.856] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.856] - tweaked: FALSE
     [14:16:47.856] - call: NULL
     [14:16:47.857] plan(): nbrOfWorkers() = 1
     [14:16:47.859] plan(): Setting new future strategy stack:
     [14:16:47.860] List of future strategies:
     [14:16:47.860] 1. sequential:
     [14:16:47.860] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.860] - tweaked: FALSE
     [14:16:47.860] - call: plan(strategy)
     [14:16:47.861] plan(): nbrOfWorkers() = 1
     [14:16:47.861] SequentialFuture started (and completed)
     x
     1 2
     2 3
     - Globals - lm(<formula>, data = cars) ...
     - Globals - lm(<formula #1 ('a')>, data = cars) ...
    
     Call:
     lm(formula = dist ~ . - 1, data = cars)
    
     Coefficients:
     speed
     2.909
    
     [14:16:47.866] getGlobalsAndPackages() ...
     [14:16:47.866] Searching for globals...
     [14:16:47.870] - globals found: [7] '{', 'lm', 'dist', '-', '.', '~', 'cars'
     [14:16:47.871] Searching for globals ... DONE
     [14:16:47.871] Resolving globals: FALSE
     [14:16:47.872]
     [14:16:47.873] - packages: [1] 'stats'
     [14:16:47.873] getGlobalsAndPackages() ... DONE
     [14:16:47.875] Packages needed by the future expression (n = 0): <none>
     [14:16:47.875] Packages needed by future strategies (n = 0): <none>
     [14:16:47.881] {
     [14:16:47.881] {
     [14:16:47.881] ...future.startTime <- base::Sys.time()
     [14:16:47.881] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:47.881] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:47.881] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:47.881] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:47.881] future.resolve.recursive = NULL, width = 80L)
     [14:16:47.881] {
     [14:16:47.881] {
     [14:16:47.881] has_future <- base::requireNamespace("future",
     [14:16:47.881] quietly = TRUE)
     [14:16:47.881] version <- if (has_future)
     [14:16:47.881] utils::packageVersion("future")
     [14:16:47.881] else NULL
     [14:16:47.881] if (!has_future || version < "1.8.0") {
     [14:16:47.881] info <- base::c(r_version = base::gsub("R version ",
     [14:16:47.881] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:47.881] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:47.881] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:47.881] "release", "version")], collapse = " "),
     [14:16:47.881] hostname = base::Sys.info()[["nodename"]])
     [14:16:47.881] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:47.881] info)
     [14:16:47.881] info <- base::paste(info, collapse = "; ")
     [14:16:47.881] if (!has_future) {
     [14:16:47.881] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:47.881] info)
     [14:16:47.881] }
     [14:16:47.881] else {
     [14:16:47.881] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:47.881] info, version)
     [14:16:47.881] }
     [14:16:47.881] base::stop(msg)
     [14:16:47.881] }
     [14:16:47.881] }
     [14:16:47.881] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:47.881] }
     [14:16:47.881] }
     [14:16:47.881] if (base::is.na(TRUE)) {
     [14:16:47.881] }
     [14:16:47.881] else {
     [14:16:47.881] if (TRUE) {
     [14:16:47.881] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:47.881] open = "w")
     [14:16:47.881] }
     [14:16:47.881] else {
     [14:16:47.881] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:47.881] windows = "NUL", "/dev/null"), open = "w")
     [14:16:47.881] }
     [14:16:47.881] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:47.881] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:47.881] base::sink(type = "output", split = FALSE)
     [14:16:47.881] base::close(...future.stdout)
     [14:16:47.881] }, add = TRUE)
     [14:16:47.881] }
     [14:16:47.881] ...future.frame <- base::sys.nframe()
     [14:16:47.881] ...future.conditions <- base::list()
     [14:16:47.881] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:47.881] ...future.result <- base::tryCatch({
     [14:16:47.881] base::withCallingHandlers({
     [14:16:47.881] ...future.value <- base::withVisible(base::local({
     [14:16:47.881] lm(dist ~ . - 1, data = cars)
     [14:16:47.881] }))
     [14:16:47.881] future::FutureResult(value = ...future.value$value,
     [14:16:47.881] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.881] ...future.rng), started = ...future.startTime,
     [14:16:47.881] version = "1.8")
     [14:16:47.881] }, condition = base::local({
     [14:16:47.881] c <- base::c
     [14:16:47.881] inherits <- base::inherits
     [14:16:47.881] invokeRestart <- base::invokeRestart
     [14:16:47.881] length <- base::length
     [14:16:47.881] list <- base::list
     [14:16:47.881] seq.int <- base::seq.int
     [14:16:47.881] signalCondition <- base::signalCondition
     [14:16:47.881] sys.calls <- base::sys.calls
     [14:16:47.881] Sys.time <- base::Sys.time
     [14:16:47.881] `[[` <- base::`[[`
     [14:16:47.881] `+` <- base::`+`
     [14:16:47.881] `<<-` <- base::`<<-`
     [14:16:47.881] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:47.881] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:47.881] 3L)]
     [14:16:47.881] }
     [14:16:47.881] function(cond) {
     [14:16:47.881] if (inherits(cond, "error")) {
     [14:16:47.881] ...future.conditions[[length(...future.conditions) +
     [14:16:47.881] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:47.881] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:47.881] signalCondition(cond)
     [14:16:47.881] }
     [14:16:47.881] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:47.881] ))) {
     [14:16:47.881] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:47.881] ...future.conditions[[length(...future.conditions) +
     [14:16:47.881] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:47.881] if (!signal) {
     [14:16:47.881] muffleCondition <- function (cond)
     [14:16:47.881] {
     [14:16:47.881] inherits <- base::inherits
     [14:16:47.881] invokeRestart <- base::invokeRestart
     [14:16:47.881] muffled <- FALSE
     [14:16:47.881] if (inherits(cond, "message")) {
     [14:16:47.881] invokeRestart("muffleMessage")
     [14:16:47.881] muffled <- TRUE
     [14:16:47.881] }
     [14:16:47.881] else if (inherits(cond, "warning")) {
     [14:16:47.881] invokeRestart("muffleWarning")
     [14:16:47.881] muffled <- TRUE
     [14:16:47.881] }
     [14:16:47.881] else if (inherits(cond, "condition")) {
     [14:16:47.881] computeRestarts <- base::computeRestarts
     [14:16:47.881] grepl <- base::grepl
     [14:16:47.881] is.null <- base::is.null
     [14:16:47.881] restarts <- computeRestarts(cond)
     [14:16:47.881] for (restart in restarts) {
     [14:16:47.881] name <- restart$name
     [14:16:47.881] if (is.null(name))
     [14:16:47.881] next
     [14:16:47.881] if (!grepl("^muffle", name))
     [14:16:47.881] next
     [14:16:47.881] invokeRestart(restart)
     [14:16:47.881] muffled <- TRUE
     [14:16:47.881] break
     [14:16:47.881] }
     [14:16:47.881] }
     [14:16:47.881] invisible(muffled)
     [14:16:47.881] }
     [14:16:47.881] muffleCondition(cond)
     [14:16:47.881] }
     [14:16:47.881] }
     [14:16:47.881] }
     [14:16:47.881] }))
     [14:16:47.881] }, error = function(ex) {
     [14:16:47.881] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:47.881] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.881] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:47.881] }, finally = {
     [14:16:47.881] {
     [14:16:47.881] NULL
     [14:16:47.881] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:47.881] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:47.881] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:47.881] label = NULL, ...)
     [14:16:47.881] {
     [14:16:47.881] if (substitute)
     [14:16:47.881] expr <- substitute(expr)
     [14:16:47.881] local <- as.logical(local)
     [14:16:47.881] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:47.881] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:47.881] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:47.881] label = label, ...)
     [14:16:47.881] if (!future$lazy)
     [14:16:47.881] future <- run(future)
     [14:16:47.881] invisible(future)
     [14:16:47.881] }), .cleanup = FALSE, .init = FALSE)
     [14:16:47.881] }
     [14:16:47.881] base::options(...future.oldOptions)
     [14:16:47.881] })
     [14:16:47.881] Sys.time
     [14:16:47.881] if (base::is.na(TRUE)) {
     [14:16:47.881] }
     [14:16:47.881] else {
     [14:16:47.881] base::sink(type = "output", split = FALSE)
     [14:16:47.881] if (TRUE) {
     [14:16:47.881] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:47.881] }
     [14:16:47.881] else {
     [14:16:47.881] ...future.result["stdout"] <- base::list(NULL)
     [14:16:47.881] }
     [14:16:47.881] base::close(...future.stdout)
     [14:16:47.881] ...future.stdout <- NULL
     [14:16:47.881] }
     [14:16:47.881] ...future.result$conditions <- ...future.conditions
     [14:16:47.881] ...future.result
     [14:16:47.881] }
     [14:16:47.886] plan(): Setting new future strategy stack:
     [14:16:47.886] List of future strategies:
     [14:16:47.886] 1. sequential:
     [14:16:47.886] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.886] - tweaked: FALSE
     [14:16:47.886] - call: NULL
     [14:16:47.887] plan(): nbrOfWorkers() = 1
     [14:16:47.890] plan(): Setting new future strategy stack:
     [14:16:47.890] List of future strategies:
     [14:16:47.890] 1. sequential:
     [14:16:47.890] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.890] - tweaked: FALSE
     [14:16:47.890] - call: plan(strategy)
     [14:16:47.891] plan(): nbrOfWorkers() = 1
     [14:16:47.892] SequentialFuture started (and completed)
    
     Call:
     lm(formula = dist ~ . - 1, data = cars)
    
     Coefficients:
     speed
     2.909
    
     - Globals - lm(<formula #2 ('b')>, data = cars) ...
    
     Call:
     lm(formula = dist ~ . + 0, data = cars)
    
     Coefficients:
     speed
     2.909
    
     [14:16:47.902] getGlobalsAndPackages() ...
     [14:16:47.902] Searching for globals...
     [14:16:47.906] - globals found: [7] '{', 'lm', 'dist', '+', '.', '~', 'cars'
     [14:16:47.906] Searching for globals ... DONE
     [14:16:47.907] Resolving globals: FALSE
     [14:16:47.908]
     [14:16:47.908] - packages: [1] 'stats'
     [14:16:47.909] getGlobalsAndPackages() ... DONE
     [14:16:47.911] Packages needed by the future expression (n = 0): <none>
     [14:16:47.911] Packages needed by future strategies (n = 0): <none>
     [14:16:47.916] {
     [14:16:47.916] {
     [14:16:47.916] ...future.startTime <- base::Sys.time()
     [14:16:47.916] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:47.916] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:47.916] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:47.916] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:47.916] future.resolve.recursive = NULL, width = 80L)
     [14:16:47.916] {
     [14:16:47.916] {
     [14:16:47.916] has_future <- base::requireNamespace("future",
     [14:16:47.916] quietly = TRUE)
     [14:16:47.916] version <- if (has_future)
     [14:16:47.916] utils::packageVersion("future")
     [14:16:47.916] else NULL
     [14:16:47.916] if (!has_future || version < "1.8.0") {
     [14:16:47.916] info <- base::c(r_version = base::gsub("R version ",
     [14:16:47.916] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:47.916] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:47.916] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:47.916] "release", "version")], collapse = " "),
     [14:16:47.916] hostname = base::Sys.info()[["nodename"]])
     [14:16:47.916] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:47.916] info)
     [14:16:47.916] info <- base::paste(info, collapse = "; ")
     [14:16:47.916] if (!has_future) {
     [14:16:47.916] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:47.916] info)
     [14:16:47.916] }
     [14:16:47.916] else {
     [14:16:47.916] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:47.916] info, version)
     [14:16:47.916] }
     [14:16:47.916] base::stop(msg)
     [14:16:47.916] }
     [14:16:47.916] }
     [14:16:47.916] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:47.916] }
     [14:16:47.916] }
     [14:16:47.916] if (base::is.na(TRUE)) {
     [14:16:47.916] }
     [14:16:47.916] else {
     [14:16:47.916] if (TRUE) {
     [14:16:47.916] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:47.916] open = "w")
     [14:16:47.916] }
     [14:16:47.916] else {
     [14:16:47.916] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:47.916] windows = "NUL", "/dev/null"), open = "w")
     [14:16:47.916] }
     [14:16:47.916] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:47.916] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:47.916] base::sink(type = "output", split = FALSE)
     [14:16:47.916] base::close(...future.stdout)
     [14:16:47.916] }, add = TRUE)
     [14:16:47.916] }
     [14:16:47.916] ...future.frame <- base::sys.nframe()
     [14:16:47.916] ...future.conditions <- base::list()
     [14:16:47.916] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:47.916] ...future.result <- base::tryCatch({
     [14:16:47.916] base::withCallingHandlers({
     [14:16:47.916] ...future.value <- base::withVisible(base::local({
     [14:16:47.916] lm(dist ~ . + 0, data = cars)
     [14:16:47.916] }))
     [14:16:47.916] future::FutureResult(value = ...future.value$value,
     [14:16:47.916] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.916] ...future.rng), started = ...future.startTime,
     [14:16:47.916] version = "1.8")
     [14:16:47.916] }, condition = base::local({
     [14:16:47.916] c <- base::c
     [14:16:47.916] inherits <- base::inherits
     [14:16:47.916] invokeRestart <- base::invokeRestart
     [14:16:47.916] length <- base::length
     [14:16:47.916] list <- base::list
     [14:16:47.916] seq.int <- base::seq.int
     [14:16:47.916] signalCondition <- base::signalCondition
     [14:16:47.916] sys.calls <- base::sys.calls
     [14:16:47.916] Sys.time <- base::Sys.time
     [14:16:47.916] `[[` <- base::`[[`
     [14:16:47.916] `+` <- base::`+`
     [14:16:47.916] `<<-` <- base::`<<-`
     [14:16:47.916] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:47.916] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:47.916] 3L)]
     [14:16:47.916] }
     [14:16:47.916] function(cond) {
     [14:16:47.916] if (inherits(cond, "error")) {
     [14:16:47.916] ...future.conditions[[length(...future.conditions) +
     [14:16:47.916] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:47.916] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:47.916] signalCondition(cond)
     [14:16:47.916] }
     [14:16:47.916] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:47.916] ))) {
     [14:16:47.916] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:47.916] ...future.conditions[[length(...future.conditions) +
     [14:16:47.916] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:47.916] if (!signal) {
     [14:16:47.916] muffleCondition <- function (cond)
     [14:16:47.916] {
     [14:16:47.916] inherits <- base::inherits
     [14:16:47.916] invokeRestart <- base::invokeRestart
     [14:16:47.916] muffled <- FALSE
     [14:16:47.916] if (inherits(cond, "message")) {
     [14:16:47.916] invokeRestart("muffleMessage")
     [14:16:47.916] muffled <- TRUE
     [14:16:47.916] }
     [14:16:47.916] else if (inherits(cond, "warning")) {
     [14:16:47.916] invokeRestart("muffleWarning")
     [14:16:47.916] muffled <- TRUE
     [14:16:47.916] }
     [14:16:47.916] else if (inherits(cond, "condition")) {
     [14:16:47.916] computeRestarts <- base::computeRestarts
     [14:16:47.916] grepl <- base::grepl
     [14:16:47.916] is.null <- base::is.null
     [14:16:47.916] restarts <- computeRestarts(cond)
     [14:16:47.916] for (restart in restarts) {
     [14:16:47.916] name <- restart$name
     [14:16:47.916] if (is.null(name))
     [14:16:47.916] next
     [14:16:47.916] if (!grepl("^muffle", name))
     [14:16:47.916] next
     [14:16:47.916] invokeRestart(restart)
     [14:16:47.916] muffled <- TRUE
     [14:16:47.916] break
     [14:16:47.916] }
     [14:16:47.916] }
     [14:16:47.916] invisible(muffled)
     [14:16:47.916] }
     [14:16:47.916] muffleCondition(cond)
     [14:16:47.916] }
     [14:16:47.916] }
     [14:16:47.916] }
     [14:16:47.916] }))
     [14:16:47.916] }, error = function(ex) {
     [14:16:47.916] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:47.916] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.916] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:47.916] }, finally = {
     [14:16:47.916] {
     [14:16:47.916] NULL
     [14:16:47.916] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:47.916] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:47.916] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:47.916] label = NULL, ...)
     [14:16:47.916] {
     [14:16:47.916] if (substitute)
     [14:16:47.916] expr <- substitute(expr)
     [14:16:47.916] local <- as.logical(local)
     [14:16:47.916] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:47.916] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:47.916] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:47.916] label = label, ...)
     [14:16:47.916] if (!future$lazy)
     [14:16:47.916] future <- run(future)
     [14:16:47.916] invisible(future)
     [14:16:47.916] }), .cleanup = FALSE, .init = FALSE)
     [14:16:47.916] }
     [14:16:47.916] base::options(...future.oldOptions)
     [14:16:47.916] })
     [14:16:47.916] Sys.time
     [14:16:47.916] if (base::is.na(TRUE)) {
     [14:16:47.916] }
     [14:16:47.916] else {
     [14:16:47.916] base::sink(type = "output", split = FALSE)
     [14:16:47.916] if (TRUE) {
     [14:16:47.916] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:47.916] }
     [14:16:47.916] else {
     [14:16:47.916] ...future.result["stdout"] <- base::list(NULL)
     [14:16:47.916] }
     [14:16:47.916] base::close(...future.stdout)
     [14:16:47.916] ...future.stdout <- NULL
     [14:16:47.916] }
     [14:16:47.916] ...future.result$conditions <- ...future.conditions
     [14:16:47.916] ...future.result
     [14:16:47.916] }
     [14:16:47.921] plan(): Setting new future strategy stack:
     [14:16:47.922] List of future strategies:
     [14:16:47.922] 1. sequential:
     [14:16:47.922] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.922] - tweaked: FALSE
     [14:16:47.922] - call: NULL
     [14:16:47.923] plan(): nbrOfWorkers() = 1
     [14:16:47.926] plan(): Setting new future strategy stack:
     [14:16:47.926] List of future strategies:
     [14:16:47.926] 1. sequential:
     [14:16:47.926] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.926] - tweaked: FALSE
     [14:16:47.926] - call: plan(strategy)
     [14:16:47.927] plan(): nbrOfWorkers() = 1
     [14:16:47.928] SequentialFuture started (and completed)
    
     Call:
     lm(formula = dist ~ . + 0, data = cars)
    
     Coefficients:
     speed
     2.909
    
     - Globals - lm(<formula #3 ('c')>, data = cars) ...
    
     Call:
     lm(formula = dist ~ speed + speed^2, data = cars)
    
     Coefficients:
     (Intercept) speed
     -17.579 3.932
    
     [14:16:47.934] getGlobalsAndPackages() ...
     [14:16:47.934] Searching for globals...
     [14:16:47.938] - globals found: [8] '{', 'lm', 'dist', '+', 'speed', '^', '~', 'cars'
     [14:16:47.939] Searching for globals ... DONE
     [14:16:47.939] Resolving globals: FALSE
     [14:16:47.941]
     [14:16:47.941] - packages: [1] 'stats'
     [14:16:47.941] getGlobalsAndPackages() ... DONE
     [14:16:47.943] Packages needed by the future expression (n = 0): <none>
     [14:16:47.944] Packages needed by future strategies (n = 0): <none>
     [14:16:47.949] {
     [14:16:47.949] {
     [14:16:47.949] ...future.startTime <- base::Sys.time()
     [14:16:47.949] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:47.949] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:47.949] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:47.949] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:47.949] future.resolve.recursive = NULL, width = 80L)
     [14:16:47.949] {
     [14:16:47.949] {
     [14:16:47.949] has_future <- base::requireNamespace("future",
     [14:16:47.949] quietly = TRUE)
     [14:16:47.949] version <- if (has_future)
     [14:16:47.949] utils::packageVersion("future")
     [14:16:47.949] else NULL
     [14:16:47.949] if (!has_future || version < "1.8.0") {
     [14:16:47.949] info <- base::c(r_version = base::gsub("R version ",
     [14:16:47.949] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:47.949] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:47.949] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:47.949] "release", "version")], collapse = " "),
     [14:16:47.949] hostname = base::Sys.info()[["nodename"]])
     [14:16:47.949] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:47.949] info)
     [14:16:47.949] info <- base::paste(info, collapse = "; ")
     [14:16:47.949] if (!has_future) {
     [14:16:47.949] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:47.949] info)
     [14:16:47.949] }
     [14:16:47.949] else {
     [14:16:47.949] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:47.949] info, version)
     [14:16:47.949] }
     [14:16:47.949] base::stop(msg)
     [14:16:47.949] }
     [14:16:47.949] }
     [14:16:47.949] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:47.949] }
     [14:16:47.949] }
     [14:16:47.949] if (base::is.na(TRUE)) {
     [14:16:47.949] }
     [14:16:47.949] else {
     [14:16:47.949] if (TRUE) {
     [14:16:47.949] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:47.949] open = "w")
     [14:16:47.949] }
     [14:16:47.949] else {
     [14:16:47.949] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:47.949] windows = "NUL", "/dev/null"), open = "w")
     [14:16:47.949] }
     [14:16:47.949] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:47.949] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:47.949] base::sink(type = "output", split = FALSE)
     [14:16:47.949] base::close(...future.stdout)
     [14:16:47.949] }, add = TRUE)
     [14:16:47.949] }
     [14:16:47.949] ...future.frame <- base::sys.nframe()
     [14:16:47.949] ...future.conditions <- base::list()
     [14:16:47.949] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:47.949] ...future.result <- base::tryCatch({
     [14:16:47.949] base::withCallingHandlers({
     [14:16:47.949] ...future.value <- base::withVisible(base::local({
     [14:16:47.949] lm(dist ~ speed + speed^2, data = cars)
     [14:16:47.949] }))
     [14:16:47.949] future::FutureResult(value = ...future.value$value,
     [14:16:47.949] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.949] ...future.rng), started = ...future.startTime,
     [14:16:47.949] version = "1.8")
     [14:16:47.949] }, condition = base::local({
     [14:16:47.949] c <- base::c
     [14:16:47.949] inherits <- base::inherits
     [14:16:47.949] invokeRestart <- base::invokeRestart
     [14:16:47.949] length <- base::length
     [14:16:47.949] list <- base::list
     [14:16:47.949] seq.int <- base::seq.int
     [14:16:47.949] signalCondition <- base::signalCondition
     [14:16:47.949] sys.calls <- base::sys.calls
     [14:16:47.949] Sys.time <- base::Sys.time
     [14:16:47.949] `[[` <- base::`[[`
     [14:16:47.949] `+` <- base::`+`
     [14:16:47.949] `<<-` <- base::`<<-`
     [14:16:47.949] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:47.949] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:47.949] 3L)]
     [14:16:47.949] }
     [14:16:47.949] function(cond) {
     [14:16:47.949] if (inherits(cond, "error")) {
     [14:16:47.949] ...future.conditions[[length(...future.conditions) +
     [14:16:47.949] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:47.949] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:47.949] signalCondition(cond)
     [14:16:47.949] }
     [14:16:47.949] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:47.949] ))) {
     [14:16:47.949] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:47.949] ...future.conditions[[length(...future.conditions) +
     [14:16:47.949] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:47.949] if (!signal) {
     [14:16:47.949] muffleCondition <- function (cond)
     [14:16:47.949] {
     [14:16:47.949] inherits <- base::inherits
     [14:16:47.949] invokeRestart <- base::invokeRestart
     [14:16:47.949] muffled <- FALSE
     [14:16:47.949] if (inherits(cond, "message")) {
     [14:16:47.949] invokeRestart("muffleMessage")
     [14:16:47.949] muffled <- TRUE
     [14:16:47.949] }
     [14:16:47.949] else if (inherits(cond, "warning")) {
     [14:16:47.949] invokeRestart("muffleWarning")
     [14:16:47.949] muffled <- TRUE
     [14:16:47.949] }
     [14:16:47.949] else if (inherits(cond, "condition")) {
     [14:16:47.949] computeRestarts <- base::computeRestarts
     [14:16:47.949] grepl <- base::grepl
     [14:16:47.949] is.null <- base::is.null
     [14:16:47.949] restarts <- computeRestarts(cond)
     [14:16:47.949] for (restart in restarts) {
     [14:16:47.949] name <- restart$name
     [14:16:47.949] if (is.null(name))
     [14:16:47.949] next
     [14:16:47.949] if (!grepl("^muffle", name))
     [14:16:47.949] next
     [14:16:47.949] invokeRestart(restart)
     [14:16:47.949] muffled <- TRUE
     [14:16:47.949] break
     [14:16:47.949] }
     [14:16:47.949] }
     [14:16:47.949] invisible(muffled)
     [14:16:47.949] }
     [14:16:47.949] muffleCondition(cond)
     [14:16:47.949] }
     [14:16:47.949] }
     [14:16:47.949] }
     [14:16:47.949] }))
     [14:16:47.949] }, error = function(ex) {
     [14:16:47.949] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:47.949] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.949] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:47.949] }, finally = {
     [14:16:47.949] {
     [14:16:47.949] NULL
     [14:16:47.949] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:47.949] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:47.949] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:47.949] label = NULL, ...)
     [14:16:47.949] {
     [14:16:47.949] if (substitute)
     [14:16:47.949] expr <- substitute(expr)
     [14:16:47.949] local <- as.logical(local)
     [14:16:47.949] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:47.949] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:47.949] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:47.949] label = label, ...)
     [14:16:47.949] if (!future$lazy)
     [14:16:47.949] future <- run(future)
     [14:16:47.949] invisible(future)
     [14:16:47.949] }), .cleanup = FALSE, .init = FALSE)
     [14:16:47.949] }
     [14:16:47.949] base::options(...future.oldOptions)
     [14:16:47.949] })
     [14:16:47.949] Sys.time
     [14:16:47.949] if (base::is.na(TRUE)) {
     [14:16:47.949] }
     [14:16:47.949] else {
     [14:16:47.949] base::sink(type = "output", split = FALSE)
     [14:16:47.949] if (TRUE) {
     [14:16:47.949] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:47.949] }
     [14:16:47.949] else {
     [14:16:47.949] ...future.result["stdout"] <- base::list(NULL)
     [14:16:47.949] }
     [14:16:47.949] base::close(...future.stdout)
     [14:16:47.949] ...future.stdout <- NULL
     [14:16:47.949] }
     [14:16:47.949] ...future.result$conditions <- ...future.conditions
     [14:16:47.949] ...future.result
     [14:16:47.949] }
     [14:16:47.954] plan(): Setting new future strategy stack:
     [14:16:47.954] List of future strategies:
     [14:16:47.954] 1. sequential:
     [14:16:47.954] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.954] - tweaked: FALSE
     [14:16:47.954] - call: NULL
     [14:16:47.955] plan(): nbrOfWorkers() = 1
     [14:16:47.958] plan(): Setting new future strategy stack:
     [14:16:47.958] List of future strategies:
     [14:16:47.958] 1. sequential:
     [14:16:47.958] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.958] - tweaked: FALSE
     [14:16:47.958] - call: plan(strategy)
     [14:16:47.959] plan(): nbrOfWorkers() = 1
     [14:16:47.960] SequentialFuture started (and completed)
    
     Call:
     lm(formula = dist ~ speed + speed^2, data = cars)
    
     Coefficients:
     (Intercept) speed
     -17.579 3.932
    
     - Globals - lm(<formula #4 ('d')>, data = cars) ...
    
     Call:
     lm(formula = dist ~ speed + I(speed^2), data = cars)
    
     Coefficients:
     (Intercept) speed I(speed^2)
     2.47014 0.91329 0.09996
    
     [14:16:47.967] getGlobalsAndPackages() ...
     [14:16:47.967] Searching for globals...
     [14:16:47.976] - globals found: [9] '{', 'lm', 'dist', '+', 'speed', 'I', '^', '~', 'cars'
     [14:16:47.976] Searching for globals ... DONE
     [14:16:47.977] Resolving globals: FALSE
     [14:16:47.978]
     [14:16:47.978] - packages: [1] 'stats'
     [14:16:47.979] getGlobalsAndPackages() ... DONE
     [14:16:47.981] Packages needed by the future expression (n = 0): <none>
     [14:16:47.981] Packages needed by future strategies (n = 0): <none>
     [14:16:47.987] {
     [14:16:47.987] {
     [14:16:47.987] ...future.startTime <- base::Sys.time()
     [14:16:47.987] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:47.987] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:47.987] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:47.987] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:47.987] future.resolve.recursive = NULL, width = 80L)
     [14:16:47.987] {
     [14:16:47.987] {
     [14:16:47.987] has_future <- base::requireNamespace("future",
     [14:16:47.987] quietly = TRUE)
     [14:16:47.987] version <- if (has_future)
     [14:16:47.987] utils::packageVersion("future")
     [14:16:47.987] else NULL
     [14:16:47.987] if (!has_future || version < "1.8.0") {
     [14:16:47.987] info <- base::c(r_version = base::gsub("R version ",
     [14:16:47.987] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:47.987] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:47.987] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:47.987] "release", "version")], collapse = " "),
     [14:16:47.987] hostname = base::Sys.info()[["nodename"]])
     [14:16:47.987] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:47.987] info)
     [14:16:47.987] info <- base::paste(info, collapse = "; ")
     [14:16:47.987] if (!has_future) {
     [14:16:47.987] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:47.987] info)
     [14:16:47.987] }
     [14:16:47.987] else {
     [14:16:47.987] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:47.987] info, version)
     [14:16:47.987] }
     [14:16:47.987] base::stop(msg)
     [14:16:47.987] }
     [14:16:47.987] }
     [14:16:47.987] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:47.987] }
     [14:16:47.987] }
     [14:16:47.987] if (base::is.na(TRUE)) {
     [14:16:47.987] }
     [14:16:47.987] else {
     [14:16:47.987] if (TRUE) {
     [14:16:47.987] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:47.987] open = "w")
     [14:16:47.987] }
     [14:16:47.987] else {
     [14:16:47.987] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:47.987] windows = "NUL", "/dev/null"), open = "w")
     [14:16:47.987] }
     [14:16:47.987] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:47.987] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:47.987] base::sink(type = "output", split = FALSE)
     [14:16:47.987] base::close(...future.stdout)
     [14:16:47.987] }, add = TRUE)
     [14:16:47.987] }
     [14:16:47.987] ...future.frame <- base::sys.nframe()
     [14:16:47.987] ...future.conditions <- base::list()
     [14:16:47.987] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:47.987] ...future.result <- base::tryCatch({
     [14:16:47.987] base::withCallingHandlers({
     [14:16:47.987] ...future.value <- base::withVisible(base::local({
     [14:16:47.987] lm(dist ~ speed + I(speed^2), data = cars)
     [14:16:47.987] }))
     [14:16:47.987] future::FutureResult(value = ...future.value$value,
     [14:16:47.987] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.987] ...future.rng), started = ...future.startTime,
     [14:16:47.987] version = "1.8")
     [14:16:47.987] }, condition = base::local({
     [14:16:47.987] c <- base::c
     [14:16:47.987] inherits <- base::inherits
     [14:16:47.987] invokeRestart <- base::invokeRestart
     [14:16:47.987] length <- base::length
     [14:16:47.987] list <- base::list
     [14:16:47.987] seq.int <- base::seq.int
     [14:16:47.987] signalCondition <- base::signalCondition
     [14:16:47.987] sys.calls <- base::sys.calls
     [14:16:47.987] Sys.time <- base::Sys.time
     [14:16:47.987] `[[` <- base::`[[`
     [14:16:47.987] `+` <- base::`+`
     [14:16:47.987] `<<-` <- base::`<<-`
     [14:16:47.987] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:47.987] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:47.987] 3L)]
     [14:16:47.987] }
     [14:16:47.987] function(cond) {
     [14:16:47.987] if (inherits(cond, "error")) {
     [14:16:47.987] ...future.conditions[[length(...future.conditions) +
     [14:16:47.987] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:47.987] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:47.987] signalCondition(cond)
     [14:16:47.987] }
     [14:16:47.987] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:47.987] ))) {
     [14:16:47.987] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:47.987] ...future.conditions[[length(...future.conditions) +
     [14:16:47.987] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:47.987] if (!signal) {
     [14:16:47.987] muffleCondition <- function (cond)
     [14:16:47.987] {
     [14:16:47.987] inherits <- base::inherits
     [14:16:47.987] invokeRestart <- base::invokeRestart
     [14:16:47.987] muffled <- FALSE
     [14:16:47.987] if (inherits(cond, "message")) {
     [14:16:47.987] invokeRestart("muffleMessage")
     [14:16:47.987] muffled <- TRUE
     [14:16:47.987] }
     [14:16:47.987] else if (inherits(cond, "warning")) {
     [14:16:47.987] invokeRestart("muffleWarning")
     [14:16:47.987] muffled <- TRUE
     [14:16:47.987] }
     [14:16:47.987] else if (inherits(cond, "condition")) {
     [14:16:47.987] computeRestarts <- base::computeRestarts
     [14:16:47.987] grepl <- base::grepl
     [14:16:47.987] is.null <- base::is.null
     [14:16:47.987] restarts <- computeRestarts(cond)
     [14:16:47.987] for (restart in restarts) {
     [14:16:47.987] name <- restart$name
     [14:16:47.987] if (is.null(name))
     [14:16:47.987] next
     [14:16:47.987] if (!grepl("^muffle", name))
     [14:16:47.987] next
     [14:16:47.987] invokeRestart(restart)
     [14:16:47.987] muffled <- TRUE
     [14:16:47.987] break
     [14:16:47.987] }
     [14:16:47.987] }
     [14:16:47.987] invisible(muffled)
     [14:16:47.987] }
     [14:16:47.987] muffleCondition(cond)
     [14:16:47.987] }
     [14:16:47.987] }
     [14:16:47.987] }
     [14:16:47.987] }))
     [14:16:47.987] }, error = function(ex) {
     [14:16:47.987] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:47.987] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:47.987] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:47.987] }, finally = {
     [14:16:47.987] {
     [14:16:47.987] NULL
     [14:16:47.987] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:47.987] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:47.987] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:47.987] label = NULL, ...)
     [14:16:47.987] {
     [14:16:47.987] if (substitute)
     [14:16:47.987] expr <- substitute(expr)
     [14:16:47.987] local <- as.logical(local)
     [14:16:47.987] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:47.987] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:47.987] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:47.987] label = label, ...)
     [14:16:47.987] if (!future$lazy)
     [14:16:47.987] future <- run(future)
     [14:16:47.987] invisible(future)
     [14:16:47.987] }), .cleanup = FALSE, .init = FALSE)
     [14:16:47.987] }
     [14:16:47.987] base::options(...future.oldOptions)
     [14:16:47.987] })
     [14:16:47.987] Sys.time
     [14:16:47.987] if (base::is.na(TRUE)) {
     [14:16:47.987] }
     [14:16:47.987] else {
     [14:16:47.987] base::sink(type = "output", split = FALSE)
     [14:16:47.987] if (TRUE) {
     [14:16:47.987] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:47.987] }
     [14:16:47.987] else {
     [14:16:47.987] ...future.result["stdout"] <- base::list(NULL)
     [14:16:47.987] }
     [14:16:47.987] base::close(...future.stdout)
     [14:16:47.987] ...future.stdout <- NULL
     [14:16:47.987] }
     [14:16:47.987] ...future.result$conditions <- ...future.conditions
     [14:16:47.987] ...future.result
     [14:16:47.987] }
     [14:16:47.992] plan(): Setting new future strategy stack:
     [14:16:47.992] List of future strategies:
     [14:16:47.992] 1. sequential:
     [14:16:47.992] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.992] - tweaked: FALSE
     [14:16:47.992] - call: NULL
     [14:16:47.993] plan(): nbrOfWorkers() = 1
     [14:16:47.996] plan(): Setting new future strategy stack:
     [14:16:47.996] List of future strategies:
     [14:16:47.996] 1. sequential:
     [14:16:47.996] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:47.996] - tweaked: FALSE
     [14:16:47.996] - call: plan(strategy)
     [14:16:47.997] plan(): nbrOfWorkers() = 1
     [14:16:47.998] SequentialFuture started (and completed)
    
     Call:
     lm(formula = dist ~ speed + I(speed^2), data = cars)
    
     Coefficients:
     (Intercept) speed I(speed^2)
     2.47014 0.91329 0.09996
    
     - Globals - lm(<formula #5 ('e')>, data = cars) ...
    
     Call:
     lm(formula = dist ~ poly(speed, 2), data = cars)
    
     Coefficients:
     (Intercept) poly(speed, 2)1 poly(speed, 2)2
     42.98 145.55 23.00
    
     [14:16:48.007] getGlobalsAndPackages() ...
     [14:16:48.007] Searching for globals...
     [14:16:48.011] - globals found: [7] '{', 'lm', 'dist', 'poly', 'speed', '~', 'cars'
     [14:16:48.011] Searching for globals ... DONE
     [14:16:48.011] Resolving globals: FALSE
     [14:16:48.013]
     [14:16:48.013] - packages: [1] 'stats'
     [14:16:48.013] getGlobalsAndPackages() ... DONE
     [14:16:48.015] Packages needed by the future expression (n = 0): <none>
     [14:16:48.016] Packages needed by future strategies (n = 0): <none>
     [14:16:48.021] {
     [14:16:48.021] {
     [14:16:48.021] ...future.startTime <- base::Sys.time()
     [14:16:48.021] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.021] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.021] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.021] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.021] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.021] {
     [14:16:48.021] {
     [14:16:48.021] has_future <- base::requireNamespace("future",
     [14:16:48.021] quietly = TRUE)
     [14:16:48.021] version <- if (has_future)
     [14:16:48.021] utils::packageVersion("future")
     [14:16:48.021] else NULL
     [14:16:48.021] if (!has_future || version < "1.8.0") {
     [14:16:48.021] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.021] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.021] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.021] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.021] "release", "version")], collapse = " "),
     [14:16:48.021] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.021] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.021] info)
     [14:16:48.021] info <- base::paste(info, collapse = "; ")
     [14:16:48.021] if (!has_future) {
     [14:16:48.021] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.021] info)
     [14:16:48.021] }
     [14:16:48.021] else {
     [14:16:48.021] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.021] info, version)
     [14:16:48.021] }
     [14:16:48.021] base::stop(msg)
     [14:16:48.021] }
     [14:16:48.021] }
     [14:16:48.021] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.021] }
     [14:16:48.021] }
     [14:16:48.021] if (base::is.na(TRUE)) {
     [14:16:48.021] }
     [14:16:48.021] else {
     [14:16:48.021] if (TRUE) {
     [14:16:48.021] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.021] open = "w")
     [14:16:48.021] }
     [14:16:48.021] else {
     [14:16:48.021] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.021] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.021] }
     [14:16:48.021] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.021] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.021] base::sink(type = "output", split = FALSE)
     [14:16:48.021] base::close(...future.stdout)
     [14:16:48.021] }, add = TRUE)
     [14:16:48.021] }
     [14:16:48.021] ...future.frame <- base::sys.nframe()
     [14:16:48.021] ...future.conditions <- base::list()
     [14:16:48.021] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.021] ...future.result <- base::tryCatch({
     [14:16:48.021] base::withCallingHandlers({
     [14:16:48.021] ...future.value <- base::withVisible(base::local({
     [14:16:48.021] lm(dist ~ poly(speed, 2), data = cars)
     [14:16:48.021] }))
     [14:16:48.021] future::FutureResult(value = ...future.value$value,
     [14:16:48.021] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.021] ...future.rng), started = ...future.startTime,
     [14:16:48.021] version = "1.8")
     [14:16:48.021] }, condition = base::local({
     [14:16:48.021] c <- base::c
     [14:16:48.021] inherits <- base::inherits
     [14:16:48.021] invokeRestart <- base::invokeRestart
     [14:16:48.021] length <- base::length
     [14:16:48.021] list <- base::list
     [14:16:48.021] seq.int <- base::seq.int
     [14:16:48.021] signalCondition <- base::signalCondition
     [14:16:48.021] sys.calls <- base::sys.calls
     [14:16:48.021] Sys.time <- base::Sys.time
     [14:16:48.021] `[[` <- base::`[[`
     [14:16:48.021] `+` <- base::`+`
     [14:16:48.021] `<<-` <- base::`<<-`
     [14:16:48.021] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.021] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.021] 3L)]
     [14:16:48.021] }
     [14:16:48.021] function(cond) {
     [14:16:48.021] if (inherits(cond, "error")) {
     [14:16:48.021] ...future.conditions[[length(...future.conditions) +
     [14:16:48.021] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.021] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.021] signalCondition(cond)
     [14:16:48.021] }
     [14:16:48.021] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:48.021] ))) {
     [14:16:48.021] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:48.021] ...future.conditions[[length(...future.conditions) +
     [14:16:48.021] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.021] if (!signal) {
     [14:16:48.021] muffleCondition <- function (cond)
     [14:16:48.021] {
     [14:16:48.021] inherits <- base::inherits
     [14:16:48.021] invokeRestart <- base::invokeRestart
     [14:16:48.021] muffled <- FALSE
     [14:16:48.021] if (inherits(cond, "message")) {
     [14:16:48.021] invokeRestart("muffleMessage")
     [14:16:48.021] muffled <- TRUE
     [14:16:48.021] }
     [14:16:48.021] else if (inherits(cond, "warning")) {
     [14:16:48.021] invokeRestart("muffleWarning")
     [14:16:48.021] muffled <- TRUE
     [14:16:48.021] }
     [14:16:48.021] else if (inherits(cond, "condition")) {
     [14:16:48.021] computeRestarts <- base::computeRestarts
     [14:16:48.021] grepl <- base::grepl
     [14:16:48.021] is.null <- base::is.null
     [14:16:48.021] restarts <- computeRestarts(cond)
     [14:16:48.021] for (restart in restarts) {
     [14:16:48.021] name <- restart$name
     [14:16:48.021] if (is.null(name))
     [14:16:48.021] next
     [14:16:48.021] if (!grepl("^muffle", name))
     [14:16:48.021] next
     [14:16:48.021] invokeRestart(restart)
     [14:16:48.021] muffled <- TRUE
     [14:16:48.021] break
     [14:16:48.021] }
     [14:16:48.021] }
     [14:16:48.021] invisible(muffled)
     [14:16:48.021] }
     [14:16:48.021] muffleCondition(cond)
     [14:16:48.021] }
     [14:16:48.021] }
     [14:16:48.021] }
     [14:16:48.021] }))
     [14:16:48.021] }, error = function(ex) {
     [14:16:48.021] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.021] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.021] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.021] }, finally = {
     [14:16:48.021] {
     [14:16:48.021] NULL
     [14:16:48.021] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.021] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.021] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:48.021] label = NULL, ...)
     [14:16:48.021] {
     [14:16:48.021] if (substitute)
     [14:16:48.021] expr <- substitute(expr)
     [14:16:48.021] local <- as.logical(local)
     [14:16:48.021] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:48.021] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.021] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:48.021] label = label, ...)
     [14:16:48.021] if (!future$lazy)
     [14:16:48.021] future <- run(future)
     [14:16:48.021] invisible(future)
     [14:16:48.021] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.021] }
     [14:16:48.021] base::options(...future.oldOptions)
     [14:16:48.021] })
     [14:16:48.021] Sys.time
     [14:16:48.021] if (base::is.na(TRUE)) {
     [14:16:48.021] }
     [14:16:48.021] else {
     [14:16:48.021] base::sink(type = "output", split = FALSE)
     [14:16:48.021] if (TRUE) {
     [14:16:48.021] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.021] }
     [14:16:48.021] else {
     [14:16:48.021] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.021] }
     [14:16:48.021] base::close(...future.stdout)
     [14:16:48.021] ...future.stdout <- NULL
     [14:16:48.021] }
     [14:16:48.021] ...future.result$conditions <- ...future.conditions
     [14:16:48.021] ...future.result
     [14:16:48.021] }
     [14:16:48.026] plan(): Setting new future strategy stack:
     [14:16:48.026] List of future strategies:
     [14:16:48.026] 1. sequential:
     [14:16:48.026] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.026] - tweaked: FALSE
     [14:16:48.026] - call: NULL
     [14:16:48.027] plan(): nbrOfWorkers() = 1
     [14:16:48.031] plan(): Setting new future strategy stack:
     [14:16:48.031] List of future strategies:
     [14:16:48.031] 1. sequential:
     [14:16:48.031] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.031] - tweaked: FALSE
     [14:16:48.031] - call: plan(strategy)
     [14:16:48.032] plan(): nbrOfWorkers() = 1
     [14:16:48.032] SequentialFuture started (and completed)
    
     Call:
     lm(formula = dist ~ poly(speed, 2), data = cars)
    
     Coefficients:
     (Intercept) poly(speed, 2)1 poly(speed, 2)2
     42.98 145.55 23.00
    
     - Globals - map(x, ~ expr) ...
     [14:16:48.038] getGlobalsAndPackages() ...
     [14:16:48.038] Searching for globals...
     [14:16:48.054] - globals found: [16] '{', 'outer_function', 'map', ':', '~', 'inner_function', '.x', 'if', 'inherits', '<-', '[[', '-', 'eval', 'bquote', 'lapply', '+'
     [14:16:48.054] Searching for globals ... DONE
     [14:16:48.054] Resolving globals: FALSE
     [14:16:48.056] The total size of the 3 globals is 7.52 KiB (7704 bytes)
     [14:16:48.057] - globals: [3] 'outer_function', 'map', 'inner_function'
     [14:16:48.057]
     [14:16:48.057] getGlobalsAndPackages() ... DONE
     [14:16:48.059] Packages needed by the future expression (n = 0): <none>
     [14:16:48.060] Packages needed by future strategies (n = 0): <none>
     [14:16:48.080] {
     [14:16:48.080] {
     [14:16:48.080] ...future.startTime <- base::Sys.time()
     [14:16:48.080] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.080] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.080] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.080] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.080] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.080] {
     [14:16:48.080] {
     [14:16:48.080] has_future <- base::requireNamespace("future",
     [14:16:48.080] quietly = TRUE)
     [14:16:48.080] version <- if (has_future)
     [14:16:48.080] utils::packageVersion("future")
     [14:16:48.080] else NULL
     [14:16:48.080] if (!has_future || version < "1.8.0") {
     [14:16:48.080] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.080] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.080] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.080] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.080] "release", "version")], collapse = " "),
     [14:16:48.080] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.080] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.080] info)
     [14:16:48.080] info <- base::paste(info, collapse = "; ")
     [14:16:48.080] if (!has_future) {
     [14:16:48.080] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.080] info)
     [14:16:48.080] }
     [14:16:48.080] else {
     [14:16:48.080] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.080] info, version)
     [14:16:48.080] }
     [14:16:48.080] base::stop(msg)
     [14:16:48.080] }
     [14:16:48.080] }
     [14:16:48.080] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.080] }
     [14:16:48.080] }
     [14:16:48.080] if (base::is.na(TRUE)) {
     [14:16:48.080] }
     [14:16:48.080] else {
     [14:16:48.080] if (TRUE) {
     [14:16:48.080] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.080] open = "w")
     [14:16:48.080] }
     [14:16:48.080] else {
     [14:16:48.080] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.080] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.080] }
     [14:16:48.080] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.080] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.080] base::sink(type = "output", split = FALSE)
     [14:16:48.080] base::close(...future.stdout)
     [14:16:48.080] }, add = TRUE)
     [14:16:48.080] }
     [14:16:48.080] ...future.frame <- base::sys.nframe()
     [14:16:48.080] ...future.conditions <- base::list()
     [14:16:48.080] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.080] ...future.result <- base::tryCatch({
     [14:16:48.080] base::withCallingHandlers({
     [14:16:48.080] ...future.value <- base::withVisible(base::local({
     [14:16:48.080] outer_function(1L)
     [14:16:48.080] }))
     [14:16:48.080] future::FutureResult(value = ...future.value$value,
     [14:16:48.080] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.080] ...future.rng), started = ...future.startTime,
     [14:16:48.080] version = "1.8")
     [14:16:48.080] }, condition = base::local({
     [14:16:48.080] c <- base::c
     [14:16:48.080] inherits <- base::inherits
     [14:16:48.080] invokeRestart <- base::invokeRestart
     [14:16:48.080] length <- base::length
     [14:16:48.080] list <- base::list
     [14:16:48.080] seq.int <- base::seq.int
     [14:16:48.080] signalCondition <- base::signalCondition
     [14:16:48.080] sys.calls <- base::sys.calls
     [14:16:48.080] Sys.time <- base::Sys.time
     [14:16:48.080] `[[` <- base::`[[`
     [14:16:48.080] `+` <- base::`+`
     [14:16:48.080] `<<-` <- base::`<<-`
     [14:16:48.080] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.080] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.080] 3L)]
     [14:16:48.080] }
     [14:16:48.080] function(cond) {
     [14:16:48.080] if (inherits(cond, "error")) {
     [14:16:48.080] ...future.conditions[[length(...future.conditions) +
     [14:16:48.080] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.080] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.080] signalCondition(cond)
     [14:16:48.080] }
     [14:16:48.080] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:48.080] ))) {
     [14:16:48.080] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:48.080] ...future.conditions[[length(...future.conditions) +
     [14:16:48.080] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.080] if (!signal) {
     [14:16:48.080] muffleCondition <- function (cond)
     [14:16:48.080] {
     [14:16:48.080] inherits <- base::inherits
     [14:16:48.080] invokeRestart <- base::invokeRestart
     [14:16:48.080] muffled <- FALSE
     [14:16:48.080] if (inherits(cond, "message")) {
     [14:16:48.080] invokeRestart("muffleMessage")
     [14:16:48.080] muffled <- TRUE
     [14:16:48.080] }
     [14:16:48.080] else if (inherits(cond, "warning")) {
     [14:16:48.080] invokeRestart("muffleWarning")
     [14:16:48.080] muffled <- TRUE
     [14:16:48.080] }
     [14:16:48.080] else if (inherits(cond, "condition")) {
     [14:16:48.080] computeRestarts <- base::computeRestarts
     [14:16:48.080] grepl <- base::grepl
     [14:16:48.080] is.null <- base::is.null
     [14:16:48.080] restarts <- computeRestarts(cond)
     [14:16:48.080] for (restart in restarts) {
     [14:16:48.080] name <- restart$name
     [14:16:48.080] if (is.null(name))
     [14:16:48.080] next
     [14:16:48.080] if (!grepl("^muffle", name))
     [14:16:48.080] next
     [14:16:48.080] invokeRestart(restart)
     [14:16:48.080] muffled <- TRUE
     [14:16:48.080] break
     [14:16:48.080] }
     [14:16:48.080] }
     [14:16:48.080] invisible(muffled)
     [14:16:48.080] }
     [14:16:48.080] muffleCondition(cond)
     [14:16:48.080] }
     [14:16:48.080] }
     [14:16:48.080] }
     [14:16:48.080] }))
     [14:16:48.080] }, error = function(ex) {
     [14:16:48.080] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.080] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.080] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.080] }, finally = {
     [14:16:48.080] {
     [14:16:48.080] NULL
     [14:16:48.080] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.080] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.080] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:48.080] label = NULL, ...)
     [14:16:48.080] {
     [14:16:48.080] if (substitute)
     [14:16:48.080] expr <- substitute(expr)
     [14:16:48.080] local <- as.logical(local)
     [14:16:48.080] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:48.080] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.080] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:48.080] label = label, ...)
     [14:16:48.080] if (!future$lazy)
     [14:16:48.080] future <- run(future)
     [14:16:48.080] invisible(future)
     [14:16:48.080] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.080] }
     [14:16:48.080] base::options(...future.oldOptions)
     [14:16:48.080] })
     [14:16:48.080] Sys.time
     [14:16:48.080] if (base::is.na(TRUE)) {
     [14:16:48.080] }
     [14:16:48.080] else {
     [14:16:48.080] base::sink(type = "output", split = FALSE)
     [14:16:48.080] if (TRUE) {
     [14:16:48.080] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.080] }
     [14:16:48.080] else {
     [14:16:48.080] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.080] }
     [14:16:48.080] base::close(...future.stdout)
     [14:16:48.080] ...future.stdout <- NULL
     [14:16:48.080] }
     [14:16:48.080] ...future.result$conditions <- ...future.conditions
     [14:16:48.080] ...future.result
     [14:16:48.080] }
     [14:16:48.085] plan(): Setting new future strategy stack:
     [14:16:48.085] List of future strategies:
     [14:16:48.085] 1. sequential:
     [14:16:48.085] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.085] - tweaked: FALSE
     [14:16:48.085] - call: NULL
     [14:16:48.086] plan(): nbrOfWorkers() = 1
     [14:16:48.099] plan(): Setting new future strategy stack:
     [14:16:48.100] List of future strategies:
     [14:16:48.100] 1. sequential:
     [14:16:48.100] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.100] - tweaked: FALSE
     [14:16:48.100] - call: plan(strategy)
     [14:16:48.101] plan(): nbrOfWorkers() = 1
     [14:16:48.101] SequentialFuture started (and completed)
     List of 2
     $ : num [1:2] 2 3
     $ : num [1:2] 2 3
     [14:16:48.105] getGlobalsAndPackages() ...
     [14:16:48.105] Searching for globals...
     [14:16:48.114] - globals found: [16] '{', 'outer_function', 'map', ':', '~', 'inner_function', '.x', 'if', 'inherits', '<-', '[[', '-', 'eval', 'bquote', 'lapply', '+'
     [14:16:48.115] Searching for globals ... DONE
     [14:16:48.115] Resolving globals: FALSE
     [14:16:48.120] The total size of the 3 globals is 28.25 KiB (28928 bytes)
     [14:16:48.121] - globals: [3] 'outer_function', 'map', 'inner_function'
     [14:16:48.121]
     [14:16:48.121] getGlobalsAndPackages() ... DONE
     [14:16:48.123] Packages needed by the future expression (n = 0): <none>
     [14:16:48.124] Packages needed by future strategies (n = 0): <none>
     [14:16:48.129] {
     [14:16:48.129] {
     [14:16:48.129] ...future.startTime <- base::Sys.time()
     [14:16:48.129] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.129] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.129] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.129] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.129] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.129] {
     [14:16:48.129] {
     [14:16:48.129] has_future <- base::requireNamespace("future",
     [14:16:48.129] quietly = TRUE)
     [14:16:48.129] version <- if (has_future)
     [14:16:48.129] utils::packageVersion("future")
     [14:16:48.129] else NULL
     [14:16:48.129] if (!has_future || version < "1.8.0") {
     [14:16:48.129] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.129] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.129] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.129] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.129] "release", "version")], collapse = " "),
     [14:16:48.129] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.129] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.129] info)
     [14:16:48.129] info <- base::paste(info, collapse = "; ")
     [14:16:48.129] if (!has_future) {
     [14:16:48.129] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.129] info)
     [14:16:48.129] }
     [14:16:48.129] else {
     [14:16:48.129] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.129] info, version)
     [14:16:48.129] }
     [14:16:48.129] base::stop(msg)
     [14:16:48.129] }
     [14:16:48.129] }
     [14:16:48.129] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.129] }
     [14:16:48.129] }
     [14:16:48.129] if (base::is.na(TRUE)) {
     [14:16:48.129] }
     [14:16:48.129] else {
     [14:16:48.129] if (TRUE) {
     [14:16:48.129] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.129] open = "w")
     [14:16:48.129] }
     [14:16:48.129] else {
     [14:16:48.129] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.129] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.129] }
     [14:16:48.129] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.129] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.129] base::sink(type = "output", split = FALSE)
     [14:16:48.129] base::close(...future.stdout)
     [14:16:48.129] }, add = TRUE)
     [14:16:48.129] }
     [14:16:48.129] ...future.frame <- base::sys.nframe()
     [14:16:48.129] ...future.conditions <- base::list()
     [14:16:48.129] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.129] ...future.result <- base::tryCatch({
     [14:16:48.129] base::withCallingHandlers({
     [14:16:48.129] ...future.value <- base::withVisible(base::local({
     [14:16:48.129] outer_function(1L)
     [14:16:48.129] }))
     [14:16:48.129] future::FutureResult(value = ...future.value$value,
     [14:16:48.129] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.129] ...future.rng), started = ...future.startTime,
     [14:16:48.129] version = "1.8")
     [14:16:48.129] }, condition = base::local({
     [14:16:48.129] c <- base::c
     [14:16:48.129] inherits <- base::inherits
     [14:16:48.129] invokeRestart <- base::invokeRestart
     [14:16:48.129] length <- base::length
     [14:16:48.129] list <- base::list
     [14:16:48.129] seq.int <- base::seq.int
     [14:16:48.129] signalCondition <- base::signalCondition
     [14:16:48.129] sys.calls <- base::sys.calls
     [14:16:48.129] Sys.time <- base::Sys.time
     [14:16:48.129] `[[` <- base::`[[`
     [14:16:48.129] `+` <- base::`+`
     [14:16:48.129] `<<-` <- base::`<<-`
     [14:16:48.129] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.129] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.129] 3L)]
     [14:16:48.129] }
     [14:16:48.129] function(cond) {
     [14:16:48.129] if (inherits(cond, "error")) {
     [14:16:48.129] ...future.conditions[[length(...future.conditions) +
     [14:16:48.129] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.129] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.129] signalCondition(cond)
     [14:16:48.129] }
     [14:16:48.129] else if (inherits(cond, c("condition", "immediateCondition"
     [14:16:48.129] ))) {
     [14:16:48.129] signal <- TRUE && inherits(cond, "immediateCondition")
     [14:16:48.129] ...future.conditions[[length(...future.conditions) +
     [14:16:48.129] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.129] if (!signal) {
     [14:16:48.129] muffleCondition <- function (cond)
     [14:16:48.129] {
     [14:16:48.129] inherits <- base::inherits
     [14:16:48.129] invokeRestart <- base::invokeRestart
     [14:16:48.129] muffled <- FALSE
     [14:16:48.129] if (inherits(cond, "message")) {
     [14:16:48.129] invokeRestart("muffleMessage")
     [14:16:48.129] muffled <- TRUE
     [14:16:48.129] }
     [14:16:48.129] else if (inherits(cond, "warning")) {
     [14:16:48.129] invokeRestart("muffleWarning")
     [14:16:48.129] muffled <- TRUE
     [14:16:48.129] }
     [14:16:48.129] else if (inherits(cond, "condition")) {
     [14:16:48.129] computeRestarts <- base::computeRestarts
     [14:16:48.129] grepl <- base::grepl
     [14:16:48.129] is.null <- base::is.null
     [14:16:48.129] restarts <- computeRestarts(cond)
     [14:16:48.129] for (restart in restarts) {
     [14:16:48.129] name <- restart$name
     [14:16:48.129] if (is.null(name))
     [14:16:48.129] next
     [14:16:48.129] if (!grepl("^muffle", name))
     [14:16:48.129] next
     [14:16:48.129] invokeRestart(restart)
     [14:16:48.129] muffled <- TRUE
     [14:16:48.129] break
     [14:16:48.129] }
     [14:16:48.129] }
     [14:16:48.129] invisible(muffled)
     [14:16:48.129] }
     [14:16:48.129] muffleCondition(cond)
     [14:16:48.129] }
     [14:16:48.129] }
     [14:16:48.129] }
     [14:16:48.129] }))
     [14:16:48.129] }, error = function(ex) {
     [14:16:48.129] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.129] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.129] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.129] }, finally = {
     [14:16:48.129] {
     [14:16:48.129] NULL
     [14:16:48.129] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.129] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.129] globals = TRUE, local = TRUE, earlySignal = FALSE,
     [14:16:48.129] label = NULL, ...)
     [14:16:48.129] {
     [14:16:48.129] if (substitute)
     [14:16:48.129] expr <- substitute(expr)
     [14:16:48.129] local <- as.logical(local)
     [14:16:48.129] future <- SequentialFuture(expr = expr, envir = envir,
     [14:16:48.129] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.129] globals = globals, local = local, earlySignal = earlySignal,
     [14:16:48.129] label = label, ...)
     [14:16:48.129] if (!future$lazy)
     [14:16:48.129] future <- run(future)
     [14:16:48.129] invisible(future)
     [14:16:48.129] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.129] }
     [14:16:48.129] base::options(...future.oldOptions)
     [14:16:48.129] })
     [14:16:48.129] Sys.time
     [14:16:48.129] if (base::is.na(TRUE)) {
     [14:16:48.129] }
     [14:16:48.129] else {
     [14:16:48.129] base::sink(type = "output", split = FALSE)
     [14:16:48.129] if (TRUE) {
     [14:16:48.129] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.129] }
     [14:16:48.129] else {
     [14:16:48.129] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.129] }
     [14:16:48.129] base::close(...future.stdout)
     [14:16:48.129] ...future.stdout <- NULL
     [14:16:48.129] }
     [14:16:48.129] ...future.result$conditions <- ...future.conditions
     [14:16:48.129] ...future.result
     [14:16:48.129] }
     [14:16:48.133] plan(): Setting new future strategy stack:
     [14:16:48.134] List of future strategies:
     [14:16:48.134] 1. sequential:
     [14:16:48.134] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.134] - tweaked: FALSE
     [14:16:48.134] - call: NULL
     [14:16:48.135] plan(): nbrOfWorkers() = 1
     [14:16:48.136] plan(): Setting new future strategy stack:
     [14:16:48.136] List of future strategies:
     [14:16:48.136] 1. sequential:
     [14:16:48.136] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.136] - tweaked: FALSE
     [14:16:48.136] - call: plan(strategy)
     [14:16:48.138] plan(): nbrOfWorkers() = 1
     [14:16:48.138] SequentialFuture started (and completed)
     List of 2
     $ : num [1:2] 2 3
     $ : num [1:2] 2 3
     Testing with 1 cores ... DONE
     Testing with 2 cores ...
     availableCores(): 2
     - plan('multicore') ...
     [14:16:48.153] plan(): Setting new future strategy stack:
     [14:16:48.154] List of future strategies:
     [14:16:48.154] 1. multicore:
     [14:16:48.154] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.154] - tweaked: FALSE
     [14:16:48.154] - call: plan(strategy)
     [14:16:48.155] plan(): nbrOfWorkers() = 2
     - lm(<formula>) ...
     [14:16:48.156] getGlobalsAndPackages() ...
     [14:16:48.157] Searching for globals...
     [14:16:48.160] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
     [14:16:48.160] Searching for globals ... DONE
     [14:16:48.160] Resolving globals: FALSE
     [14:16:48.162] The total size of the 2 globals is 896 bytes (896 bytes)
     [14:16:48.162] - globals: [2] 'weight', 'group'
     [14:16:48.162] - packages: [1] 'stats'
     [14:16:48.163] getGlobalsAndPackages() ... DONE
     [14:16:48.166] Packages needed by the future expression (n = 0): <none>
     [14:16:48.166] Packages needed by future strategies (n = 0): <none>
     [14:16:48.171] {
     [14:16:48.171] {
     [14:16:48.171] ...future.startTime <- base::Sys.time()
     [14:16:48.171] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.171] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.171] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.171] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.171] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.171] {
     [14:16:48.171] {
     [14:16:48.171] {
     [14:16:48.171] has_future <- base::requireNamespace("future",
     [14:16:48.171] quietly = TRUE)
     [14:16:48.171] version <- if (has_future)
     [14:16:48.171] utils::packageVersion("future")
     [14:16:48.171] else NULL
     [14:16:48.171] if (!has_future || version < "1.8.0") {
     [14:16:48.171] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.171] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.171] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.171] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.171] "release", "version")], collapse = " "),
     [14:16:48.171] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.171] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.171] info)
     [14:16:48.171] info <- base::paste(info, collapse = "; ")
     [14:16:48.171] if (!has_future) {
     [14:16:48.171] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.171] info)
     [14:16:48.171] }
     [14:16:48.171] else {
     [14:16:48.171] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.171] info, version)
     [14:16:48.171] }
     [14:16:48.171] base::stop(msg)
     [14:16:48.171] }
     [14:16:48.171] }
     [14:16:48.171] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.171] base::options(mc.cores = 1L)
     [14:16:48.171] }
     [14:16:48.171] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.171] }
     [14:16:48.171] }
     [14:16:48.171] if (base::is.na(TRUE)) {
     [14:16:48.171] }
     [14:16:48.171] else {
     [14:16:48.171] if (TRUE) {
     [14:16:48.171] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.171] open = "w")
     [14:16:48.171] }
     [14:16:48.171] else {
     [14:16:48.171] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.171] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.171] }
     [14:16:48.171] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.171] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.171] base::sink(type = "output", split = FALSE)
     [14:16:48.171] base::close(...future.stdout)
     [14:16:48.171] }, add = TRUE)
     [14:16:48.171] }
     [14:16:48.171] ...future.frame <- base::sys.nframe()
     [14:16:48.171] ...future.conditions <- base::list()
     [14:16:48.171] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.171] ...future.result <- base::tryCatch({
     [14:16:48.171] base::withCallingHandlers({
     [14:16:48.171] ...future.value <- base::withVisible(base::local({
     [14:16:48.171] lm(weight ~ group - 1)
     [14:16:48.171] }))
     [14:16:48.171] future::FutureResult(value = ...future.value$value,
     [14:16:48.171] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.171] ...future.rng), started = ...future.startTime,
     [14:16:48.171] version = "1.8")
     [14:16:48.171] }, condition = base::local({
     [14:16:48.171] c <- base::c
     [14:16:48.171] inherits <- base::inherits
     [14:16:48.171] invokeRestart <- base::invokeRestart
     [14:16:48.171] length <- base::length
     [14:16:48.171] list <- base::list
     [14:16:48.171] seq.int <- base::seq.int
     [14:16:48.171] signalCondition <- base::signalCondition
     [14:16:48.171] sys.calls <- base::sys.calls
     [14:16:48.171] Sys.time <- base::Sys.time
     [14:16:48.171] `[[` <- base::`[[`
     [14:16:48.171] `+` <- base::`+`
     [14:16:48.171] `<<-` <- base::`<<-`
     [14:16:48.171] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.171] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.171] 3L)]
     [14:16:48.171] }
     [14:16:48.171] function(cond) {
     [14:16:48.171] if (inherits(cond, "error")) {
     [14:16:48.171] ...future.conditions[[length(...future.conditions) +
     [14:16:48.171] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.171] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.171] signalCondition(cond)
     [14:16:48.171] }
     [14:16:48.171] else if (inherits(cond, "condition")) {
     [14:16:48.171] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.171] ...future.conditions[[length(...future.conditions) +
     [14:16:48.171] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.171] if (!signal) {
     [14:16:48.171] muffleCondition <- function (cond)
     [14:16:48.171] {
     [14:16:48.171] inherits <- base::inherits
     [14:16:48.171] invokeRestart <- base::invokeRestart
     [14:16:48.171] muffled <- FALSE
     [14:16:48.171] if (inherits(cond, "message")) {
     [14:16:48.171] invokeRestart("muffleMessage")
     [14:16:48.171] muffled <- TRUE
     [14:16:48.171] }
     [14:16:48.171] else if (inherits(cond, "warning")) {
     [14:16:48.171] invokeRestart("muffleWarning")
     [14:16:48.171] muffled <- TRUE
     [14:16:48.171] }
     [14:16:48.171] else if (inherits(cond, "condition")) {
     [14:16:48.171] computeRestarts <- base::computeRestarts
     [14:16:48.171] grepl <- base::grepl
     [14:16:48.171] is.null <- base::is.null
     [14:16:48.171] restarts <- computeRestarts(cond)
     [14:16:48.171] for (restart in restarts) {
     [14:16:48.171] name <- restart$name
     [14:16:48.171] if (is.null(name))
     [14:16:48.171] next
     [14:16:48.171] if (!grepl("^muffle", name))
     [14:16:48.171] next
     [14:16:48.171] invokeRestart(restart)
     [14:16:48.171] muffled <- TRUE
     [14:16:48.171] break
     [14:16:48.171] }
     [14:16:48.171] }
     [14:16:48.171] invisible(muffled)
     [14:16:48.171] }
     [14:16:48.171] muffleCondition(cond)
     [14:16:48.171] }
     [14:16:48.171] }
     [14:16:48.171] }
     [14:16:48.171] }))
     [14:16:48.171] }, error = function(ex) {
     [14:16:48.171] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.171] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.171] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.171] }, finally = {
     [14:16:48.171] {
     [14:16:48.171] {
     [14:16:48.171] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.171] }
     [14:16:48.171] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.171] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.171] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.171] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.171] {
     [14:16:48.171] if (substitute)
     [14:16:48.171] expr <- substitute(expr)
     [14:16:48.171] if (is.function(workers))
     [14:16:48.171] workers <- workers()
     [14:16:48.171] workers <- as.integer(workers)
     [14:16:48.171] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.171] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.171] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.171] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.171] local = TRUE, label = label, ...))
     [14:16:48.171] }
     [14:16:48.171] oopts <- options(mc.cores = workers)
     [14:16:48.171] on.exit(options(oopts))
     [14:16:48.171] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.171] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.171] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.171] label = label, ...)
     [14:16:48.171] if (!future$lazy)
     [14:16:48.171] future <- run(future)
     [14:16:48.171] invisible(future)
     [14:16:48.171] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.171] }
     [14:16:48.171] base::options(...future.oldOptions)
     [14:16:48.171] })
     [14:16:48.171] Sys.time
     [14:16:48.171] if (base::is.na(TRUE)) {
     [14:16:48.171] }
     [14:16:48.171] else {
     [14:16:48.171] base::sink(type = "output", split = FALSE)
     [14:16:48.171] if (TRUE) {
     [14:16:48.171] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.171] }
     [14:16:48.171] else {
     [14:16:48.171] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.171] }
     [14:16:48.171] base::close(...future.stdout)
     [14:16:48.171] ...future.stdout <- NULL
     [14:16:48.171] }
     [14:16:48.171] ...future.result$conditions <- ...future.conditions
     [14:16:48.171] ...future.result
     [14:16:48.171] }
     [14:16:48.175] requestCore(): workers = 2
     [14:16:48.180] MulticoreFuture started
     [14:16:48.189] plan(): Setting new future strategy stack:
     [14:16:48.189] List of future strategies:
     [14:16:48.189] 1. sequential:
     [14:16:48.189] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.189] - tweaked: FALSE
     [14:16:48.189] - call: NULL
     [14:16:48.191] plan(): nbrOfWorkers() = 1
     [14:16:48.195] plan(): Setting new future strategy stack:
     [14:16:48.196] List of future strategies:
     [14:16:48.196] 1. multicore:
     [14:16:48.196] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.196] - tweaked: FALSE
     [14:16:48.196] - call: plan(strategy)
     [14:16:48.207] plan(): nbrOfWorkers() = 2
    
     Call:
     lm(formula = weight ~ group - 1)
    
     Coefficients:
     groupCtl groupTrt
     5.032 4.661
    
     [14:16:48.231] getGlobalsAndPackages() ...
     [14:16:48.231] Searching for globals...
     [14:16:48.235] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
     [14:16:48.235] Searching for globals ... DONE
     [14:16:48.236] Resolving globals: FALSE
     [14:16:48.237] The total size of the 2 globals is 896 bytes (896 bytes)
     [14:16:48.237] - globals: [2] 'weight', 'group'
     [14:16:48.238] - packages: [1] 'stats'
     [14:16:48.238] getGlobalsAndPackages() ... DONE
     [14:16:48.241] Packages needed by the future expression (n = 0): <none>
     [14:16:48.242] Packages needed by future strategies (n = 0): <none>
     [14:16:48.247] {
     [14:16:48.247] {
     [14:16:48.247] ...future.startTime <- base::Sys.time()
     [14:16:48.247] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.247] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.247] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.247] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.247] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.247] {
     [14:16:48.247] {
     [14:16:48.247] {
     [14:16:48.247] has_future <- base::requireNamespace("future",
     [14:16:48.247] quietly = TRUE)
     [14:16:48.247] version <- if (has_future)
     [14:16:48.247] utils::packageVersion("future")
     [14:16:48.247] else NULL
     [14:16:48.247] if (!has_future || version < "1.8.0") {
     [14:16:48.247] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.247] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.247] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.247] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.247] "release", "version")], collapse = " "),
     [14:16:48.247] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.247] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.247] info)
     [14:16:48.247] info <- base::paste(info, collapse = "; ")
     [14:16:48.247] if (!has_future) {
     [14:16:48.247] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.247] info)
     [14:16:48.247] }
     [14:16:48.247] else {
     [14:16:48.247] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.247] info, version)
     [14:16:48.247] }
     [14:16:48.247] base::stop(msg)
     [14:16:48.247] }
     [14:16:48.247] }
     [14:16:48.247] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.247] base::options(mc.cores = 1L)
     [14:16:48.247] }
     [14:16:48.247] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.247] }
     [14:16:48.247] }
     [14:16:48.247] if (base::is.na(TRUE)) {
     [14:16:48.247] }
     [14:16:48.247] else {
     [14:16:48.247] if (TRUE) {
     [14:16:48.247] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.247] open = "w")
     [14:16:48.247] }
     [14:16:48.247] else {
     [14:16:48.247] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.247] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.247] }
     [14:16:48.247] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.247] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.247] base::sink(type = "output", split = FALSE)
     [14:16:48.247] base::close(...future.stdout)
     [14:16:48.247] }, add = TRUE)
     [14:16:48.247] }
     [14:16:48.247] ...future.frame <- base::sys.nframe()
     [14:16:48.247] ...future.conditions <- base::list()
     [14:16:48.247] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.247] ...future.result <- base::tryCatch({
     [14:16:48.247] base::withCallingHandlers({
     [14:16:48.247] ...future.value <- base::withVisible(base::local({
     [14:16:48.247] lm(weight ~ group - 1)
     [14:16:48.247] }))
     [14:16:48.247] future::FutureResult(value = ...future.value$value,
     [14:16:48.247] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.247] ...future.rng), started = ...future.startTime,
     [14:16:48.247] version = "1.8")
     [14:16:48.247] }, condition = base::local({
     [14:16:48.247] c <- base::c
     [14:16:48.247] inherits <- base::inherits
     [14:16:48.247] invokeRestart <- base::invokeRestart
     [14:16:48.247] length <- base::length
     [14:16:48.247] list <- base::list
     [14:16:48.247] seq.int <- base::seq.int
     [14:16:48.247] signalCondition <- base::signalCondition
     [14:16:48.247] sys.calls <- base::sys.calls
     [14:16:48.247] Sys.time <- base::Sys.time
     [14:16:48.247] `[[` <- base::`[[`
     [14:16:48.247] `+` <- base::`+`
     [14:16:48.247] `<<-` <- base::`<<-`
     [14:16:48.247] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.247] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.247] 3L)]
     [14:16:48.247] }
     [14:16:48.247] function(cond) {
     [14:16:48.247] if (inherits(cond, "error")) {
     [14:16:48.247] ...future.conditions[[length(...future.conditions) +
     [14:16:48.247] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.247] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.247] signalCondition(cond)
     [14:16:48.247] }
     [14:16:48.247] else if (inherits(cond, "condition")) {
     [14:16:48.247] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.247] ...future.conditions[[length(...future.conditions) +
     [14:16:48.247] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.247] if (!signal) {
     [14:16:48.247] muffleCondition <- function (cond)
     [14:16:48.247] {
     [14:16:48.247] inherits <- base::inherits
     [14:16:48.247] invokeRestart <- base::invokeRestart
     [14:16:48.247] muffled <- FALSE
     [14:16:48.247] if (inherits(cond, "message")) {
     [14:16:48.247] invokeRestart("muffleMessage")
     [14:16:48.247] muffled <- TRUE
     [14:16:48.247] }
     [14:16:48.247] else if (inherits(cond, "warning")) {
     [14:16:48.247] invokeRestart("muffleWarning")
     [14:16:48.247] muffled <- TRUE
     [14:16:48.247] }
     [14:16:48.247] else if (inherits(cond, "condition")) {
     [14:16:48.247] computeRestarts <- base::computeRestarts
     [14:16:48.247] grepl <- base::grepl
     [14:16:48.247] is.null <- base::is.null
     [14:16:48.247] restarts <- computeRestarts(cond)
     [14:16:48.247] for (restart in restarts) {
     [14:16:48.247] name <- restart$name
     [14:16:48.247] if (is.null(name))
     [14:16:48.247] next
     [14:16:48.247] if (!grepl("^muffle", name))
     [14:16:48.247] next
     [14:16:48.247] invokeRestart(restart)
     [14:16:48.247] muffled <- TRUE
     [14:16:48.247] break
     [14:16:48.247] }
     [14:16:48.247] }
     [14:16:48.247] invisible(muffled)
     [14:16:48.247] }
     [14:16:48.247] muffleCondition(cond)
     [14:16:48.247] }
     [14:16:48.247] }
     [14:16:48.247] }
     [14:16:48.247] }))
     [14:16:48.247] }, error = function(ex) {
     [14:16:48.247] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.247] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.247] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.247] }, finally = {
     [14:16:48.247] {
     [14:16:48.247] {
     [14:16:48.247] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.247] }
     [14:16:48.247] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.247] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.247] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.247] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.247] {
     [14:16:48.247] if (substitute)
     [14:16:48.247] expr <- substitute(expr)
     [14:16:48.247] if (is.function(workers))
     [14:16:48.247] workers <- workers()
     [14:16:48.247] workers <- as.integer(workers)
     [14:16:48.247] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.247] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.247] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.247] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.247] local = TRUE, label = label, ...))
     [14:16:48.247] }
     [14:16:48.247] oopts <- options(mc.cores = workers)
     [14:16:48.247] on.exit(options(oopts))
     [14:16:48.247] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.247] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.247] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.247] label = label, ...)
     [14:16:48.247] if (!future$lazy)
     [14:16:48.247] future <- run(future)
     [14:16:48.247] invisible(future)
     [14:16:48.247] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.247] }
     [14:16:48.247] base::options(...future.oldOptions)
     [14:16:48.247] })
     [14:16:48.247] Sys.time
     [14:16:48.247] if (base::is.na(TRUE)) {
     [14:16:48.247] }
     [14:16:48.247] else {
     [14:16:48.247] base::sink(type = "output", split = FALSE)
     [14:16:48.247] if (TRUE) {
     [14:16:48.247] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.247] }
     [14:16:48.247] else {
     [14:16:48.247] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.247] }
     [14:16:48.247] base::close(...future.stdout)
     [14:16:48.247] ...future.stdout <- NULL
     [14:16:48.247] }
     [14:16:48.247] ...future.result$conditions <- ...future.conditions
     [14:16:48.247] ...future.result
     [14:16:48.247] }
     [14:16:48.252] requestCore(): workers = 2
     [14:16:48.255] MulticoreFuture started
     [14:16:48.261] plan(): Setting new future strategy stack:
     [14:16:48.262] List of future strategies:
     [14:16:48.262] 1. sequential:
     [14:16:48.262] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.262] - tweaked: FALSE
     [14:16:48.262] - call: NULL
     [14:16:48.263] plan(): nbrOfWorkers() = 1
     [14:16:48.268] plan(): Setting new future strategy stack:
     [14:16:48.268] List of future strategies:
     [14:16:48.268] 1. multicore:
     [14:16:48.268] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.268] - tweaked: FALSE
     [14:16:48.268] - call: plan(strategy)
     [14:16:48.271] plan(): nbrOfWorkers() = 2
    
     Call:
     lm(formula = weight ~ group - 1)
    
     Coefficients:
     groupCtl groupTrt
     5.032 4.661
    
     [14:16:48.280] getGlobalsAndPackages() ...
     [14:16:48.280] Searching for globals...
     [14:16:48.285] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
     [14:16:48.289] Searching for globals ... DONE
     [14:16:48.290] Resolving globals: FALSE
     [14:16:48.291] The total size of the 2 globals is 896 bytes (896 bytes)
     [14:16:48.292] - globals: [2] 'weight', 'group'
     [14:16:48.292] - packages: [1] 'stats'
     [14:16:48.293] getGlobalsAndPackages() ... DONE
     [14:16:48.295] Packages needed by the future expression (n = 0): <none>
     [14:16:48.296] Packages needed by future strategies (n = 0): <none>
     [14:16:48.302] {
     [14:16:48.302] {
     [14:16:48.302] ...future.startTime <- base::Sys.time()
     [14:16:48.302] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.302] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.302] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.302] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.302] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.302] {
     [14:16:48.302] {
     [14:16:48.302] {
     [14:16:48.302] has_future <- base::requireNamespace("future",
     [14:16:48.302] quietly = TRUE)
     [14:16:48.302] version <- if (has_future)
     [14:16:48.302] utils::packageVersion("future")
     [14:16:48.302] else NULL
     [14:16:48.302] if (!has_future || version < "1.8.0") {
     [14:16:48.302] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.302] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.302] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.302] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.302] "release", "version")], collapse = " "),
     [14:16:48.302] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.302] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.302] info)
     [14:16:48.302] info <- base::paste(info, collapse = "; ")
     [14:16:48.302] if (!has_future) {
     [14:16:48.302] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.302] info)
     [14:16:48.302] }
     [14:16:48.302] else {
     [14:16:48.302] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.302] info, version)
     [14:16:48.302] }
     [14:16:48.302] base::stop(msg)
     [14:16:48.302] }
     [14:16:48.302] }
     [14:16:48.302] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.302] base::options(mc.cores = 1L)
     [14:16:48.302] }
     [14:16:48.302] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.302] }
     [14:16:48.302] }
     [14:16:48.302] if (base::is.na(TRUE)) {
     [14:16:48.302] }
     [14:16:48.302] else {
     [14:16:48.302] if (TRUE) {
     [14:16:48.302] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.302] open = "w")
     [14:16:48.302] }
     [14:16:48.302] else {
     [14:16:48.302] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.302] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.302] }
     [14:16:48.302] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.302] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.302] base::sink(type = "output", split = FALSE)
     [14:16:48.302] base::close(...future.stdout)
     [14:16:48.302] }, add = TRUE)
     [14:16:48.302] }
     [14:16:48.302] ...future.frame <- base::sys.nframe()
     [14:16:48.302] ...future.conditions <- base::list()
     [14:16:48.302] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.302] ...future.result <- base::tryCatch({
     [14:16:48.302] base::withCallingHandlers({
     [14:16:48.302] ...future.value <- base::withVisible(base::local({
     [14:16:48.302] lm(weight ~ group - 1)
     [14:16:48.302] }))
     [14:16:48.302] future::FutureResult(value = ...future.value$value,
     [14:16:48.302] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.302] ...future.rng), started = ...future.startTime,
     [14:16:48.302] version = "1.8")
     [14:16:48.302] }, condition = base::local({
     [14:16:48.302] c <- base::c
     [14:16:48.302] inherits <- base::inherits
     [14:16:48.302] invokeRestart <- base::invokeRestart
     [14:16:48.302] length <- base::length
     [14:16:48.302] list <- base::list
     [14:16:48.302] seq.int <- base::seq.int
     [14:16:48.302] signalCondition <- base::signalCondition
     [14:16:48.302] sys.calls <- base::sys.calls
     [14:16:48.302] Sys.time <- base::Sys.time
     [14:16:48.302] `[[` <- base::`[[`
     [14:16:48.302] `+` <- base::`+`
     [14:16:48.302] `<<-` <- base::`<<-`
     [14:16:48.302] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.302] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.302] 3L)]
     [14:16:48.302] }
     [14:16:48.302] function(cond) {
     [14:16:48.302] if (inherits(cond, "error")) {
     [14:16:48.302] ...future.conditions[[length(...future.conditions) +
     [14:16:48.302] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.302] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.302] signalCondition(cond)
     [14:16:48.302] }
     [14:16:48.302] else if (inherits(cond, "condition")) {
     [14:16:48.302] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.302] ...future.conditions[[length(...future.conditions) +
     [14:16:48.302] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.302] if (!signal) {
     [14:16:48.302] muffleCondition <- function (cond)
     [14:16:48.302] {
     [14:16:48.302] inherits <- base::inherits
     [14:16:48.302] invokeRestart <- base::invokeRestart
     [14:16:48.302] muffled <- FALSE
     [14:16:48.302] if (inherits(cond, "message")) {
     [14:16:48.302] invokeRestart("muffleMessage")
     [14:16:48.302] muffled <- TRUE
     [14:16:48.302] }
     [14:16:48.302] else if (inherits(cond, "warning")) {
     [14:16:48.302] invokeRestart("muffleWarning")
     [14:16:48.302] muffled <- TRUE
     [14:16:48.302] }
     [14:16:48.302] else if (inherits(cond, "condition")) {
     [14:16:48.302] computeRestarts <- base::computeRestarts
     [14:16:48.302] grepl <- base::grepl
     [14:16:48.302] is.null <- base::is.null
     [14:16:48.302] restarts <- computeRestarts(cond)
     [14:16:48.302] for (restart in restarts) {
     [14:16:48.302] name <- restart$name
     [14:16:48.302] if (is.null(name))
     [14:16:48.302] next
     [14:16:48.302] if (!grepl("^muffle", name))
     [14:16:48.302] next
     [14:16:48.302] invokeRestart(restart)
     [14:16:48.302] muffled <- TRUE
     [14:16:48.302] break
     [14:16:48.302] }
     [14:16:48.302] }
     [14:16:48.302] invisible(muffled)
     [14:16:48.302] }
     [14:16:48.302] muffleCondition(cond)
     [14:16:48.302] }
     [14:16:48.302] }
     [14:16:48.302] }
     [14:16:48.302] }))
     [14:16:48.302] }, error = function(ex) {
     [14:16:48.302] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.302] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.302] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.302] }, finally = {
     [14:16:48.302] {
     [14:16:48.302] {
     [14:16:48.302] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.302] }
     [14:16:48.302] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.302] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.302] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.302] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.302] {
     [14:16:48.302] if (substitute)
     [14:16:48.302] expr <- substitute(expr)
     [14:16:48.302] if (is.function(workers))
     [14:16:48.302] workers <- workers()
     [14:16:48.302] workers <- as.integer(workers)
     [14:16:48.302] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.302] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.302] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.302] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.302] local = TRUE, label = label, ...))
     [14:16:48.302] }
     [14:16:48.302] oopts <- options(mc.cores = workers)
     [14:16:48.302] on.exit(options(oopts))
     [14:16:48.302] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.302] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.302] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.302] label = label, ...)
     [14:16:48.302] if (!future$lazy)
     [14:16:48.302] future <- run(future)
     [14:16:48.302] invisible(future)
     [14:16:48.302] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.302] }
     [14:16:48.302] base::options(...future.oldOptions)
     [14:16:48.302] })
     [14:16:48.302] Sys.time
     [14:16:48.302] if (base::is.na(TRUE)) {
     [14:16:48.302] }
     [14:16:48.302] else {
     [14:16:48.302] base::sink(type = "output", split = FALSE)
     [14:16:48.302] if (TRUE) {
     [14:16:48.302] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.302] }
     [14:16:48.302] else {
     [14:16:48.302] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.302] }
     [14:16:48.302] base::close(...future.stdout)
     [14:16:48.302] ...future.stdout <- NULL
     [14:16:48.302] }
     [14:16:48.302] ...future.result$conditions <- ...future.conditions
     [14:16:48.302] ...future.result
     [14:16:48.302] }
     [14:16:48.307] requestCore(): workers = 2
     [14:16:48.311] MulticoreFuture started
     [14:16:48.316] plan(): Setting new future strategy stack:
     [14:16:48.317] List of future strategies:
     [14:16:48.317] 1. sequential:
     [14:16:48.317] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.317] - tweaked: FALSE
     [14:16:48.317] - call: NULL
     [14:16:48.318] plan(): nbrOfWorkers() = 1
     [14:16:48.323] plan(): Setting new future strategy stack:
     [14:16:48.324] List of future strategies:
     [14:16:48.324] 1. multicore:
     [14:16:48.324] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.324] - tweaked: FALSE
     [14:16:48.324] - call: plan(strategy)
     [14:16:48.327] plan(): nbrOfWorkers() = 2
    
     Call:
     lm(formula = weight ~ group - 1)
    
     Coefficients:
     groupCtl groupTrt
     5.032 4.661
    
     [14:16:48.335] getGlobalsAndPackages() ...
     [14:16:48.336] Searching for globals...
     [14:16:48.346] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
     [14:16:48.346] Searching for globals ... DONE
     [14:16:48.347] Resolving globals: FALSE
     [14:16:48.348] The total size of the 2 globals is 896 bytes (896 bytes)
     [14:16:48.349] - globals: [2] 'weight', 'group'
     [14:16:48.349] - packages: [1] 'stats'
     [14:16:48.349] getGlobalsAndPackages() ... DONE
     [14:16:48.352] Packages needed by the future expression (n = 0): <none>
     [14:16:48.353] Packages needed by future strategies (n = 0): <none>
     [14:16:48.359] {
     [14:16:48.359] {
     [14:16:48.359] ...future.startTime <- base::Sys.time()
     [14:16:48.359] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.359] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.359] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.359] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.359] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.359] {
     [14:16:48.359] {
     [14:16:48.359] {
     [14:16:48.359] has_future <- base::requireNamespace("future",
     [14:16:48.359] quietly = TRUE)
     [14:16:48.359] version <- if (has_future)
     [14:16:48.359] utils::packageVersion("future")
     [14:16:48.359] else NULL
     [14:16:48.359] if (!has_future || version < "1.8.0") {
     [14:16:48.359] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.359] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.359] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.359] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.359] "release", "version")], collapse = " "),
     [14:16:48.359] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.359] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.359] info)
     [14:16:48.359] info <- base::paste(info, collapse = "; ")
     [14:16:48.359] if (!has_future) {
     [14:16:48.359] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.359] info)
     [14:16:48.359] }
     [14:16:48.359] else {
     [14:16:48.359] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.359] info, version)
     [14:16:48.359] }
     [14:16:48.359] base::stop(msg)
     [14:16:48.359] }
     [14:16:48.359] }
     [14:16:48.359] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.359] base::options(mc.cores = 1L)
     [14:16:48.359] }
     [14:16:48.359] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.359] }
     [14:16:48.359] }
     [14:16:48.359] if (base::is.na(TRUE)) {
     [14:16:48.359] }
     [14:16:48.359] else {
     [14:16:48.359] if (TRUE) {
     [14:16:48.359] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.359] open = "w")
     [14:16:48.359] }
     [14:16:48.359] else {
     [14:16:48.359] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.359] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.359] }
     [14:16:48.359] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.359] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.359] base::sink(type = "output", split = FALSE)
     [14:16:48.359] base::close(...future.stdout)
     [14:16:48.359] }, add = TRUE)
     [14:16:48.359] }
     [14:16:48.359] ...future.frame <- base::sys.nframe()
     [14:16:48.359] ...future.conditions <- base::list()
     [14:16:48.359] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.359] ...future.result <- base::tryCatch({
     [14:16:48.359] base::withCallingHandlers({
     [14:16:48.359] ...future.value <- base::withVisible(base::local({
     [14:16:48.359] lm(weight ~ group - 1)
     [14:16:48.359] }))
     [14:16:48.359] future::FutureResult(value = ...future.value$value,
     [14:16:48.359] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.359] ...future.rng), started = ...future.startTime,
     [14:16:48.359] version = "1.8")
     [14:16:48.359] }, condition = base::local({
     [14:16:48.359] c <- base::c
     [14:16:48.359] inherits <- base::inherits
     [14:16:48.359] invokeRestart <- base::invokeRestart
     [14:16:48.359] length <- base::length
     [14:16:48.359] list <- base::list
     [14:16:48.359] seq.int <- base::seq.int
     [14:16:48.359] signalCondition <- base::signalCondition
     [14:16:48.359] sys.calls <- base::sys.calls
     [14:16:48.359] Sys.time <- base::Sys.time
     [14:16:48.359] `[[` <- base::`[[`
     [14:16:48.359] `+` <- base::`+`
     [14:16:48.359] `<<-` <- base::`<<-`
     [14:16:48.359] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.359] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.359] 3L)]
     [14:16:48.359] }
     [14:16:48.359] function(cond) {
     [14:16:48.359] if (inherits(cond, "error")) {
     [14:16:48.359] ...future.conditions[[length(...future.conditions) +
     [14:16:48.359] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.359] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.359] signalCondition(cond)
     [14:16:48.359] }
     [14:16:48.359] else if (inherits(cond, "condition")) {
     [14:16:48.359] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.359] ...future.conditions[[length(...future.conditions) +
     [14:16:48.359] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.359] if (!signal) {
     [14:16:48.359] muffleCondition <- function (cond)
     [14:16:48.359] {
     [14:16:48.359] inherits <- base::inherits
     [14:16:48.359] invokeRestart <- base::invokeRestart
     [14:16:48.359] muffled <- FALSE
     [14:16:48.359] if (inherits(cond, "message")) {
     [14:16:48.359] invokeRestart("muffleMessage")
     [14:16:48.359] muffled <- TRUE
     [14:16:48.359] }
     [14:16:48.359] else if (inherits(cond, "warning")) {
     [14:16:48.359] invokeRestart("muffleWarning")
     [14:16:48.359] muffled <- TRUE
     [14:16:48.359] }
     [14:16:48.359] else if (inherits(cond, "condition")) {
     [14:16:48.359] computeRestarts <- base::computeRestarts
     [14:16:48.359] grepl <- base::grepl
     [14:16:48.359] is.null <- base::is.null
     [14:16:48.359] restarts <- computeRestarts(cond)
     [14:16:48.359] for (restart in restarts) {
     [14:16:48.359] name <- restart$name
     [14:16:48.359] if (is.null(name))
     [14:16:48.359] next
     [14:16:48.359] if (!grepl("^muffle", name))
     [14:16:48.359] next
     [14:16:48.359] invokeRestart(restart)
     [14:16:48.359] muffled <- TRUE
     [14:16:48.359] break
     [14:16:48.359] }
     [14:16:48.359] }
     [14:16:48.359] invisible(muffled)
     [14:16:48.359] }
     [14:16:48.359] muffleCondition(cond)
     [14:16:48.359] }
     [14:16:48.359] }
     [14:16:48.359] }
     [14:16:48.359] }))
     [14:16:48.359] }, error = function(ex) {
     [14:16:48.359] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.359] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.359] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.359] }, finally = {
     [14:16:48.359] {
     [14:16:48.359] {
     [14:16:48.359] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.359] }
     [14:16:48.359] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.359] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.359] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.359] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.359] {
     [14:16:48.359] if (substitute)
     [14:16:48.359] expr <- substitute(expr)
     [14:16:48.359] if (is.function(workers))
     [14:16:48.359] workers <- workers()
     [14:16:48.359] workers <- as.integer(workers)
     [14:16:48.359] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.359] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.359] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.359] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.359] local = TRUE, label = label, ...))
     [14:16:48.359] }
     [14:16:48.359] oopts <- options(mc.cores = workers)
     [14:16:48.359] on.exit(options(oopts))
     [14:16:48.359] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.359] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.359] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.359] label = label, ...)
     [14:16:48.359] if (!future$lazy)
     [14:16:48.359] future <- run(future)
     [14:16:48.359] invisible(future)
     [14:16:48.359] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.359] }
     [14:16:48.359] base::options(...future.oldOptions)
     [14:16:48.359] })
     [14:16:48.359] Sys.time
     [14:16:48.359] if (base::is.na(TRUE)) {
     [14:16:48.359] }
     [14:16:48.359] else {
     [14:16:48.359] base::sink(type = "output", split = FALSE)
     [14:16:48.359] if (TRUE) {
     [14:16:48.359] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.359] }
     [14:16:48.359] else {
     [14:16:48.359] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.359] }
     [14:16:48.359] base::close(...future.stdout)
     [14:16:48.359] ...future.stdout <- NULL
     [14:16:48.359] }
     [14:16:48.359] ...future.result$conditions <- ...future.conditions
     [14:16:48.359] ...future.result
     [14:16:48.359] }
     [14:16:48.363] requestCore(): workers = 2
     [14:16:48.367] MulticoreFuture started
     [14:16:48.372] plan(): Setting new future strategy stack:
     [14:16:48.373] List of future strategies:
     [14:16:48.373] 1. sequential:
     [14:16:48.373] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.373] - tweaked: FALSE
     [14:16:48.373] - call: NULL
     [14:16:48.375] plan(): nbrOfWorkers() = 1
     [14:16:48.379] plan(): Setting new future strategy stack:
     [14:16:48.380] List of future strategies:
     [14:16:48.380] 1. multicore:
     [14:16:48.380] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.380] - tweaked: FALSE
     [14:16:48.380] - call: plan(strategy)
     [14:16:48.382] plan(): nbrOfWorkers() = 2
    
     Call:
     lm(formula = weight ~ group - 1)
    
     Coefficients:
     groupCtl groupTrt
     5.032 4.661
    
     [14:16:48.391] getGlobalsAndPackages() ...
     [14:16:48.391] Searching for globals...
     [14:16:48.396] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
     [14:16:48.397] Searching for globals ... DONE
     [14:16:48.397] Resolving globals: FALSE
     [14:16:48.402] The total size of the 2 globals is 896 bytes (896 bytes)
     [14:16:48.403] - globals: [2] 'weight', 'group'
     [14:16:48.403] - packages: [1] 'stats'
     [14:16:48.403] getGlobalsAndPackages() ... DONE
     [14:16:48.406] Packages needed by the future expression (n = 0): <none>
     [14:16:48.407] Packages needed by future strategies (n = 0): <none>
     [14:16:48.412] {
     [14:16:48.412] {
     [14:16:48.412] ...future.startTime <- base::Sys.time()
     [14:16:48.412] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.412] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.412] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.412] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.412] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.412] {
     [14:16:48.412] {
     [14:16:48.412] {
     [14:16:48.412] has_future <- base::requireNamespace("future",
     [14:16:48.412] quietly = TRUE)
     [14:16:48.412] version <- if (has_future)
     [14:16:48.412] utils::packageVersion("future")
     [14:16:48.412] else NULL
     [14:16:48.412] if (!has_future || version < "1.8.0") {
     [14:16:48.412] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.412] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.412] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.412] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.412] "release", "version")], collapse = " "),
     [14:16:48.412] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.412] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.412] info)
     [14:16:48.412] info <- base::paste(info, collapse = "; ")
     [14:16:48.412] if (!has_future) {
     [14:16:48.412] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.412] info)
     [14:16:48.412] }
     [14:16:48.412] else {
     [14:16:48.412] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.412] info, version)
     [14:16:48.412] }
     [14:16:48.412] base::stop(msg)
     [14:16:48.412] }
     [14:16:48.412] }
     [14:16:48.412] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.412] base::options(mc.cores = 1L)
     [14:16:48.412] }
     [14:16:48.412] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.412] }
     [14:16:48.412] }
     [14:16:48.412] if (base::is.na(TRUE)) {
     [14:16:48.412] }
     [14:16:48.412] else {
     [14:16:48.412] if (TRUE) {
     [14:16:48.412] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.412] open = "w")
     [14:16:48.412] }
     [14:16:48.412] else {
     [14:16:48.412] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.412] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.412] }
     [14:16:48.412] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.412] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.412] base::sink(type = "output", split = FALSE)
     [14:16:48.412] base::close(...future.stdout)
     [14:16:48.412] }, add = TRUE)
     [14:16:48.412] }
     [14:16:48.412] ...future.frame <- base::sys.nframe()
     [14:16:48.412] ...future.conditions <- base::list()
     [14:16:48.412] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.412] ...future.result <- base::tryCatch({
     [14:16:48.412] base::withCallingHandlers({
     [14:16:48.412] ...future.value <- base::withVisible(base::local({
     [14:16:48.412] lm(weight ~ group - 1)
     [14:16:48.412] }))
     [14:16:48.412] future::FutureResult(value = ...future.value$value,
     [14:16:48.412] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.412] ...future.rng), started = ...future.startTime,
     [14:16:48.412] version = "1.8")
     [14:16:48.412] }, condition = base::local({
     [14:16:48.412] c <- base::c
     [14:16:48.412] inherits <- base::inherits
     [14:16:48.412] invokeRestart <- base::invokeRestart
     [14:16:48.412] length <- base::length
     [14:16:48.412] list <- base::list
     [14:16:48.412] seq.int <- base::seq.int
     [14:16:48.412] signalCondition <- base::signalCondition
     [14:16:48.412] sys.calls <- base::sys.calls
     [14:16:48.412] Sys.time <- base::Sys.time
     [14:16:48.412] `[[` <- base::`[[`
     [14:16:48.412] `+` <- base::`+`
     [14:16:48.412] `<<-` <- base::`<<-`
     [14:16:48.412] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.412] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.412] 3L)]
     [14:16:48.412] }
     [14:16:48.412] function(cond) {
     [14:16:48.412] if (inherits(cond, "error")) {
     [14:16:48.412] ...future.conditions[[length(...future.conditions) +
     [14:16:48.412] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.412] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.412] signalCondition(cond)
     [14:16:48.412] }
     [14:16:48.412] else if (inherits(cond, "condition")) {
     [14:16:48.412] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.412] ...future.conditions[[length(...future.conditions) +
     [14:16:48.412] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.412] if (!signal) {
     [14:16:48.412] muffleCondition <- function (cond)
     [14:16:48.412] {
     [14:16:48.412] inherits <- base::inherits
     [14:16:48.412] invokeRestart <- base::invokeRestart
     [14:16:48.412] muffled <- FALSE
     [14:16:48.412] if (inherits(cond, "message")) {
     [14:16:48.412] invokeRestart("muffleMessage")
     [14:16:48.412] muffled <- TRUE
     [14:16:48.412] }
     [14:16:48.412] else if (inherits(cond, "warning")) {
     [14:16:48.412] invokeRestart("muffleWarning")
     [14:16:48.412] muffled <- TRUE
     [14:16:48.412] }
     [14:16:48.412] else if (inherits(cond, "condition")) {
     [14:16:48.412] computeRestarts <- base::computeRestarts
     [14:16:48.412] grepl <- base::grepl
     [14:16:48.412] is.null <- base::is.null
     [14:16:48.412] restarts <- computeRestarts(cond)
     [14:16:48.412] for (restart in restarts) {
     [14:16:48.412] name <- restart$name
     [14:16:48.412] if (is.null(name))
     [14:16:48.412] next
     [14:16:48.412] if (!grepl("^muffle", name))
     [14:16:48.412] next
     [14:16:48.412] invokeRestart(restart)
     [14:16:48.412] muffled <- TRUE
     [14:16:48.412] break
     [14:16:48.412] }
     [14:16:48.412] }
     [14:16:48.412] invisible(muffled)
     [14:16:48.412] }
     [14:16:48.412] muffleCondition(cond)
     [14:16:48.412] }
     [14:16:48.412] }
     [14:16:48.412] }
     [14:16:48.412] }))
     [14:16:48.412] }, error = function(ex) {
     [14:16:48.412] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.412] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.412] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.412] }, finally = {
     [14:16:48.412] {
     [14:16:48.412] {
     [14:16:48.412] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.412] }
     [14:16:48.412] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.412] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.412] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.412] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.412] {
     [14:16:48.412] if (substitute)
     [14:16:48.412] expr <- substitute(expr)
     [14:16:48.412] if (is.function(workers))
     [14:16:48.412] workers <- workers()
     [14:16:48.412] workers <- as.integer(workers)
     [14:16:48.412] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.412] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.412] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.412] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.412] local = TRUE, label = label, ...))
     [14:16:48.412] }
     [14:16:48.412] oopts <- options(mc.cores = workers)
     [14:16:48.412] on.exit(options(oopts))
     [14:16:48.412] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.412] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.412] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.412] label = label, ...)
     [14:16:48.412] if (!future$lazy)
     [14:16:48.412] future <- run(future)
     [14:16:48.412] invisible(future)
     [14:16:48.412] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.412] }
     [14:16:48.412] base::options(...future.oldOptions)
     [14:16:48.412] })
     [14:16:48.412] Sys.time
     [14:16:48.412] if (base::is.na(TRUE)) {
     [14:16:48.412] }
     [14:16:48.412] else {
     [14:16:48.412] base::sink(type = "output", split = FALSE)
     [14:16:48.412] if (TRUE) {
     [14:16:48.412] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.412] }
     [14:16:48.412] else {
     [14:16:48.412] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.412] }
     [14:16:48.412] base::close(...future.stdout)
     [14:16:48.412] ...future.stdout <- NULL
     [14:16:48.412] }
     [14:16:48.412] ...future.result$conditions <- ...future.conditions
     [14:16:48.412] ...future.result
     [14:16:48.412] }
     [14:16:48.417] requestCore(): workers = 2
     [14:16:48.420] MulticoreFuture started
     [14:16:48.425] plan(): Setting new future strategy stack:
     [14:16:48.426] List of future strategies:
     [14:16:48.426] 1. sequential:
     [14:16:48.426] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.426] - tweaked: FALSE
     [14:16:48.426] - call: NULL
     [14:16:48.427] plan(): nbrOfWorkers() = 1
     [14:16:48.432] plan(): Setting new future strategy stack:
     [14:16:48.432] List of future strategies:
     [14:16:48.432] 1. multicore:
     [14:16:48.432] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.432] - tweaked: FALSE
     [14:16:48.432] - call: plan(strategy)
     [14:16:48.435] plan(): nbrOfWorkers() = 2
    
     Call:
     lm(formula = weight ~ group - 1)
    
     Coefficients:
     groupCtl groupTrt
     5.032 4.661
    
     - Globals - one-side formulas, e.g. xtabs(~ x) ...
     [14:16:48.443] getGlobalsAndPackages() ...
     [14:16:48.443] Searching for globals...
     [14:16:48.447] - globals found: [4] '{', 'xtabs', 'x', '~'
     [14:16:48.447] Searching for globals ... DONE
     [14:16:48.448] Resolving globals: FALSE
     [14:16:48.449] The total size of the 1 globals is 96 bytes (96 bytes)
     [14:16:48.450] - globals: [1] 'x'
     [14:16:48.450] - packages: [1] 'stats'
     [14:16:48.454] getGlobalsAndPackages() ... DONE
     [14:16:48.456] Packages needed by the future expression (n = 0): <none>
     [14:16:48.457] Packages needed by future strategies (n = 0): <none>
     [14:16:48.467] {
     [14:16:48.467] {
     [14:16:48.467] ...future.startTime <- base::Sys.time()
     [14:16:48.467] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.467] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.467] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.467] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.467] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.467] {
     [14:16:48.467] {
     [14:16:48.467] {
     [14:16:48.467] has_future <- base::requireNamespace("future",
     [14:16:48.467] quietly = TRUE)
     [14:16:48.467] version <- if (has_future)
     [14:16:48.467] utils::packageVersion("future")
     [14:16:48.467] else NULL
     [14:16:48.467] if (!has_future || version < "1.8.0") {
     [14:16:48.467] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.467] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.467] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.467] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.467] "release", "version")], collapse = " "),
     [14:16:48.467] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.467] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.467] info)
     [14:16:48.467] info <- base::paste(info, collapse = "; ")
     [14:16:48.467] if (!has_future) {
     [14:16:48.467] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.467] info)
     [14:16:48.467] }
     [14:16:48.467] else {
     [14:16:48.467] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.467] info, version)
     [14:16:48.467] }
     [14:16:48.467] base::stop(msg)
     [14:16:48.467] }
     [14:16:48.467] }
     [14:16:48.467] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.467] base::options(mc.cores = 1L)
     [14:16:48.467] }
     [14:16:48.467] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.467] }
     [14:16:48.467] }
     [14:16:48.467] if (base::is.na(TRUE)) {
     [14:16:48.467] }
     [14:16:48.467] else {
     [14:16:48.467] if (TRUE) {
     [14:16:48.467] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.467] open = "w")
     [14:16:48.467] }
     [14:16:48.467] else {
     [14:16:48.467] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.467] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.467] }
     [14:16:48.467] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.467] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.467] base::sink(type = "output", split = FALSE)
     [14:16:48.467] base::close(...future.stdout)
     [14:16:48.467] }, add = TRUE)
     [14:16:48.467] }
     [14:16:48.467] ...future.frame <- base::sys.nframe()
     [14:16:48.467] ...future.conditions <- base::list()
     [14:16:48.467] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.467] ...future.result <- base::tryCatch({
     [14:16:48.467] base::withCallingHandlers({
     [14:16:48.467] ...future.value <- base::withVisible(base::local({
     [14:16:48.467] xtabs(~x)
     [14:16:48.467] }))
     [14:16:48.467] future::FutureResult(value = ...future.value$value,
     [14:16:48.467] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.467] ...future.rng), started = ...future.startTime,
     [14:16:48.467] version = "1.8")
     [14:16:48.467] }, condition = base::local({
     [14:16:48.467] c <- base::c
     [14:16:48.467] inherits <- base::inherits
     [14:16:48.467] invokeRestart <- base::invokeRestart
     [14:16:48.467] length <- base::length
     [14:16:48.467] list <- base::list
     [14:16:48.467] seq.int <- base::seq.int
     [14:16:48.467] signalCondition <- base::signalCondition
     [14:16:48.467] sys.calls <- base::sys.calls
     [14:16:48.467] Sys.time <- base::Sys.time
     [14:16:48.467] `[[` <- base::`[[`
     [14:16:48.467] `+` <- base::`+`
     [14:16:48.467] `<<-` <- base::`<<-`
     [14:16:48.467] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.467] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.467] 3L)]
     [14:16:48.467] }
     [14:16:48.467] function(cond) {
     [14:16:48.467] if (inherits(cond, "error")) {
     [14:16:48.467] ...future.conditions[[length(...future.conditions) +
     [14:16:48.467] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.467] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.467] signalCondition(cond)
     [14:16:48.467] }
     [14:16:48.467] else if (inherits(cond, "condition")) {
     [14:16:48.467] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.467] ...future.conditions[[length(...future.conditions) +
     [14:16:48.467] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.467] if (!signal) {
     [14:16:48.467] muffleCondition <- function (cond)
     [14:16:48.467] {
     [14:16:48.467] inherits <- base::inherits
     [14:16:48.467] invokeRestart <- base::invokeRestart
     [14:16:48.467] muffled <- FALSE
     [14:16:48.467] if (inherits(cond, "message")) {
     [14:16:48.467] invokeRestart("muffleMessage")
     [14:16:48.467] muffled <- TRUE
     [14:16:48.467] }
     [14:16:48.467] else if (inherits(cond, "warning")) {
     [14:16:48.467] invokeRestart("muffleWarning")
     [14:16:48.467] muffled <- TRUE
     [14:16:48.467] }
     [14:16:48.467] else if (inherits(cond, "condition")) {
     [14:16:48.467] computeRestarts <- base::computeRestarts
     [14:16:48.467] grepl <- base::grepl
     [14:16:48.467] is.null <- base::is.null
     [14:16:48.467] restarts <- computeRestarts(cond)
     [14:16:48.467] for (restart in restarts) {
     [14:16:48.467] name <- restart$name
     [14:16:48.467] if (is.null(name))
     [14:16:48.467] next
     [14:16:48.467] if (!grepl("^muffle", name))
     [14:16:48.467] next
     [14:16:48.467] invokeRestart(restart)
     [14:16:48.467] muffled <- TRUE
     [14:16:48.467] break
     [14:16:48.467] }
     [14:16:48.467] }
     [14:16:48.467] invisible(muffled)
     [14:16:48.467] }
     [14:16:48.467] muffleCondition(cond)
     [14:16:48.467] }
     [14:16:48.467] }
     [14:16:48.467] }
     [14:16:48.467] }))
     [14:16:48.467] }, error = function(ex) {
     [14:16:48.467] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.467] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.467] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.467] }, finally = {
     [14:16:48.467] {
     [14:16:48.467] {
     [14:16:48.467] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.467] }
     [14:16:48.467] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.467] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.467] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.467] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.467] {
     [14:16:48.467] if (substitute)
     [14:16:48.467] expr <- substitute(expr)
     [14:16:48.467] if (is.function(workers))
     [14:16:48.467] workers <- workers()
     [14:16:48.467] workers <- as.integer(workers)
     [14:16:48.467] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.467] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.467] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.467] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.467] local = TRUE, label = label, ...))
     [14:16:48.467] }
     [14:16:48.467] oopts <- options(mc.cores = workers)
     [14:16:48.467] on.exit(options(oopts))
     [14:16:48.467] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.467] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.467] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.467] label = label, ...)
     [14:16:48.467] if (!future$lazy)
     [14:16:48.467] future <- run(future)
     [14:16:48.467] invisible(future)
     [14:16:48.467] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.467] }
     [14:16:48.467] base::options(...future.oldOptions)
     [14:16:48.467] })
     [14:16:48.467] Sys.time
     [14:16:48.467] if (base::is.na(TRUE)) {
     [14:16:48.467] }
     [14:16:48.467] else {
     [14:16:48.467] base::sink(type = "output", split = FALSE)
     [14:16:48.467] if (TRUE) {
     [14:16:48.467] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.467] }
     [14:16:48.467] else {
     [14:16:48.467] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.467] }
     [14:16:48.467] base::close(...future.stdout)
     [14:16:48.467] ...future.stdout <- NULL
     [14:16:48.467] }
     [14:16:48.467] ...future.result$conditions <- ...future.conditions
     [14:16:48.467] ...future.result
     [14:16:48.467] }
     [14:16:48.471] requestCore(): workers = 2
     [14:16:48.475] MulticoreFuture started
     [14:16:48.495] plan(): Setting new future strategy stack:
     [14:16:48.495] List of future strategies:
     [14:16:48.495] 1. sequential:
     [14:16:48.495] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.495] - tweaked: FALSE
     [14:16:48.495] - call: NULL
     [14:16:48.497] plan(): nbrOfWorkers() = 1
     [14:16:48.502] plan(): Setting new future strategy stack:
     [14:16:48.502] List of future strategies:
     [14:16:48.502] 1. multicore:
     [14:16:48.502] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.502] - tweaked: FALSE
     [14:16:48.502] - call: plan(strategy)
     [14:16:48.505] plan(): nbrOfWorkers() = 2
     x
     1 2
     2 3
     [14:16:48.526] getGlobalsAndPackages() ...
     [14:16:48.526] Searching for globals...
     [14:16:48.529] - globals found: [4] '{', 'xtabs', 'x', '~'
     [14:16:48.530] Searching for globals ... DONE
     [14:16:48.530] Resolving globals: FALSE
     [14:16:48.531] The total size of the 1 globals is 96 bytes (96 bytes)
     [14:16:48.532] - globals: [1] 'x'
     [14:16:48.532] - packages: [1] 'stats'
     [14:16:48.533] getGlobalsAndPackages() ... DONE
     [14:16:48.535] Packages needed by the future expression (n = 0): <none>
     [14:16:48.536] Packages needed by future strategies (n = 0): <none>
     [14:16:48.552] {
     [14:16:48.552] {
     [14:16:48.552] ...future.startTime <- base::Sys.time()
     [14:16:48.552] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.552] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.552] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.552] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.552] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.552] {
     [14:16:48.552] {
     [14:16:48.552] {
     [14:16:48.552] has_future <- base::requireNamespace("future",
     [14:16:48.552] quietly = TRUE)
     [14:16:48.552] version <- if (has_future)
     [14:16:48.552] utils::packageVersion("future")
     [14:16:48.552] else NULL
     [14:16:48.552] if (!has_future || version < "1.8.0") {
     [14:16:48.552] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.552] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.552] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.552] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.552] "release", "version")], collapse = " "),
     [14:16:48.552] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.552] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.552] info)
     [14:16:48.552] info <- base::paste(info, collapse = "; ")
     [14:16:48.552] if (!has_future) {
     [14:16:48.552] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.552] info)
     [14:16:48.552] }
     [14:16:48.552] else {
     [14:16:48.552] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.552] info, version)
     [14:16:48.552] }
     [14:16:48.552] base::stop(msg)
     [14:16:48.552] }
     [14:16:48.552] }
     [14:16:48.552] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.552] base::options(mc.cores = 1L)
     [14:16:48.552] }
     [14:16:48.552] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.552] }
     [14:16:48.552] }
     [14:16:48.552] if (base::is.na(TRUE)) {
     [14:16:48.552] }
     [14:16:48.552] else {
     [14:16:48.552] if (TRUE) {
     [14:16:48.552] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.552] open = "w")
     [14:16:48.552] }
     [14:16:48.552] else {
     [14:16:48.552] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.552] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.552] }
     [14:16:48.552] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.552] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.552] base::sink(type = "output", split = FALSE)
     [14:16:48.552] base::close(...future.stdout)
     [14:16:48.552] }, add = TRUE)
     [14:16:48.552] }
     [14:16:48.552] ...future.frame <- base::sys.nframe()
     [14:16:48.552] ...future.conditions <- base::list()
     [14:16:48.552] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.552] ...future.result <- base::tryCatch({
     [14:16:48.552] base::withCallingHandlers({
     [14:16:48.552] ...future.value <- base::withVisible(base::local({
     [14:16:48.552] xtabs(~x)
     [14:16:48.552] }))
     [14:16:48.552] future::FutureResult(value = ...future.value$value,
     [14:16:48.552] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.552] ...future.rng), started = ...future.startTime,
     [14:16:48.552] version = "1.8")
     [14:16:48.552] }, condition = base::local({
     [14:16:48.552] c <- base::c
     [14:16:48.552] inherits <- base::inherits
     [14:16:48.552] invokeRestart <- base::invokeRestart
     [14:16:48.552] length <- base::length
     [14:16:48.552] list <- base::list
     [14:16:48.552] seq.int <- base::seq.int
     [14:16:48.552] signalCondition <- base::signalCondition
     [14:16:48.552] sys.calls <- base::sys.calls
     [14:16:48.552] Sys.time <- base::Sys.time
     [14:16:48.552] `[[` <- base::`[[`
     [14:16:48.552] `+` <- base::`+`
     [14:16:48.552] `<<-` <- base::`<<-`
     [14:16:48.552] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.552] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.552] 3L)]
     [14:16:48.552] }
     [14:16:48.552] function(cond) {
     [14:16:48.552] if (inherits(cond, "error")) {
     [14:16:48.552] ...future.conditions[[length(...future.conditions) +
     [14:16:48.552] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.552] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.552] signalCondition(cond)
     [14:16:48.552] }
     [14:16:48.552] else if (inherits(cond, "condition")) {
     [14:16:48.552] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.552] ...future.conditions[[length(...future.conditions) +
     [14:16:48.552] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.552] if (!signal) {
     [14:16:48.552] muffleCondition <- function (cond)
     [14:16:48.552] {
     [14:16:48.552] inherits <- base::inherits
     [14:16:48.552] invokeRestart <- base::invokeRestart
     [14:16:48.552] muffled <- FALSE
     [14:16:48.552] if (inherits(cond, "message")) {
     [14:16:48.552] invokeRestart("muffleMessage")
     [14:16:48.552] muffled <- TRUE
     [14:16:48.552] }
     [14:16:48.552] else if (inherits(cond, "warning")) {
     [14:16:48.552] invokeRestart("muffleWarning")
     [14:16:48.552] muffled <- TRUE
     [14:16:48.552] }
     [14:16:48.552] else if (inherits(cond, "condition")) {
     [14:16:48.552] computeRestarts <- base::computeRestarts
     [14:16:48.552] grepl <- base::grepl
     [14:16:48.552] is.null <- base::is.null
     [14:16:48.552] restarts <- computeRestarts(cond)
     [14:16:48.552] for (restart in restarts) {
     [14:16:48.552] name <- restart$name
     [14:16:48.552] if (is.null(name))
     [14:16:48.552] next
     [14:16:48.552] if (!grepl("^muffle", name))
     [14:16:48.552] next
     [14:16:48.552] invokeRestart(restart)
     [14:16:48.552] muffled <- TRUE
     [14:16:48.552] break
     [14:16:48.552] }
     [14:16:48.552] }
     [14:16:48.552] invisible(muffled)
     [14:16:48.552] }
     [14:16:48.552] muffleCondition(cond)
     [14:16:48.552] }
     [14:16:48.552] }
     [14:16:48.552] }
     [14:16:48.552] }))
     [14:16:48.552] }, error = function(ex) {
     [14:16:48.552] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.552] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.552] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.552] }, finally = {
     [14:16:48.552] {
     [14:16:48.552] {
     [14:16:48.552] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.552] }
     [14:16:48.552] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.552] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.552] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.552] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.552] {
     [14:16:48.552] if (substitute)
     [14:16:48.552] expr <- substitute(expr)
     [14:16:48.552] if (is.function(workers))
     [14:16:48.552] workers <- workers()
     [14:16:48.552] workers <- as.integer(workers)
     [14:16:48.552] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.552] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.552] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.552] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.552] local = TRUE, label = label, ...))
     [14:16:48.552] }
     [14:16:48.552] oopts <- options(mc.cores = workers)
     [14:16:48.552] on.exit(options(oopts))
     [14:16:48.552] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.552] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.552] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.552] label = label, ...)
     [14:16:48.552] if (!future$lazy)
     [14:16:48.552] future <- run(future)
     [14:16:48.552] invisible(future)
     [14:16:48.552] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.552] }
     [14:16:48.552] base::options(...future.oldOptions)
     [14:16:48.552] })
     [14:16:48.552] Sys.time
     [14:16:48.552] if (base::is.na(TRUE)) {
     [14:16:48.552] }
     [14:16:48.552] else {
     [14:16:48.552] base::sink(type = "output", split = FALSE)
     [14:16:48.552] if (TRUE) {
     [14:16:48.552] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.552] }
     [14:16:48.552] else {
     [14:16:48.552] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.552] }
     [14:16:48.552] base::close(...future.stdout)
     [14:16:48.552] ...future.stdout <- NULL
     [14:16:48.552] }
     [14:16:48.552] ...future.result$conditions <- ...future.conditions
     [14:16:48.552] ...future.result
     [14:16:48.552] }
     [14:16:48.556] requestCore(): workers = 2
     [14:16:48.560] MulticoreFuture started
     [14:16:48.564] plan(): Setting new future strategy stack:
     [14:16:48.565] List of future strategies:
     [14:16:48.565] 1. sequential:
     [14:16:48.565] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.565] - tweaked: FALSE
     [14:16:48.565] - call: NULL
     [14:16:48.580] plan(): nbrOfWorkers() = 1
     [14:16:48.584] plan(): Setting new future strategy stack:
     [14:16:48.585] List of future strategies:
     [14:16:48.585] 1. multicore:
     [14:16:48.585] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.585] - tweaked: FALSE
     [14:16:48.585] - call: plan(strategy)
     [14:16:48.588] plan(): nbrOfWorkers() = 2
     x
     1 2
     2 3
     - Globals - lm(<formula>, data = cars) ...
     - Globals - lm(<formula #1 ('a')>, data = cars) ...
    
     Call:
     lm(formula = dist ~ . - 1, data = cars)
    
     Coefficients:
     speed
     2.909
    
     [14:16:48.595] getGlobalsAndPackages() ...
     [14:16:48.595] Searching for globals...
     [14:16:48.600] - globals found: [7] '{', 'lm', 'dist', '-', '.', '~', 'cars'
     [14:16:48.601] Searching for globals ... DONE
     [14:16:48.601] Resolving globals: FALSE
     [14:16:48.603]
     [14:16:48.603] - packages: [1] 'stats'
     [14:16:48.603] getGlobalsAndPackages() ... DONE
     [14:16:48.606] Packages needed by the future expression (n = 0): <none>
     [14:16:48.607] Packages needed by future strategies (n = 0): <none>
     [14:16:48.613] {
     [14:16:48.613] {
     [14:16:48.613] ...future.startTime <- base::Sys.time()
     [14:16:48.613] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.613] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.613] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.613] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.613] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.613] {
     [14:16:48.613] {
     [14:16:48.613] {
     [14:16:48.613] has_future <- base::requireNamespace("future",
     [14:16:48.613] quietly = TRUE)
     [14:16:48.613] version <- if (has_future)
     [14:16:48.613] utils::packageVersion("future")
     [14:16:48.613] else NULL
     [14:16:48.613] if (!has_future || version < "1.8.0") {
     [14:16:48.613] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.613] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.613] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.613] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.613] "release", "version")], collapse = " "),
     [14:16:48.613] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.613] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.613] info)
     [14:16:48.613] info <- base::paste(info, collapse = "; ")
     [14:16:48.613] if (!has_future) {
     [14:16:48.613] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.613] info)
     [14:16:48.613] }
     [14:16:48.613] else {
     [14:16:48.613] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.613] info, version)
     [14:16:48.613] }
     [14:16:48.613] base::stop(msg)
     [14:16:48.613] }
     [14:16:48.613] }
     [14:16:48.613] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.613] base::options(mc.cores = 1L)
     [14:16:48.613] }
     [14:16:48.613] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.613] }
     [14:16:48.613] }
     [14:16:48.613] if (base::is.na(TRUE)) {
     [14:16:48.613] }
     [14:16:48.613] else {
     [14:16:48.613] if (TRUE) {
     [14:16:48.613] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.613] open = "w")
     [14:16:48.613] }
     [14:16:48.613] else {
     [14:16:48.613] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.613] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.613] }
     [14:16:48.613] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.613] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.613] base::sink(type = "output", split = FALSE)
     [14:16:48.613] base::close(...future.stdout)
     [14:16:48.613] }, add = TRUE)
     [14:16:48.613] }
     [14:16:48.613] ...future.frame <- base::sys.nframe()
     [14:16:48.613] ...future.conditions <- base::list()
     [14:16:48.613] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.613] ...future.result <- base::tryCatch({
     [14:16:48.613] base::withCallingHandlers({
     [14:16:48.613] ...future.value <- base::withVisible(base::local({
     [14:16:48.613] lm(dist ~ . - 1, data = cars)
     [14:16:48.613] }))
     [14:16:48.613] future::FutureResult(value = ...future.value$value,
     [14:16:48.613] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.613] ...future.rng), started = ...future.startTime,
     [14:16:48.613] version = "1.8")
     [14:16:48.613] }, condition = base::local({
     [14:16:48.613] c <- base::c
     [14:16:48.613] inherits <- base::inherits
     [14:16:48.613] invokeRestart <- base::invokeRestart
     [14:16:48.613] length <- base::length
     [14:16:48.613] list <- base::list
     [14:16:48.613] seq.int <- base::seq.int
     [14:16:48.613] signalCondition <- base::signalCondition
     [14:16:48.613] sys.calls <- base::sys.calls
     [14:16:48.613] Sys.time <- base::Sys.time
     [14:16:48.613] `[[` <- base::`[[`
     [14:16:48.613] `+` <- base::`+`
     [14:16:48.613] `<<-` <- base::`<<-`
     [14:16:48.613] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.613] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.613] 3L)]
     [14:16:48.613] }
     [14:16:48.613] function(cond) {
     [14:16:48.613] if (inherits(cond, "error")) {
     [14:16:48.613] ...future.conditions[[length(...future.conditions) +
     [14:16:48.613] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.613] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.613] signalCondition(cond)
     [14:16:48.613] }
     [14:16:48.613] else if (inherits(cond, "condition")) {
     [14:16:48.613] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.613] ...future.conditions[[length(...future.conditions) +
     [14:16:48.613] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.613] if (!signal) {
     [14:16:48.613] muffleCondition <- function (cond)
     [14:16:48.613] {
     [14:16:48.613] inherits <- base::inherits
     [14:16:48.613] invokeRestart <- base::invokeRestart
     [14:16:48.613] muffled <- FALSE
     [14:16:48.613] if (inherits(cond, "message")) {
     [14:16:48.613] invokeRestart("muffleMessage")
     [14:16:48.613] muffled <- TRUE
     [14:16:48.613] }
     [14:16:48.613] else if (inherits(cond, "warning")) {
     [14:16:48.613] invokeRestart("muffleWarning")
     [14:16:48.613] muffled <- TRUE
     [14:16:48.613] }
     [14:16:48.613] else if (inherits(cond, "condition")) {
     [14:16:48.613] computeRestarts <- base::computeRestarts
     [14:16:48.613] grepl <- base::grepl
     [14:16:48.613] is.null <- base::is.null
     [14:16:48.613] restarts <- computeRestarts(cond)
     [14:16:48.613] for (restart in restarts) {
     [14:16:48.613] name <- restart$name
     [14:16:48.613] if (is.null(name))
     [14:16:48.613] next
     [14:16:48.613] if (!grepl("^muffle", name))
     [14:16:48.613] next
     [14:16:48.613] invokeRestart(restart)
     [14:16:48.613] muffled <- TRUE
     [14:16:48.613] break
     [14:16:48.613] }
     [14:16:48.613] }
     [14:16:48.613] invisible(muffled)
     [14:16:48.613] }
     [14:16:48.613] muffleCondition(cond)
     [14:16:48.613] }
     [14:16:48.613] }
     [14:16:48.613] }
     [14:16:48.613] }))
     [14:16:48.613] }, error = function(ex) {
     [14:16:48.613] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.613] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.613] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.613] }, finally = {
     [14:16:48.613] {
     [14:16:48.613] {
     [14:16:48.613] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.613] }
     [14:16:48.613] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.613] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.613] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.613] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.613] {
     [14:16:48.613] if (substitute)
     [14:16:48.613] expr <- substitute(expr)
     [14:16:48.613] if (is.function(workers))
     [14:16:48.613] workers <- workers()
     [14:16:48.613] workers <- as.integer(workers)
     [14:16:48.613] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.613] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.613] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.613] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.613] local = TRUE, label = label, ...))
     [14:16:48.613] }
     [14:16:48.613] oopts <- options(mc.cores = workers)
     [14:16:48.613] on.exit(options(oopts))
     [14:16:48.613] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.613] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.613] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.613] label = label, ...)
     [14:16:48.613] if (!future$lazy)
     [14:16:48.613] future <- run(future)
     [14:16:48.613] invisible(future)
     [14:16:48.613] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.613] }
     [14:16:48.613] base::options(...future.oldOptions)
     [14:16:48.613] })
     [14:16:48.613] Sys.time
     [14:16:48.613] if (base::is.na(TRUE)) {
     [14:16:48.613] }
     [14:16:48.613] else {
     [14:16:48.613] base::sink(type = "output", split = FALSE)
     [14:16:48.613] if (TRUE) {
     [14:16:48.613] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.613] }
     [14:16:48.613] else {
     [14:16:48.613] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.613] }
     [14:16:48.613] base::close(...future.stdout)
     [14:16:48.613] ...future.stdout <- NULL
     [14:16:48.613] }
     [14:16:48.613] ...future.result$conditions <- ...future.conditions
     [14:16:48.613] ...future.result
     [14:16:48.613] }
     [14:16:48.617] requestCore(): workers = 2
     [14:16:48.621] MulticoreFuture started
     [14:16:48.630] plan(): Setting new future strategy stack:
     [14:16:48.631] List of future strategies:
     [14:16:48.631] 1. sequential:
     [14:16:48.631] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.631] - tweaked: FALSE
     [14:16:48.631] - call: NULL
     [14:16:48.632] plan(): nbrOfWorkers() = 1
     [14:16:48.637] plan(): Setting new future strategy stack:
     [14:16:48.637] List of future strategies:
     [14:16:48.637] 1. multicore:
     [14:16:48.637] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.637] - tweaked: FALSE
     [14:16:48.637] - call: plan(strategy)
     [14:16:48.640] plan(): nbrOfWorkers() = 2
    
     Call:
     lm(formula = dist ~ . - 1, data = cars)
    
     Coefficients:
     speed
     2.909
    
     - Globals - lm(<formula #2 ('b')>, data = cars) ...
    
     Call:
     lm(formula = dist ~ . + 0, data = cars)
    
     Coefficients:
     speed
     2.909
    
     [14:16:48.650] getGlobalsAndPackages() ...
     [14:16:48.651] Searching for globals...
     [14:16:48.660] - globals found: [7] '{', 'lm', 'dist', '+', '.', '~', 'cars'
     [14:16:48.660] Searching for globals ... DONE
     [14:16:48.660] Resolving globals: FALSE
     [14:16:48.662]
     [14:16:48.662] - packages: [1] 'stats'
     [14:16:48.662] getGlobalsAndPackages() ... DONE
     [14:16:48.665] Packages needed by the future expression (n = 0): <none>
     [14:16:48.665] Packages needed by future strategies (n = 0): <none>
     [14:16:48.672] {
     [14:16:48.672] {
     [14:16:48.672] ...future.startTime <- base::Sys.time()
     [14:16:48.672] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.672] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.672] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.672] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.672] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.672] {
     [14:16:48.672] {
     [14:16:48.672] {
     [14:16:48.672] has_future <- base::requireNamespace("future",
     [14:16:48.672] quietly = TRUE)
     [14:16:48.672] version <- if (has_future)
     [14:16:48.672] utils::packageVersion("future")
     [14:16:48.672] else NULL
     [14:16:48.672] if (!has_future || version < "1.8.0") {
     [14:16:48.672] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.672] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.672] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.672] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.672] "release", "version")], collapse = " "),
     [14:16:48.672] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.672] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.672] info)
     [14:16:48.672] info <- base::paste(info, collapse = "; ")
     [14:16:48.672] if (!has_future) {
     [14:16:48.672] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.672] info)
     [14:16:48.672] }
     [14:16:48.672] else {
     [14:16:48.672] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.672] info, version)
     [14:16:48.672] }
     [14:16:48.672] base::stop(msg)
     [14:16:48.672] }
     [14:16:48.672] }
     [14:16:48.672] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.672] base::options(mc.cores = 1L)
     [14:16:48.672] }
     [14:16:48.672] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.672] }
     [14:16:48.672] }
     [14:16:48.672] if (base::is.na(TRUE)) {
     [14:16:48.672] }
     [14:16:48.672] else {
     [14:16:48.672] if (TRUE) {
     [14:16:48.672] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.672] open = "w")
     [14:16:48.672] }
     [14:16:48.672] else {
     [14:16:48.672] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.672] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.672] }
     [14:16:48.672] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.672] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.672] base::sink(type = "output", split = FALSE)
     [14:16:48.672] base::close(...future.stdout)
     [14:16:48.672] }, add = TRUE)
     [14:16:48.672] }
     [14:16:48.672] ...future.frame <- base::sys.nframe()
     [14:16:48.672] ...future.conditions <- base::list()
     [14:16:48.672] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.672] ...future.result <- base::tryCatch({
     [14:16:48.672] base::withCallingHandlers({
     [14:16:48.672] ...future.value <- base::withVisible(base::local({
     [14:16:48.672] lm(dist ~ . + 0, data = cars)
     [14:16:48.672] }))
     [14:16:48.672] future::FutureResult(value = ...future.value$value,
     [14:16:48.672] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.672] ...future.rng), started = ...future.startTime,
     [14:16:48.672] version = "1.8")
     [14:16:48.672] }, condition = base::local({
     [14:16:48.672] c <- base::c
     [14:16:48.672] inherits <- base::inherits
     [14:16:48.672] invokeRestart <- base::invokeRestart
     [14:16:48.672] length <- base::length
     [14:16:48.672] list <- base::list
     [14:16:48.672] seq.int <- base::seq.int
     [14:16:48.672] signalCondition <- base::signalCondition
     [14:16:48.672] sys.calls <- base::sys.calls
     [14:16:48.672] Sys.time <- base::Sys.time
     [14:16:48.672] `[[` <- base::`[[`
     [14:16:48.672] `+` <- base::`+`
     [14:16:48.672] `<<-` <- base::`<<-`
     [14:16:48.672] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.672] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.672] 3L)]
     [14:16:48.672] }
     [14:16:48.672] function(cond) {
     [14:16:48.672] if (inherits(cond, "error")) {
     [14:16:48.672] ...future.conditions[[length(...future.conditions) +
     [14:16:48.672] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.672] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.672] signalCondition(cond)
     [14:16:48.672] }
     [14:16:48.672] else if (inherits(cond, "condition")) {
     [14:16:48.672] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.672] ...future.conditions[[length(...future.conditions) +
     [14:16:48.672] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.672] if (!signal) {
     [14:16:48.672] muffleCondition <- function (cond)
     [14:16:48.672] {
     [14:16:48.672] inherits <- base::inherits
     [14:16:48.672] invokeRestart <- base::invokeRestart
     [14:16:48.672] muffled <- FALSE
     [14:16:48.672] if (inherits(cond, "message")) {
     [14:16:48.672] invokeRestart("muffleMessage")
     [14:16:48.672] muffled <- TRUE
     [14:16:48.672] }
     [14:16:48.672] else if (inherits(cond, "warning")) {
     [14:16:48.672] invokeRestart("muffleWarning")
     [14:16:48.672] muffled <- TRUE
     [14:16:48.672] }
     [14:16:48.672] else if (inherits(cond, "condition")) {
     [14:16:48.672] computeRestarts <- base::computeRestarts
     [14:16:48.672] grepl <- base::grepl
     [14:16:48.672] is.null <- base::is.null
     [14:16:48.672] restarts <- computeRestarts(cond)
     [14:16:48.672] for (restart in restarts) {
     [14:16:48.672] name <- restart$name
     [14:16:48.672] if (is.null(name))
     [14:16:48.672] next
     [14:16:48.672] if (!grepl("^muffle", name))
     [14:16:48.672] next
     [14:16:48.672] invokeRestart(restart)
     [14:16:48.672] muffled <- TRUE
     [14:16:48.672] break
     [14:16:48.672] }
     [14:16:48.672] }
     [14:16:48.672] invisible(muffled)
     [14:16:48.672] }
     [14:16:48.672] muffleCondition(cond)
     [14:16:48.672] }
     [14:16:48.672] }
     [14:16:48.672] }
     [14:16:48.672] }))
     [14:16:48.672] }, error = function(ex) {
     [14:16:48.672] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.672] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.672] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.672] }, finally = {
     [14:16:48.672] {
     [14:16:48.672] {
     [14:16:48.672] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.672] }
     [14:16:48.672] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.672] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.672] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.672] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.672] {
     [14:16:48.672] if (substitute)
     [14:16:48.672] expr <- substitute(expr)
     [14:16:48.672] if (is.function(workers))
     [14:16:48.672] workers <- workers()
     [14:16:48.672] workers <- as.integer(workers)
     [14:16:48.672] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.672] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.672] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.672] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.672] local = TRUE, label = label, ...))
     [14:16:48.672] }
     [14:16:48.672] oopts <- options(mc.cores = workers)
     [14:16:48.672] on.exit(options(oopts))
     [14:16:48.672] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.672] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.672] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.672] label = label, ...)
     [14:16:48.672] if (!future$lazy)
     [14:16:48.672] future <- run(future)
     [14:16:48.672] invisible(future)
     [14:16:48.672] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.672] }
     [14:16:48.672] base::options(...future.oldOptions)
     [14:16:48.672] })
     [14:16:48.672] Sys.time
     [14:16:48.672] if (base::is.na(TRUE)) {
     [14:16:48.672] }
     [14:16:48.672] else {
     [14:16:48.672] base::sink(type = "output", split = FALSE)
     [14:16:48.672] if (TRUE) {
     [14:16:48.672] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.672] }
     [14:16:48.672] else {
     [14:16:48.672] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.672] }
     [14:16:48.672] base::close(...future.stdout)
     [14:16:48.672] ...future.stdout <- NULL
     [14:16:48.672] }
     [14:16:48.672] ...future.result$conditions <- ...future.conditions
     [14:16:48.672] ...future.result
     [14:16:48.672] }
     [14:16:48.676] requestCore(): workers = 2
     [14:16:48.679] MulticoreFuture started
     [14:16:48.694] plan(): Setting new future strategy stack:
     [14:16:48.695] List of future strategies:
     [14:16:48.695] 1. sequential:
     [14:16:48.695] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.695] - tweaked: FALSE
     [14:16:48.695] - call: NULL
     [14:16:48.697] plan(): nbrOfWorkers() = 1
     [14:16:48.701] plan(): Setting new future strategy stack:
     [14:16:48.702] List of future strategies:
     [14:16:48.702] 1. multicore:
     [14:16:48.702] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.702] - tweaked: FALSE
     [14:16:48.702] - call: plan(strategy)
     [14:16:48.705] plan(): nbrOfWorkers() = 2
    
     Call:
     lm(formula = dist ~ . + 0, data = cars)
    
     Coefficients:
     speed
     2.909
    
     - Globals - lm(<formula #3 ('c')>, data = cars) ...
    
     Call:
     lm(formula = dist ~ speed + speed^2, data = cars)
    
     Coefficients:
     (Intercept) speed
     -17.579 3.932
    
     [14:16:48.716] getGlobalsAndPackages() ...
     [14:16:48.717] Searching for globals...
     [14:16:48.727] - globals found: [8] '{', 'lm', 'dist', '+', 'speed', '^', '~', 'cars'
     [14:16:48.728] Searching for globals ... DONE
     [14:16:48.728] Resolving globals: FALSE
     [14:16:48.730]
     [14:16:48.730] - packages: [1] 'stats'
     [14:16:48.731] getGlobalsAndPackages() ... DONE
     [14:16:48.734] Packages needed by the future expression (n = 0): <none>
     [14:16:48.735] Packages needed by future strategies (n = 0): <none>
     [14:16:48.741] {
     [14:16:48.741] {
     [14:16:48.741] ...future.startTime <- base::Sys.time()
     [14:16:48.741] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.741] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.741] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.741] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.741] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.741] {
     [14:16:48.741] {
     [14:16:48.741] {
     [14:16:48.741] has_future <- base::requireNamespace("future",
     [14:16:48.741] quietly = TRUE)
     [14:16:48.741] version <- if (has_future)
     [14:16:48.741] utils::packageVersion("future")
     [14:16:48.741] else NULL
     [14:16:48.741] if (!has_future || version < "1.8.0") {
     [14:16:48.741] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.741] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.741] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.741] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.741] "release", "version")], collapse = " "),
     [14:16:48.741] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.741] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.741] info)
     [14:16:48.741] info <- base::paste(info, collapse = "; ")
     [14:16:48.741] if (!has_future) {
     [14:16:48.741] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.741] info)
     [14:16:48.741] }
     [14:16:48.741] else {
     [14:16:48.741] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.741] info, version)
     [14:16:48.741] }
     [14:16:48.741] base::stop(msg)
     [14:16:48.741] }
     [14:16:48.741] }
     [14:16:48.741] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.741] base::options(mc.cores = 1L)
     [14:16:48.741] }
     [14:16:48.741] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.741] }
     [14:16:48.741] }
     [14:16:48.741] if (base::is.na(TRUE)) {
     [14:16:48.741] }
     [14:16:48.741] else {
     [14:16:48.741] if (TRUE) {
     [14:16:48.741] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.741] open = "w")
     [14:16:48.741] }
     [14:16:48.741] else {
     [14:16:48.741] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.741] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.741] }
     [14:16:48.741] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.741] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.741] base::sink(type = "output", split = FALSE)
     [14:16:48.741] base::close(...future.stdout)
     [14:16:48.741] }, add = TRUE)
     [14:16:48.741] }
     [14:16:48.741] ...future.frame <- base::sys.nframe()
     [14:16:48.741] ...future.conditions <- base::list()
     [14:16:48.741] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.741] ...future.result <- base::tryCatch({
     [14:16:48.741] base::withCallingHandlers({
     [14:16:48.741] ...future.value <- base::withVisible(base::local({
     [14:16:48.741] lm(dist ~ speed + speed^2, data = cars)
     [14:16:48.741] }))
     [14:16:48.741] future::FutureResult(value = ...future.value$value,
     [14:16:48.741] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.741] ...future.rng), started = ...future.startTime,
     [14:16:48.741] version = "1.8")
     [14:16:48.741] }, condition = base::local({
     [14:16:48.741] c <- base::c
     [14:16:48.741] inherits <- base::inherits
     [14:16:48.741] invokeRestart <- base::invokeRestart
     [14:16:48.741] length <- base::length
     [14:16:48.741] list <- base::list
     [14:16:48.741] seq.int <- base::seq.int
     [14:16:48.741] signalCondition <- base::signalCondition
     [14:16:48.741] sys.calls <- base::sys.calls
     [14:16:48.741] Sys.time <- base::Sys.time
     [14:16:48.741] `[[` <- base::`[[`
     [14:16:48.741] `+` <- base::`+`
     [14:16:48.741] `<<-` <- base::`<<-`
     [14:16:48.741] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.741] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.741] 3L)]
     [14:16:48.741] }
     [14:16:48.741] function(cond) {
     [14:16:48.741] if (inherits(cond, "error")) {
     [14:16:48.741] ...future.conditions[[length(...future.conditions) +
     [14:16:48.741] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.741] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.741] signalCondition(cond)
     [14:16:48.741] }
     [14:16:48.741] else if (inherits(cond, "condition")) {
     [14:16:48.741] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.741] ...future.conditions[[length(...future.conditions) +
     [14:16:48.741] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.741] if (!signal) {
     [14:16:48.741] muffleCondition <- function (cond)
     [14:16:48.741] {
     [14:16:48.741] inherits <- base::inherits
     [14:16:48.741] invokeRestart <- base::invokeRestart
     [14:16:48.741] muffled <- FALSE
     [14:16:48.741] if (inherits(cond, "message")) {
     [14:16:48.741] invokeRestart("muffleMessage")
     [14:16:48.741] muffled <- TRUE
     [14:16:48.741] }
     [14:16:48.741] else if (inherits(cond, "warning")) {
     [14:16:48.741] invokeRestart("muffleWarning")
     [14:16:48.741] muffled <- TRUE
     [14:16:48.741] }
     [14:16:48.741] else if (inherits(cond, "condition")) {
     [14:16:48.741] computeRestarts <- base::computeRestarts
     [14:16:48.741] grepl <- base::grepl
     [14:16:48.741] is.null <- base::is.null
     [14:16:48.741] restarts <- computeRestarts(cond)
     [14:16:48.741] for (restart in restarts) {
     [14:16:48.741] name <- restart$name
     [14:16:48.741] if (is.null(name))
     [14:16:48.741] next
     [14:16:48.741] if (!grepl("^muffle", name))
     [14:16:48.741] next
     [14:16:48.741] invokeRestart(restart)
     [14:16:48.741] muffled <- TRUE
     [14:16:48.741] break
     [14:16:48.741] }
     [14:16:48.741] }
     [14:16:48.741] invisible(muffled)
     [14:16:48.741] }
     [14:16:48.741] muffleCondition(cond)
     [14:16:48.741] }
     [14:16:48.741] }
     [14:16:48.741] }
     [14:16:48.741] }))
     [14:16:48.741] }, error = function(ex) {
     [14:16:48.741] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.741] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.741] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.741] }, finally = {
     [14:16:48.741] {
     [14:16:48.741] {
     [14:16:48.741] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.741] }
     [14:16:48.741] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.741] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.741] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.741] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.741] {
     [14:16:48.741] if (substitute)
     [14:16:48.741] expr <- substitute(expr)
     [14:16:48.741] if (is.function(workers))
     [14:16:48.741] workers <- workers()
     [14:16:48.741] workers <- as.integer(workers)
     [14:16:48.741] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.741] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.741] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.741] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.741] local = TRUE, label = label, ...))
     [14:16:48.741] }
     [14:16:48.741] oopts <- options(mc.cores = workers)
     [14:16:48.741] on.exit(options(oopts))
     [14:16:48.741] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.741] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.741] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.741] label = label, ...)
     [14:16:48.741] if (!future$lazy)
     [14:16:48.741] future <- run(future)
     [14:16:48.741] invisible(future)
     [14:16:48.741] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.741] }
     [14:16:48.741] base::options(...future.oldOptions)
     [14:16:48.741] })
     [14:16:48.741] Sys.time
     [14:16:48.741] if (base::is.na(TRUE)) {
     [14:16:48.741] }
     [14:16:48.741] else {
     [14:16:48.741] base::sink(type = "output", split = FALSE)
     [14:16:48.741] if (TRUE) {
     [14:16:48.741] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.741] }
     [14:16:48.741] else {
     [14:16:48.741] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.741] }
     [14:16:48.741] base::close(...future.stdout)
     [14:16:48.741] ...future.stdout <- NULL
     [14:16:48.741] }
     [14:16:48.741] ...future.result$conditions <- ...future.conditions
     [14:16:48.741] ...future.result
     [14:16:48.741] }
     [14:16:48.746] requestCore(): workers = 2
     [14:16:48.750] MulticoreFuture started
     [14:16:48.760] plan(): Setting new future strategy stack:
     [14:16:48.761] List of future strategies:
     [14:16:48.761] 1. sequential:
     [14:16:48.761] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.761] - tweaked: FALSE
     [14:16:48.761] - call: NULL
     [14:16:48.764] plan(): nbrOfWorkers() = 1
     [14:16:48.768] plan(): Setting new future strategy stack:
     [14:16:48.769] List of future strategies:
     [14:16:48.769] 1. multicore:
     [14:16:48.769] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.769] - tweaked: FALSE
     [14:16:48.769] - call: plan(strategy)
     [14:16:48.772] plan(): nbrOfWorkers() = 2
    
     Call:
     lm(formula = dist ~ speed + speed^2, data = cars)
    
     Coefficients:
     (Intercept) speed
     -17.579 3.932
    
     - Globals - lm(<formula #4 ('d')>, data = cars) ...
    
     Call:
     lm(formula = dist ~ speed + I(speed^2), data = cars)
    
     Coefficients:
     (Intercept) speed I(speed^2)
     2.47014 0.91329 0.09996
    
     [14:16:48.784] getGlobalsAndPackages() ...
     [14:16:48.784] Searching for globals...
     [14:16:48.801] - globals found: [9] '{', 'lm', 'dist', '+', 'speed', 'I', '^', '~', 'cars'
     [14:16:48.802] Searching for globals ... DONE
     [14:16:48.802] Resolving globals: FALSE
     [14:16:48.804]
     [14:16:48.805] - packages: [1] 'stats'
     [14:16:48.805] getGlobalsAndPackages() ... DONE
     [14:16:48.808] Packages needed by the future expression (n = 0): <none>
     [14:16:48.809] Packages needed by future strategies (n = 0): <none>
     [14:16:48.815] {
     [14:16:48.815] {
     [14:16:48.815] ...future.startTime <- base::Sys.time()
     [14:16:48.815] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.815] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.815] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.815] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.815] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.815] {
     [14:16:48.815] {
     [14:16:48.815] {
     [14:16:48.815] has_future <- base::requireNamespace("future",
     [14:16:48.815] quietly = TRUE)
     [14:16:48.815] version <- if (has_future)
     [14:16:48.815] utils::packageVersion("future")
     [14:16:48.815] else NULL
     [14:16:48.815] if (!has_future || version < "1.8.0") {
     [14:16:48.815] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.815] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.815] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.815] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.815] "release", "version")], collapse = " "),
     [14:16:48.815] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.815] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.815] info)
     [14:16:48.815] info <- base::paste(info, collapse = "; ")
     [14:16:48.815] if (!has_future) {
     [14:16:48.815] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.815] info)
     [14:16:48.815] }
     [14:16:48.815] else {
     [14:16:48.815] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.815] info, version)
     [14:16:48.815] }
     [14:16:48.815] base::stop(msg)
     [14:16:48.815] }
     [14:16:48.815] }
     [14:16:48.815] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.815] base::options(mc.cores = 1L)
     [14:16:48.815] }
     [14:16:48.815] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.815] }
     [14:16:48.815] }
     [14:16:48.815] if (base::is.na(TRUE)) {
     [14:16:48.815] }
     [14:16:48.815] else {
     [14:16:48.815] if (TRUE) {
     [14:16:48.815] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.815] open = "w")
     [14:16:48.815] }
     [14:16:48.815] else {
     [14:16:48.815] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.815] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.815] }
     [14:16:48.815] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.815] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.815] base::sink(type = "output", split = FALSE)
     [14:16:48.815] base::close(...future.stdout)
     [14:16:48.815] }, add = TRUE)
     [14:16:48.815] }
     [14:16:48.815] ...future.frame <- base::sys.nframe()
     [14:16:48.815] ...future.conditions <- base::list()
     [14:16:48.815] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.815] ...future.result <- base::tryCatch({
     [14:16:48.815] base::withCallingHandlers({
     [14:16:48.815] ...future.value <- base::withVisible(base::local({
     [14:16:48.815] lm(dist ~ speed + I(speed^2), data = cars)
     [14:16:48.815] }))
     [14:16:48.815] future::FutureResult(value = ...future.value$value,
     [14:16:48.815] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.815] ...future.rng), started = ...future.startTime,
     [14:16:48.815] version = "1.8")
     [14:16:48.815] }, condition = base::local({
     [14:16:48.815] c <- base::c
     [14:16:48.815] inherits <- base::inherits
     [14:16:48.815] invokeRestart <- base::invokeRestart
     [14:16:48.815] length <- base::length
     [14:16:48.815] list <- base::list
     [14:16:48.815] seq.int <- base::seq.int
     [14:16:48.815] signalCondition <- base::signalCondition
     [14:16:48.815] sys.calls <- base::sys.calls
     [14:16:48.815] Sys.time <- base::Sys.time
     [14:16:48.815] `[[` <- base::`[[`
     [14:16:48.815] `+` <- base::`+`
     [14:16:48.815] `<<-` <- base::`<<-`
     [14:16:48.815] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.815] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.815] 3L)]
     [14:16:48.815] }
     [14:16:48.815] function(cond) {
     [14:16:48.815] if (inherits(cond, "error")) {
     [14:16:48.815] ...future.conditions[[length(...future.conditions) +
     [14:16:48.815] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.815] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.815] signalCondition(cond)
     [14:16:48.815] }
     [14:16:48.815] else if (inherits(cond, "condition")) {
     [14:16:48.815] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.815] ...future.conditions[[length(...future.conditions) +
     [14:16:48.815] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.815] if (!signal) {
     [14:16:48.815] muffleCondition <- function (cond)
     [14:16:48.815] {
     [14:16:48.815] inherits <- base::inherits
     [14:16:48.815] invokeRestart <- base::invokeRestart
     [14:16:48.815] muffled <- FALSE
     [14:16:48.815] if (inherits(cond, "message")) {
     [14:16:48.815] invokeRestart("muffleMessage")
     [14:16:48.815] muffled <- TRUE
     [14:16:48.815] }
     [14:16:48.815] else if (inherits(cond, "warning")) {
     [14:16:48.815] invokeRestart("muffleWarning")
     [14:16:48.815] muffled <- TRUE
     [14:16:48.815] }
     [14:16:48.815] else if (inherits(cond, "condition")) {
     [14:16:48.815] computeRestarts <- base::computeRestarts
     [14:16:48.815] grepl <- base::grepl
     [14:16:48.815] is.null <- base::is.null
     [14:16:48.815] restarts <- computeRestarts(cond)
     [14:16:48.815] for (restart in restarts) {
     [14:16:48.815] name <- restart$name
     [14:16:48.815] if (is.null(name))
     [14:16:48.815] next
     [14:16:48.815] if (!grepl("^muffle", name))
     [14:16:48.815] next
     [14:16:48.815] invokeRestart(restart)
     [14:16:48.815] muffled <- TRUE
     [14:16:48.815] break
     [14:16:48.815] }
     [14:16:48.815] }
     [14:16:48.815] invisible(muffled)
     [14:16:48.815] }
     [14:16:48.815] muffleCondition(cond)
     [14:16:48.815] }
     [14:16:48.815] }
     [14:16:48.815] }
     [14:16:48.815] }))
     [14:16:48.815] }, error = function(ex) {
     [14:16:48.815] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.815] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.815] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.815] }, finally = {
     [14:16:48.815] {
     [14:16:48.815] {
     [14:16:48.815] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.815] }
     [14:16:48.815] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.815] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.815] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.815] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.815] {
     [14:16:48.815] if (substitute)
     [14:16:48.815] expr <- substitute(expr)
     [14:16:48.815] if (is.function(workers))
     [14:16:48.815] workers <- workers()
     [14:16:48.815] workers <- as.integer(workers)
     [14:16:48.815] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.815] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.815] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.815] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.815] local = TRUE, label = label, ...))
     [14:16:48.815] }
     [14:16:48.815] oopts <- options(mc.cores = workers)
     [14:16:48.815] on.exit(options(oopts))
     [14:16:48.815] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.815] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.815] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.815] label = label, ...)
     [14:16:48.815] if (!future$lazy)
     [14:16:48.815] future <- run(future)
     [14:16:48.815] invisible(future)
     [14:16:48.815] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.815] }
     [14:16:48.815] base::options(...future.oldOptions)
     [14:16:48.815] })
     [14:16:48.815] Sys.time
     [14:16:48.815] if (base::is.na(TRUE)) {
     [14:16:48.815] }
     [14:16:48.815] else {
     [14:16:48.815] base::sink(type = "output", split = FALSE)
     [14:16:48.815] if (TRUE) {
     [14:16:48.815] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.815] }
     [14:16:48.815] else {
     [14:16:48.815] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.815] }
     [14:16:48.815] base::close(...future.stdout)
     [14:16:48.815] ...future.stdout <- NULL
     [14:16:48.815] }
     [14:16:48.815] ...future.result$conditions <- ...future.conditions
     [14:16:48.815] ...future.result
     [14:16:48.815] }
     [14:16:48.819] requestCore(): workers = 2
     [14:16:48.823] MulticoreFuture started
     [14:16:48.842] plan(): Setting new future strategy stack:
     [14:16:48.843] List of future strategies:
     [14:16:48.843] 1. sequential:
     [14:16:48.843] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.843] - tweaked: FALSE
     [14:16:48.843] - call: NULL
     [14:16:48.845] plan(): nbrOfWorkers() = 1
     [14:16:48.850] plan(): Setting new future strategy stack:
     [14:16:48.850] List of future strategies:
     [14:16:48.850] 1. multicore:
     [14:16:48.850] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.850] - tweaked: FALSE
     [14:16:48.850] - call: plan(strategy)
     [14:16:48.853] plan(): nbrOfWorkers() = 2
    
     Call:
     lm(formula = dist ~ speed + I(speed^2), data = cars)
    
     Coefficients:
     (Intercept) speed I(speed^2)
     2.47014 0.91329 0.09996
    
     - Globals - lm(<formula #5 ('e')>, data = cars) ...
    
     Call:
     lm(formula = dist ~ poly(speed, 2), data = cars)
    
     Coefficients:
     (Intercept) poly(speed, 2)1 poly(speed, 2)2
     42.98 145.55 23.00
    
     [14:16:48.866] getGlobalsAndPackages() ...
     [14:16:48.866] Searching for globals...
     [14:16:48.875] - globals found: [7] '{', 'lm', 'dist', 'poly', 'speed', '~', 'cars'
     [14:16:48.876] Searching for globals ... DONE
     [14:16:48.876] Resolving globals: FALSE
     [14:16:48.877]
     [14:16:48.878] - packages: [1] 'stats'
     [14:16:48.878] getGlobalsAndPackages() ... DONE
     [14:16:48.881] Packages needed by the future expression (n = 0): <none>
     [14:16:48.882] Packages needed by future strategies (n = 0): <none>
     [14:16:48.888] {
     [14:16:48.888] {
     [14:16:48.888] ...future.startTime <- base::Sys.time()
     [14:16:48.888] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.888] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.888] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.888] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.888] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.888] {
     [14:16:48.888] {
     [14:16:48.888] {
     [14:16:48.888] has_future <- base::requireNamespace("future",
     [14:16:48.888] quietly = TRUE)
     [14:16:48.888] version <- if (has_future)
     [14:16:48.888] utils::packageVersion("future")
     [14:16:48.888] else NULL
     [14:16:48.888] if (!has_future || version < "1.8.0") {
     [14:16:48.888] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.888] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.888] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.888] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.888] "release", "version")], collapse = " "),
     [14:16:48.888] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.888] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.888] info)
     [14:16:48.888] info <- base::paste(info, collapse = "; ")
     [14:16:48.888] if (!has_future) {
     [14:16:48.888] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.888] info)
     [14:16:48.888] }
     [14:16:48.888] else {
     [14:16:48.888] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.888] info, version)
     [14:16:48.888] }
     [14:16:48.888] base::stop(msg)
     [14:16:48.888] }
     [14:16:48.888] }
     [14:16:48.888] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.888] base::options(mc.cores = 1L)
     [14:16:48.888] }
     [14:16:48.888] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.888] }
     [14:16:48.888] }
     [14:16:48.888] if (base::is.na(TRUE)) {
     [14:16:48.888] }
     [14:16:48.888] else {
     [14:16:48.888] if (TRUE) {
     [14:16:48.888] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.888] open = "w")
     [14:16:48.888] }
     [14:16:48.888] else {
     [14:16:48.888] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.888] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.888] }
     [14:16:48.888] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.888] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.888] base::sink(type = "output", split = FALSE)
     [14:16:48.888] base::close(...future.stdout)
     [14:16:48.888] }, add = TRUE)
     [14:16:48.888] }
     [14:16:48.888] ...future.frame <- base::sys.nframe()
     [14:16:48.888] ...future.conditions <- base::list()
     [14:16:48.888] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.888] ...future.result <- base::tryCatch({
     [14:16:48.888] base::withCallingHandlers({
     [14:16:48.888] ...future.value <- base::withVisible(base::local({
     [14:16:48.888] lm(dist ~ poly(speed, 2), data = cars)
     [14:16:48.888] }))
     [14:16:48.888] future::FutureResult(value = ...future.value$value,
     [14:16:48.888] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.888] ...future.rng), started = ...future.startTime,
     [14:16:48.888] version = "1.8")
     [14:16:48.888] }, condition = base::local({
     [14:16:48.888] c <- base::c
     [14:16:48.888] inherits <- base::inherits
     [14:16:48.888] invokeRestart <- base::invokeRestart
     [14:16:48.888] length <- base::length
     [14:16:48.888] list <- base::list
     [14:16:48.888] seq.int <- base::seq.int
     [14:16:48.888] signalCondition <- base::signalCondition
     [14:16:48.888] sys.calls <- base::sys.calls
     [14:16:48.888] Sys.time <- base::Sys.time
     [14:16:48.888] `[[` <- base::`[[`
     [14:16:48.888] `+` <- base::`+`
     [14:16:48.888] `<<-` <- base::`<<-`
     [14:16:48.888] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.888] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.888] 3L)]
     [14:16:48.888] }
     [14:16:48.888] function(cond) {
     [14:16:48.888] if (inherits(cond, "error")) {
     [14:16:48.888] ...future.conditions[[length(...future.conditions) +
     [14:16:48.888] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.888] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.888] signalCondition(cond)
     [14:16:48.888] }
     [14:16:48.888] else if (inherits(cond, "condition")) {
     [14:16:48.888] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.888] ...future.conditions[[length(...future.conditions) +
     [14:16:48.888] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.888] if (!signal) {
     [14:16:48.888] muffleCondition <- function (cond)
     [14:16:48.888] {
     [14:16:48.888] inherits <- base::inherits
     [14:16:48.888] invokeRestart <- base::invokeRestart
     [14:16:48.888] muffled <- FALSE
     [14:16:48.888] if (inherits(cond, "message")) {
     [14:16:48.888] invokeRestart("muffleMessage")
     [14:16:48.888] muffled <- TRUE
     [14:16:48.888] }
     [14:16:48.888] else if (inherits(cond, "warning")) {
     [14:16:48.888] invokeRestart("muffleWarning")
     [14:16:48.888] muffled <- TRUE
     [14:16:48.888] }
     [14:16:48.888] else if (inherits(cond, "condition")) {
     [14:16:48.888] computeRestarts <- base::computeRestarts
     [14:16:48.888] grepl <- base::grepl
     [14:16:48.888] is.null <- base::is.null
     [14:16:48.888] restarts <- computeRestarts(cond)
     [14:16:48.888] for (restart in restarts) {
     [14:16:48.888] name <- restart$name
     [14:16:48.888] if (is.null(name))
     [14:16:48.888] next
     [14:16:48.888] if (!grepl("^muffle", name))
     [14:16:48.888] next
     [14:16:48.888] invokeRestart(restart)
     [14:16:48.888] muffled <- TRUE
     [14:16:48.888] break
     [14:16:48.888] }
     [14:16:48.888] }
     [14:16:48.888] invisible(muffled)
     [14:16:48.888] }
     [14:16:48.888] muffleCondition(cond)
     [14:16:48.888] }
     [14:16:48.888] }
     [14:16:48.888] }
     [14:16:48.888] }))
     [14:16:48.888] }, error = function(ex) {
     [14:16:48.888] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.888] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.888] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.888] }, finally = {
     [14:16:48.888] {
     [14:16:48.888] {
     [14:16:48.888] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.888] }
     [14:16:48.888] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.888] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.888] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.888] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.888] {
     [14:16:48.888] if (substitute)
     [14:16:48.888] expr <- substitute(expr)
     [14:16:48.888] if (is.function(workers))
     [14:16:48.888] workers <- workers()
     [14:16:48.888] workers <- as.integer(workers)
     [14:16:48.888] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.888] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.888] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.888] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.888] local = TRUE, label = label, ...))
     [14:16:48.888] }
     [14:16:48.888] oopts <- options(mc.cores = workers)
     [14:16:48.888] on.exit(options(oopts))
     [14:16:48.888] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.888] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.888] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.888] label = label, ...)
     [14:16:48.888] if (!future$lazy)
     [14:16:48.888] future <- run(future)
     [14:16:48.888] invisible(future)
     [14:16:48.888] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.888] }
     [14:16:48.888] base::options(...future.oldOptions)
     [14:16:48.888] })
     [14:16:48.888] Sys.time
     [14:16:48.888] if (base::is.na(TRUE)) {
     [14:16:48.888] }
     [14:16:48.888] else {
     [14:16:48.888] base::sink(type = "output", split = FALSE)
     [14:16:48.888] if (TRUE) {
     [14:16:48.888] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.888] }
     [14:16:48.888] else {
     [14:16:48.888] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.888] }
     [14:16:48.888] base::close(...future.stdout)
     [14:16:48.888] ...future.stdout <- NULL
     [14:16:48.888] }
     [14:16:48.888] ...future.result$conditions <- ...future.conditions
     [14:16:48.888] ...future.result
     [14:16:48.888] }
     [14:16:48.893] requestCore(): workers = 2
     [14:16:48.898] MulticoreFuture started
     [14:16:48.910] plan(): Setting new future strategy stack:
     [14:16:48.911] List of future strategies:
     [14:16:48.911] 1. sequential:
     [14:16:48.911] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.911] - tweaked: FALSE
     [14:16:48.911] - call: NULL
     [14:16:48.912] plan(): nbrOfWorkers() = 1
     [14:16:48.924] plan(): Setting new future strategy stack:
     [14:16:48.925] List of future strategies:
     [14:16:48.925] 1. multicore:
     [14:16:48.925] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.925] - tweaked: FALSE
     [14:16:48.925] - call: plan(strategy)
     [14:16:48.927] plan(): nbrOfWorkers() = 2
    
     Call:
     lm(formula = dist ~ poly(speed, 2), data = cars)
    
     Coefficients:
     (Intercept) poly(speed, 2)1 poly(speed, 2)2
     42.98 145.55 23.00
    
     - Globals - map(x, ~ expr) ...
     [14:16:48.936] getGlobalsAndPackages() ...
     [14:16:48.936] Searching for globals...
     [14:16:48.962] - globals found: [16] '{', 'outer_function', 'map', ':', '~', 'inner_function', '.x', 'if', 'inherits', '<-', '[[', '-', 'eval', 'bquote', 'lapply', '+'
     [14:16:48.962] Searching for globals ... DONE
     [14:16:48.963] Resolving globals: FALSE
     [14:16:48.965] The total size of the 3 globals is 28.25 KiB (28928 bytes)
     [14:16:48.966] - globals: [3] 'outer_function', 'map', 'inner_function'
     [14:16:48.966]
     [14:16:48.967] getGlobalsAndPackages() ... DONE
     [14:16:48.970] Packages needed by the future expression (n = 0): <none>
     [14:16:48.970] Packages needed by future strategies (n = 0): <none>
     [14:16:48.978] {
     [14:16:48.978] {
     [14:16:48.978] ...future.startTime <- base::Sys.time()
     [14:16:48.978] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:48.978] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:48.978] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:48.978] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:48.978] future.resolve.recursive = NULL, width = 80L)
     [14:16:48.978] {
     [14:16:48.978] {
     [14:16:48.978] {
     [14:16:48.978] has_future <- base::requireNamespace("future",
     [14:16:48.978] quietly = TRUE)
     [14:16:48.978] version <- if (has_future)
     [14:16:48.978] utils::packageVersion("future")
     [14:16:48.978] else NULL
     [14:16:48.978] if (!has_future || version < "1.8.0") {
     [14:16:48.978] info <- base::c(r_version = base::gsub("R version ",
     [14:16:48.978] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:48.978] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:48.978] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:48.978] "release", "version")], collapse = " "),
     [14:16:48.978] hostname = base::Sys.info()[["nodename"]])
     [14:16:48.978] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:48.978] info)
     [14:16:48.978] info <- base::paste(info, collapse = "; ")
     [14:16:48.978] if (!has_future) {
     [14:16:48.978] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:48.978] info)
     [14:16:48.978] }
     [14:16:48.978] else {
     [14:16:48.978] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:48.978] info, version)
     [14:16:48.978] }
     [14:16:48.978] base::stop(msg)
     [14:16:48.978] }
     [14:16:48.978] }
     [14:16:48.978] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:48.978] base::options(mc.cores = 1L)
     [14:16:48.978] }
     [14:16:48.978] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:48.978] }
     [14:16:48.978] }
     [14:16:48.978] if (base::is.na(TRUE)) {
     [14:16:48.978] }
     [14:16:48.978] else {
     [14:16:48.978] if (TRUE) {
     [14:16:48.978] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:48.978] open = "w")
     [14:16:48.978] }
     [14:16:48.978] else {
     [14:16:48.978] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:48.978] windows = "NUL", "/dev/null"), open = "w")
     [14:16:48.978] }
     [14:16:48.978] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:48.978] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:48.978] base::sink(type = "output", split = FALSE)
     [14:16:48.978] base::close(...future.stdout)
     [14:16:48.978] }, add = TRUE)
     [14:16:48.978] }
     [14:16:48.978] ...future.frame <- base::sys.nframe()
     [14:16:48.978] ...future.conditions <- base::list()
     [14:16:48.978] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:48.978] ...future.result <- base::tryCatch({
     [14:16:48.978] base::withCallingHandlers({
     [14:16:48.978] ...future.value <- base::withVisible(base::local({
     [14:16:48.978] outer_function(1L)
     [14:16:48.978] }))
     [14:16:48.978] future::FutureResult(value = ...future.value$value,
     [14:16:48.978] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.978] ...future.rng), started = ...future.startTime,
     [14:16:48.978] version = "1.8")
     [14:16:48.978] }, condition = base::local({
     [14:16:48.978] c <- base::c
     [14:16:48.978] inherits <- base::inherits
     [14:16:48.978] invokeRestart <- base::invokeRestart
     [14:16:48.978] length <- base::length
     [14:16:48.978] list <- base::list
     [14:16:48.978] seq.int <- base::seq.int
     [14:16:48.978] signalCondition <- base::signalCondition
     [14:16:48.978] sys.calls <- base::sys.calls
     [14:16:48.978] Sys.time <- base::Sys.time
     [14:16:48.978] `[[` <- base::`[[`
     [14:16:48.978] `+` <- base::`+`
     [14:16:48.978] `<<-` <- base::`<<-`
     [14:16:48.978] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:48.978] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:48.978] 3L)]
     [14:16:48.978] }
     [14:16:48.978] function(cond) {
     [14:16:48.978] if (inherits(cond, "error")) {
     [14:16:48.978] ...future.conditions[[length(...future.conditions) +
     [14:16:48.978] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:48.978] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:48.978] signalCondition(cond)
     [14:16:48.978] }
     [14:16:48.978] else if (inherits(cond, "condition")) {
     [14:16:48.978] signal <- FALSE && inherits(cond, character(0))
     [14:16:48.978] ...future.conditions[[length(...future.conditions) +
     [14:16:48.978] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:48.978] if (!signal) {
     [14:16:48.978] muffleCondition <- function (cond)
     [14:16:48.978] {
     [14:16:48.978] inherits <- base::inherits
     [14:16:48.978] invokeRestart <- base::invokeRestart
     [14:16:48.978] muffled <- FALSE
     [14:16:48.978] if (inherits(cond, "message")) {
     [14:16:48.978] invokeRestart("muffleMessage")
     [14:16:48.978] muffled <- TRUE
     [14:16:48.978] }
     [14:16:48.978] else if (inherits(cond, "warning")) {
     [14:16:48.978] invokeRestart("muffleWarning")
     [14:16:48.978] muffled <- TRUE
     [14:16:48.978] }
     [14:16:48.978] else if (inherits(cond, "condition")) {
     [14:16:48.978] computeRestarts <- base::computeRestarts
     [14:16:48.978] grepl <- base::grepl
     [14:16:48.978] is.null <- base::is.null
     [14:16:48.978] restarts <- computeRestarts(cond)
     [14:16:48.978] for (restart in restarts) {
     [14:16:48.978] name <- restart$name
     [14:16:48.978] if (is.null(name))
     [14:16:48.978] next
     [14:16:48.978] if (!grepl("^muffle", name))
     [14:16:48.978] next
     [14:16:48.978] invokeRestart(restart)
     [14:16:48.978] muffled <- TRUE
     [14:16:48.978] break
     [14:16:48.978] }
     [14:16:48.978] }
     [14:16:48.978] invisible(muffled)
     [14:16:48.978] }
     [14:16:48.978] muffleCondition(cond)
     [14:16:48.978] }
     [14:16:48.978] }
     [14:16:48.978] }
     [14:16:48.978] }))
     [14:16:48.978] }, error = function(ex) {
     [14:16:48.978] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:48.978] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:48.978] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:48.978] }, finally = {
     [14:16:48.978] {
     [14:16:48.978] {
     [14:16:48.978] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:48.978] }
     [14:16:48.978] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:48.978] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:48.978] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:48.978] earlySignal = FALSE, label = NULL, ...)
     [14:16:48.978] {
     [14:16:48.978] if (substitute)
     [14:16:48.978] expr <- substitute(expr)
     [14:16:48.978] if (is.function(workers))
     [14:16:48.978] workers <- workers()
     [14:16:48.978] workers <- as.integer(workers)
     [14:16:48.978] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:48.978] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:48.978] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:48.978] lazy = lazy, seed = seed, globals = globals,
     [14:16:48.978] local = TRUE, label = label, ...))
     [14:16:48.978] }
     [14:16:48.978] oopts <- options(mc.cores = workers)
     [14:16:48.978] on.exit(options(oopts))
     [14:16:48.978] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:48.978] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:48.978] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:48.978] label = label, ...)
     [14:16:48.978] if (!future$lazy)
     [14:16:48.978] future <- run(future)
     [14:16:48.978] invisible(future)
     [14:16:48.978] }), .cleanup = FALSE, .init = FALSE)
     [14:16:48.978] }
     [14:16:48.978] base::options(...future.oldOptions)
     [14:16:48.978] })
     [14:16:48.978] Sys.time
     [14:16:48.978] if (base::is.na(TRUE)) {
     [14:16:48.978] }
     [14:16:48.978] else {
     [14:16:48.978] base::sink(type = "output", split = FALSE)
     [14:16:48.978] if (TRUE) {
     [14:16:48.978] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:48.978] }
     [14:16:48.978] else {
     [14:16:48.978] ...future.result["stdout"] <- base::list(NULL)
     [14:16:48.978] }
     [14:16:48.978] base::close(...future.stdout)
     [14:16:48.978] ...future.stdout <- NULL
     [14:16:48.978] }
     [14:16:48.978] ...future.result$conditions <- ...future.conditions
     [14:16:48.978] ...future.result
     [14:16:48.978] }
     [14:16:48.983] requestCore(): workers = 2
     [14:16:48.987] MulticoreFuture started
     [14:16:48.994] plan(): Setting new future strategy stack:
     [14:16:48.994] List of future strategies:
     [14:16:48.994] 1. sequential:
     [14:16:48.994] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:48.994] - tweaked: FALSE
     [14:16:48.994] - call: NULL
     [14:16:48.996] plan(): nbrOfWorkers() = 1
     [14:16:48.999] plan(): Setting new future strategy stack:
     [14:16:48.999] List of future strategies:
     [14:16:48.999] 1. multicore:
     [14:16:48.999] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:48.999] - tweaked: FALSE
     [14:16:48.999] - call: plan(strategy)
     [14:16:49.002] plan(): nbrOfWorkers() = 2
     List of 2
     $ : num [1:2] 2 3
     $ : num [1:2] 2 3
     [14:16:49.009] getGlobalsAndPackages() ...
     [14:16:49.010] Searching for globals...
     [14:16:49.028] - globals found: [16] '{', 'outer_function', 'map', ':', '~', 'inner_function', '.x', 'if', 'inherits', '<-', '[[', '-', 'eval', 'bquote', 'lapply', '+'
     [14:16:49.029] Searching for globals ... DONE
     [14:16:49.029] Resolving globals: FALSE
     [14:16:49.031] The total size of the 3 globals is 28.25 KiB (28928 bytes)
     [14:16:49.032] - globals: [3] 'outer_function', 'map', 'inner_function'
     [14:16:49.032]
     [14:16:49.032] getGlobalsAndPackages() ... DONE
     [14:16:49.036] Packages needed by the future expression (n = 0): <none>
     [14:16:49.036] Packages needed by future strategies (n = 0): <none>
     [14:16:49.043] {
     [14:16:49.043] {
     [14:16:49.043] ...future.startTime <- base::Sys.time()
     [14:16:49.043] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [14:16:49.043] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [14:16:49.043] future.globals.method = NULL, future.globals.onMissing = "ignore",
     [14:16:49.043] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [14:16:49.043] future.resolve.recursive = NULL, width = 80L)
     [14:16:49.043] {
     [14:16:49.043] {
     [14:16:49.043] {
     [14:16:49.043] has_future <- base::requireNamespace("future",
     [14:16:49.043] quietly = TRUE)
     [14:16:49.043] version <- if (has_future)
     [14:16:49.043] utils::packageVersion("future")
     [14:16:49.043] else NULL
     [14:16:49.043] if (!has_future || version < "1.8.0") {
     [14:16:49.043] info <- base::c(r_version = base::gsub("R version ",
     [14:16:49.043] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [14:16:49.043] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [14:16:49.043] os = base::paste(base::Sys.info()[base::c("sysname",
     [14:16:49.043] "release", "version")], collapse = " "),
     [14:16:49.043] hostname = base::Sys.info()[["nodename"]])
     [14:16:49.043] info <- base::sprintf("%s: %s", base::names(info),
     [14:16:49.043] info)
     [14:16:49.043] info <- base::paste(info, collapse = "; ")
     [14:16:49.043] if (!has_future) {
     [14:16:49.043] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [14:16:49.043] info)
     [14:16:49.043] }
     [14:16:49.043] else {
     [14:16:49.043] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [14:16:49.043] info, version)
     [14:16:49.043] }
     [14:16:49.043] base::stop(msg)
     [14:16:49.043] }
     [14:16:49.043] }
     [14:16:49.043] ...future.mc.cores.old <- base::getOption("mc.cores")
     [14:16:49.043] base::options(mc.cores = 1L)
     [14:16:49.043] }
     [14:16:49.043] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [14:16:49.043] }
     [14:16:49.043] }
     [14:16:49.043] if (base::is.na(TRUE)) {
     [14:16:49.043] }
     [14:16:49.043] else {
     [14:16:49.043] if (TRUE) {
     [14:16:49.043] ...future.stdout <- base::rawConnection(base::raw(0L),
     [14:16:49.043] open = "w")
     [14:16:49.043] }
     [14:16:49.043] else {
     [14:16:49.043] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [14:16:49.043] windows = "NUL", "/dev/null"), open = "w")
     [14:16:49.043] }
     [14:16:49.043] base::sink(...future.stdout, type = "output", split = FALSE)
     [14:16:49.043] base::on.exit(if (!base::is.null(...future.stdout)) {
     [14:16:49.043] base::sink(type = "output", split = FALSE)
     [14:16:49.043] base::close(...future.stdout)
     [14:16:49.043] }, add = TRUE)
     [14:16:49.043] }
     [14:16:49.043] ...future.frame <- base::sys.nframe()
     [14:16:49.043] ...future.conditions <- base::list()
     [14:16:49.043] ...future.rng <- base::globalenv()$.Random.seed
     [14:16:49.043] ...future.result <- base::tryCatch({
     [14:16:49.043] base::withCallingHandlers({
     [14:16:49.043] ...future.value <- base::withVisible(base::local({
     [14:16:49.043] outer_function(1L)
     [14:16:49.043] }))
     [14:16:49.043] future::FutureResult(value = ...future.value$value,
     [14:16:49.043] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:49.043] ...future.rng), started = ...future.startTime,
     [14:16:49.043] version = "1.8")
     [14:16:49.043] }, condition = base::local({
     [14:16:49.043] c <- base::c
     [14:16:49.043] inherits <- base::inherits
     [14:16:49.043] invokeRestart <- base::invokeRestart
     [14:16:49.043] length <- base::length
     [14:16:49.043] list <- base::list
     [14:16:49.043] seq.int <- base::seq.int
     [14:16:49.043] signalCondition <- base::signalCondition
     [14:16:49.043] sys.calls <- base::sys.calls
     [14:16:49.043] Sys.time <- base::Sys.time
     [14:16:49.043] `[[` <- base::`[[`
     [14:16:49.043] `+` <- base::`+`
     [14:16:49.043] `<<-` <- base::`<<-`
     [14:16:49.043] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [14:16:49.043] calls[seq.int(from = from + 12L, to = length(calls) -
     [14:16:49.043] 3L)]
     [14:16:49.043] }
     [14:16:49.043] function(cond) {
     [14:16:49.043] if (inherits(cond, "error")) {
     [14:16:49.043] ...future.conditions[[length(...future.conditions) +
     [14:16:49.043] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [14:16:49.043] cond$call), timestamp = Sys.time(), signaled = 0L)
     [14:16:49.043] signalCondition(cond)
     [14:16:49.043] }
     [14:16:49.043] else if (inherits(cond, "condition")) {
     [14:16:49.043] signal <- FALSE && inherits(cond, character(0))
     [14:16:49.043] ...future.conditions[[length(...future.conditions) +
     [14:16:49.043] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [14:16:49.043] if (!signal) {
     [14:16:49.043] muffleCondition <- function (cond)
     [14:16:49.043] {
     [14:16:49.043] inherits <- base::inherits
     [14:16:49.043] invokeRestart <- base::invokeRestart
     [14:16:49.043] muffled <- FALSE
     [14:16:49.043] if (inherits(cond, "message")) {
     [14:16:49.043] invokeRestart("muffleMessage")
     [14:16:49.043] muffled <- TRUE
     [14:16:49.043] }
     [14:16:49.043] else if (inherits(cond, "warning")) {
     [14:16:49.043] invokeRestart("muffleWarning")
     [14:16:49.043] muffled <- TRUE
     [14:16:49.043] }
     [14:16:49.043] else if (inherits(cond, "condition")) {
     [14:16:49.043] computeRestarts <- base::computeRestarts
     [14:16:49.043] grepl <- base::grepl
     [14:16:49.043] is.null <- base::is.null
     [14:16:49.043] restarts <- computeRestarts(cond)
     [14:16:49.043] for (restart in restarts) {
     [14:16:49.043] name <- restart$name
     [14:16:49.043] if (is.null(name))
     [14:16:49.043] next
     [14:16:49.043] if (!grepl("^muffle", name))
     [14:16:49.043] next
     [14:16:49.043] invokeRestart(restart)
     [14:16:49.043] muffled <- TRUE
     [14:16:49.043] break
     [14:16:49.043] }
     [14:16:49.043] }
     [14:16:49.043] invisible(muffled)
     [14:16:49.043] }
     [14:16:49.043] muffleCondition(cond)
     [14:16:49.043] }
     [14:16:49.043] }
     [14:16:49.043] }
     [14:16:49.043] }))
     [14:16:49.043] }, error = function(ex) {
     [14:16:49.043] base::structure(base::list(value = NULL, visible = NULL,
     [14:16:49.043] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [14:16:49.043] ...future.rng), version = "1.8"), class = "FutureResult")
     [14:16:49.043] }, finally = {
     [14:16:49.043] {
     [14:16:49.043] {
     [14:16:49.043] base::options(mc.cores = ...future.mc.cores.old)
     [14:16:49.043] }
     [14:16:49.043] future::plan(list(function (expr, envir = parent.frame(),
     [14:16:49.043] substitute = TRUE, lazy = FALSE, seed = NULL,
     [14:16:49.043] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [14:16:49.043] earlySignal = FALSE, label = NULL, ...)
     [14:16:49.043] {
     [14:16:49.043] if (substitute)
     [14:16:49.043] expr <- substitute(expr)
     [14:16:49.043] if (is.function(workers))
     [14:16:49.043] workers <- workers()
     [14:16:49.043] workers <- as.integer(workers)
     [14:16:49.043] stop_if_not(is.finite(workers), workers >= 1L)
     [14:16:49.043] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [14:16:49.043] return(sequential(expr, envir = envir, substitute = FALSE,
     [14:16:49.043] lazy = lazy, seed = seed, globals = globals,
     [14:16:49.043] local = TRUE, label = label, ...))
     [14:16:49.043] }
     [14:16:49.043] oopts <- options(mc.cores = workers)
     [14:16:49.043] on.exit(options(oopts))
     [14:16:49.043] future <- MulticoreFuture(expr = expr, envir = envir,
     [14:16:49.043] substitute = FALSE, lazy = lazy, seed = seed,
     [14:16:49.043] globals = globals, workers = workers, earlySignal = earlySignal,
     [14:16:49.043] label = label, ...)
     [14:16:49.043] if (!future$lazy)
     [14:16:49.043] future <- run(future)
     [14:16:49.043] invisible(future)
     [14:16:49.043] }), .cleanup = FALSE, .init = FALSE)
     [14:16:49.043] }
     [14:16:49.043] base::options(...future.oldOptions)
     [14:16:49.043] })
     [14:16:49.043] Sys.time
     [14:16:49.043] if (base::is.na(TRUE)) {
     [14:16:49.043] }
     [14:16:49.043] else {
     [14:16:49.043] base::sink(type = "output", split = FALSE)
     [14:16:49.043] if (TRUE) {
     [14:16:49.043] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [14:16:49.043] }
     [14:16:49.043] else {
     [14:16:49.043] ...future.result["stdout"] <- base::list(NULL)
     [14:16:49.043] }
     [14:16:49.043] base::close(...future.stdout)
     [14:16:49.043] ...future.stdout <- NULL
     [14:16:49.043] }
     [14:16:49.043] ...future.result$conditions <- ...future.conditions
     [14:16:49.043] ...future.result
     [14:16:49.043] }
     [14:16:49.048] requestCore(): workers = 2
     [14:16:49.052] MulticoreFuture started
     [14:16:49.059] plan(): Setting new future strategy stack:
     [14:16:49.060] List of future strategies:
     [14:16:49.060] 1. sequential:
     [14:16:49.060] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [14:16:49.060] - tweaked: FALSE
     [14:16:49.060] - call: NULL
     [14:16:49.061] plan(): nbrOfWorkers() = 1
     [14:16:49.064] plan(): Setting new future strategy stack:
     [14:16:49.064] List of future strategies:
     [14:16:49.064] 1. multicore:
     [14:16:49.064] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [14:16:49.064] - tweaked: FALSE
     [14:16:49.064] - call: plan(strategy)
     [14:16:49.067] plan(): nbrOfWorkers() = 2
     List of 2
     $ : num [1:2] 2 3
     $ : num [1:2] 2 3
     - plan('multisession') ...
     [14:16:49.074] plan(): Setting new future strategy stack:
     [14:16:49.074] List of future strategies:
     [14:16:49.074] 1. multisession:
     [14:16:49.074] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     [14:16:49.074] - tweaked: FALSE
     [14:16:49.074] - call: plan(strategy)
     [14:16:49.076] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
     [14:16:49.076] multisession:
     [14:16:49.076] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     [14:16:49.076] - tweaked: FALSE
     [14:16:49.076] - call: plan(strategy)
     [local output] Workers: [n = 2] 'localhost', 'localhost'
     [local output] Base port: 37242
     [local output] Creating node 1 of 2 ...
     [local output] - setting up node
     Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmp8MmkUU/future.parent=14694.3966677fd8d3.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmp8MmkUU/future.parent=14694.3966677fd8d3.pid')"'
     - Possible to infer worker's PID: TRUE
     [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/globals,formulas.R:gimli:hornik:14694' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmp8MmkUU/future.parent=14694.3966677fd8d3.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=37242 OUT=/dev/null TIMEOUT=120 XDR=TRUE
     [local output] - Exit code of system() call: 0
     [local output] Waiting for worker #1 on 'localhost' to connect back
     [local output] Detected a warning from socketConnection(): 'port 37242 cannot be opened'
     Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE, :
     port 37242 cannot be opened
     Killing worker process (PID 15893) if still alive
     [14:16:51.115] Attempting to find a working pid_exists_*() function ...
     Call: tools::pskill(14694, signal = 0L)
     [1] TRUE
     Call: tools::pskill(14694, signal = 0L)
     [1] TRUE
     [14:16:51.116] - success
     [14:16:51.117] Attempting to find a working pid_exists_*() function ... done
     Worker (PID 15893) was successfully killed: TRUE
     Error in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE, :
     Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gimli'.
     * The error produced by socketConnection() was: 'cannot open the connection'
     * In addition, socketConnection() produced 1 warning(s):
     - Warning #1: 'port 37242 cannot be opened' (which suggests that this port is either already occupied by another process or blocked by the firewall on your local machine)
     * The localhost socket connection that failed to connect to the R worker used port 37242 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
     * Worker launch call: '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/globals,formulas.R:gimli:hornik:14694' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmp8MmkUU/future.parent=14694.3966677fd8d3.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=37242 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
     * Worker (PID 15893) was successfully killed: TRUE
     * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
     Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
     Execution halted
Flavor: r-patched-linux-x86_64

Package future.apply

Current CRAN status: OK: 13

Package future.BatchJobs

Current CRAN status: OK: 13

Package future.batchtools

Current CRAN status: OK: 13

Package future.callr

Current CRAN status: OK: 13

Package globals

Current CRAN status: OK: 13

Package listenv

Current CRAN status: OK: 13

Package matrixStats

Current CRAN status: NOTE: 8, OK: 5

Version: 0.55.0
Check: installed package size
Result: NOTE
     installed size is 11.3Mb
     sub-directories of 1Mb or more:
     libs 10.5Mb
Flavors: r-devel-linux-x86_64-fedora-clang, r-devel-windows-ix86+x86_64, r-devel-windows-ix86+x86_64-gcc8, r-patched-solaris-x86, r-release-windows-ix86+x86_64, r-release-osx-x86_64, r-oldrel-windows-ix86+x86_64, r-oldrel-osx-x86_64

Package profmem

Current CRAN status: OK: 13

Package PSCBS

Current CRAN status: OK: 13

Package R.cache

Current CRAN status: OK: 13

Package R.devices

Current CRAN status: ERROR: 1, OK: 12

Version: 2.16.1
Check: tests
Result: ERROR
     Running ‘DevEvalFileProduct.R’
     Running ‘DevEvalProduct.R’
     Running ‘capabilitiesX11.R’
     Running ‘capturePlot.R’
     Running ‘dataURI.R’
     Running ‘devAll.R’
     Running ‘devDump.R’
     Running ‘devEqualTypes.R’
     Running ‘devEval,error.R’
     Running ‘devEval.R’ [6s/22s]
     Running ‘devIsInteractive.R’
     Running ‘devIsOpen.R’
     Running ‘devList.R’
     Running ‘devListIndexOf.R’
     Running ‘devNew.R’
     Running ‘devOptions.R’
     Running ‘devSet.R’
     Running ‘devTypeName.R’
     Running ‘favicon.R’
     Running ‘toNNN.R’
     Running ‘withPar.R’
    Running the tests in ‘tests/devEval.R’ failed.
    Complete output:
     > message("*** devEval() ...")
     *** devEval() ...
     >
     > library("R.devices")
     R.devices v2.16.1 successfully loaded. See ?R.devices for help.
     > library("R.utils")
     Loading required package: R.oo
     Loading required package: R.methodsS3
     R.methodsS3 v1.7.1 (2016-02-15) successfully loaded. See ?R.methodsS3 for help.
     R.oo v1.23.0 successfully loaded. See ?R.oo for help.
    
     Attaching package: 'R.oo'
    
     The following object is masked from 'package:R.methodsS3':
    
     throw
    
     The following objects are masked from 'package:methods':
    
     getClasses, getMethods
    
     The following objects are masked from 'package:base':
    
     attach, detach, load, save
    
     R.utils v2.9.2 successfully loaded. See ?R.utils for help.
    
     Attaching package: 'R.utils'
    
     The following object is masked from 'package:utils':
    
     timestamp
    
     The following objects are masked from 'package:base':
    
     cat, commandArgs, getOption, inherits, isOpen, nullfile, parse,
     warnings
    
     > graphics.off()
     >
     > png <- grDevices::png
     > jpeg <- grDevices::jpeg
     > tiff <- grDevices::tiff
     >
     >
     > # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     > # Various types of single and multiple device outputs
     > # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     > message("*** devEval() - single and multiple device outputs ...")
     *** devEval() - single and multiple device outputs ...
     >
     > types <- list(
     + character(0L),
     + "png",
     + "jpg",
     + "nulldev",
     + c("png", "png", "jpeg"),
     + "png,nulldev,pdf"
     + )
     >
     > for (type in types) {
     + cat("Device types: ", paste(sQuote(type), collapse=", "), "\n", sep="")
     + devList0 <- devList()
     + res <- devEval(type, name="multi", aspectRatio=2/3, {
     + plot(1:10)
     + })
     + print(res)
     + stopifnot(length(res) == length(unlist(strsplit(type, split=","))))
     + stopifnot(all.equal(devList(), devList0))
     + }
     Device types:
     character(0)
     Device types: 'png'
     [1] "figures/multi.png"
     Device types: 'jpg'
     [1] "figures/multi.jpg"
     Device types: 'nulldev'
     [1] "/dev/null"
     Device types: 'png', 'png', 'jpeg'
     $png
     [1] "figures/multi.png"
    
     $png
     [1] "figures/multi.png"
    
     $jpeg
     [1] "figures/multi.jpg"
    
     Device types: 'png,nulldev,pdf'
     $png
     [1] "figures/multi.png"
    
     $nulldev
     [1] "/dev/null"
    
     $pdf
     [1] "figures/multi.pdf"
    
     >
     > # Sanity checks
     > print(devList())
     named integer(0)
     > stopifnot(length(devList()) == 0L)
     >
     > message("*** devEval() - single and multiple device outputs ... DONE")
     *** devEval() - single and multiple device outputs ... DONE
     >
     >
     > # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     > # With 'initially' and 'finally' expression
     > # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     > message("*** devEval() - initially and finally ...")
     *** devEval() - initially and finally ...
     >
     > devList0 <- devList()
     > devEval(c("png", "jpg"), name="count", {
     + plot(1:10)
     + count <- count + 1L
     + }, initially = {
     + # Emulate an overhead
     + cat("Initiate...")
     + count <- 0L
     + Sys.sleep(1)
     + cat("done\n")
     + }, finally = {
     + cat("Number of image files created: ", count, "\n", sep="")
     + })
     Initiate...done
     Number of image files created: 2
     $png
     [1] "figures/count.png"
    
     $jpeg
     [1] "figures/count.jpg"
    
     > stopifnot(all.equal(devList(), devList0))
     >
     > # Sanity checks
     > print(devList())
     named integer(0)
     > stopifnot(length(devList()) == 0L)
     >
     > message("*** devEval() - initially and finally ... DONE")
     *** devEval() - initially and finally ... DONE
     >
     >
     > # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     > # Try several devices until first successful device is found
     > # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     > message("*** devEval() - first successful device ...")
     *** devEval() - first successful device ...
     >
     > types <- list(
     + "png|jpg|pdf", # PNG, JPG and then PDF
     + "dummy|png|jpg|pdf", # "Non-existing", PNG, JPG and then PDF
     + "quartz|x11|windows", # Any interactive device (depending on OS)
     + c("png|jpg", "x11|windows"), # PNG or JPG and then x11 or windows
     + "eps|postscript|pdf", # EPS, Postscript or PDF
     + "jpeg2|jpeg", # JPEG via bitmap() or via jpeg()
     + "png,jpg|x11|windows", # == c("png", "jpg|x11|windows")
     + "nulldev|jpeg" # NULL devices, otherwise jpeg
     + )
     >
     > if (!capabilitiesX11()) {
     + message("Skipping test for X11")
     + types <- lapply(types, FUN=function(x) gsub("x11|", "", x, fixed=TRUE))
     + }
     >
     > devList0 <- devList()
     >
     > for (type in types) {
     + printf("Any of %s\n", paste(sQuote(type), collapse=" + "))
     +
     + # Use try-catch in case not supported on some test systems
     + tryCatch({
     + res <- devEval(type, name="any", aspectRatio=2/3, scale=1.2, {
     + plot(100:1)
     + })
     + printf("Result: %s (%s)\n\n", sQuote(res), attr(res, "type"))
     +
     + if (length(devList()) > 0) devOff()
     + }, error = function(ex) {
     + printf("Failed: %s\n\n", sQuote(ex$message))
     + })
     + } # for (type ...)
     Any of 'png|jpg|pdf'
     Any of 'dummy|png|jpg|pdf'
     Any of 'quartz|x11|windows'
     Failed: 'Failed to open graphics device: quartz'
    
     Any of 'png|jpg' + 'x11|windows'
     Any of 'eps|postscript|pdf'
     Any of 'jpeg2|jpeg'
     Any of 'png,jpg|x11|windows'
    
     *** caught segfault ***
     address f7fb6018, cause 'memory not mapped'
    
     Traceback:
     1: .External2(C_X11, d$display, d$width, d$height, d$pointsize, d$gamma, d$colortype, d$maxcubesize, d$bg, d$canvas, d$fonts, NA_integer_, d$xpos, d$ypos, d$title, type, antialias, d$family)
     2: (function (display = "", width, height, pointsize, gamma, bg, canvas, fonts, family, xpos, ypos, title, type, antialias, ...) { if (display != "XImage") { check <- Sys.getenv("_R_CHECK_SCREEN_DEVICE_", "") msg <- "screen devices should not be used in examples etc" if (identical(check, "stop")) stop(msg, domain = NA) else if (identical(check, "warn")) warning(msg, immediate. = TRUE, noBreaks. = TRUE, domain = NA) } if (display == "" && .Platform$GUI == "AQUA" && is.na(Sys.getenv("DISPLAY", NA))) Sys.setenv(DISPLAY = ":0") new <- list() if (!missing(display)) new$display <- display if (!missing(width)) new$width <- width if (!missing(height)) new$height <- height if (!missing(gamma)) new$gamma <- gamma if (!missing(pointsize)) new$pointsize <- pointsize if (!missing(bg)) new$bg <- bg if (!missing(canvas)) new$canvas <- canvas if (!missing(xpos)) new$xpos <- xpos if (!missing(ypos)) new$ypos <- ypos if (!missing(title)) new$title <- title if (!checkIntFormat(new$title)) stop("invalid 'title'") if (!missing(type)) { new$type <- match.arg(type, c("Xlib", "cairo", "nbcairo", "dbcairo")) if (!capabilities("cairo") && type != "Xlib") warning("cairo-based types are not supported on this build - using \"Xlib\"") } if (!missing(family)) new$family <- family if (!missing(fonts)) new$fonts <- fonts if (!missing(antialias) && type != "Xlib") new$antialias <- match.arg(antialias, aa.cairo) d <- check.options(new, name.opt = ".X11.Options", envir = .X11env) if (d$type == "Xlib" && !missing(family)) { fns <- X11Fonts() if (!family %in% names(fns)) stop("unknown family for X11(type = \"XLib\")") d$fonts[1] <- fns[[family]] } type <- if (capabilities("cairo")) switch(d$type, cairo = 1L, nbcairo = 2L, dbcairo = 3L, 0L) else 0L if (display == "XImage") type <- 0L antialias <- match(d$antialias, aa.cairo) if (grepl("darwin", R.version$os)) check_for_XQuartz() .External2(C_X11, d$display, d$width, d$height, d$pointsize, d$gamma, d$colortype, d$maxcubesize, d$bg, d$canvas, d$fonts, NA_integer_, d$xpos, d$ypos, d$title, type, antialias, d$family) invisible()})()
     3: do.call(typeT, args = args)
     4: devNew(type, which = fullname, ..., .allowUnknownArgs = .allowUnknownArgs)
     5: devEval(type = type, expr = expr, initially = NULL, finally = NULL, envir = envir, name = nameOrg, tags = tags, sep = sep, ..., ext = ext, filename = filename, path = path, field = field, onIncomplete = onIncomplete, force = force, .exprAsIs = TRUE, .allowUnknownArgs = TRUE)
     6: FUN(X[[i]], ...)
     7: lapply(types, FUN = function(type) { devEval(type = type, expr = expr, initially = NULL, finally = NULL, envir = envir, name = nameOrg, tags = tags, sep = sep, ..., ext = ext, filename = filename, path = path, field = field, onIncomplete = onIncomplete, force = force, .exprAsIs = TRUE, .allowUnknownArgs = TRUE)})
     8: devEval(type, name = "any", aspectRatio = 2/3, scale = 1.2, { plot(100:1)})
     9: doTryCatch(return(expr), name, parentenv, handler)
     10: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     11: tryCatchList(expr, classes, parentenv, handlers)
     12: tryCatch({ res <- devEval(type, name = "any", aspectRatio = 2/3, scale = 1.2, { plot(100:1) }) printf("Result: %s (%s)\n\n", sQuote(res), attr(res, "type")) if (length(devList()) > 0) devOff()}, error = function(ex) { printf("Failed: %s\n\n", sQuote(ex$message))})
     An irrecoverable exception occurred. R is aborting now ...
Flavor: r-patched-solaris-x86

Package R.filesets

Current CRAN status: OK: 13

Package R.huge

Current CRAN status: OK: 13

Package R.matlab

Current CRAN status: OK: 13

Package R.methodsS3

Current CRAN status: OK: 13

Package R.oo

Current CRAN status: OK: 13

Package R.rsp

Current CRAN status: NOTE: 2, OK: 11

Version: 0.43.2
Check: dependencies in R code
Result: NOTE
    No protocol specified
    No protocol specified
Flavors: r-release-osx-x86_64, r-oldrel-osx-x86_64

Package R.utils

Current CRAN status: OK: 13

Package startup

Current CRAN status: NOTE: 2, OK: 11

Version: 0.14.0
Check: dependencies in R code
Result: NOTE
    No protocol specified
    No protocol specified
Flavors: r-release-osx-x86_64, r-oldrel-osx-x86_64