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