R Under development (unstable) (2024-07-28 r86931 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2024 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> source("incl/start.R")
[17:27:47.594] plan(): Setting new future strategy stack:
[17:27:47.597] List of future strategies:
[17:27:47.597] 1. sequential:
[17:27:47.597]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.597]    - tweaked: FALSE
[17:27:47.597]    - call: future::plan("sequential")
[17:27:47.625] 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') ...
[17:27:47.739] plan(): Setting new future strategy stack:
[17:27:47.739] List of future strategies:
[17:27:47.739] 1. sequential:
[17:27:47.739]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.739]    - tweaked: FALSE
[17:27:47.739]    - call: plan(strategy)
[17:27:47.754] plan(): nbrOfWorkers() = 1
- lm(<formula>) ...
[17:27:47.755] getGlobalsAndPackages() ...
[17:27:47.755] Searching for globals...
[17:27:47.763] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
[17:27:47.763] Searching for globals ... DONE
[17:27:47.763] Resolving globals: FALSE
[17:27:47.765] The total size of the 2 globals is 401 bytes (401 bytes)
[17:27:47.765] The total size of the 2 globals exported for future expression ('{; lm(weight ~ group - 1); }') is 401 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'group' (210 bytes of class 'numeric') and 'weight' (191 bytes of class 'numeric')
[17:27:47.765] - globals: [2] 'weight', 'group'
[17:27:47.766] - packages: [1] 'stats'
[17:27:47.766] getGlobalsAndPackages() ... DONE
[17:27:47.767] run() for 'Future' ...
[17:27:47.767] - state: 'created'
[17:27:47.767] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:47.768] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:47.768] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:47.768]   - Field: 'label'
[17:27:47.768]   - Field: 'local'
[17:27:47.768]   - Field: 'owner'
[17:27:47.768]   - Field: 'envir'
[17:27:47.769]   - Field: 'packages'
[17:27:47.769]   - Field: 'gc'
[17:27:47.769]   - Field: 'conditions'
[17:27:47.769]   - Field: 'expr'
[17:27:47.769]   - Field: 'uuid'
[17:27:47.770]   - Field: 'seed'
[17:27:47.770]   - Field: 'version'
[17:27:47.770]   - Field: 'result'
[17:27:47.770]   - Field: 'asynchronous'
[17:27:47.770]   - Field: 'calls'
[17:27:47.770]   - Field: 'globals'
[17:27:47.771]   - Field: 'stdout'
[17:27:47.771]   - Field: 'earlySignal'
[17:27:47.771]   - Field: 'lazy'
[17:27:47.771]   - Field: 'state'
[17:27:47.771] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:47.771] - Launch lazy future ...
[17:27:47.772] Packages needed by the future expression (n = 1): 'stats'
[17:27:47.773] Packages needed by future strategies (n = 0): <none>
[17:27:47.774] {
[17:27:47.774]     {
[17:27:47.774]         {
[17:27:47.774]             ...future.startTime <- base::Sys.time()
[17:27:47.774]             {
[17:27:47.774]                 {
[17:27:47.774]                   {
[17:27:47.774]                     {
[17:27:47.774]                       base::local({
[17:27:47.774]                         has_future <- base::requireNamespace("future", 
[17:27:47.774]                           quietly = TRUE)
[17:27:47.774]                         if (has_future) {
[17:27:47.774]                           ns <- base::getNamespace("future")
[17:27:47.774]                           version <- ns[[".package"]][["version"]]
[17:27:47.774]                           if (is.null(version)) 
[17:27:47.774]                             version <- utils::packageVersion("future")
[17:27:47.774]                         }
[17:27:47.774]                         else {
[17:27:47.774]                           version <- NULL
[17:27:47.774]                         }
[17:27:47.774]                         if (!has_future || version < "1.8.0") {
[17:27:47.774]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:47.774]                             "", base::R.version$version.string), 
[17:27:47.774]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:47.774]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:47.774]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:47.774]                               "release", "version")], collapse = " "), 
[17:27:47.774]                             hostname = base::Sys.info()[["nodename"]])
[17:27:47.774]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:47.774]                             info)
[17:27:47.774]                           info <- base::paste(info, collapse = "; ")
[17:27:47.774]                           if (!has_future) {
[17:27:47.774]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:47.774]                               info)
[17:27:47.774]                           }
[17:27:47.774]                           else {
[17:27:47.774]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:47.774]                               info, version)
[17:27:47.774]                           }
[17:27:47.774]                           base::stop(msg)
[17:27:47.774]                         }
[17:27:47.774]                       })
[17:27:47.774]                     }
[17:27:47.774]                     base::local({
[17:27:47.774]                       for (pkg in "stats") {
[17:27:47.774]                         base::loadNamespace(pkg)
[17:27:47.774]                         base::library(pkg, character.only = TRUE)
[17:27:47.774]                       }
[17:27:47.774]                     })
[17:27:47.774]                   }
[17:27:47.774]                   ...future.strategy.old <- future::plan("list")
[17:27:47.774]                   options(future.plan = NULL)
[17:27:47.774]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:47.774]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:47.774]                 }
[17:27:47.774]                 ...future.workdir <- getwd()
[17:27:47.774]             }
[17:27:47.774]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:47.774]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:47.774]         }
[17:27:47.774]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:47.774]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:47.774]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:47.774]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:47.774]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:47.774]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:47.774]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:47.774]             base::names(...future.oldOptions))
[17:27:47.774]     }
[17:27:47.774]     if (FALSE) {
[17:27:47.774]     }
[17:27:47.774]     else {
[17:27:47.774]         if (TRUE) {
[17:27:47.774]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:47.774]                 open = "w")
[17:27:47.774]         }
[17:27:47.774]         else {
[17:27:47.774]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:47.774]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:47.774]         }
[17:27:47.774]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:47.774]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:47.774]             base::sink(type = "output", split = FALSE)
[17:27:47.774]             base::close(...future.stdout)
[17:27:47.774]         }, add = TRUE)
[17:27:47.774]     }
[17:27:47.774]     ...future.frame <- base::sys.nframe()
[17:27:47.774]     ...future.conditions <- base::list()
[17:27:47.774]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:47.774]     if (FALSE) {
[17:27:47.774]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:47.774]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:47.774]     }
[17:27:47.774]     ...future.result <- base::tryCatch({
[17:27:47.774]         base::withCallingHandlers({
[17:27:47.774]             ...future.value <- base::withVisible(base::local({
[17:27:47.774]                 lm(weight ~ group - 1)
[17:27:47.774]             }))
[17:27:47.774]             future::FutureResult(value = ...future.value$value, 
[17:27:47.774]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:47.774]                   ...future.rng), globalenv = if (FALSE) 
[17:27:47.774]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:47.774]                     ...future.globalenv.names))
[17:27:47.774]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:47.774]         }, condition = base::local({
[17:27:47.774]             c <- base::c
[17:27:47.774]             inherits <- base::inherits
[17:27:47.774]             invokeRestart <- base::invokeRestart
[17:27:47.774]             length <- base::length
[17:27:47.774]             list <- base::list
[17:27:47.774]             seq.int <- base::seq.int
[17:27:47.774]             signalCondition <- base::signalCondition
[17:27:47.774]             sys.calls <- base::sys.calls
[17:27:47.774]             `[[` <- base::`[[`
[17:27:47.774]             `+` <- base::`+`
[17:27:47.774]             `<<-` <- base::`<<-`
[17:27:47.774]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:47.774]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:47.774]                   3L)]
[17:27:47.774]             }
[17:27:47.774]             function(cond) {
[17:27:47.774]                 is_error <- inherits(cond, "error")
[17:27:47.774]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:47.774]                   NULL)
[17:27:47.774]                 if (is_error) {
[17:27:47.774]                   sessionInformation <- function() {
[17:27:47.774]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:47.774]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:47.774]                       search = base::search(), system = base::Sys.info())
[17:27:47.774]                   }
[17:27:47.774]                   ...future.conditions[[length(...future.conditions) + 
[17:27:47.774]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:47.774]                     cond$call), session = sessionInformation(), 
[17:27:47.774]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:47.774]                   signalCondition(cond)
[17:27:47.774]                 }
[17:27:47.774]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:47.774]                 "immediateCondition"))) {
[17:27:47.774]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:47.774]                   ...future.conditions[[length(...future.conditions) + 
[17:27:47.774]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:47.774]                   if (TRUE && !signal) {
[17:27:47.774]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:47.774]                     {
[17:27:47.774]                       inherits <- base::inherits
[17:27:47.774]                       invokeRestart <- base::invokeRestart
[17:27:47.774]                       is.null <- base::is.null
[17:27:47.774]                       muffled <- FALSE
[17:27:47.774]                       if (inherits(cond, "message")) {
[17:27:47.774]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:47.774]                         if (muffled) 
[17:27:47.774]                           invokeRestart("muffleMessage")
[17:27:47.774]                       }
[17:27:47.774]                       else if (inherits(cond, "warning")) {
[17:27:47.774]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:47.774]                         if (muffled) 
[17:27:47.774]                           invokeRestart("muffleWarning")
[17:27:47.774]                       }
[17:27:47.774]                       else if (inherits(cond, "condition")) {
[17:27:47.774]                         if (!is.null(pattern)) {
[17:27:47.774]                           computeRestarts <- base::computeRestarts
[17:27:47.774]                           grepl <- base::grepl
[17:27:47.774]                           restarts <- computeRestarts(cond)
[17:27:47.774]                           for (restart in restarts) {
[17:27:47.774]                             name <- restart$name
[17:27:47.774]                             if (is.null(name)) 
[17:27:47.774]                               next
[17:27:47.774]                             if (!grepl(pattern, name)) 
[17:27:47.774]                               next
[17:27:47.774]                             invokeRestart(restart)
[17:27:47.774]                             muffled <- TRUE
[17:27:47.774]                             break
[17:27:47.774]                           }
[17:27:47.774]                         }
[17:27:47.774]                       }
[17:27:47.774]                       invisible(muffled)
[17:27:47.774]                     }
[17:27:47.774]                     muffleCondition(cond, pattern = "^muffle")
[17:27:47.774]                   }
[17:27:47.774]                 }
[17:27:47.774]                 else {
[17:27:47.774]                   if (TRUE) {
[17:27:47.774]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:47.774]                     {
[17:27:47.774]                       inherits <- base::inherits
[17:27:47.774]                       invokeRestart <- base::invokeRestart
[17:27:47.774]                       is.null <- base::is.null
[17:27:47.774]                       muffled <- FALSE
[17:27:47.774]                       if (inherits(cond, "message")) {
[17:27:47.774]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:47.774]                         if (muffled) 
[17:27:47.774]                           invokeRestart("muffleMessage")
[17:27:47.774]                       }
[17:27:47.774]                       else if (inherits(cond, "warning")) {
[17:27:47.774]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:47.774]                         if (muffled) 
[17:27:47.774]                           invokeRestart("muffleWarning")
[17:27:47.774]                       }
[17:27:47.774]                       else if (inherits(cond, "condition")) {
[17:27:47.774]                         if (!is.null(pattern)) {
[17:27:47.774]                           computeRestarts <- base::computeRestarts
[17:27:47.774]                           grepl <- base::grepl
[17:27:47.774]                           restarts <- computeRestarts(cond)
[17:27:47.774]                           for (restart in restarts) {
[17:27:47.774]                             name <- restart$name
[17:27:47.774]                             if (is.null(name)) 
[17:27:47.774]                               next
[17:27:47.774]                             if (!grepl(pattern, name)) 
[17:27:47.774]                               next
[17:27:47.774]                             invokeRestart(restart)
[17:27:47.774]                             muffled <- TRUE
[17:27:47.774]                             break
[17:27:47.774]                           }
[17:27:47.774]                         }
[17:27:47.774]                       }
[17:27:47.774]                       invisible(muffled)
[17:27:47.774]                     }
[17:27:47.774]                     muffleCondition(cond, pattern = "^muffle")
[17:27:47.774]                   }
[17:27:47.774]                 }
[17:27:47.774]             }
[17:27:47.774]         }))
[17:27:47.774]     }, error = function(ex) {
[17:27:47.774]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:47.774]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:47.774]                 ...future.rng), started = ...future.startTime, 
[17:27:47.774]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:47.774]             version = "1.8"), class = "FutureResult")
[17:27:47.774]     }, finally = {
[17:27:47.774]         if (!identical(...future.workdir, getwd())) 
[17:27:47.774]             setwd(...future.workdir)
[17:27:47.774]         {
[17:27:47.774]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:47.774]                 ...future.oldOptions$nwarnings <- NULL
[17:27:47.774]             }
[17:27:47.774]             base::options(...future.oldOptions)
[17:27:47.774]             if (.Platform$OS.type == "windows") {
[17:27:47.774]                 old_names <- names(...future.oldEnvVars)
[17:27:47.774]                 envs <- base::Sys.getenv()
[17:27:47.774]                 names <- names(envs)
[17:27:47.774]                 common <- intersect(names, old_names)
[17:27:47.774]                 added <- setdiff(names, old_names)
[17:27:47.774]                 removed <- setdiff(old_names, names)
[17:27:47.774]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:47.774]                   envs[common]]
[17:27:47.774]                 NAMES <- toupper(changed)
[17:27:47.774]                 args <- list()
[17:27:47.774]                 for (kk in seq_along(NAMES)) {
[17:27:47.774]                   name <- changed[[kk]]
[17:27:47.774]                   NAME <- NAMES[[kk]]
[17:27:47.774]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.774]                     next
[17:27:47.774]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:47.774]                 }
[17:27:47.774]                 NAMES <- toupper(added)
[17:27:47.774]                 for (kk in seq_along(NAMES)) {
[17:27:47.774]                   name <- added[[kk]]
[17:27:47.774]                   NAME <- NAMES[[kk]]
[17:27:47.774]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.774]                     next
[17:27:47.774]                   args[[name]] <- ""
[17:27:47.774]                 }
[17:27:47.774]                 NAMES <- toupper(removed)
[17:27:47.774]                 for (kk in seq_along(NAMES)) {
[17:27:47.774]                   name <- removed[[kk]]
[17:27:47.774]                   NAME <- NAMES[[kk]]
[17:27:47.774]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.774]                     next
[17:27:47.774]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:47.774]                 }
[17:27:47.774]                 if (length(args) > 0) 
[17:27:47.774]                   base::do.call(base::Sys.setenv, args = args)
[17:27:47.774]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:47.774]             }
[17:27:47.774]             else {
[17:27:47.774]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:47.774]             }
[17:27:47.774]             {
[17:27:47.774]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:47.774]                   0L) {
[17:27:47.774]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:47.774]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:47.774]                   base::options(opts)
[17:27:47.774]                 }
[17:27:47.774]                 {
[17:27:47.774]                   {
[17:27:47.774]                     NULL
[17:27:47.774]                     RNGkind("Mersenne-Twister")
[17:27:47.774]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:47.774]                       inherits = FALSE)
[17:27:47.774]                   }
[17:27:47.774]                   options(future.plan = NULL)
[17:27:47.774]                   if (is.na(NA_character_)) 
[17:27:47.774]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:47.774]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:47.774]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:47.774]                     .init = FALSE)
[17:27:47.774]                 }
[17:27:47.774]             }
[17:27:47.774]         }
[17:27:47.774]     })
[17:27:47.774]     if (TRUE) {
[17:27:47.774]         base::sink(type = "output", split = FALSE)
[17:27:47.774]         if (TRUE) {
[17:27:47.774]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:47.774]         }
[17:27:47.774]         else {
[17:27:47.774]             ...future.result["stdout"] <- base::list(NULL)
[17:27:47.774]         }
[17:27:47.774]         base::close(...future.stdout)
[17:27:47.774]         ...future.stdout <- NULL
[17:27:47.774]     }
[17:27:47.774]     ...future.result$conditions <- ...future.conditions
[17:27:47.774]     ...future.result$finished <- base::Sys.time()
[17:27:47.774]     ...future.result
[17:27:47.774] }
[17:27:47.778] assign_globals() ...
[17:27:47.778] List of 2
[17:27:47.778]  $ weight: num [1:20] 4.17 5.58 5.18 6.11 4.5 4.61 5.17 4.53 5.33 5.14 ...
[17:27:47.778]  $ group : Factor w/ 2 levels "Ctl","Trt": 1 1 1 1 1 1 1 1 1 1 ...
[17:27:47.778]  - attr(*, "where")=List of 2
[17:27:47.778]   ..$ weight:<environment: R_EmptyEnv> 
[17:27:47.778]   ..$ group :<environment: R_EmptyEnv> 
[17:27:47.778]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:47.778]  - attr(*, "resolved")= logi FALSE
[17:27:47.778]  - attr(*, "total_size")= int 401
[17:27:47.778]  - attr(*, "already-done")= logi TRUE
[17:27:47.784] - copied 'weight' to environment
[17:27:47.784] - copied 'group' to environment
[17:27:47.785] assign_globals() ... done
[17:27:47.785] plan(): Setting new future strategy stack:
[17:27:47.786] List of future strategies:
[17:27:47.786] 1. sequential:
[17:27:47.786]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.786]    - tweaked: FALSE
[17:27:47.786]    - call: NULL
[17:27:47.786] plan(): nbrOfWorkers() = 1
[17:27:47.789] plan(): Setting new future strategy stack:
[17:27:47.789] List of future strategies:
[17:27:47.789] 1. sequential:
[17:27:47.789]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.789]    - tweaked: FALSE
[17:27:47.789]    - call: plan(strategy)
[17:27:47.790] plan(): nbrOfWorkers() = 1
[17:27:47.790] SequentialFuture started (and completed)
[17:27:47.791] - Launch lazy future ... done
[17:27:47.791] run() for 'SequentialFuture' ... done

Call:
lm(formula = weight ~ group - 1)

Coefficients:
groupCtl  groupTrt  
   5.032     4.661  

[17:27:47.794] getGlobalsAndPackages() ...
[17:27:47.794] Searching for globals...
[17:27:47.796] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
[17:27:47.796] Searching for globals ... DONE
[17:27:47.796] Resolving globals: FALSE
[17:27:47.797] The total size of the 2 globals is 401 bytes (401 bytes)
[17:27:47.798] The total size of the 2 globals exported for future expression ('{; lm(weight ~ group - 1); }') is 401 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'group' (210 bytes of class 'numeric') and 'weight' (191 bytes of class 'numeric')
[17:27:47.798] - globals: [2] 'weight', 'group'
[17:27:47.798] - packages: [1] 'stats'
[17:27:47.798] getGlobalsAndPackages() ... DONE
[17:27:47.799] run() for 'Future' ...
[17:27:47.799] - state: 'created'
[17:27:47.799] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:47.800] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:47.800] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:47.800]   - Field: 'label'
[17:27:47.800]   - Field: 'local'
[17:27:47.800]   - Field: 'owner'
[17:27:47.800]   - Field: 'envir'
[17:27:47.801]   - Field: 'packages'
[17:27:47.801]   - Field: 'gc'
[17:27:47.801]   - Field: 'conditions'
[17:27:47.801]   - Field: 'expr'
[17:27:47.802]   - Field: 'uuid'
[17:27:47.802]   - Field: 'seed'
[17:27:47.802]   - Field: 'version'
[17:27:47.802]   - Field: 'result'
[17:27:47.802]   - Field: 'asynchronous'
[17:27:47.803]   - Field: 'calls'
[17:27:47.803]   - Field: 'globals'
[17:27:47.803]   - Field: 'stdout'
[17:27:47.803]   - Field: 'earlySignal'
[17:27:47.803]   - Field: 'lazy'
[17:27:47.804]   - Field: 'state'
[17:27:47.804] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:47.804] - Launch lazy future ...
[17:27:47.804] Packages needed by the future expression (n = 1): 'stats'
[17:27:47.805] Packages needed by future strategies (n = 0): <none>
[17:27:47.805] {
[17:27:47.805]     {
[17:27:47.805]         {
[17:27:47.805]             ...future.startTime <- base::Sys.time()
[17:27:47.805]             {
[17:27:47.805]                 {
[17:27:47.805]                   {
[17:27:47.805]                     {
[17:27:47.805]                       base::local({
[17:27:47.805]                         has_future <- base::requireNamespace("future", 
[17:27:47.805]                           quietly = TRUE)
[17:27:47.805]                         if (has_future) {
[17:27:47.805]                           ns <- base::getNamespace("future")
[17:27:47.805]                           version <- ns[[".package"]][["version"]]
[17:27:47.805]                           if (is.null(version)) 
[17:27:47.805]                             version <- utils::packageVersion("future")
[17:27:47.805]                         }
[17:27:47.805]                         else {
[17:27:47.805]                           version <- NULL
[17:27:47.805]                         }
[17:27:47.805]                         if (!has_future || version < "1.8.0") {
[17:27:47.805]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:47.805]                             "", base::R.version$version.string), 
[17:27:47.805]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:47.805]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:47.805]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:47.805]                               "release", "version")], collapse = " "), 
[17:27:47.805]                             hostname = base::Sys.info()[["nodename"]])
[17:27:47.805]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:47.805]                             info)
[17:27:47.805]                           info <- base::paste(info, collapse = "; ")
[17:27:47.805]                           if (!has_future) {
[17:27:47.805]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:47.805]                               info)
[17:27:47.805]                           }
[17:27:47.805]                           else {
[17:27:47.805]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:47.805]                               info, version)
[17:27:47.805]                           }
[17:27:47.805]                           base::stop(msg)
[17:27:47.805]                         }
[17:27:47.805]                       })
[17:27:47.805]                     }
[17:27:47.805]                     base::local({
[17:27:47.805]                       for (pkg in "stats") {
[17:27:47.805]                         base::loadNamespace(pkg)
[17:27:47.805]                         base::library(pkg, character.only = TRUE)
[17:27:47.805]                       }
[17:27:47.805]                     })
[17:27:47.805]                   }
[17:27:47.805]                   ...future.strategy.old <- future::plan("list")
[17:27:47.805]                   options(future.plan = NULL)
[17:27:47.805]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:47.805]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:47.805]                 }
[17:27:47.805]                 ...future.workdir <- getwd()
[17:27:47.805]             }
[17:27:47.805]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:47.805]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:47.805]         }
[17:27:47.805]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:47.805]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:47.805]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:47.805]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:47.805]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:47.805]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:47.805]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:47.805]             base::names(...future.oldOptions))
[17:27:47.805]     }
[17:27:47.805]     if (FALSE) {
[17:27:47.805]     }
[17:27:47.805]     else {
[17:27:47.805]         if (TRUE) {
[17:27:47.805]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:47.805]                 open = "w")
[17:27:47.805]         }
[17:27:47.805]         else {
[17:27:47.805]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:47.805]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:47.805]         }
[17:27:47.805]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:47.805]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:47.805]             base::sink(type = "output", split = FALSE)
[17:27:47.805]             base::close(...future.stdout)
[17:27:47.805]         }, add = TRUE)
[17:27:47.805]     }
[17:27:47.805]     ...future.frame <- base::sys.nframe()
[17:27:47.805]     ...future.conditions <- base::list()
[17:27:47.805]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:47.805]     if (FALSE) {
[17:27:47.805]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:47.805]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:47.805]     }
[17:27:47.805]     ...future.result <- base::tryCatch({
[17:27:47.805]         base::withCallingHandlers({
[17:27:47.805]             ...future.value <- base::withVisible(base::local({
[17:27:47.805]                 lm(weight ~ group - 1)
[17:27:47.805]             }))
[17:27:47.805]             future::FutureResult(value = ...future.value$value, 
[17:27:47.805]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:47.805]                   ...future.rng), globalenv = if (FALSE) 
[17:27:47.805]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:47.805]                     ...future.globalenv.names))
[17:27:47.805]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:47.805]         }, condition = base::local({
[17:27:47.805]             c <- base::c
[17:27:47.805]             inherits <- base::inherits
[17:27:47.805]             invokeRestart <- base::invokeRestart
[17:27:47.805]             length <- base::length
[17:27:47.805]             list <- base::list
[17:27:47.805]             seq.int <- base::seq.int
[17:27:47.805]             signalCondition <- base::signalCondition
[17:27:47.805]             sys.calls <- base::sys.calls
[17:27:47.805]             `[[` <- base::`[[`
[17:27:47.805]             `+` <- base::`+`
[17:27:47.805]             `<<-` <- base::`<<-`
[17:27:47.805]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:47.805]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:47.805]                   3L)]
[17:27:47.805]             }
[17:27:47.805]             function(cond) {
[17:27:47.805]                 is_error <- inherits(cond, "error")
[17:27:47.805]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:47.805]                   NULL)
[17:27:47.805]                 if (is_error) {
[17:27:47.805]                   sessionInformation <- function() {
[17:27:47.805]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:47.805]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:47.805]                       search = base::search(), system = base::Sys.info())
[17:27:47.805]                   }
[17:27:47.805]                   ...future.conditions[[length(...future.conditions) + 
[17:27:47.805]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:47.805]                     cond$call), session = sessionInformation(), 
[17:27:47.805]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:47.805]                   signalCondition(cond)
[17:27:47.805]                 }
[17:27:47.805]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:47.805]                 "immediateCondition"))) {
[17:27:47.805]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:47.805]                   ...future.conditions[[length(...future.conditions) + 
[17:27:47.805]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:47.805]                   if (TRUE && !signal) {
[17:27:47.805]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:47.805]                     {
[17:27:47.805]                       inherits <- base::inherits
[17:27:47.805]                       invokeRestart <- base::invokeRestart
[17:27:47.805]                       is.null <- base::is.null
[17:27:47.805]                       muffled <- FALSE
[17:27:47.805]                       if (inherits(cond, "message")) {
[17:27:47.805]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:47.805]                         if (muffled) 
[17:27:47.805]                           invokeRestart("muffleMessage")
[17:27:47.805]                       }
[17:27:47.805]                       else if (inherits(cond, "warning")) {
[17:27:47.805]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:47.805]                         if (muffled) 
[17:27:47.805]                           invokeRestart("muffleWarning")
[17:27:47.805]                       }
[17:27:47.805]                       else if (inherits(cond, "condition")) {
[17:27:47.805]                         if (!is.null(pattern)) {
[17:27:47.805]                           computeRestarts <- base::computeRestarts
[17:27:47.805]                           grepl <- base::grepl
[17:27:47.805]                           restarts <- computeRestarts(cond)
[17:27:47.805]                           for (restart in restarts) {
[17:27:47.805]                             name <- restart$name
[17:27:47.805]                             if (is.null(name)) 
[17:27:47.805]                               next
[17:27:47.805]                             if (!grepl(pattern, name)) 
[17:27:47.805]                               next
[17:27:47.805]                             invokeRestart(restart)
[17:27:47.805]                             muffled <- TRUE
[17:27:47.805]                             break
[17:27:47.805]                           }
[17:27:47.805]                         }
[17:27:47.805]                       }
[17:27:47.805]                       invisible(muffled)
[17:27:47.805]                     }
[17:27:47.805]                     muffleCondition(cond, pattern = "^muffle")
[17:27:47.805]                   }
[17:27:47.805]                 }
[17:27:47.805]                 else {
[17:27:47.805]                   if (TRUE) {
[17:27:47.805]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:47.805]                     {
[17:27:47.805]                       inherits <- base::inherits
[17:27:47.805]                       invokeRestart <- base::invokeRestart
[17:27:47.805]                       is.null <- base::is.null
[17:27:47.805]                       muffled <- FALSE
[17:27:47.805]                       if (inherits(cond, "message")) {
[17:27:47.805]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:47.805]                         if (muffled) 
[17:27:47.805]                           invokeRestart("muffleMessage")
[17:27:47.805]                       }
[17:27:47.805]                       else if (inherits(cond, "warning")) {
[17:27:47.805]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:47.805]                         if (muffled) 
[17:27:47.805]                           invokeRestart("muffleWarning")
[17:27:47.805]                       }
[17:27:47.805]                       else if (inherits(cond, "condition")) {
[17:27:47.805]                         if (!is.null(pattern)) {
[17:27:47.805]                           computeRestarts <- base::computeRestarts
[17:27:47.805]                           grepl <- base::grepl
[17:27:47.805]                           restarts <- computeRestarts(cond)
[17:27:47.805]                           for (restart in restarts) {
[17:27:47.805]                             name <- restart$name
[17:27:47.805]                             if (is.null(name)) 
[17:27:47.805]                               next
[17:27:47.805]                             if (!grepl(pattern, name)) 
[17:27:47.805]                               next
[17:27:47.805]                             invokeRestart(restart)
[17:27:47.805]                             muffled <- TRUE
[17:27:47.805]                             break
[17:27:47.805]                           }
[17:27:47.805]                         }
[17:27:47.805]                       }
[17:27:47.805]                       invisible(muffled)
[17:27:47.805]                     }
[17:27:47.805]                     muffleCondition(cond, pattern = "^muffle")
[17:27:47.805]                   }
[17:27:47.805]                 }
[17:27:47.805]             }
[17:27:47.805]         }))
[17:27:47.805]     }, error = function(ex) {
[17:27:47.805]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:47.805]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:47.805]                 ...future.rng), started = ...future.startTime, 
[17:27:47.805]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:47.805]             version = "1.8"), class = "FutureResult")
[17:27:47.805]     }, finally = {
[17:27:47.805]         if (!identical(...future.workdir, getwd())) 
[17:27:47.805]             setwd(...future.workdir)
[17:27:47.805]         {
[17:27:47.805]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:47.805]                 ...future.oldOptions$nwarnings <- NULL
[17:27:47.805]             }
[17:27:47.805]             base::options(...future.oldOptions)
[17:27:47.805]             if (.Platform$OS.type == "windows") {
[17:27:47.805]                 old_names <- names(...future.oldEnvVars)
[17:27:47.805]                 envs <- base::Sys.getenv()
[17:27:47.805]                 names <- names(envs)
[17:27:47.805]                 common <- intersect(names, old_names)
[17:27:47.805]                 added <- setdiff(names, old_names)
[17:27:47.805]                 removed <- setdiff(old_names, names)
[17:27:47.805]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:47.805]                   envs[common]]
[17:27:47.805]                 NAMES <- toupper(changed)
[17:27:47.805]                 args <- list()
[17:27:47.805]                 for (kk in seq_along(NAMES)) {
[17:27:47.805]                   name <- changed[[kk]]
[17:27:47.805]                   NAME <- NAMES[[kk]]
[17:27:47.805]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.805]                     next
[17:27:47.805]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:47.805]                 }
[17:27:47.805]                 NAMES <- toupper(added)
[17:27:47.805]                 for (kk in seq_along(NAMES)) {
[17:27:47.805]                   name <- added[[kk]]
[17:27:47.805]                   NAME <- NAMES[[kk]]
[17:27:47.805]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.805]                     next
[17:27:47.805]                   args[[name]] <- ""
[17:27:47.805]                 }
[17:27:47.805]                 NAMES <- toupper(removed)
[17:27:47.805]                 for (kk in seq_along(NAMES)) {
[17:27:47.805]                   name <- removed[[kk]]
[17:27:47.805]                   NAME <- NAMES[[kk]]
[17:27:47.805]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.805]                     next
[17:27:47.805]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:47.805]                 }
[17:27:47.805]                 if (length(args) > 0) 
[17:27:47.805]                   base::do.call(base::Sys.setenv, args = args)
[17:27:47.805]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:47.805]             }
[17:27:47.805]             else {
[17:27:47.805]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:47.805]             }
[17:27:47.805]             {
[17:27:47.805]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:47.805]                   0L) {
[17:27:47.805]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:47.805]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:47.805]                   base::options(opts)
[17:27:47.805]                 }
[17:27:47.805]                 {
[17:27:47.805]                   {
[17:27:47.805]                     NULL
[17:27:47.805]                     RNGkind("Mersenne-Twister")
[17:27:47.805]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:47.805]                       inherits = FALSE)
[17:27:47.805]                   }
[17:27:47.805]                   options(future.plan = NULL)
[17:27:47.805]                   if (is.na(NA_character_)) 
[17:27:47.805]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:47.805]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:47.805]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:47.805]                     .init = FALSE)
[17:27:47.805]                 }
[17:27:47.805]             }
[17:27:47.805]         }
[17:27:47.805]     })
[17:27:47.805]     if (TRUE) {
[17:27:47.805]         base::sink(type = "output", split = FALSE)
[17:27:47.805]         if (TRUE) {
[17:27:47.805]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:47.805]         }
[17:27:47.805]         else {
[17:27:47.805]             ...future.result["stdout"] <- base::list(NULL)
[17:27:47.805]         }
[17:27:47.805]         base::close(...future.stdout)
[17:27:47.805]         ...future.stdout <- NULL
[17:27:47.805]     }
[17:27:47.805]     ...future.result$conditions <- ...future.conditions
[17:27:47.805]     ...future.result$finished <- base::Sys.time()
[17:27:47.805]     ...future.result
[17:27:47.805] }
[17:27:47.810] assign_globals() ...
[17:27:47.810] List of 2
[17:27:47.810]  $ weight: num [1:20] 4.17 5.58 5.18 6.11 4.5 4.61 5.17 4.53 5.33 5.14 ...
[17:27:47.810]  $ group : Factor w/ 2 levels "Ctl","Trt": 1 1 1 1 1 1 1 1 1 1 ...
[17:27:47.810]  - attr(*, "where")=List of 2
[17:27:47.810]   ..$ weight:<environment: R_EmptyEnv> 
[17:27:47.810]   ..$ group :<environment: R_EmptyEnv> 
[17:27:47.810]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:47.810]  - attr(*, "resolved")= logi FALSE
[17:27:47.810]  - attr(*, "total_size")= int 401
[17:27:47.810]  - attr(*, "already-done")= logi TRUE
[17:27:47.817] - copied 'weight' to environment
[17:27:47.817] - copied 'group' to environment
[17:27:47.817] assign_globals() ... done
[17:27:47.818] plan(): Setting new future strategy stack:
[17:27:47.818] List of future strategies:
[17:27:47.818] 1. sequential:
[17:27:47.818]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.818]    - tweaked: FALSE
[17:27:47.818]    - call: NULL
[17:27:47.819] plan(): nbrOfWorkers() = 1
[17:27:47.821] plan(): Setting new future strategy stack:
[17:27:47.822] List of future strategies:
[17:27:47.822] 1. sequential:
[17:27:47.822]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.822]    - tweaked: FALSE
[17:27:47.822]    - call: plan(strategy)
[17:27:47.822] plan(): nbrOfWorkers() = 1
[17:27:47.823] SequentialFuture started (and completed)
[17:27:47.823] - Launch lazy future ... done
[17:27:47.823] run() for 'SequentialFuture' ... done

Call:
lm(formula = weight ~ group - 1)

Coefficients:
groupCtl  groupTrt  
   5.032     4.661  

[17:27:47.827] getGlobalsAndPackages() ...
[17:27:47.827] Searching for globals...
[17:27:47.829] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
[17:27:47.829] Searching for globals ... DONE
[17:27:47.830] Resolving globals: FALSE
[17:27:47.830] The total size of the 2 globals is 401 bytes (401 bytes)
[17:27:47.831] The total size of the 2 globals exported for future expression ('{; lm(weight ~ group - 1); }') is 401 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'group' (210 bytes of class 'numeric') and 'weight' (191 bytes of class 'numeric')
[17:27:47.831] - globals: [2] 'weight', 'group'
[17:27:47.831] - packages: [1] 'stats'
[17:27:47.832] getGlobalsAndPackages() ... DONE
[17:27:47.832] run() for 'Future' ...
[17:27:47.832] - state: 'created'
[17:27:47.832] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:47.833] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:47.833] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:47.833]   - Field: 'label'
[17:27:47.834]   - Field: 'local'
[17:27:47.834]   - Field: 'owner'
[17:27:47.834]   - Field: 'envir'
[17:27:47.834]   - Field: 'packages'
[17:27:47.834]   - Field: 'gc'
[17:27:47.835]   - Field: 'conditions'
[17:27:47.835]   - Field: 'expr'
[17:27:47.835]   - Field: 'uuid'
[17:27:47.835]   - Field: 'seed'
[17:27:47.835]   - Field: 'version'
[17:27:47.836]   - Field: 'result'
[17:27:47.836]   - Field: 'asynchronous'
[17:27:47.836]   - Field: 'calls'
[17:27:47.836]   - Field: 'globals'
[17:27:47.836]   - Field: 'stdout'
[17:27:47.837]   - Field: 'earlySignal'
[17:27:47.837]   - Field: 'lazy'
[17:27:47.837]   - Field: 'state'
[17:27:47.837] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:47.837] - Launch lazy future ...
[17:27:47.838] Packages needed by the future expression (n = 1): 'stats'
[17:27:47.838] Packages needed by future strategies (n = 0): <none>
[17:27:47.839] {
[17:27:47.839]     {
[17:27:47.839]         {
[17:27:47.839]             ...future.startTime <- base::Sys.time()
[17:27:47.839]             {
[17:27:47.839]                 {
[17:27:47.839]                   {
[17:27:47.839]                     {
[17:27:47.839]                       base::local({
[17:27:47.839]                         has_future <- base::requireNamespace("future", 
[17:27:47.839]                           quietly = TRUE)
[17:27:47.839]                         if (has_future) {
[17:27:47.839]                           ns <- base::getNamespace("future")
[17:27:47.839]                           version <- ns[[".package"]][["version"]]
[17:27:47.839]                           if (is.null(version)) 
[17:27:47.839]                             version <- utils::packageVersion("future")
[17:27:47.839]                         }
[17:27:47.839]                         else {
[17:27:47.839]                           version <- NULL
[17:27:47.839]                         }
[17:27:47.839]                         if (!has_future || version < "1.8.0") {
[17:27:47.839]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:47.839]                             "", base::R.version$version.string), 
[17:27:47.839]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:47.839]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:47.839]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:47.839]                               "release", "version")], collapse = " "), 
[17:27:47.839]                             hostname = base::Sys.info()[["nodename"]])
[17:27:47.839]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:47.839]                             info)
[17:27:47.839]                           info <- base::paste(info, collapse = "; ")
[17:27:47.839]                           if (!has_future) {
[17:27:47.839]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:47.839]                               info)
[17:27:47.839]                           }
[17:27:47.839]                           else {
[17:27:47.839]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:47.839]                               info, version)
[17:27:47.839]                           }
[17:27:47.839]                           base::stop(msg)
[17:27:47.839]                         }
[17:27:47.839]                       })
[17:27:47.839]                     }
[17:27:47.839]                     base::local({
[17:27:47.839]                       for (pkg in "stats") {
[17:27:47.839]                         base::loadNamespace(pkg)
[17:27:47.839]                         base::library(pkg, character.only = TRUE)
[17:27:47.839]                       }
[17:27:47.839]                     })
[17:27:47.839]                   }
[17:27:47.839]                   ...future.strategy.old <- future::plan("list")
[17:27:47.839]                   options(future.plan = NULL)
[17:27:47.839]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:47.839]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:47.839]                 }
[17:27:47.839]                 ...future.workdir <- getwd()
[17:27:47.839]             }
[17:27:47.839]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:47.839]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:47.839]         }
[17:27:47.839]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:47.839]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:47.839]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:47.839]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:47.839]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:47.839]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:47.839]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:47.839]             base::names(...future.oldOptions))
[17:27:47.839]     }
[17:27:47.839]     if (FALSE) {
[17:27:47.839]     }
[17:27:47.839]     else {
[17:27:47.839]         if (TRUE) {
[17:27:47.839]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:47.839]                 open = "w")
[17:27:47.839]         }
[17:27:47.839]         else {
[17:27:47.839]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:47.839]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:47.839]         }
[17:27:47.839]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:47.839]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:47.839]             base::sink(type = "output", split = FALSE)
[17:27:47.839]             base::close(...future.stdout)
[17:27:47.839]         }, add = TRUE)
[17:27:47.839]     }
[17:27:47.839]     ...future.frame <- base::sys.nframe()
[17:27:47.839]     ...future.conditions <- base::list()
[17:27:47.839]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:47.839]     if (FALSE) {
[17:27:47.839]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:47.839]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:47.839]     }
[17:27:47.839]     ...future.result <- base::tryCatch({
[17:27:47.839]         base::withCallingHandlers({
[17:27:47.839]             ...future.value <- base::withVisible(base::local({
[17:27:47.839]                 lm(weight ~ group - 1)
[17:27:47.839]             }))
[17:27:47.839]             future::FutureResult(value = ...future.value$value, 
[17:27:47.839]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:47.839]                   ...future.rng), globalenv = if (FALSE) 
[17:27:47.839]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:47.839]                     ...future.globalenv.names))
[17:27:47.839]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:47.839]         }, condition = base::local({
[17:27:47.839]             c <- base::c
[17:27:47.839]             inherits <- base::inherits
[17:27:47.839]             invokeRestart <- base::invokeRestart
[17:27:47.839]             length <- base::length
[17:27:47.839]             list <- base::list
[17:27:47.839]             seq.int <- base::seq.int
[17:27:47.839]             signalCondition <- base::signalCondition
[17:27:47.839]             sys.calls <- base::sys.calls
[17:27:47.839]             `[[` <- base::`[[`
[17:27:47.839]             `+` <- base::`+`
[17:27:47.839]             `<<-` <- base::`<<-`
[17:27:47.839]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:47.839]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:47.839]                   3L)]
[17:27:47.839]             }
[17:27:47.839]             function(cond) {
[17:27:47.839]                 is_error <- inherits(cond, "error")
[17:27:47.839]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:47.839]                   NULL)
[17:27:47.839]                 if (is_error) {
[17:27:47.839]                   sessionInformation <- function() {
[17:27:47.839]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:47.839]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:47.839]                       search = base::search(), system = base::Sys.info())
[17:27:47.839]                   }
[17:27:47.839]                   ...future.conditions[[length(...future.conditions) + 
[17:27:47.839]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:47.839]                     cond$call), session = sessionInformation(), 
[17:27:47.839]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:47.839]                   signalCondition(cond)
[17:27:47.839]                 }
[17:27:47.839]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:47.839]                 "immediateCondition"))) {
[17:27:47.839]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:47.839]                   ...future.conditions[[length(...future.conditions) + 
[17:27:47.839]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:47.839]                   if (TRUE && !signal) {
[17:27:47.839]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:47.839]                     {
[17:27:47.839]                       inherits <- base::inherits
[17:27:47.839]                       invokeRestart <- base::invokeRestart
[17:27:47.839]                       is.null <- base::is.null
[17:27:47.839]                       muffled <- FALSE
[17:27:47.839]                       if (inherits(cond, "message")) {
[17:27:47.839]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:47.839]                         if (muffled) 
[17:27:47.839]                           invokeRestart("muffleMessage")
[17:27:47.839]                       }
[17:27:47.839]                       else if (inherits(cond, "warning")) {
[17:27:47.839]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:47.839]                         if (muffled) 
[17:27:47.839]                           invokeRestart("muffleWarning")
[17:27:47.839]                       }
[17:27:47.839]                       else if (inherits(cond, "condition")) {
[17:27:47.839]                         if (!is.null(pattern)) {
[17:27:47.839]                           computeRestarts <- base::computeRestarts
[17:27:47.839]                           grepl <- base::grepl
[17:27:47.839]                           restarts <- computeRestarts(cond)
[17:27:47.839]                           for (restart in restarts) {
[17:27:47.839]                             name <- restart$name
[17:27:47.839]                             if (is.null(name)) 
[17:27:47.839]                               next
[17:27:47.839]                             if (!grepl(pattern, name)) 
[17:27:47.839]                               next
[17:27:47.839]                             invokeRestart(restart)
[17:27:47.839]                             muffled <- TRUE
[17:27:47.839]                             break
[17:27:47.839]                           }
[17:27:47.839]                         }
[17:27:47.839]                       }
[17:27:47.839]                       invisible(muffled)
[17:27:47.839]                     }
[17:27:47.839]                     muffleCondition(cond, pattern = "^muffle")
[17:27:47.839]                   }
[17:27:47.839]                 }
[17:27:47.839]                 else {
[17:27:47.839]                   if (TRUE) {
[17:27:47.839]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:47.839]                     {
[17:27:47.839]                       inherits <- base::inherits
[17:27:47.839]                       invokeRestart <- base::invokeRestart
[17:27:47.839]                       is.null <- base::is.null
[17:27:47.839]                       muffled <- FALSE
[17:27:47.839]                       if (inherits(cond, "message")) {
[17:27:47.839]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:47.839]                         if (muffled) 
[17:27:47.839]                           invokeRestart("muffleMessage")
[17:27:47.839]                       }
[17:27:47.839]                       else if (inherits(cond, "warning")) {
[17:27:47.839]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:47.839]                         if (muffled) 
[17:27:47.839]                           invokeRestart("muffleWarning")
[17:27:47.839]                       }
[17:27:47.839]                       else if (inherits(cond, "condition")) {
[17:27:47.839]                         if (!is.null(pattern)) {
[17:27:47.839]                           computeRestarts <- base::computeRestarts
[17:27:47.839]                           grepl <- base::grepl
[17:27:47.839]                           restarts <- computeRestarts(cond)
[17:27:47.839]                           for (restart in restarts) {
[17:27:47.839]                             name <- restart$name
[17:27:47.839]                             if (is.null(name)) 
[17:27:47.839]                               next
[17:27:47.839]                             if (!grepl(pattern, name)) 
[17:27:47.839]                               next
[17:27:47.839]                             invokeRestart(restart)
[17:27:47.839]                             muffled <- TRUE
[17:27:47.839]                             break
[17:27:47.839]                           }
[17:27:47.839]                         }
[17:27:47.839]                       }
[17:27:47.839]                       invisible(muffled)
[17:27:47.839]                     }
[17:27:47.839]                     muffleCondition(cond, pattern = "^muffle")
[17:27:47.839]                   }
[17:27:47.839]                 }
[17:27:47.839]             }
[17:27:47.839]         }))
[17:27:47.839]     }, error = function(ex) {
[17:27:47.839]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:47.839]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:47.839]                 ...future.rng), started = ...future.startTime, 
[17:27:47.839]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:47.839]             version = "1.8"), class = "FutureResult")
[17:27:47.839]     }, finally = {
[17:27:47.839]         if (!identical(...future.workdir, getwd())) 
[17:27:47.839]             setwd(...future.workdir)
[17:27:47.839]         {
[17:27:47.839]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:47.839]                 ...future.oldOptions$nwarnings <- NULL
[17:27:47.839]             }
[17:27:47.839]             base::options(...future.oldOptions)
[17:27:47.839]             if (.Platform$OS.type == "windows") {
[17:27:47.839]                 old_names <- names(...future.oldEnvVars)
[17:27:47.839]                 envs <- base::Sys.getenv()
[17:27:47.839]                 names <- names(envs)
[17:27:47.839]                 common <- intersect(names, old_names)
[17:27:47.839]                 added <- setdiff(names, old_names)
[17:27:47.839]                 removed <- setdiff(old_names, names)
[17:27:47.839]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:47.839]                   envs[common]]
[17:27:47.839]                 NAMES <- toupper(changed)
[17:27:47.839]                 args <- list()
[17:27:47.839]                 for (kk in seq_along(NAMES)) {
[17:27:47.839]                   name <- changed[[kk]]
[17:27:47.839]                   NAME <- NAMES[[kk]]
[17:27:47.839]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.839]                     next
[17:27:47.839]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:47.839]                 }
[17:27:47.839]                 NAMES <- toupper(added)
[17:27:47.839]                 for (kk in seq_along(NAMES)) {
[17:27:47.839]                   name <- added[[kk]]
[17:27:47.839]                   NAME <- NAMES[[kk]]
[17:27:47.839]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.839]                     next
[17:27:47.839]                   args[[name]] <- ""
[17:27:47.839]                 }
[17:27:47.839]                 NAMES <- toupper(removed)
[17:27:47.839]                 for (kk in seq_along(NAMES)) {
[17:27:47.839]                   name <- removed[[kk]]
[17:27:47.839]                   NAME <- NAMES[[kk]]
[17:27:47.839]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.839]                     next
[17:27:47.839]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:47.839]                 }
[17:27:47.839]                 if (length(args) > 0) 
[17:27:47.839]                   base::do.call(base::Sys.setenv, args = args)
[17:27:47.839]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:47.839]             }
[17:27:47.839]             else {
[17:27:47.839]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:47.839]             }
[17:27:47.839]             {
[17:27:47.839]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:47.839]                   0L) {
[17:27:47.839]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:47.839]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:47.839]                   base::options(opts)
[17:27:47.839]                 }
[17:27:47.839]                 {
[17:27:47.839]                   {
[17:27:47.839]                     NULL
[17:27:47.839]                     RNGkind("Mersenne-Twister")
[17:27:47.839]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:47.839]                       inherits = FALSE)
[17:27:47.839]                   }
[17:27:47.839]                   options(future.plan = NULL)
[17:27:47.839]                   if (is.na(NA_character_)) 
[17:27:47.839]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:47.839]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:47.839]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:47.839]                     .init = FALSE)
[17:27:47.839]                 }
[17:27:47.839]             }
[17:27:47.839]         }
[17:27:47.839]     })
[17:27:47.839]     if (TRUE) {
[17:27:47.839]         base::sink(type = "output", split = FALSE)
[17:27:47.839]         if (TRUE) {
[17:27:47.839]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:47.839]         }
[17:27:47.839]         else {
[17:27:47.839]             ...future.result["stdout"] <- base::list(NULL)
[17:27:47.839]         }
[17:27:47.839]         base::close(...future.stdout)
[17:27:47.839]         ...future.stdout <- NULL
[17:27:47.839]     }
[17:27:47.839]     ...future.result$conditions <- ...future.conditions
[17:27:47.839]     ...future.result$finished <- base::Sys.time()
[17:27:47.839]     ...future.result
[17:27:47.839] }
[17:27:47.843] assign_globals() ...
[17:27:47.844] List of 2
[17:27:47.844]  $ weight: num [1:20] 4.17 5.58 5.18 6.11 4.5 4.61 5.17 4.53 5.33 5.14 ...
[17:27:47.844]  $ group : Factor w/ 2 levels "Ctl","Trt": 1 1 1 1 1 1 1 1 1 1 ...
[17:27:47.844]  - attr(*, "where")=List of 2
[17:27:47.844]   ..$ weight:<environment: R_EmptyEnv> 
[17:27:47.844]   ..$ group :<environment: R_EmptyEnv> 
[17:27:47.844]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:47.844]  - attr(*, "resolved")= logi FALSE
[17:27:47.844]  - attr(*, "total_size")= int 401
[17:27:47.844]  - attr(*, "already-done")= logi TRUE
[17:27:47.850] - copied 'weight' to environment
[17:27:47.850] - copied 'group' to environment
[17:27:47.851] assign_globals() ... done
[17:27:47.851] plan(): Setting new future strategy stack:
[17:27:47.852] List of future strategies:
[17:27:47.852] 1. sequential:
[17:27:47.852]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.852]    - tweaked: FALSE
[17:27:47.852]    - call: NULL
[17:27:47.852] plan(): nbrOfWorkers() = 1
[17:27:47.855] plan(): Setting new future strategy stack:
[17:27:47.855] List of future strategies:
[17:27:47.855] 1. sequential:
[17:27:47.855]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.855]    - tweaked: FALSE
[17:27:47.855]    - call: plan(strategy)
[17:27:47.856] plan(): nbrOfWorkers() = 1
[17:27:47.856] SequentialFuture started (and completed)
[17:27:47.856] - Launch lazy future ... done
[17:27:47.857] run() for 'SequentialFuture' ... done

Call:
lm(formula = weight ~ group - 1)

Coefficients:
groupCtl  groupTrt  
   5.032     4.661  

[17:27:47.859] getGlobalsAndPackages() ...
[17:27:47.860] Searching for globals...
[17:27:47.862] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
[17:27:47.862] Searching for globals ... DONE
[17:27:47.862] Resolving globals: FALSE
[17:27:47.863] The total size of the 2 globals is 401 bytes (401 bytes)
[17:27:47.864] The total size of the 2 globals exported for future expression ('{; lm(weight ~ group - 1); }') is 401 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'group' (210 bytes of class 'numeric') and 'weight' (191 bytes of class 'numeric')
[17:27:47.864] - globals: [2] 'weight', 'group'
[17:27:47.864] - packages: [1] 'stats'
[17:27:47.864] getGlobalsAndPackages() ... DONE
[17:27:47.865] run() for 'Future' ...
[17:27:47.865] - state: 'created'
[17:27:47.865] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:47.866] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:47.866] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:47.866]   - Field: 'label'
[17:27:47.866]   - Field: 'local'
[17:27:47.867]   - Field: 'owner'
[17:27:47.867]   - Field: 'envir'
[17:27:47.867]   - Field: 'packages'
[17:27:47.867]   - Field: 'gc'
[17:27:47.867]   - Field: 'conditions'
[17:27:47.868]   - Field: 'expr'
[17:27:47.868]   - Field: 'uuid'
[17:27:47.868]   - Field: 'seed'
[17:27:47.868]   - Field: 'version'
[17:27:47.868]   - Field: 'result'
[17:27:47.869]   - Field: 'asynchronous'
[17:27:47.869]   - Field: 'calls'
[17:27:47.869]   - Field: 'globals'
[17:27:47.869]   - Field: 'stdout'
[17:27:47.869]   - Field: 'earlySignal'
[17:27:47.870]   - Field: 'lazy'
[17:27:47.870]   - Field: 'state'
[17:27:47.870] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:47.870] - Launch lazy future ...
[17:27:47.871] Packages needed by the future expression (n = 1): 'stats'
[17:27:47.871] Packages needed by future strategies (n = 0): <none>
[17:27:47.872] {
[17:27:47.872]     {
[17:27:47.872]         {
[17:27:47.872]             ...future.startTime <- base::Sys.time()
[17:27:47.872]             {
[17:27:47.872]                 {
[17:27:47.872]                   {
[17:27:47.872]                     {
[17:27:47.872]                       base::local({
[17:27:47.872]                         has_future <- base::requireNamespace("future", 
[17:27:47.872]                           quietly = TRUE)
[17:27:47.872]                         if (has_future) {
[17:27:47.872]                           ns <- base::getNamespace("future")
[17:27:47.872]                           version <- ns[[".package"]][["version"]]
[17:27:47.872]                           if (is.null(version)) 
[17:27:47.872]                             version <- utils::packageVersion("future")
[17:27:47.872]                         }
[17:27:47.872]                         else {
[17:27:47.872]                           version <- NULL
[17:27:47.872]                         }
[17:27:47.872]                         if (!has_future || version < "1.8.0") {
[17:27:47.872]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:47.872]                             "", base::R.version$version.string), 
[17:27:47.872]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:47.872]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:47.872]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:47.872]                               "release", "version")], collapse = " "), 
[17:27:47.872]                             hostname = base::Sys.info()[["nodename"]])
[17:27:47.872]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:47.872]                             info)
[17:27:47.872]                           info <- base::paste(info, collapse = "; ")
[17:27:47.872]                           if (!has_future) {
[17:27:47.872]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:47.872]                               info)
[17:27:47.872]                           }
[17:27:47.872]                           else {
[17:27:47.872]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:47.872]                               info, version)
[17:27:47.872]                           }
[17:27:47.872]                           base::stop(msg)
[17:27:47.872]                         }
[17:27:47.872]                       })
[17:27:47.872]                     }
[17:27:47.872]                     base::local({
[17:27:47.872]                       for (pkg in "stats") {
[17:27:47.872]                         base::loadNamespace(pkg)
[17:27:47.872]                         base::library(pkg, character.only = TRUE)
[17:27:47.872]                       }
[17:27:47.872]                     })
[17:27:47.872]                   }
[17:27:47.872]                   ...future.strategy.old <- future::plan("list")
[17:27:47.872]                   options(future.plan = NULL)
[17:27:47.872]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:47.872]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:47.872]                 }
[17:27:47.872]                 ...future.workdir <- getwd()
[17:27:47.872]             }
[17:27:47.872]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:47.872]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:47.872]         }
[17:27:47.872]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:47.872]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:47.872]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:47.872]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:47.872]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:47.872]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:47.872]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:47.872]             base::names(...future.oldOptions))
[17:27:47.872]     }
[17:27:47.872]     if (FALSE) {
[17:27:47.872]     }
[17:27:47.872]     else {
[17:27:47.872]         if (TRUE) {
[17:27:47.872]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:47.872]                 open = "w")
[17:27:47.872]         }
[17:27:47.872]         else {
[17:27:47.872]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:47.872]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:47.872]         }
[17:27:47.872]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:47.872]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:47.872]             base::sink(type = "output", split = FALSE)
[17:27:47.872]             base::close(...future.stdout)
[17:27:47.872]         }, add = TRUE)
[17:27:47.872]     }
[17:27:47.872]     ...future.frame <- base::sys.nframe()
[17:27:47.872]     ...future.conditions <- base::list()
[17:27:47.872]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:47.872]     if (FALSE) {
[17:27:47.872]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:47.872]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:47.872]     }
[17:27:47.872]     ...future.result <- base::tryCatch({
[17:27:47.872]         base::withCallingHandlers({
[17:27:47.872]             ...future.value <- base::withVisible(base::local({
[17:27:47.872]                 lm(weight ~ group - 1)
[17:27:47.872]             }))
[17:27:47.872]             future::FutureResult(value = ...future.value$value, 
[17:27:47.872]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:47.872]                   ...future.rng), globalenv = if (FALSE) 
[17:27:47.872]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:47.872]                     ...future.globalenv.names))
[17:27:47.872]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:47.872]         }, condition = base::local({
[17:27:47.872]             c <- base::c
[17:27:47.872]             inherits <- base::inherits
[17:27:47.872]             invokeRestart <- base::invokeRestart
[17:27:47.872]             length <- base::length
[17:27:47.872]             list <- base::list
[17:27:47.872]             seq.int <- base::seq.int
[17:27:47.872]             signalCondition <- base::signalCondition
[17:27:47.872]             sys.calls <- base::sys.calls
[17:27:47.872]             `[[` <- base::`[[`
[17:27:47.872]             `+` <- base::`+`
[17:27:47.872]             `<<-` <- base::`<<-`
[17:27:47.872]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:47.872]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:47.872]                   3L)]
[17:27:47.872]             }
[17:27:47.872]             function(cond) {
[17:27:47.872]                 is_error <- inherits(cond, "error")
[17:27:47.872]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:47.872]                   NULL)
[17:27:47.872]                 if (is_error) {
[17:27:47.872]                   sessionInformation <- function() {
[17:27:47.872]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:47.872]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:47.872]                       search = base::search(), system = base::Sys.info())
[17:27:47.872]                   }
[17:27:47.872]                   ...future.conditions[[length(...future.conditions) + 
[17:27:47.872]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:47.872]                     cond$call), session = sessionInformation(), 
[17:27:47.872]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:47.872]                   signalCondition(cond)
[17:27:47.872]                 }
[17:27:47.872]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:47.872]                 "immediateCondition"))) {
[17:27:47.872]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:47.872]                   ...future.conditions[[length(...future.conditions) + 
[17:27:47.872]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:47.872]                   if (TRUE && !signal) {
[17:27:47.872]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:47.872]                     {
[17:27:47.872]                       inherits <- base::inherits
[17:27:47.872]                       invokeRestart <- base::invokeRestart
[17:27:47.872]                       is.null <- base::is.null
[17:27:47.872]                       muffled <- FALSE
[17:27:47.872]                       if (inherits(cond, "message")) {
[17:27:47.872]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:47.872]                         if (muffled) 
[17:27:47.872]                           invokeRestart("muffleMessage")
[17:27:47.872]                       }
[17:27:47.872]                       else if (inherits(cond, "warning")) {
[17:27:47.872]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:47.872]                         if (muffled) 
[17:27:47.872]                           invokeRestart("muffleWarning")
[17:27:47.872]                       }
[17:27:47.872]                       else if (inherits(cond, "condition")) {
[17:27:47.872]                         if (!is.null(pattern)) {
[17:27:47.872]                           computeRestarts <- base::computeRestarts
[17:27:47.872]                           grepl <- base::grepl
[17:27:47.872]                           restarts <- computeRestarts(cond)
[17:27:47.872]                           for (restart in restarts) {
[17:27:47.872]                             name <- restart$name
[17:27:47.872]                             if (is.null(name)) 
[17:27:47.872]                               next
[17:27:47.872]                             if (!grepl(pattern, name)) 
[17:27:47.872]                               next
[17:27:47.872]                             invokeRestart(restart)
[17:27:47.872]                             muffled <- TRUE
[17:27:47.872]                             break
[17:27:47.872]                           }
[17:27:47.872]                         }
[17:27:47.872]                       }
[17:27:47.872]                       invisible(muffled)
[17:27:47.872]                     }
[17:27:47.872]                     muffleCondition(cond, pattern = "^muffle")
[17:27:47.872]                   }
[17:27:47.872]                 }
[17:27:47.872]                 else {
[17:27:47.872]                   if (TRUE) {
[17:27:47.872]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:47.872]                     {
[17:27:47.872]                       inherits <- base::inherits
[17:27:47.872]                       invokeRestart <- base::invokeRestart
[17:27:47.872]                       is.null <- base::is.null
[17:27:47.872]                       muffled <- FALSE
[17:27:47.872]                       if (inherits(cond, "message")) {
[17:27:47.872]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:47.872]                         if (muffled) 
[17:27:47.872]                           invokeRestart("muffleMessage")
[17:27:47.872]                       }
[17:27:47.872]                       else if (inherits(cond, "warning")) {
[17:27:47.872]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:47.872]                         if (muffled) 
[17:27:47.872]                           invokeRestart("muffleWarning")
[17:27:47.872]                       }
[17:27:47.872]                       else if (inherits(cond, "condition")) {
[17:27:47.872]                         if (!is.null(pattern)) {
[17:27:47.872]                           computeRestarts <- base::computeRestarts
[17:27:47.872]                           grepl <- base::grepl
[17:27:47.872]                           restarts <- computeRestarts(cond)
[17:27:47.872]                           for (restart in restarts) {
[17:27:47.872]                             name <- restart$name
[17:27:47.872]                             if (is.null(name)) 
[17:27:47.872]                               next
[17:27:47.872]                             if (!grepl(pattern, name)) 
[17:27:47.872]                               next
[17:27:47.872]                             invokeRestart(restart)
[17:27:47.872]                             muffled <- TRUE
[17:27:47.872]                             break
[17:27:47.872]                           }
[17:27:47.872]                         }
[17:27:47.872]                       }
[17:27:47.872]                       invisible(muffled)
[17:27:47.872]                     }
[17:27:47.872]                     muffleCondition(cond, pattern = "^muffle")
[17:27:47.872]                   }
[17:27:47.872]                 }
[17:27:47.872]             }
[17:27:47.872]         }))
[17:27:47.872]     }, error = function(ex) {
[17:27:47.872]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:47.872]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:47.872]                 ...future.rng), started = ...future.startTime, 
[17:27:47.872]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:47.872]             version = "1.8"), class = "FutureResult")
[17:27:47.872]     }, finally = {
[17:27:47.872]         if (!identical(...future.workdir, getwd())) 
[17:27:47.872]             setwd(...future.workdir)
[17:27:47.872]         {
[17:27:47.872]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:47.872]                 ...future.oldOptions$nwarnings <- NULL
[17:27:47.872]             }
[17:27:47.872]             base::options(...future.oldOptions)
[17:27:47.872]             if (.Platform$OS.type == "windows") {
[17:27:47.872]                 old_names <- names(...future.oldEnvVars)
[17:27:47.872]                 envs <- base::Sys.getenv()
[17:27:47.872]                 names <- names(envs)
[17:27:47.872]                 common <- intersect(names, old_names)
[17:27:47.872]                 added <- setdiff(names, old_names)
[17:27:47.872]                 removed <- setdiff(old_names, names)
[17:27:47.872]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:47.872]                   envs[common]]
[17:27:47.872]                 NAMES <- toupper(changed)
[17:27:47.872]                 args <- list()
[17:27:47.872]                 for (kk in seq_along(NAMES)) {
[17:27:47.872]                   name <- changed[[kk]]
[17:27:47.872]                   NAME <- NAMES[[kk]]
[17:27:47.872]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.872]                     next
[17:27:47.872]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:47.872]                 }
[17:27:47.872]                 NAMES <- toupper(added)
[17:27:47.872]                 for (kk in seq_along(NAMES)) {
[17:27:47.872]                   name <- added[[kk]]
[17:27:47.872]                   NAME <- NAMES[[kk]]
[17:27:47.872]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.872]                     next
[17:27:47.872]                   args[[name]] <- ""
[17:27:47.872]                 }
[17:27:47.872]                 NAMES <- toupper(removed)
[17:27:47.872]                 for (kk in seq_along(NAMES)) {
[17:27:47.872]                   name <- removed[[kk]]
[17:27:47.872]                   NAME <- NAMES[[kk]]
[17:27:47.872]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.872]                     next
[17:27:47.872]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:47.872]                 }
[17:27:47.872]                 if (length(args) > 0) 
[17:27:47.872]                   base::do.call(base::Sys.setenv, args = args)
[17:27:47.872]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:47.872]             }
[17:27:47.872]             else {
[17:27:47.872]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:47.872]             }
[17:27:47.872]             {
[17:27:47.872]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:47.872]                   0L) {
[17:27:47.872]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:47.872]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:47.872]                   base::options(opts)
[17:27:47.872]                 }
[17:27:47.872]                 {
[17:27:47.872]                   {
[17:27:47.872]                     NULL
[17:27:47.872]                     RNGkind("Mersenne-Twister")
[17:27:47.872]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:47.872]                       inherits = FALSE)
[17:27:47.872]                   }
[17:27:47.872]                   options(future.plan = NULL)
[17:27:47.872]                   if (is.na(NA_character_)) 
[17:27:47.872]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:47.872]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:47.872]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:47.872]                     .init = FALSE)
[17:27:47.872]                 }
[17:27:47.872]             }
[17:27:47.872]         }
[17:27:47.872]     })
[17:27:47.872]     if (TRUE) {
[17:27:47.872]         base::sink(type = "output", split = FALSE)
[17:27:47.872]         if (TRUE) {
[17:27:47.872]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:47.872]         }
[17:27:47.872]         else {
[17:27:47.872]             ...future.result["stdout"] <- base::list(NULL)
[17:27:47.872]         }
[17:27:47.872]         base::close(...future.stdout)
[17:27:47.872]         ...future.stdout <- NULL
[17:27:47.872]     }
[17:27:47.872]     ...future.result$conditions <- ...future.conditions
[17:27:47.872]     ...future.result$finished <- base::Sys.time()
[17:27:47.872]     ...future.result
[17:27:47.872] }
[17:27:47.876] assign_globals() ...
[17:27:47.876] List of 2
[17:27:47.876]  $ weight: num [1:20] 4.17 5.58 5.18 6.11 4.5 4.61 5.17 4.53 5.33 5.14 ...
[17:27:47.876]  $ group : Factor w/ 2 levels "Ctl","Trt": 1 1 1 1 1 1 1 1 1 1 ...
[17:27:47.876]  - attr(*, "where")=List of 2
[17:27:47.876]   ..$ weight:<environment: R_EmptyEnv> 
[17:27:47.876]   ..$ group :<environment: R_EmptyEnv> 
[17:27:47.876]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:47.876]  - attr(*, "resolved")= logi FALSE
[17:27:47.876]  - attr(*, "total_size")= int 401
[17:27:47.876]  - attr(*, "already-done")= logi TRUE
[17:27:47.883] - copied 'weight' to environment
[17:27:47.883] - copied 'group' to environment
[17:27:47.883] assign_globals() ... done
[17:27:47.884] plan(): Setting new future strategy stack:
[17:27:47.884] List of future strategies:
[17:27:47.884] 1. sequential:
[17:27:47.884]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.884]    - tweaked: FALSE
[17:27:47.884]    - call: NULL
[17:27:47.885] plan(): nbrOfWorkers() = 1
[17:27:47.887] plan(): Setting new future strategy stack:
[17:27:47.887] List of future strategies:
[17:27:47.887] 1. sequential:
[17:27:47.887]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.887]    - tweaked: FALSE
[17:27:47.887]    - call: plan(strategy)
[17:27:47.888] plan(): nbrOfWorkers() = 1
[17:27:47.888] SequentialFuture started (and completed)
[17:27:47.889] - Launch lazy future ... done
[17:27:47.889] run() for 'SequentialFuture' ... done

Call:
lm(formula = weight ~ group - 1)

Coefficients:
groupCtl  groupTrt  
   5.032     4.661  

[17:27:47.892] getGlobalsAndPackages() ...
[17:27:47.892] Searching for globals...
[17:27:47.894] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
[17:27:47.894] Searching for globals ... DONE
[17:27:47.895] Resolving globals: FALSE
[17:27:47.895] The total size of the 2 globals is 401 bytes (401 bytes)
[17:27:47.896] The total size of the 2 globals exported for future expression ('{; lm(weight ~ group - 1); }') is 401 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'group' (210 bytes of class 'numeric') and 'weight' (191 bytes of class 'numeric')
[17:27:47.896] - globals: [2] 'weight', 'group'
[17:27:47.896] - packages: [1] 'stats'
[17:27:47.897] getGlobalsAndPackages() ... DONE
[17:27:47.897] run() for 'Future' ...
[17:27:47.897] - state: 'created'
[17:27:47.898] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:47.898] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:47.898] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:47.899]   - Field: 'label'
[17:27:47.899]   - Field: 'local'
[17:27:47.899]   - Field: 'owner'
[17:27:47.899]   - Field: 'envir'
[17:27:47.899]   - Field: 'packages'
[17:27:47.900]   - Field: 'gc'
[17:27:47.900]   - Field: 'conditions'
[17:27:47.900]   - Field: 'expr'
[17:27:47.900]   - Field: 'uuid'
[17:27:47.900]   - Field: 'seed'
[17:27:47.901]   - Field: 'version'
[17:27:47.901]   - Field: 'result'
[17:27:47.901]   - Field: 'asynchronous'
[17:27:47.901]   - Field: 'calls'
[17:27:47.901]   - Field: 'globals'
[17:27:47.902]   - Field: 'stdout'
[17:27:47.902]   - Field: 'earlySignal'
[17:27:47.902]   - Field: 'lazy'
[17:27:47.902]   - Field: 'state'
[17:27:47.903] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:47.903] - Launch lazy future ...
[17:27:47.903] Packages needed by the future expression (n = 1): 'stats'
[17:27:47.903] Packages needed by future strategies (n = 0): <none>
[17:27:47.904] {
[17:27:47.904]     {
[17:27:47.904]         {
[17:27:47.904]             ...future.startTime <- base::Sys.time()
[17:27:47.904]             {
[17:27:47.904]                 {
[17:27:47.904]                   {
[17:27:47.904]                     {
[17:27:47.904]                       base::local({
[17:27:47.904]                         has_future <- base::requireNamespace("future", 
[17:27:47.904]                           quietly = TRUE)
[17:27:47.904]                         if (has_future) {
[17:27:47.904]                           ns <- base::getNamespace("future")
[17:27:47.904]                           version <- ns[[".package"]][["version"]]
[17:27:47.904]                           if (is.null(version)) 
[17:27:47.904]                             version <- utils::packageVersion("future")
[17:27:47.904]                         }
[17:27:47.904]                         else {
[17:27:47.904]                           version <- NULL
[17:27:47.904]                         }
[17:27:47.904]                         if (!has_future || version < "1.8.0") {
[17:27:47.904]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:47.904]                             "", base::R.version$version.string), 
[17:27:47.904]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:47.904]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:47.904]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:47.904]                               "release", "version")], collapse = " "), 
[17:27:47.904]                             hostname = base::Sys.info()[["nodename"]])
[17:27:47.904]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:47.904]                             info)
[17:27:47.904]                           info <- base::paste(info, collapse = "; ")
[17:27:47.904]                           if (!has_future) {
[17:27:47.904]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:47.904]                               info)
[17:27:47.904]                           }
[17:27:47.904]                           else {
[17:27:47.904]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:47.904]                               info, version)
[17:27:47.904]                           }
[17:27:47.904]                           base::stop(msg)
[17:27:47.904]                         }
[17:27:47.904]                       })
[17:27:47.904]                     }
[17:27:47.904]                     base::local({
[17:27:47.904]                       for (pkg in "stats") {
[17:27:47.904]                         base::loadNamespace(pkg)
[17:27:47.904]                         base::library(pkg, character.only = TRUE)
[17:27:47.904]                       }
[17:27:47.904]                     })
[17:27:47.904]                   }
[17:27:47.904]                   ...future.strategy.old <- future::plan("list")
[17:27:47.904]                   options(future.plan = NULL)
[17:27:47.904]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:47.904]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:47.904]                 }
[17:27:47.904]                 ...future.workdir <- getwd()
[17:27:47.904]             }
[17:27:47.904]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:47.904]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:47.904]         }
[17:27:47.904]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:47.904]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:47.904]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:47.904]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:47.904]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:47.904]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:47.904]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:47.904]             base::names(...future.oldOptions))
[17:27:47.904]     }
[17:27:47.904]     if (FALSE) {
[17:27:47.904]     }
[17:27:47.904]     else {
[17:27:47.904]         if (TRUE) {
[17:27:47.904]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:47.904]                 open = "w")
[17:27:47.904]         }
[17:27:47.904]         else {
[17:27:47.904]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:47.904]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:47.904]         }
[17:27:47.904]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:47.904]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:47.904]             base::sink(type = "output", split = FALSE)
[17:27:47.904]             base::close(...future.stdout)
[17:27:47.904]         }, add = TRUE)
[17:27:47.904]     }
[17:27:47.904]     ...future.frame <- base::sys.nframe()
[17:27:47.904]     ...future.conditions <- base::list()
[17:27:47.904]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:47.904]     if (FALSE) {
[17:27:47.904]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:47.904]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:47.904]     }
[17:27:47.904]     ...future.result <- base::tryCatch({
[17:27:47.904]         base::withCallingHandlers({
[17:27:47.904]             ...future.value <- base::withVisible(base::local({
[17:27:47.904]                 lm(weight ~ group - 1)
[17:27:47.904]             }))
[17:27:47.904]             future::FutureResult(value = ...future.value$value, 
[17:27:47.904]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:47.904]                   ...future.rng), globalenv = if (FALSE) 
[17:27:47.904]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:47.904]                     ...future.globalenv.names))
[17:27:47.904]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:47.904]         }, condition = base::local({
[17:27:47.904]             c <- base::c
[17:27:47.904]             inherits <- base::inherits
[17:27:47.904]             invokeRestart <- base::invokeRestart
[17:27:47.904]             length <- base::length
[17:27:47.904]             list <- base::list
[17:27:47.904]             seq.int <- base::seq.int
[17:27:47.904]             signalCondition <- base::signalCondition
[17:27:47.904]             sys.calls <- base::sys.calls
[17:27:47.904]             `[[` <- base::`[[`
[17:27:47.904]             `+` <- base::`+`
[17:27:47.904]             `<<-` <- base::`<<-`
[17:27:47.904]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:47.904]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:47.904]                   3L)]
[17:27:47.904]             }
[17:27:47.904]             function(cond) {
[17:27:47.904]                 is_error <- inherits(cond, "error")
[17:27:47.904]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:47.904]                   NULL)
[17:27:47.904]                 if (is_error) {
[17:27:47.904]                   sessionInformation <- function() {
[17:27:47.904]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:47.904]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:47.904]                       search = base::search(), system = base::Sys.info())
[17:27:47.904]                   }
[17:27:47.904]                   ...future.conditions[[length(...future.conditions) + 
[17:27:47.904]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:47.904]                     cond$call), session = sessionInformation(), 
[17:27:47.904]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:47.904]                   signalCondition(cond)
[17:27:47.904]                 }
[17:27:47.904]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:47.904]                 "immediateCondition"))) {
[17:27:47.904]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:47.904]                   ...future.conditions[[length(...future.conditions) + 
[17:27:47.904]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:47.904]                   if (TRUE && !signal) {
[17:27:47.904]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:47.904]                     {
[17:27:47.904]                       inherits <- base::inherits
[17:27:47.904]                       invokeRestart <- base::invokeRestart
[17:27:47.904]                       is.null <- base::is.null
[17:27:47.904]                       muffled <- FALSE
[17:27:47.904]                       if (inherits(cond, "message")) {
[17:27:47.904]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:47.904]                         if (muffled) 
[17:27:47.904]                           invokeRestart("muffleMessage")
[17:27:47.904]                       }
[17:27:47.904]                       else if (inherits(cond, "warning")) {
[17:27:47.904]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:47.904]                         if (muffled) 
[17:27:47.904]                           invokeRestart("muffleWarning")
[17:27:47.904]                       }
[17:27:47.904]                       else if (inherits(cond, "condition")) {
[17:27:47.904]                         if (!is.null(pattern)) {
[17:27:47.904]                           computeRestarts <- base::computeRestarts
[17:27:47.904]                           grepl <- base::grepl
[17:27:47.904]                           restarts <- computeRestarts(cond)
[17:27:47.904]                           for (restart in restarts) {
[17:27:47.904]                             name <- restart$name
[17:27:47.904]                             if (is.null(name)) 
[17:27:47.904]                               next
[17:27:47.904]                             if (!grepl(pattern, name)) 
[17:27:47.904]                               next
[17:27:47.904]                             invokeRestart(restart)
[17:27:47.904]                             muffled <- TRUE
[17:27:47.904]                             break
[17:27:47.904]                           }
[17:27:47.904]                         }
[17:27:47.904]                       }
[17:27:47.904]                       invisible(muffled)
[17:27:47.904]                     }
[17:27:47.904]                     muffleCondition(cond, pattern = "^muffle")
[17:27:47.904]                   }
[17:27:47.904]                 }
[17:27:47.904]                 else {
[17:27:47.904]                   if (TRUE) {
[17:27:47.904]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:47.904]                     {
[17:27:47.904]                       inherits <- base::inherits
[17:27:47.904]                       invokeRestart <- base::invokeRestart
[17:27:47.904]                       is.null <- base::is.null
[17:27:47.904]                       muffled <- FALSE
[17:27:47.904]                       if (inherits(cond, "message")) {
[17:27:47.904]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:47.904]                         if (muffled) 
[17:27:47.904]                           invokeRestart("muffleMessage")
[17:27:47.904]                       }
[17:27:47.904]                       else if (inherits(cond, "warning")) {
[17:27:47.904]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:47.904]                         if (muffled) 
[17:27:47.904]                           invokeRestart("muffleWarning")
[17:27:47.904]                       }
[17:27:47.904]                       else if (inherits(cond, "condition")) {
[17:27:47.904]                         if (!is.null(pattern)) {
[17:27:47.904]                           computeRestarts <- base::computeRestarts
[17:27:47.904]                           grepl <- base::grepl
[17:27:47.904]                           restarts <- computeRestarts(cond)
[17:27:47.904]                           for (restart in restarts) {
[17:27:47.904]                             name <- restart$name
[17:27:47.904]                             if (is.null(name)) 
[17:27:47.904]                               next
[17:27:47.904]                             if (!grepl(pattern, name)) 
[17:27:47.904]                               next
[17:27:47.904]                             invokeRestart(restart)
[17:27:47.904]                             muffled <- TRUE
[17:27:47.904]                             break
[17:27:47.904]                           }
[17:27:47.904]                         }
[17:27:47.904]                       }
[17:27:47.904]                       invisible(muffled)
[17:27:47.904]                     }
[17:27:47.904]                     muffleCondition(cond, pattern = "^muffle")
[17:27:47.904]                   }
[17:27:47.904]                 }
[17:27:47.904]             }
[17:27:47.904]         }))
[17:27:47.904]     }, error = function(ex) {
[17:27:47.904]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:47.904]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:47.904]                 ...future.rng), started = ...future.startTime, 
[17:27:47.904]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:47.904]             version = "1.8"), class = "FutureResult")
[17:27:47.904]     }, finally = {
[17:27:47.904]         if (!identical(...future.workdir, getwd())) 
[17:27:47.904]             setwd(...future.workdir)
[17:27:47.904]         {
[17:27:47.904]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:47.904]                 ...future.oldOptions$nwarnings <- NULL
[17:27:47.904]             }
[17:27:47.904]             base::options(...future.oldOptions)
[17:27:47.904]             if (.Platform$OS.type == "windows") {
[17:27:47.904]                 old_names <- names(...future.oldEnvVars)
[17:27:47.904]                 envs <- base::Sys.getenv()
[17:27:47.904]                 names <- names(envs)
[17:27:47.904]                 common <- intersect(names, old_names)
[17:27:47.904]                 added <- setdiff(names, old_names)
[17:27:47.904]                 removed <- setdiff(old_names, names)
[17:27:47.904]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:47.904]                   envs[common]]
[17:27:47.904]                 NAMES <- toupper(changed)
[17:27:47.904]                 args <- list()
[17:27:47.904]                 for (kk in seq_along(NAMES)) {
[17:27:47.904]                   name <- changed[[kk]]
[17:27:47.904]                   NAME <- NAMES[[kk]]
[17:27:47.904]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.904]                     next
[17:27:47.904]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:47.904]                 }
[17:27:47.904]                 NAMES <- toupper(added)
[17:27:47.904]                 for (kk in seq_along(NAMES)) {
[17:27:47.904]                   name <- added[[kk]]
[17:27:47.904]                   NAME <- NAMES[[kk]]
[17:27:47.904]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.904]                     next
[17:27:47.904]                   args[[name]] <- ""
[17:27:47.904]                 }
[17:27:47.904]                 NAMES <- toupper(removed)
[17:27:47.904]                 for (kk in seq_along(NAMES)) {
[17:27:47.904]                   name <- removed[[kk]]
[17:27:47.904]                   NAME <- NAMES[[kk]]
[17:27:47.904]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.904]                     next
[17:27:47.904]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:47.904]                 }
[17:27:47.904]                 if (length(args) > 0) 
[17:27:47.904]                   base::do.call(base::Sys.setenv, args = args)
[17:27:47.904]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:47.904]             }
[17:27:47.904]             else {
[17:27:47.904]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:47.904]             }
[17:27:47.904]             {
[17:27:47.904]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:47.904]                   0L) {
[17:27:47.904]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:47.904]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:47.904]                   base::options(opts)
[17:27:47.904]                 }
[17:27:47.904]                 {
[17:27:47.904]                   {
[17:27:47.904]                     NULL
[17:27:47.904]                     RNGkind("Mersenne-Twister")
[17:27:47.904]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:47.904]                       inherits = FALSE)
[17:27:47.904]                   }
[17:27:47.904]                   options(future.plan = NULL)
[17:27:47.904]                   if (is.na(NA_character_)) 
[17:27:47.904]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:47.904]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:47.904]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:47.904]                     .init = FALSE)
[17:27:47.904]                 }
[17:27:47.904]             }
[17:27:47.904]         }
[17:27:47.904]     })
[17:27:47.904]     if (TRUE) {
[17:27:47.904]         base::sink(type = "output", split = FALSE)
[17:27:47.904]         if (TRUE) {
[17:27:47.904]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:47.904]         }
[17:27:47.904]         else {
[17:27:47.904]             ...future.result["stdout"] <- base::list(NULL)
[17:27:47.904]         }
[17:27:47.904]         base::close(...future.stdout)
[17:27:47.904]         ...future.stdout <- NULL
[17:27:47.904]     }
[17:27:47.904]     ...future.result$conditions <- ...future.conditions
[17:27:47.904]     ...future.result$finished <- base::Sys.time()
[17:27:47.904]     ...future.result
[17:27:47.904] }
[17:27:47.909] assign_globals() ...
[17:27:47.909] List of 2
[17:27:47.909]  $ weight: num [1:20] 4.17 5.58 5.18 6.11 4.5 4.61 5.17 4.53 5.33 5.14 ...
[17:27:47.909]  $ group : Factor w/ 2 levels "Ctl","Trt": 1 1 1 1 1 1 1 1 1 1 ...
[17:27:47.909]  - attr(*, "where")=List of 2
[17:27:47.909]   ..$ weight:<environment: R_EmptyEnv> 
[17:27:47.909]   ..$ group :<environment: R_EmptyEnv> 
[17:27:47.909]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:47.909]  - attr(*, "resolved")= logi FALSE
[17:27:47.909]  - attr(*, "total_size")= int 401
[17:27:47.909]  - attr(*, "already-done")= logi TRUE
[17:27:47.915] - copied 'weight' to environment
[17:27:47.915] - copied 'group' to environment
[17:27:47.916] assign_globals() ... done
[17:27:47.916] plan(): Setting new future strategy stack:
[17:27:47.917] List of future strategies:
[17:27:47.917] 1. sequential:
[17:27:47.917]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.917]    - tweaked: FALSE
[17:27:47.917]    - call: NULL
[17:27:47.917] plan(): nbrOfWorkers() = 1
[17:27:47.920] plan(): Setting new future strategy stack:
[17:27:47.920] List of future strategies:
[17:27:47.920] 1. sequential:
[17:27:47.920]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.920]    - tweaked: FALSE
[17:27:47.920]    - call: plan(strategy)
[17:27:47.921] plan(): nbrOfWorkers() = 1
[17:27:47.921] SequentialFuture started (and completed)
[17:27:47.921] - Launch lazy future ... done
[17:27:47.922] run() for 'SequentialFuture' ... done

Call:
lm(formula = weight ~ group - 1)

Coefficients:
groupCtl  groupTrt  
   5.032     4.661  

- Globals - one-side formulas, e.g. xtabs(~ x) ...
[17:27:47.924] getGlobalsAndPackages() ...
[17:27:47.924] Searching for globals...
[17:27:47.926] - globals found: [4] '{', 'xtabs', 'x', '~'
[17:27:47.926] Searching for globals ... DONE
[17:27:47.926] Resolving globals: FALSE
[17:27:47.927] The total size of the 1 globals is 71 bytes (71 bytes)
[17:27:47.928] The total size of the 1 globals exported for future expression ('{; xtabs(~x); }') is 71 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (71 bytes of class 'numeric')
[17:27:47.928] - globals: [1] 'x'
[17:27:47.928] - packages: [1] 'stats'
[17:27:47.928] getGlobalsAndPackages() ... DONE
[17:27:47.929] run() for 'Future' ...
[17:27:47.929] - state: 'created'
[17:27:47.929] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:47.930] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:47.930] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:47.930]   - Field: 'label'
[17:27:47.930]   - Field: 'local'
[17:27:47.931]   - Field: 'owner'
[17:27:47.931]   - Field: 'envir'
[17:27:47.931]   - Field: 'packages'
[17:27:47.931]   - Field: 'gc'
[17:27:47.931]   - Field: 'conditions'
[17:27:47.932]   - Field: 'expr'
[17:27:47.932]   - Field: 'uuid'
[17:27:47.932]   - Field: 'seed'
[17:27:47.932]   - Field: 'version'
[17:27:47.932]   - Field: 'result'
[17:27:47.933]   - Field: 'asynchronous'
[17:27:47.933]   - Field: 'calls'
[17:27:47.933]   - Field: 'globals'
[17:27:47.933]   - Field: 'stdout'
[17:27:47.933]   - Field: 'earlySignal'
[17:27:47.934]   - Field: 'lazy'
[17:27:47.934]   - Field: 'state'
[17:27:47.934] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:47.934] - Launch lazy future ...
[17:27:47.935] Packages needed by the future expression (n = 1): 'stats'
[17:27:47.935] Packages needed by future strategies (n = 0): <none>
[17:27:47.936] {
[17:27:47.936]     {
[17:27:47.936]         {
[17:27:47.936]             ...future.startTime <- base::Sys.time()
[17:27:47.936]             {
[17:27:47.936]                 {
[17:27:47.936]                   {
[17:27:47.936]                     {
[17:27:47.936]                       base::local({
[17:27:47.936]                         has_future <- base::requireNamespace("future", 
[17:27:47.936]                           quietly = TRUE)
[17:27:47.936]                         if (has_future) {
[17:27:47.936]                           ns <- base::getNamespace("future")
[17:27:47.936]                           version <- ns[[".package"]][["version"]]
[17:27:47.936]                           if (is.null(version)) 
[17:27:47.936]                             version <- utils::packageVersion("future")
[17:27:47.936]                         }
[17:27:47.936]                         else {
[17:27:47.936]                           version <- NULL
[17:27:47.936]                         }
[17:27:47.936]                         if (!has_future || version < "1.8.0") {
[17:27:47.936]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:47.936]                             "", base::R.version$version.string), 
[17:27:47.936]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:47.936]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:47.936]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:47.936]                               "release", "version")], collapse = " "), 
[17:27:47.936]                             hostname = base::Sys.info()[["nodename"]])
[17:27:47.936]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:47.936]                             info)
[17:27:47.936]                           info <- base::paste(info, collapse = "; ")
[17:27:47.936]                           if (!has_future) {
[17:27:47.936]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:47.936]                               info)
[17:27:47.936]                           }
[17:27:47.936]                           else {
[17:27:47.936]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:47.936]                               info, version)
[17:27:47.936]                           }
[17:27:47.936]                           base::stop(msg)
[17:27:47.936]                         }
[17:27:47.936]                       })
[17:27:47.936]                     }
[17:27:47.936]                     base::local({
[17:27:47.936]                       for (pkg in "stats") {
[17:27:47.936]                         base::loadNamespace(pkg)
[17:27:47.936]                         base::library(pkg, character.only = TRUE)
[17:27:47.936]                       }
[17:27:47.936]                     })
[17:27:47.936]                   }
[17:27:47.936]                   ...future.strategy.old <- future::plan("list")
[17:27:47.936]                   options(future.plan = NULL)
[17:27:47.936]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:47.936]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:47.936]                 }
[17:27:47.936]                 ...future.workdir <- getwd()
[17:27:47.936]             }
[17:27:47.936]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:47.936]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:47.936]         }
[17:27:47.936]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:47.936]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:47.936]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:47.936]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:47.936]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:47.936]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:47.936]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:47.936]             base::names(...future.oldOptions))
[17:27:47.936]     }
[17:27:47.936]     if (FALSE) {
[17:27:47.936]     }
[17:27:47.936]     else {
[17:27:47.936]         if (TRUE) {
[17:27:47.936]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:47.936]                 open = "w")
[17:27:47.936]         }
[17:27:47.936]         else {
[17:27:47.936]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:47.936]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:47.936]         }
[17:27:47.936]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:47.936]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:47.936]             base::sink(type = "output", split = FALSE)
[17:27:47.936]             base::close(...future.stdout)
[17:27:47.936]         }, add = TRUE)
[17:27:47.936]     }
[17:27:47.936]     ...future.frame <- base::sys.nframe()
[17:27:47.936]     ...future.conditions <- base::list()
[17:27:47.936]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:47.936]     if (FALSE) {
[17:27:47.936]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:47.936]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:47.936]     }
[17:27:47.936]     ...future.result <- base::tryCatch({
[17:27:47.936]         base::withCallingHandlers({
[17:27:47.936]             ...future.value <- base::withVisible(base::local({
[17:27:47.936]                 xtabs(~x)
[17:27:47.936]             }))
[17:27:47.936]             future::FutureResult(value = ...future.value$value, 
[17:27:47.936]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:47.936]                   ...future.rng), globalenv = if (FALSE) 
[17:27:47.936]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:47.936]                     ...future.globalenv.names))
[17:27:47.936]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:47.936]         }, condition = base::local({
[17:27:47.936]             c <- base::c
[17:27:47.936]             inherits <- base::inherits
[17:27:47.936]             invokeRestart <- base::invokeRestart
[17:27:47.936]             length <- base::length
[17:27:47.936]             list <- base::list
[17:27:47.936]             seq.int <- base::seq.int
[17:27:47.936]             signalCondition <- base::signalCondition
[17:27:47.936]             sys.calls <- base::sys.calls
[17:27:47.936]             `[[` <- base::`[[`
[17:27:47.936]             `+` <- base::`+`
[17:27:47.936]             `<<-` <- base::`<<-`
[17:27:47.936]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:47.936]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:47.936]                   3L)]
[17:27:47.936]             }
[17:27:47.936]             function(cond) {
[17:27:47.936]                 is_error <- inherits(cond, "error")
[17:27:47.936]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:47.936]                   NULL)
[17:27:47.936]                 if (is_error) {
[17:27:47.936]                   sessionInformation <- function() {
[17:27:47.936]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:47.936]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:47.936]                       search = base::search(), system = base::Sys.info())
[17:27:47.936]                   }
[17:27:47.936]                   ...future.conditions[[length(...future.conditions) + 
[17:27:47.936]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:47.936]                     cond$call), session = sessionInformation(), 
[17:27:47.936]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:47.936]                   signalCondition(cond)
[17:27:47.936]                 }
[17:27:47.936]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:47.936]                 "immediateCondition"))) {
[17:27:47.936]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:47.936]                   ...future.conditions[[length(...future.conditions) + 
[17:27:47.936]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:47.936]                   if (TRUE && !signal) {
[17:27:47.936]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:47.936]                     {
[17:27:47.936]                       inherits <- base::inherits
[17:27:47.936]                       invokeRestart <- base::invokeRestart
[17:27:47.936]                       is.null <- base::is.null
[17:27:47.936]                       muffled <- FALSE
[17:27:47.936]                       if (inherits(cond, "message")) {
[17:27:47.936]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:47.936]                         if (muffled) 
[17:27:47.936]                           invokeRestart("muffleMessage")
[17:27:47.936]                       }
[17:27:47.936]                       else if (inherits(cond, "warning")) {
[17:27:47.936]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:47.936]                         if (muffled) 
[17:27:47.936]                           invokeRestart("muffleWarning")
[17:27:47.936]                       }
[17:27:47.936]                       else if (inherits(cond, "condition")) {
[17:27:47.936]                         if (!is.null(pattern)) {
[17:27:47.936]                           computeRestarts <- base::computeRestarts
[17:27:47.936]                           grepl <- base::grepl
[17:27:47.936]                           restarts <- computeRestarts(cond)
[17:27:47.936]                           for (restart in restarts) {
[17:27:47.936]                             name <- restart$name
[17:27:47.936]                             if (is.null(name)) 
[17:27:47.936]                               next
[17:27:47.936]                             if (!grepl(pattern, name)) 
[17:27:47.936]                               next
[17:27:47.936]                             invokeRestart(restart)
[17:27:47.936]                             muffled <- TRUE
[17:27:47.936]                             break
[17:27:47.936]                           }
[17:27:47.936]                         }
[17:27:47.936]                       }
[17:27:47.936]                       invisible(muffled)
[17:27:47.936]                     }
[17:27:47.936]                     muffleCondition(cond, pattern = "^muffle")
[17:27:47.936]                   }
[17:27:47.936]                 }
[17:27:47.936]                 else {
[17:27:47.936]                   if (TRUE) {
[17:27:47.936]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:47.936]                     {
[17:27:47.936]                       inherits <- base::inherits
[17:27:47.936]                       invokeRestart <- base::invokeRestart
[17:27:47.936]                       is.null <- base::is.null
[17:27:47.936]                       muffled <- FALSE
[17:27:47.936]                       if (inherits(cond, "message")) {
[17:27:47.936]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:47.936]                         if (muffled) 
[17:27:47.936]                           invokeRestart("muffleMessage")
[17:27:47.936]                       }
[17:27:47.936]                       else if (inherits(cond, "warning")) {
[17:27:47.936]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:47.936]                         if (muffled) 
[17:27:47.936]                           invokeRestart("muffleWarning")
[17:27:47.936]                       }
[17:27:47.936]                       else if (inherits(cond, "condition")) {
[17:27:47.936]                         if (!is.null(pattern)) {
[17:27:47.936]                           computeRestarts <- base::computeRestarts
[17:27:47.936]                           grepl <- base::grepl
[17:27:47.936]                           restarts <- computeRestarts(cond)
[17:27:47.936]                           for (restart in restarts) {
[17:27:47.936]                             name <- restart$name
[17:27:47.936]                             if (is.null(name)) 
[17:27:47.936]                               next
[17:27:47.936]                             if (!grepl(pattern, name)) 
[17:27:47.936]                               next
[17:27:47.936]                             invokeRestart(restart)
[17:27:47.936]                             muffled <- TRUE
[17:27:47.936]                             break
[17:27:47.936]                           }
[17:27:47.936]                         }
[17:27:47.936]                       }
[17:27:47.936]                       invisible(muffled)
[17:27:47.936]                     }
[17:27:47.936]                     muffleCondition(cond, pattern = "^muffle")
[17:27:47.936]                   }
[17:27:47.936]                 }
[17:27:47.936]             }
[17:27:47.936]         }))
[17:27:47.936]     }, error = function(ex) {
[17:27:47.936]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:47.936]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:47.936]                 ...future.rng), started = ...future.startTime, 
[17:27:47.936]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:47.936]             version = "1.8"), class = "FutureResult")
[17:27:47.936]     }, finally = {
[17:27:47.936]         if (!identical(...future.workdir, getwd())) 
[17:27:47.936]             setwd(...future.workdir)
[17:27:47.936]         {
[17:27:47.936]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:47.936]                 ...future.oldOptions$nwarnings <- NULL
[17:27:47.936]             }
[17:27:47.936]             base::options(...future.oldOptions)
[17:27:47.936]             if (.Platform$OS.type == "windows") {
[17:27:47.936]                 old_names <- names(...future.oldEnvVars)
[17:27:47.936]                 envs <- base::Sys.getenv()
[17:27:47.936]                 names <- names(envs)
[17:27:47.936]                 common <- intersect(names, old_names)
[17:27:47.936]                 added <- setdiff(names, old_names)
[17:27:47.936]                 removed <- setdiff(old_names, names)
[17:27:47.936]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:47.936]                   envs[common]]
[17:27:47.936]                 NAMES <- toupper(changed)
[17:27:47.936]                 args <- list()
[17:27:47.936]                 for (kk in seq_along(NAMES)) {
[17:27:47.936]                   name <- changed[[kk]]
[17:27:47.936]                   NAME <- NAMES[[kk]]
[17:27:47.936]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.936]                     next
[17:27:47.936]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:47.936]                 }
[17:27:47.936]                 NAMES <- toupper(added)
[17:27:47.936]                 for (kk in seq_along(NAMES)) {
[17:27:47.936]                   name <- added[[kk]]
[17:27:47.936]                   NAME <- NAMES[[kk]]
[17:27:47.936]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.936]                     next
[17:27:47.936]                   args[[name]] <- ""
[17:27:47.936]                 }
[17:27:47.936]                 NAMES <- toupper(removed)
[17:27:47.936]                 for (kk in seq_along(NAMES)) {
[17:27:47.936]                   name <- removed[[kk]]
[17:27:47.936]                   NAME <- NAMES[[kk]]
[17:27:47.936]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:47.936]                     next
[17:27:47.936]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:47.936]                 }
[17:27:47.936]                 if (length(args) > 0) 
[17:27:47.936]                   base::do.call(base::Sys.setenv, args = args)
[17:27:47.936]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:47.936]             }
[17:27:47.936]             else {
[17:27:47.936]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:47.936]             }
[17:27:47.936]             {
[17:27:47.936]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:47.936]                   0L) {
[17:27:47.936]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:47.936]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:47.936]                   base::options(opts)
[17:27:47.936]                 }
[17:27:47.936]                 {
[17:27:47.936]                   {
[17:27:47.936]                     NULL
[17:27:47.936]                     RNGkind("Mersenne-Twister")
[17:27:47.936]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:47.936]                       inherits = FALSE)
[17:27:47.936]                   }
[17:27:47.936]                   options(future.plan = NULL)
[17:27:47.936]                   if (is.na(NA_character_)) 
[17:27:47.936]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:47.936]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:47.936]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:47.936]                     .init = FALSE)
[17:27:47.936]                 }
[17:27:47.936]             }
[17:27:47.936]         }
[17:27:47.936]     })
[17:27:47.936]     if (TRUE) {
[17:27:47.936]         base::sink(type = "output", split = FALSE)
[17:27:47.936]         if (TRUE) {
[17:27:47.936]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:47.936]         }
[17:27:47.936]         else {
[17:27:47.936]             ...future.result["stdout"] <- base::list(NULL)
[17:27:47.936]         }
[17:27:47.936]         base::close(...future.stdout)
[17:27:47.936]         ...future.stdout <- NULL
[17:27:47.936]     }
[17:27:47.936]     ...future.result$conditions <- ...future.conditions
[17:27:47.936]     ...future.result$finished <- base::Sys.time()
[17:27:47.936]     ...future.result
[17:27:47.936] }
[17:27:47.940] assign_globals() ...
[17:27:47.941] List of 1
[17:27:47.941]  $ x: num [1:5] 1 1 2 2 2
[17:27:47.941]  - attr(*, "where")=List of 1
[17:27:47.941]   ..$ x:<environment: R_EmptyEnv> 
[17:27:47.941]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:47.941]  - attr(*, "resolved")= logi FALSE
[17:27:47.941]  - attr(*, "total_size")= int 71
[17:27:47.941]  - attr(*, "already-done")= logi TRUE
[17:27:47.979] - copied 'x' to environment
[17:27:47.979] assign_globals() ... done
[17:27:47.980] plan(): Setting new future strategy stack:
[17:27:47.981] List of future strategies:
[17:27:47.981] 1. sequential:
[17:27:47.981]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.981]    - tweaked: FALSE
[17:27:47.981]    - call: NULL
[17:27:47.982] plan(): nbrOfWorkers() = 1
[17:27:47.984] plan(): Setting new future strategy stack:
[17:27:47.985] List of future strategies:
[17:27:47.985] 1. sequential:
[17:27:47.985]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:47.985]    - tweaked: FALSE
[17:27:47.985]    - call: plan(strategy)
[17:27:47.986] plan(): nbrOfWorkers() = 1
[17:27:47.986] SequentialFuture started (and completed)
[17:27:47.987] - Launch lazy future ... done
[17:27:47.987] run() for 'SequentialFuture' ... done
x
1 2 
2 3 
[17:27:47.989] getGlobalsAndPackages() ...
[17:27:47.989] Searching for globals...
[17:27:47.991] - globals found: [4] '{', 'xtabs', 'x', '~'
[17:27:47.992] Searching for globals ... DONE
[17:27:47.992] Resolving globals: FALSE
[17:27:47.993] The total size of the 1 globals is 71 bytes (71 bytes)
[17:27:47.994] The total size of the 1 globals exported for future expression ('{; xtabs(~x); }') is 71 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (71 bytes of class 'numeric')
[17:27:47.994] - globals: [1] 'x'
[17:27:47.995] - packages: [1] 'stats'
[17:27:47.995] getGlobalsAndPackages() ... DONE
[17:27:47.996] run() for 'Future' ...
[17:27:47.996] - state: 'created'
[17:27:47.996] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:47.997] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:47.997] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:47.998]   - Field: 'label'
[17:27:47.998]   - Field: 'local'
[17:27:47.998]   - Field: 'owner'
[17:27:47.999]   - Field: 'envir'
[17:27:47.999]   - Field: 'packages'
[17:27:48.000]   - Field: 'gc'
[17:27:48.000]   - Field: 'conditions'
[17:27:48.000]   - Field: 'expr'
[17:27:48.001]   - Field: 'uuid'
[17:27:48.001]   - Field: 'seed'
[17:27:48.001]   - Field: 'version'
[17:27:48.001]   - Field: 'result'
[17:27:48.002]   - Field: 'asynchronous'
[17:27:48.002]   - Field: 'calls'
[17:27:48.002]   - Field: 'globals'
[17:27:48.002]   - Field: 'stdout'
[17:27:48.002]   - Field: 'earlySignal'
[17:27:48.002]   - Field: 'lazy'
[17:27:48.003]   - Field: 'state'
[17:27:48.003] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:48.003] - Launch lazy future ...
[17:27:48.003] Packages needed by the future expression (n = 1): 'stats'
[17:27:48.003] Packages needed by future strategies (n = 0): <none>
[17:27:48.004] {
[17:27:48.004]     {
[17:27:48.004]         {
[17:27:48.004]             ...future.startTime <- base::Sys.time()
[17:27:48.004]             {
[17:27:48.004]                 {
[17:27:48.004]                   {
[17:27:48.004]                     {
[17:27:48.004]                       base::local({
[17:27:48.004]                         has_future <- base::requireNamespace("future", 
[17:27:48.004]                           quietly = TRUE)
[17:27:48.004]                         if (has_future) {
[17:27:48.004]                           ns <- base::getNamespace("future")
[17:27:48.004]                           version <- ns[[".package"]][["version"]]
[17:27:48.004]                           if (is.null(version)) 
[17:27:48.004]                             version <- utils::packageVersion("future")
[17:27:48.004]                         }
[17:27:48.004]                         else {
[17:27:48.004]                           version <- NULL
[17:27:48.004]                         }
[17:27:48.004]                         if (!has_future || version < "1.8.0") {
[17:27:48.004]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:48.004]                             "", base::R.version$version.string), 
[17:27:48.004]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:48.004]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:48.004]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:48.004]                               "release", "version")], collapse = " "), 
[17:27:48.004]                             hostname = base::Sys.info()[["nodename"]])
[17:27:48.004]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:48.004]                             info)
[17:27:48.004]                           info <- base::paste(info, collapse = "; ")
[17:27:48.004]                           if (!has_future) {
[17:27:48.004]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:48.004]                               info)
[17:27:48.004]                           }
[17:27:48.004]                           else {
[17:27:48.004]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:48.004]                               info, version)
[17:27:48.004]                           }
[17:27:48.004]                           base::stop(msg)
[17:27:48.004]                         }
[17:27:48.004]                       })
[17:27:48.004]                     }
[17:27:48.004]                     base::local({
[17:27:48.004]                       for (pkg in "stats") {
[17:27:48.004]                         base::loadNamespace(pkg)
[17:27:48.004]                         base::library(pkg, character.only = TRUE)
[17:27:48.004]                       }
[17:27:48.004]                     })
[17:27:48.004]                   }
[17:27:48.004]                   ...future.strategy.old <- future::plan("list")
[17:27:48.004]                   options(future.plan = NULL)
[17:27:48.004]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.004]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:48.004]                 }
[17:27:48.004]                 ...future.workdir <- getwd()
[17:27:48.004]             }
[17:27:48.004]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:48.004]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:48.004]         }
[17:27:48.004]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:48.004]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:48.004]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:48.004]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:48.004]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:48.004]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:48.004]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:48.004]             base::names(...future.oldOptions))
[17:27:48.004]     }
[17:27:48.004]     if (FALSE) {
[17:27:48.004]     }
[17:27:48.004]     else {
[17:27:48.004]         if (TRUE) {
[17:27:48.004]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:48.004]                 open = "w")
[17:27:48.004]         }
[17:27:48.004]         else {
[17:27:48.004]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:48.004]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:48.004]         }
[17:27:48.004]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:48.004]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:48.004]             base::sink(type = "output", split = FALSE)
[17:27:48.004]             base::close(...future.stdout)
[17:27:48.004]         }, add = TRUE)
[17:27:48.004]     }
[17:27:48.004]     ...future.frame <- base::sys.nframe()
[17:27:48.004]     ...future.conditions <- base::list()
[17:27:48.004]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:48.004]     if (FALSE) {
[17:27:48.004]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:48.004]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:48.004]     }
[17:27:48.004]     ...future.result <- base::tryCatch({
[17:27:48.004]         base::withCallingHandlers({
[17:27:48.004]             ...future.value <- base::withVisible(base::local({
[17:27:48.004]                 xtabs(~x)
[17:27:48.004]             }))
[17:27:48.004]             future::FutureResult(value = ...future.value$value, 
[17:27:48.004]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.004]                   ...future.rng), globalenv = if (FALSE) 
[17:27:48.004]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:48.004]                     ...future.globalenv.names))
[17:27:48.004]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:48.004]         }, condition = base::local({
[17:27:48.004]             c <- base::c
[17:27:48.004]             inherits <- base::inherits
[17:27:48.004]             invokeRestart <- base::invokeRestart
[17:27:48.004]             length <- base::length
[17:27:48.004]             list <- base::list
[17:27:48.004]             seq.int <- base::seq.int
[17:27:48.004]             signalCondition <- base::signalCondition
[17:27:48.004]             sys.calls <- base::sys.calls
[17:27:48.004]             `[[` <- base::`[[`
[17:27:48.004]             `+` <- base::`+`
[17:27:48.004]             `<<-` <- base::`<<-`
[17:27:48.004]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:48.004]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:48.004]                   3L)]
[17:27:48.004]             }
[17:27:48.004]             function(cond) {
[17:27:48.004]                 is_error <- inherits(cond, "error")
[17:27:48.004]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:48.004]                   NULL)
[17:27:48.004]                 if (is_error) {
[17:27:48.004]                   sessionInformation <- function() {
[17:27:48.004]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:48.004]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:48.004]                       search = base::search(), system = base::Sys.info())
[17:27:48.004]                   }
[17:27:48.004]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.004]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:48.004]                     cond$call), session = sessionInformation(), 
[17:27:48.004]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:48.004]                   signalCondition(cond)
[17:27:48.004]                 }
[17:27:48.004]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:48.004]                 "immediateCondition"))) {
[17:27:48.004]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:48.004]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.004]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:48.004]                   if (TRUE && !signal) {
[17:27:48.004]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.004]                     {
[17:27:48.004]                       inherits <- base::inherits
[17:27:48.004]                       invokeRestart <- base::invokeRestart
[17:27:48.004]                       is.null <- base::is.null
[17:27:48.004]                       muffled <- FALSE
[17:27:48.004]                       if (inherits(cond, "message")) {
[17:27:48.004]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.004]                         if (muffled) 
[17:27:48.004]                           invokeRestart("muffleMessage")
[17:27:48.004]                       }
[17:27:48.004]                       else if (inherits(cond, "warning")) {
[17:27:48.004]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.004]                         if (muffled) 
[17:27:48.004]                           invokeRestart("muffleWarning")
[17:27:48.004]                       }
[17:27:48.004]                       else if (inherits(cond, "condition")) {
[17:27:48.004]                         if (!is.null(pattern)) {
[17:27:48.004]                           computeRestarts <- base::computeRestarts
[17:27:48.004]                           grepl <- base::grepl
[17:27:48.004]                           restarts <- computeRestarts(cond)
[17:27:48.004]                           for (restart in restarts) {
[17:27:48.004]                             name <- restart$name
[17:27:48.004]                             if (is.null(name)) 
[17:27:48.004]                               next
[17:27:48.004]                             if (!grepl(pattern, name)) 
[17:27:48.004]                               next
[17:27:48.004]                             invokeRestart(restart)
[17:27:48.004]                             muffled <- TRUE
[17:27:48.004]                             break
[17:27:48.004]                           }
[17:27:48.004]                         }
[17:27:48.004]                       }
[17:27:48.004]                       invisible(muffled)
[17:27:48.004]                     }
[17:27:48.004]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.004]                   }
[17:27:48.004]                 }
[17:27:48.004]                 else {
[17:27:48.004]                   if (TRUE) {
[17:27:48.004]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.004]                     {
[17:27:48.004]                       inherits <- base::inherits
[17:27:48.004]                       invokeRestart <- base::invokeRestart
[17:27:48.004]                       is.null <- base::is.null
[17:27:48.004]                       muffled <- FALSE
[17:27:48.004]                       if (inherits(cond, "message")) {
[17:27:48.004]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.004]                         if (muffled) 
[17:27:48.004]                           invokeRestart("muffleMessage")
[17:27:48.004]                       }
[17:27:48.004]                       else if (inherits(cond, "warning")) {
[17:27:48.004]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.004]                         if (muffled) 
[17:27:48.004]                           invokeRestart("muffleWarning")
[17:27:48.004]                       }
[17:27:48.004]                       else if (inherits(cond, "condition")) {
[17:27:48.004]                         if (!is.null(pattern)) {
[17:27:48.004]                           computeRestarts <- base::computeRestarts
[17:27:48.004]                           grepl <- base::grepl
[17:27:48.004]                           restarts <- computeRestarts(cond)
[17:27:48.004]                           for (restart in restarts) {
[17:27:48.004]                             name <- restart$name
[17:27:48.004]                             if (is.null(name)) 
[17:27:48.004]                               next
[17:27:48.004]                             if (!grepl(pattern, name)) 
[17:27:48.004]                               next
[17:27:48.004]                             invokeRestart(restart)
[17:27:48.004]                             muffled <- TRUE
[17:27:48.004]                             break
[17:27:48.004]                           }
[17:27:48.004]                         }
[17:27:48.004]                       }
[17:27:48.004]                       invisible(muffled)
[17:27:48.004]                     }
[17:27:48.004]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.004]                   }
[17:27:48.004]                 }
[17:27:48.004]             }
[17:27:48.004]         }))
[17:27:48.004]     }, error = function(ex) {
[17:27:48.004]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:48.004]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.004]                 ...future.rng), started = ...future.startTime, 
[17:27:48.004]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:48.004]             version = "1.8"), class = "FutureResult")
[17:27:48.004]     }, finally = {
[17:27:48.004]         if (!identical(...future.workdir, getwd())) 
[17:27:48.004]             setwd(...future.workdir)
[17:27:48.004]         {
[17:27:48.004]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:48.004]                 ...future.oldOptions$nwarnings <- NULL
[17:27:48.004]             }
[17:27:48.004]             base::options(...future.oldOptions)
[17:27:48.004]             if (.Platform$OS.type == "windows") {
[17:27:48.004]                 old_names <- names(...future.oldEnvVars)
[17:27:48.004]                 envs <- base::Sys.getenv()
[17:27:48.004]                 names <- names(envs)
[17:27:48.004]                 common <- intersect(names, old_names)
[17:27:48.004]                 added <- setdiff(names, old_names)
[17:27:48.004]                 removed <- setdiff(old_names, names)
[17:27:48.004]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:48.004]                   envs[common]]
[17:27:48.004]                 NAMES <- toupper(changed)
[17:27:48.004]                 args <- list()
[17:27:48.004]                 for (kk in seq_along(NAMES)) {
[17:27:48.004]                   name <- changed[[kk]]
[17:27:48.004]                   NAME <- NAMES[[kk]]
[17:27:48.004]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.004]                     next
[17:27:48.004]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.004]                 }
[17:27:48.004]                 NAMES <- toupper(added)
[17:27:48.004]                 for (kk in seq_along(NAMES)) {
[17:27:48.004]                   name <- added[[kk]]
[17:27:48.004]                   NAME <- NAMES[[kk]]
[17:27:48.004]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.004]                     next
[17:27:48.004]                   args[[name]] <- ""
[17:27:48.004]                 }
[17:27:48.004]                 NAMES <- toupper(removed)
[17:27:48.004]                 for (kk in seq_along(NAMES)) {
[17:27:48.004]                   name <- removed[[kk]]
[17:27:48.004]                   NAME <- NAMES[[kk]]
[17:27:48.004]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.004]                     next
[17:27:48.004]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.004]                 }
[17:27:48.004]                 if (length(args) > 0) 
[17:27:48.004]                   base::do.call(base::Sys.setenv, args = args)
[17:27:48.004]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:48.004]             }
[17:27:48.004]             else {
[17:27:48.004]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:48.004]             }
[17:27:48.004]             {
[17:27:48.004]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:48.004]                   0L) {
[17:27:48.004]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:48.004]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:48.004]                   base::options(opts)
[17:27:48.004]                 }
[17:27:48.004]                 {
[17:27:48.004]                   {
[17:27:48.004]                     NULL
[17:27:48.004]                     RNGkind("Mersenne-Twister")
[17:27:48.004]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:48.004]                       inherits = FALSE)
[17:27:48.004]                   }
[17:27:48.004]                   options(future.plan = NULL)
[17:27:48.004]                   if (is.na(NA_character_)) 
[17:27:48.004]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.004]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:48.004]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:48.004]                     .init = FALSE)
[17:27:48.004]                 }
[17:27:48.004]             }
[17:27:48.004]         }
[17:27:48.004]     })
[17:27:48.004]     if (TRUE) {
[17:27:48.004]         base::sink(type = "output", split = FALSE)
[17:27:48.004]         if (TRUE) {
[17:27:48.004]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:48.004]         }
[17:27:48.004]         else {
[17:27:48.004]             ...future.result["stdout"] <- base::list(NULL)
[17:27:48.004]         }
[17:27:48.004]         base::close(...future.stdout)
[17:27:48.004]         ...future.stdout <- NULL
[17:27:48.004]     }
[17:27:48.004]     ...future.result$conditions <- ...future.conditions
[17:27:48.004]     ...future.result$finished <- base::Sys.time()
[17:27:48.004]     ...future.result
[17:27:48.004] }
[17:27:48.008] assign_globals() ...
[17:27:48.008] List of 1
[17:27:48.008]  $ x: num [1:5] 1 1 2 2 2
[17:27:48.008]  - attr(*, "where")=List of 1
[17:27:48.008]   ..$ x:<environment: R_EmptyEnv> 
[17:27:48.008]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:48.008]  - attr(*, "resolved")= logi FALSE
[17:27:48.008]  - attr(*, "total_size")= int 71
[17:27:48.008]  - attr(*, "already-done")= logi TRUE
[17:27:48.012] - copied 'x' to environment
[17:27:48.012] assign_globals() ... done
[17:27:48.013] plan(): Setting new future strategy stack:
[17:27:48.013] List of future strategies:
[17:27:48.013] 1. sequential:
[17:27:48.013]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.013]    - tweaked: FALSE
[17:27:48.013]    - call: NULL
[17:27:48.014] plan(): nbrOfWorkers() = 1
[17:27:48.016] plan(): Setting new future strategy stack:
[17:27:48.017] List of future strategies:
[17:27:48.017] 1. sequential:
[17:27:48.017]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.017]    - tweaked: FALSE
[17:27:48.017]    - call: plan(strategy)
[17:27:48.018] plan(): nbrOfWorkers() = 1
[17:27:48.018] SequentialFuture started (and completed)
[17:27:48.019] - Launch lazy future ... done
[17:27:48.019] run() for 'SequentialFuture' ... done
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  

[17:27:48.023] getGlobalsAndPackages() ...
[17:27:48.023] Searching for globals...
[17:27:48.028] - globals found: [7] '{', 'lm', 'dist', '-', '.', '~', 'cars'
[17:27:48.028] Searching for globals ... DONE
[17:27:48.029] Resolving globals: FALSE
[17:27:48.029] 
[17:27:48.029] - packages: [2] 'stats', 'datasets'
[17:27:48.030] getGlobalsAndPackages() ... DONE
[17:27:48.030] run() for 'Future' ...
[17:27:48.030] - state: 'created'
[17:27:48.030] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:48.031] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:48.031] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:48.031]   - Field: 'label'
[17:27:48.031]   - Field: 'local'
[17:27:48.032]   - Field: 'owner'
[17:27:48.032]   - Field: 'envir'
[17:27:48.032]   - Field: 'packages'
[17:27:48.032]   - Field: 'gc'
[17:27:48.032]   - Field: 'conditions'
[17:27:48.033]   - Field: 'expr'
[17:27:48.033]   - Field: 'uuid'
[17:27:48.033]   - Field: 'seed'
[17:27:48.033]   - Field: 'version'
[17:27:48.033]   - Field: 'result'
[17:27:48.033]   - Field: 'asynchronous'
[17:27:48.034]   - Field: 'calls'
[17:27:48.034]   - Field: 'globals'
[17:27:48.034]   - Field: 'stdout'
[17:27:48.034]   - Field: 'earlySignal'
[17:27:48.034]   - Field: 'lazy'
[17:27:48.035]   - Field: 'state'
[17:27:48.035] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:48.035] - Launch lazy future ...
[17:27:48.035] Packages needed by the future expression (n = 2): 'stats', 'datasets'
[17:27:48.035] Packages needed by future strategies (n = 0): <none>
[17:27:48.036] {
[17:27:48.036]     {
[17:27:48.036]         {
[17:27:48.036]             ...future.startTime <- base::Sys.time()
[17:27:48.036]             {
[17:27:48.036]                 {
[17:27:48.036]                   {
[17:27:48.036]                     {
[17:27:48.036]                       base::local({
[17:27:48.036]                         has_future <- base::requireNamespace("future", 
[17:27:48.036]                           quietly = TRUE)
[17:27:48.036]                         if (has_future) {
[17:27:48.036]                           ns <- base::getNamespace("future")
[17:27:48.036]                           version <- ns[[".package"]][["version"]]
[17:27:48.036]                           if (is.null(version)) 
[17:27:48.036]                             version <- utils::packageVersion("future")
[17:27:48.036]                         }
[17:27:48.036]                         else {
[17:27:48.036]                           version <- NULL
[17:27:48.036]                         }
[17:27:48.036]                         if (!has_future || version < "1.8.0") {
[17:27:48.036]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:48.036]                             "", base::R.version$version.string), 
[17:27:48.036]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:48.036]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:48.036]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:48.036]                               "release", "version")], collapse = " "), 
[17:27:48.036]                             hostname = base::Sys.info()[["nodename"]])
[17:27:48.036]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:48.036]                             info)
[17:27:48.036]                           info <- base::paste(info, collapse = "; ")
[17:27:48.036]                           if (!has_future) {
[17:27:48.036]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:48.036]                               info)
[17:27:48.036]                           }
[17:27:48.036]                           else {
[17:27:48.036]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:48.036]                               info, version)
[17:27:48.036]                           }
[17:27:48.036]                           base::stop(msg)
[17:27:48.036]                         }
[17:27:48.036]                       })
[17:27:48.036]                     }
[17:27:48.036]                     base::local({
[17:27:48.036]                       for (pkg in c("stats", "datasets")) {
[17:27:48.036]                         base::loadNamespace(pkg)
[17:27:48.036]                         base::library(pkg, character.only = TRUE)
[17:27:48.036]                       }
[17:27:48.036]                     })
[17:27:48.036]                   }
[17:27:48.036]                   ...future.strategy.old <- future::plan("list")
[17:27:48.036]                   options(future.plan = NULL)
[17:27:48.036]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.036]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:48.036]                 }
[17:27:48.036]                 ...future.workdir <- getwd()
[17:27:48.036]             }
[17:27:48.036]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:48.036]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:48.036]         }
[17:27:48.036]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:48.036]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:48.036]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:48.036]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:48.036]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:48.036]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:48.036]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:48.036]             base::names(...future.oldOptions))
[17:27:48.036]     }
[17:27:48.036]     if (FALSE) {
[17:27:48.036]     }
[17:27:48.036]     else {
[17:27:48.036]         if (TRUE) {
[17:27:48.036]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:48.036]                 open = "w")
[17:27:48.036]         }
[17:27:48.036]         else {
[17:27:48.036]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:48.036]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:48.036]         }
[17:27:48.036]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:48.036]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:48.036]             base::sink(type = "output", split = FALSE)
[17:27:48.036]             base::close(...future.stdout)
[17:27:48.036]         }, add = TRUE)
[17:27:48.036]     }
[17:27:48.036]     ...future.frame <- base::sys.nframe()
[17:27:48.036]     ...future.conditions <- base::list()
[17:27:48.036]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:48.036]     if (FALSE) {
[17:27:48.036]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:48.036]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:48.036]     }
[17:27:48.036]     ...future.result <- base::tryCatch({
[17:27:48.036]         base::withCallingHandlers({
[17:27:48.036]             ...future.value <- base::withVisible(base::local({
[17:27:48.036]                 lm(dist ~ . - 1, data = cars)
[17:27:48.036]             }))
[17:27:48.036]             future::FutureResult(value = ...future.value$value, 
[17:27:48.036]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.036]                   ...future.rng), globalenv = if (FALSE) 
[17:27:48.036]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:48.036]                     ...future.globalenv.names))
[17:27:48.036]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:48.036]         }, condition = base::local({
[17:27:48.036]             c <- base::c
[17:27:48.036]             inherits <- base::inherits
[17:27:48.036]             invokeRestart <- base::invokeRestart
[17:27:48.036]             length <- base::length
[17:27:48.036]             list <- base::list
[17:27:48.036]             seq.int <- base::seq.int
[17:27:48.036]             signalCondition <- base::signalCondition
[17:27:48.036]             sys.calls <- base::sys.calls
[17:27:48.036]             `[[` <- base::`[[`
[17:27:48.036]             `+` <- base::`+`
[17:27:48.036]             `<<-` <- base::`<<-`
[17:27:48.036]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:48.036]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:48.036]                   3L)]
[17:27:48.036]             }
[17:27:48.036]             function(cond) {
[17:27:48.036]                 is_error <- inherits(cond, "error")
[17:27:48.036]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:48.036]                   NULL)
[17:27:48.036]                 if (is_error) {
[17:27:48.036]                   sessionInformation <- function() {
[17:27:48.036]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:48.036]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:48.036]                       search = base::search(), system = base::Sys.info())
[17:27:48.036]                   }
[17:27:48.036]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.036]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:48.036]                     cond$call), session = sessionInformation(), 
[17:27:48.036]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:48.036]                   signalCondition(cond)
[17:27:48.036]                 }
[17:27:48.036]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:48.036]                 "immediateCondition"))) {
[17:27:48.036]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:48.036]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.036]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:48.036]                   if (TRUE && !signal) {
[17:27:48.036]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.036]                     {
[17:27:48.036]                       inherits <- base::inherits
[17:27:48.036]                       invokeRestart <- base::invokeRestart
[17:27:48.036]                       is.null <- base::is.null
[17:27:48.036]                       muffled <- FALSE
[17:27:48.036]                       if (inherits(cond, "message")) {
[17:27:48.036]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.036]                         if (muffled) 
[17:27:48.036]                           invokeRestart("muffleMessage")
[17:27:48.036]                       }
[17:27:48.036]                       else if (inherits(cond, "warning")) {
[17:27:48.036]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.036]                         if (muffled) 
[17:27:48.036]                           invokeRestart("muffleWarning")
[17:27:48.036]                       }
[17:27:48.036]                       else if (inherits(cond, "condition")) {
[17:27:48.036]                         if (!is.null(pattern)) {
[17:27:48.036]                           computeRestarts <- base::computeRestarts
[17:27:48.036]                           grepl <- base::grepl
[17:27:48.036]                           restarts <- computeRestarts(cond)
[17:27:48.036]                           for (restart in restarts) {
[17:27:48.036]                             name <- restart$name
[17:27:48.036]                             if (is.null(name)) 
[17:27:48.036]                               next
[17:27:48.036]                             if (!grepl(pattern, name)) 
[17:27:48.036]                               next
[17:27:48.036]                             invokeRestart(restart)
[17:27:48.036]                             muffled <- TRUE
[17:27:48.036]                             break
[17:27:48.036]                           }
[17:27:48.036]                         }
[17:27:48.036]                       }
[17:27:48.036]                       invisible(muffled)
[17:27:48.036]                     }
[17:27:48.036]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.036]                   }
[17:27:48.036]                 }
[17:27:48.036]                 else {
[17:27:48.036]                   if (TRUE) {
[17:27:48.036]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.036]                     {
[17:27:48.036]                       inherits <- base::inherits
[17:27:48.036]                       invokeRestart <- base::invokeRestart
[17:27:48.036]                       is.null <- base::is.null
[17:27:48.036]                       muffled <- FALSE
[17:27:48.036]                       if (inherits(cond, "message")) {
[17:27:48.036]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.036]                         if (muffled) 
[17:27:48.036]                           invokeRestart("muffleMessage")
[17:27:48.036]                       }
[17:27:48.036]                       else if (inherits(cond, "warning")) {
[17:27:48.036]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.036]                         if (muffled) 
[17:27:48.036]                           invokeRestart("muffleWarning")
[17:27:48.036]                       }
[17:27:48.036]                       else if (inherits(cond, "condition")) {
[17:27:48.036]                         if (!is.null(pattern)) {
[17:27:48.036]                           computeRestarts <- base::computeRestarts
[17:27:48.036]                           grepl <- base::grepl
[17:27:48.036]                           restarts <- computeRestarts(cond)
[17:27:48.036]                           for (restart in restarts) {
[17:27:48.036]                             name <- restart$name
[17:27:48.036]                             if (is.null(name)) 
[17:27:48.036]                               next
[17:27:48.036]                             if (!grepl(pattern, name)) 
[17:27:48.036]                               next
[17:27:48.036]                             invokeRestart(restart)
[17:27:48.036]                             muffled <- TRUE
[17:27:48.036]                             break
[17:27:48.036]                           }
[17:27:48.036]                         }
[17:27:48.036]                       }
[17:27:48.036]                       invisible(muffled)
[17:27:48.036]                     }
[17:27:48.036]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.036]                   }
[17:27:48.036]                 }
[17:27:48.036]             }
[17:27:48.036]         }))
[17:27:48.036]     }, error = function(ex) {
[17:27:48.036]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:48.036]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.036]                 ...future.rng), started = ...future.startTime, 
[17:27:48.036]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:48.036]             version = "1.8"), class = "FutureResult")
[17:27:48.036]     }, finally = {
[17:27:48.036]         if (!identical(...future.workdir, getwd())) 
[17:27:48.036]             setwd(...future.workdir)
[17:27:48.036]         {
[17:27:48.036]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:48.036]                 ...future.oldOptions$nwarnings <- NULL
[17:27:48.036]             }
[17:27:48.036]             base::options(...future.oldOptions)
[17:27:48.036]             if (.Platform$OS.type == "windows") {
[17:27:48.036]                 old_names <- names(...future.oldEnvVars)
[17:27:48.036]                 envs <- base::Sys.getenv()
[17:27:48.036]                 names <- names(envs)
[17:27:48.036]                 common <- intersect(names, old_names)
[17:27:48.036]                 added <- setdiff(names, old_names)
[17:27:48.036]                 removed <- setdiff(old_names, names)
[17:27:48.036]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:48.036]                   envs[common]]
[17:27:48.036]                 NAMES <- toupper(changed)
[17:27:48.036]                 args <- list()
[17:27:48.036]                 for (kk in seq_along(NAMES)) {
[17:27:48.036]                   name <- changed[[kk]]
[17:27:48.036]                   NAME <- NAMES[[kk]]
[17:27:48.036]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.036]                     next
[17:27:48.036]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.036]                 }
[17:27:48.036]                 NAMES <- toupper(added)
[17:27:48.036]                 for (kk in seq_along(NAMES)) {
[17:27:48.036]                   name <- added[[kk]]
[17:27:48.036]                   NAME <- NAMES[[kk]]
[17:27:48.036]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.036]                     next
[17:27:48.036]                   args[[name]] <- ""
[17:27:48.036]                 }
[17:27:48.036]                 NAMES <- toupper(removed)
[17:27:48.036]                 for (kk in seq_along(NAMES)) {
[17:27:48.036]                   name <- removed[[kk]]
[17:27:48.036]                   NAME <- NAMES[[kk]]
[17:27:48.036]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.036]                     next
[17:27:48.036]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.036]                 }
[17:27:48.036]                 if (length(args) > 0) 
[17:27:48.036]                   base::do.call(base::Sys.setenv, args = args)
[17:27:48.036]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:48.036]             }
[17:27:48.036]             else {
[17:27:48.036]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:48.036]             }
[17:27:48.036]             {
[17:27:48.036]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:48.036]                   0L) {
[17:27:48.036]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:48.036]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:48.036]                   base::options(opts)
[17:27:48.036]                 }
[17:27:48.036]                 {
[17:27:48.036]                   {
[17:27:48.036]                     NULL
[17:27:48.036]                     RNGkind("Mersenne-Twister")
[17:27:48.036]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:48.036]                       inherits = FALSE)
[17:27:48.036]                   }
[17:27:48.036]                   options(future.plan = NULL)
[17:27:48.036]                   if (is.na(NA_character_)) 
[17:27:48.036]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.036]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:48.036]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:48.036]                     .init = FALSE)
[17:27:48.036]                 }
[17:27:48.036]             }
[17:27:48.036]         }
[17:27:48.036]     })
[17:27:48.036]     if (TRUE) {
[17:27:48.036]         base::sink(type = "output", split = FALSE)
[17:27:48.036]         if (TRUE) {
[17:27:48.036]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:48.036]         }
[17:27:48.036]         else {
[17:27:48.036]             ...future.result["stdout"] <- base::list(NULL)
[17:27:48.036]         }
[17:27:48.036]         base::close(...future.stdout)
[17:27:48.036]         ...future.stdout <- NULL
[17:27:48.036]     }
[17:27:48.036]     ...future.result$conditions <- ...future.conditions
[17:27:48.036]     ...future.result$finished <- base::Sys.time()
[17:27:48.036]     ...future.result
[17:27:48.036] }
[17:27:48.041] plan(): Setting new future strategy stack:
[17:27:48.041] List of future strategies:
[17:27:48.041] 1. sequential:
[17:27:48.041]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.041]    - tweaked: FALSE
[17:27:48.041]    - call: NULL
[17:27:48.042] plan(): nbrOfWorkers() = 1
[17:27:48.044] plan(): Setting new future strategy stack:
[17:27:48.044] List of future strategies:
[17:27:48.044] 1. sequential:
[17:27:48.044]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.044]    - tweaked: FALSE
[17:27:48.044]    - call: plan(strategy)
[17:27:48.045] plan(): nbrOfWorkers() = 1
[17:27:48.045] SequentialFuture started (and completed)
[17:27:48.045] - Launch lazy future ... done
[17:27:48.045] run() for 'SequentialFuture' ... done

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  

[17:27:48.049] getGlobalsAndPackages() ...
[17:27:48.049] Searching for globals...
[17:27:48.052] - globals found: [7] '{', 'lm', 'dist', '+', '.', '~', 'cars'
[17:27:48.053] Searching for globals ... DONE
[17:27:48.053] Resolving globals: FALSE
[17:27:48.054] 
[17:27:48.054] - packages: [2] 'stats', 'datasets'
[17:27:48.055] getGlobalsAndPackages() ... DONE
[17:27:48.055] run() for 'Future' ...
[17:27:48.056] - state: 'created'
[17:27:48.056] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:48.057] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:48.057] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:48.057]   - Field: 'label'
[17:27:48.058]   - Field: 'local'
[17:27:48.058]   - Field: 'owner'
[17:27:48.058]   - Field: 'envir'
[17:27:48.059]   - Field: 'packages'
[17:27:48.059]   - Field: 'gc'
[17:27:48.059]   - Field: 'conditions'
[17:27:48.060]   - Field: 'expr'
[17:27:48.060]   - Field: 'uuid'
[17:27:48.060]   - Field: 'seed'
[17:27:48.061]   - Field: 'version'
[17:27:48.063]   - Field: 'result'
[17:27:48.063]   - Field: 'asynchronous'
[17:27:48.064]   - Field: 'calls'
[17:27:48.064]   - Field: 'globals'
[17:27:48.065]   - Field: 'stdout'
[17:27:48.065]   - Field: 'earlySignal'
[17:27:48.066]   - Field: 'lazy'
[17:27:48.066]   - Field: 'state'
[17:27:48.066] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:48.067] - Launch lazy future ...
[17:27:48.067] Packages needed by the future expression (n = 2): 'stats', 'datasets'
[17:27:48.068] Packages needed by future strategies (n = 0): <none>
[17:27:48.069] {
[17:27:48.069]     {
[17:27:48.069]         {
[17:27:48.069]             ...future.startTime <- base::Sys.time()
[17:27:48.069]             {
[17:27:48.069]                 {
[17:27:48.069]                   {
[17:27:48.069]                     {
[17:27:48.069]                       base::local({
[17:27:48.069]                         has_future <- base::requireNamespace("future", 
[17:27:48.069]                           quietly = TRUE)
[17:27:48.069]                         if (has_future) {
[17:27:48.069]                           ns <- base::getNamespace("future")
[17:27:48.069]                           version <- ns[[".package"]][["version"]]
[17:27:48.069]                           if (is.null(version)) 
[17:27:48.069]                             version <- utils::packageVersion("future")
[17:27:48.069]                         }
[17:27:48.069]                         else {
[17:27:48.069]                           version <- NULL
[17:27:48.069]                         }
[17:27:48.069]                         if (!has_future || version < "1.8.0") {
[17:27:48.069]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:48.069]                             "", base::R.version$version.string), 
[17:27:48.069]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:48.069]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:48.069]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:48.069]                               "release", "version")], collapse = " "), 
[17:27:48.069]                             hostname = base::Sys.info()[["nodename"]])
[17:27:48.069]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:48.069]                             info)
[17:27:48.069]                           info <- base::paste(info, collapse = "; ")
[17:27:48.069]                           if (!has_future) {
[17:27:48.069]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:48.069]                               info)
[17:27:48.069]                           }
[17:27:48.069]                           else {
[17:27:48.069]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:48.069]                               info, version)
[17:27:48.069]                           }
[17:27:48.069]                           base::stop(msg)
[17:27:48.069]                         }
[17:27:48.069]                       })
[17:27:48.069]                     }
[17:27:48.069]                     base::local({
[17:27:48.069]                       for (pkg in c("stats", "datasets")) {
[17:27:48.069]                         base::loadNamespace(pkg)
[17:27:48.069]                         base::library(pkg, character.only = TRUE)
[17:27:48.069]                       }
[17:27:48.069]                     })
[17:27:48.069]                   }
[17:27:48.069]                   ...future.strategy.old <- future::plan("list")
[17:27:48.069]                   options(future.plan = NULL)
[17:27:48.069]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.069]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:48.069]                 }
[17:27:48.069]                 ...future.workdir <- getwd()
[17:27:48.069]             }
[17:27:48.069]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:48.069]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:48.069]         }
[17:27:48.069]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:48.069]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:48.069]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:48.069]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:48.069]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:48.069]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:48.069]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:48.069]             base::names(...future.oldOptions))
[17:27:48.069]     }
[17:27:48.069]     if (FALSE) {
[17:27:48.069]     }
[17:27:48.069]     else {
[17:27:48.069]         if (TRUE) {
[17:27:48.069]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:48.069]                 open = "w")
[17:27:48.069]         }
[17:27:48.069]         else {
[17:27:48.069]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:48.069]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:48.069]         }
[17:27:48.069]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:48.069]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:48.069]             base::sink(type = "output", split = FALSE)
[17:27:48.069]             base::close(...future.stdout)
[17:27:48.069]         }, add = TRUE)
[17:27:48.069]     }
[17:27:48.069]     ...future.frame <- base::sys.nframe()
[17:27:48.069]     ...future.conditions <- base::list()
[17:27:48.069]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:48.069]     if (FALSE) {
[17:27:48.069]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:48.069]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:48.069]     }
[17:27:48.069]     ...future.result <- base::tryCatch({
[17:27:48.069]         base::withCallingHandlers({
[17:27:48.069]             ...future.value <- base::withVisible(base::local({
[17:27:48.069]                 lm(dist ~ . + 0, data = cars)
[17:27:48.069]             }))
[17:27:48.069]             future::FutureResult(value = ...future.value$value, 
[17:27:48.069]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.069]                   ...future.rng), globalenv = if (FALSE) 
[17:27:48.069]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:48.069]                     ...future.globalenv.names))
[17:27:48.069]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:48.069]         }, condition = base::local({
[17:27:48.069]             c <- base::c
[17:27:48.069]             inherits <- base::inherits
[17:27:48.069]             invokeRestart <- base::invokeRestart
[17:27:48.069]             length <- base::length
[17:27:48.069]             list <- base::list
[17:27:48.069]             seq.int <- base::seq.int
[17:27:48.069]             signalCondition <- base::signalCondition
[17:27:48.069]             sys.calls <- base::sys.calls
[17:27:48.069]             `[[` <- base::`[[`
[17:27:48.069]             `+` <- base::`+`
[17:27:48.069]             `<<-` <- base::`<<-`
[17:27:48.069]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:48.069]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:48.069]                   3L)]
[17:27:48.069]             }
[17:27:48.069]             function(cond) {
[17:27:48.069]                 is_error <- inherits(cond, "error")
[17:27:48.069]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:48.069]                   NULL)
[17:27:48.069]                 if (is_error) {
[17:27:48.069]                   sessionInformation <- function() {
[17:27:48.069]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:48.069]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:48.069]                       search = base::search(), system = base::Sys.info())
[17:27:48.069]                   }
[17:27:48.069]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.069]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:48.069]                     cond$call), session = sessionInformation(), 
[17:27:48.069]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:48.069]                   signalCondition(cond)
[17:27:48.069]                 }
[17:27:48.069]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:48.069]                 "immediateCondition"))) {
[17:27:48.069]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:48.069]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.069]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:48.069]                   if (TRUE && !signal) {
[17:27:48.069]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.069]                     {
[17:27:48.069]                       inherits <- base::inherits
[17:27:48.069]                       invokeRestart <- base::invokeRestart
[17:27:48.069]                       is.null <- base::is.null
[17:27:48.069]                       muffled <- FALSE
[17:27:48.069]                       if (inherits(cond, "message")) {
[17:27:48.069]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.069]                         if (muffled) 
[17:27:48.069]                           invokeRestart("muffleMessage")
[17:27:48.069]                       }
[17:27:48.069]                       else if (inherits(cond, "warning")) {
[17:27:48.069]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.069]                         if (muffled) 
[17:27:48.069]                           invokeRestart("muffleWarning")
[17:27:48.069]                       }
[17:27:48.069]                       else if (inherits(cond, "condition")) {
[17:27:48.069]                         if (!is.null(pattern)) {
[17:27:48.069]                           computeRestarts <- base::computeRestarts
[17:27:48.069]                           grepl <- base::grepl
[17:27:48.069]                           restarts <- computeRestarts(cond)
[17:27:48.069]                           for (restart in restarts) {
[17:27:48.069]                             name <- restart$name
[17:27:48.069]                             if (is.null(name)) 
[17:27:48.069]                               next
[17:27:48.069]                             if (!grepl(pattern, name)) 
[17:27:48.069]                               next
[17:27:48.069]                             invokeRestart(restart)
[17:27:48.069]                             muffled <- TRUE
[17:27:48.069]                             break
[17:27:48.069]                           }
[17:27:48.069]                         }
[17:27:48.069]                       }
[17:27:48.069]                       invisible(muffled)
[17:27:48.069]                     }
[17:27:48.069]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.069]                   }
[17:27:48.069]                 }
[17:27:48.069]                 else {
[17:27:48.069]                   if (TRUE) {
[17:27:48.069]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.069]                     {
[17:27:48.069]                       inherits <- base::inherits
[17:27:48.069]                       invokeRestart <- base::invokeRestart
[17:27:48.069]                       is.null <- base::is.null
[17:27:48.069]                       muffled <- FALSE
[17:27:48.069]                       if (inherits(cond, "message")) {
[17:27:48.069]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.069]                         if (muffled) 
[17:27:48.069]                           invokeRestart("muffleMessage")
[17:27:48.069]                       }
[17:27:48.069]                       else if (inherits(cond, "warning")) {
[17:27:48.069]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.069]                         if (muffled) 
[17:27:48.069]                           invokeRestart("muffleWarning")
[17:27:48.069]                       }
[17:27:48.069]                       else if (inherits(cond, "condition")) {
[17:27:48.069]                         if (!is.null(pattern)) {
[17:27:48.069]                           computeRestarts <- base::computeRestarts
[17:27:48.069]                           grepl <- base::grepl
[17:27:48.069]                           restarts <- computeRestarts(cond)
[17:27:48.069]                           for (restart in restarts) {
[17:27:48.069]                             name <- restart$name
[17:27:48.069]                             if (is.null(name)) 
[17:27:48.069]                               next
[17:27:48.069]                             if (!grepl(pattern, name)) 
[17:27:48.069]                               next
[17:27:48.069]                             invokeRestart(restart)
[17:27:48.069]                             muffled <- TRUE
[17:27:48.069]                             break
[17:27:48.069]                           }
[17:27:48.069]                         }
[17:27:48.069]                       }
[17:27:48.069]                       invisible(muffled)
[17:27:48.069]                     }
[17:27:48.069]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.069]                   }
[17:27:48.069]                 }
[17:27:48.069]             }
[17:27:48.069]         }))
[17:27:48.069]     }, error = function(ex) {
[17:27:48.069]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:48.069]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.069]                 ...future.rng), started = ...future.startTime, 
[17:27:48.069]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:48.069]             version = "1.8"), class = "FutureResult")
[17:27:48.069]     }, finally = {
[17:27:48.069]         if (!identical(...future.workdir, getwd())) 
[17:27:48.069]             setwd(...future.workdir)
[17:27:48.069]         {
[17:27:48.069]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:48.069]                 ...future.oldOptions$nwarnings <- NULL
[17:27:48.069]             }
[17:27:48.069]             base::options(...future.oldOptions)
[17:27:48.069]             if (.Platform$OS.type == "windows") {
[17:27:48.069]                 old_names <- names(...future.oldEnvVars)
[17:27:48.069]                 envs <- base::Sys.getenv()
[17:27:48.069]                 names <- names(envs)
[17:27:48.069]                 common <- intersect(names, old_names)
[17:27:48.069]                 added <- setdiff(names, old_names)
[17:27:48.069]                 removed <- setdiff(old_names, names)
[17:27:48.069]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:48.069]                   envs[common]]
[17:27:48.069]                 NAMES <- toupper(changed)
[17:27:48.069]                 args <- list()
[17:27:48.069]                 for (kk in seq_along(NAMES)) {
[17:27:48.069]                   name <- changed[[kk]]
[17:27:48.069]                   NAME <- NAMES[[kk]]
[17:27:48.069]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.069]                     next
[17:27:48.069]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.069]                 }
[17:27:48.069]                 NAMES <- toupper(added)
[17:27:48.069]                 for (kk in seq_along(NAMES)) {
[17:27:48.069]                   name <- added[[kk]]
[17:27:48.069]                   NAME <- NAMES[[kk]]
[17:27:48.069]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.069]                     next
[17:27:48.069]                   args[[name]] <- ""
[17:27:48.069]                 }
[17:27:48.069]                 NAMES <- toupper(removed)
[17:27:48.069]                 for (kk in seq_along(NAMES)) {
[17:27:48.069]                   name <- removed[[kk]]
[17:27:48.069]                   NAME <- NAMES[[kk]]
[17:27:48.069]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.069]                     next
[17:27:48.069]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.069]                 }
[17:27:48.069]                 if (length(args) > 0) 
[17:27:48.069]                   base::do.call(base::Sys.setenv, args = args)
[17:27:48.069]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:48.069]             }
[17:27:48.069]             else {
[17:27:48.069]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:48.069]             }
[17:27:48.069]             {
[17:27:48.069]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:48.069]                   0L) {
[17:27:48.069]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:48.069]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:48.069]                   base::options(opts)
[17:27:48.069]                 }
[17:27:48.069]                 {
[17:27:48.069]                   {
[17:27:48.069]                     NULL
[17:27:48.069]                     RNGkind("Mersenne-Twister")
[17:27:48.069]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:48.069]                       inherits = FALSE)
[17:27:48.069]                   }
[17:27:48.069]                   options(future.plan = NULL)
[17:27:48.069]                   if (is.na(NA_character_)) 
[17:27:48.069]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.069]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:48.069]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:48.069]                     .init = FALSE)
[17:27:48.069]                 }
[17:27:48.069]             }
[17:27:48.069]         }
[17:27:48.069]     })
[17:27:48.069]     if (TRUE) {
[17:27:48.069]         base::sink(type = "output", split = FALSE)
[17:27:48.069]         if (TRUE) {
[17:27:48.069]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:48.069]         }
[17:27:48.069]         else {
[17:27:48.069]             ...future.result["stdout"] <- base::list(NULL)
[17:27:48.069]         }
[17:27:48.069]         base::close(...future.stdout)
[17:27:48.069]         ...future.stdout <- NULL
[17:27:48.069]     }
[17:27:48.069]     ...future.result$conditions <- ...future.conditions
[17:27:48.069]     ...future.result$finished <- base::Sys.time()
[17:27:48.069]     ...future.result
[17:27:48.069] }
[17:27:48.077] plan(): Setting new future strategy stack:
[17:27:48.077] List of future strategies:
[17:27:48.077] 1. sequential:
[17:27:48.077]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.077]    - tweaked: FALSE
[17:27:48.077]    - call: NULL
[17:27:48.079] plan(): nbrOfWorkers() = 1
[17:27:48.082] plan(): Setting new future strategy stack:
[17:27:48.082] List of future strategies:
[17:27:48.082] 1. sequential:
[17:27:48.082]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.082]    - tweaked: FALSE
[17:27:48.082]    - call: plan(strategy)
[17:27:48.083] plan(): nbrOfWorkers() = 1
[17:27:48.084] SequentialFuture started (and completed)
[17:27:48.084] - Launch lazy future ... done
[17:27:48.085] run() for 'SequentialFuture' ... done

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  

[17:27:48.090] getGlobalsAndPackages() ...
[17:27:48.090] Searching for globals...
[17:27:48.094] - globals found: [8] '{', 'lm', 'dist', '+', 'speed', '^', '~', 'cars'
[17:27:48.095] Searching for globals ... DONE
[17:27:48.095] Resolving globals: FALSE
[17:27:48.096] 
[17:27:48.097] - packages: [2] 'stats', 'datasets'
[17:27:48.097] getGlobalsAndPackages() ... DONE
[17:27:48.098] run() for 'Future' ...
[17:27:48.098] - state: 'created'
[17:27:48.098] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:48.099] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:48.099] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:48.100]   - Field: 'label'
[17:27:48.100]   - Field: 'local'
[17:27:48.100]   - Field: 'owner'
[17:27:48.101]   - Field: 'envir'
[17:27:48.101]   - Field: 'packages'
[17:27:48.101]   - Field: 'gc'
[17:27:48.102]   - Field: 'conditions'
[17:27:48.102]   - Field: 'expr'
[17:27:48.102]   - Field: 'uuid'
[17:27:48.103]   - Field: 'seed'
[17:27:48.103]   - Field: 'version'
[17:27:48.103]   - Field: 'result'
[17:27:48.103]   - Field: 'asynchronous'
[17:27:48.104]   - Field: 'calls'
[17:27:48.104]   - Field: 'globals'
[17:27:48.104]   - Field: 'stdout'
[17:27:48.105]   - Field: 'earlySignal'
[17:27:48.105]   - Field: 'lazy'
[17:27:48.105]   - Field: 'state'
[17:27:48.106] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:48.106] - Launch lazy future ...
[17:27:48.106] Packages needed by the future expression (n = 2): 'stats', 'datasets'
[17:27:48.107] Packages needed by future strategies (n = 0): <none>
[17:27:48.108] {
[17:27:48.108]     {
[17:27:48.108]         {
[17:27:48.108]             ...future.startTime <- base::Sys.time()
[17:27:48.108]             {
[17:27:48.108]                 {
[17:27:48.108]                   {
[17:27:48.108]                     {
[17:27:48.108]                       base::local({
[17:27:48.108]                         has_future <- base::requireNamespace("future", 
[17:27:48.108]                           quietly = TRUE)
[17:27:48.108]                         if (has_future) {
[17:27:48.108]                           ns <- base::getNamespace("future")
[17:27:48.108]                           version <- ns[[".package"]][["version"]]
[17:27:48.108]                           if (is.null(version)) 
[17:27:48.108]                             version <- utils::packageVersion("future")
[17:27:48.108]                         }
[17:27:48.108]                         else {
[17:27:48.108]                           version <- NULL
[17:27:48.108]                         }
[17:27:48.108]                         if (!has_future || version < "1.8.0") {
[17:27:48.108]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:48.108]                             "", base::R.version$version.string), 
[17:27:48.108]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:48.108]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:48.108]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:48.108]                               "release", "version")], collapse = " "), 
[17:27:48.108]                             hostname = base::Sys.info()[["nodename"]])
[17:27:48.108]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:48.108]                             info)
[17:27:48.108]                           info <- base::paste(info, collapse = "; ")
[17:27:48.108]                           if (!has_future) {
[17:27:48.108]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:48.108]                               info)
[17:27:48.108]                           }
[17:27:48.108]                           else {
[17:27:48.108]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:48.108]                               info, version)
[17:27:48.108]                           }
[17:27:48.108]                           base::stop(msg)
[17:27:48.108]                         }
[17:27:48.108]                       })
[17:27:48.108]                     }
[17:27:48.108]                     base::local({
[17:27:48.108]                       for (pkg in c("stats", "datasets")) {
[17:27:48.108]                         base::loadNamespace(pkg)
[17:27:48.108]                         base::library(pkg, character.only = TRUE)
[17:27:48.108]                       }
[17:27:48.108]                     })
[17:27:48.108]                   }
[17:27:48.108]                   ...future.strategy.old <- future::plan("list")
[17:27:48.108]                   options(future.plan = NULL)
[17:27:48.108]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.108]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:48.108]                 }
[17:27:48.108]                 ...future.workdir <- getwd()
[17:27:48.108]             }
[17:27:48.108]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:48.108]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:48.108]         }
[17:27:48.108]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:48.108]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:48.108]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:48.108]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:48.108]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:48.108]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:48.108]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:48.108]             base::names(...future.oldOptions))
[17:27:48.108]     }
[17:27:48.108]     if (FALSE) {
[17:27:48.108]     }
[17:27:48.108]     else {
[17:27:48.108]         if (TRUE) {
[17:27:48.108]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:48.108]                 open = "w")
[17:27:48.108]         }
[17:27:48.108]         else {
[17:27:48.108]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:48.108]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:48.108]         }
[17:27:48.108]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:48.108]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:48.108]             base::sink(type = "output", split = FALSE)
[17:27:48.108]             base::close(...future.stdout)
[17:27:48.108]         }, add = TRUE)
[17:27:48.108]     }
[17:27:48.108]     ...future.frame <- base::sys.nframe()
[17:27:48.108]     ...future.conditions <- base::list()
[17:27:48.108]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:48.108]     if (FALSE) {
[17:27:48.108]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:48.108]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:48.108]     }
[17:27:48.108]     ...future.result <- base::tryCatch({
[17:27:48.108]         base::withCallingHandlers({
[17:27:48.108]             ...future.value <- base::withVisible(base::local({
[17:27:48.108]                 lm(dist ~ speed + speed^2, data = cars)
[17:27:48.108]             }))
[17:27:48.108]             future::FutureResult(value = ...future.value$value, 
[17:27:48.108]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.108]                   ...future.rng), globalenv = if (FALSE) 
[17:27:48.108]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:48.108]                     ...future.globalenv.names))
[17:27:48.108]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:48.108]         }, condition = base::local({
[17:27:48.108]             c <- base::c
[17:27:48.108]             inherits <- base::inherits
[17:27:48.108]             invokeRestart <- base::invokeRestart
[17:27:48.108]             length <- base::length
[17:27:48.108]             list <- base::list
[17:27:48.108]             seq.int <- base::seq.int
[17:27:48.108]             signalCondition <- base::signalCondition
[17:27:48.108]             sys.calls <- base::sys.calls
[17:27:48.108]             `[[` <- base::`[[`
[17:27:48.108]             `+` <- base::`+`
[17:27:48.108]             `<<-` <- base::`<<-`
[17:27:48.108]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:48.108]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:48.108]                   3L)]
[17:27:48.108]             }
[17:27:48.108]             function(cond) {
[17:27:48.108]                 is_error <- inherits(cond, "error")
[17:27:48.108]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:48.108]                   NULL)
[17:27:48.108]                 if (is_error) {
[17:27:48.108]                   sessionInformation <- function() {
[17:27:48.108]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:48.108]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:48.108]                       search = base::search(), system = base::Sys.info())
[17:27:48.108]                   }
[17:27:48.108]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.108]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:48.108]                     cond$call), session = sessionInformation(), 
[17:27:48.108]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:48.108]                   signalCondition(cond)
[17:27:48.108]                 }
[17:27:48.108]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:48.108]                 "immediateCondition"))) {
[17:27:48.108]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:48.108]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.108]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:48.108]                   if (TRUE && !signal) {
[17:27:48.108]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.108]                     {
[17:27:48.108]                       inherits <- base::inherits
[17:27:48.108]                       invokeRestart <- base::invokeRestart
[17:27:48.108]                       is.null <- base::is.null
[17:27:48.108]                       muffled <- FALSE
[17:27:48.108]                       if (inherits(cond, "message")) {
[17:27:48.108]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.108]                         if (muffled) 
[17:27:48.108]                           invokeRestart("muffleMessage")
[17:27:48.108]                       }
[17:27:48.108]                       else if (inherits(cond, "warning")) {
[17:27:48.108]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.108]                         if (muffled) 
[17:27:48.108]                           invokeRestart("muffleWarning")
[17:27:48.108]                       }
[17:27:48.108]                       else if (inherits(cond, "condition")) {
[17:27:48.108]                         if (!is.null(pattern)) {
[17:27:48.108]                           computeRestarts <- base::computeRestarts
[17:27:48.108]                           grepl <- base::grepl
[17:27:48.108]                           restarts <- computeRestarts(cond)
[17:27:48.108]                           for (restart in restarts) {
[17:27:48.108]                             name <- restart$name
[17:27:48.108]                             if (is.null(name)) 
[17:27:48.108]                               next
[17:27:48.108]                             if (!grepl(pattern, name)) 
[17:27:48.108]                               next
[17:27:48.108]                             invokeRestart(restart)
[17:27:48.108]                             muffled <- TRUE
[17:27:48.108]                             break
[17:27:48.108]                           }
[17:27:48.108]                         }
[17:27:48.108]                       }
[17:27:48.108]                       invisible(muffled)
[17:27:48.108]                     }
[17:27:48.108]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.108]                   }
[17:27:48.108]                 }
[17:27:48.108]                 else {
[17:27:48.108]                   if (TRUE) {
[17:27:48.108]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.108]                     {
[17:27:48.108]                       inherits <- base::inherits
[17:27:48.108]                       invokeRestart <- base::invokeRestart
[17:27:48.108]                       is.null <- base::is.null
[17:27:48.108]                       muffled <- FALSE
[17:27:48.108]                       if (inherits(cond, "message")) {
[17:27:48.108]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.108]                         if (muffled) 
[17:27:48.108]                           invokeRestart("muffleMessage")
[17:27:48.108]                       }
[17:27:48.108]                       else if (inherits(cond, "warning")) {
[17:27:48.108]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.108]                         if (muffled) 
[17:27:48.108]                           invokeRestart("muffleWarning")
[17:27:48.108]                       }
[17:27:48.108]                       else if (inherits(cond, "condition")) {
[17:27:48.108]                         if (!is.null(pattern)) {
[17:27:48.108]                           computeRestarts <- base::computeRestarts
[17:27:48.108]                           grepl <- base::grepl
[17:27:48.108]                           restarts <- computeRestarts(cond)
[17:27:48.108]                           for (restart in restarts) {
[17:27:48.108]                             name <- restart$name
[17:27:48.108]                             if (is.null(name)) 
[17:27:48.108]                               next
[17:27:48.108]                             if (!grepl(pattern, name)) 
[17:27:48.108]                               next
[17:27:48.108]                             invokeRestart(restart)
[17:27:48.108]                             muffled <- TRUE
[17:27:48.108]                             break
[17:27:48.108]                           }
[17:27:48.108]                         }
[17:27:48.108]                       }
[17:27:48.108]                       invisible(muffled)
[17:27:48.108]                     }
[17:27:48.108]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.108]                   }
[17:27:48.108]                 }
[17:27:48.108]             }
[17:27:48.108]         }))
[17:27:48.108]     }, error = function(ex) {
[17:27:48.108]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:48.108]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.108]                 ...future.rng), started = ...future.startTime, 
[17:27:48.108]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:48.108]             version = "1.8"), class = "FutureResult")
[17:27:48.108]     }, finally = {
[17:27:48.108]         if (!identical(...future.workdir, getwd())) 
[17:27:48.108]             setwd(...future.workdir)
[17:27:48.108]         {
[17:27:48.108]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:48.108]                 ...future.oldOptions$nwarnings <- NULL
[17:27:48.108]             }
[17:27:48.108]             base::options(...future.oldOptions)
[17:27:48.108]             if (.Platform$OS.type == "windows") {
[17:27:48.108]                 old_names <- names(...future.oldEnvVars)
[17:27:48.108]                 envs <- base::Sys.getenv()
[17:27:48.108]                 names <- names(envs)
[17:27:48.108]                 common <- intersect(names, old_names)
[17:27:48.108]                 added <- setdiff(names, old_names)
[17:27:48.108]                 removed <- setdiff(old_names, names)
[17:27:48.108]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:48.108]                   envs[common]]
[17:27:48.108]                 NAMES <- toupper(changed)
[17:27:48.108]                 args <- list()
[17:27:48.108]                 for (kk in seq_along(NAMES)) {
[17:27:48.108]                   name <- changed[[kk]]
[17:27:48.108]                   NAME <- NAMES[[kk]]
[17:27:48.108]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.108]                     next
[17:27:48.108]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.108]                 }
[17:27:48.108]                 NAMES <- toupper(added)
[17:27:48.108]                 for (kk in seq_along(NAMES)) {
[17:27:48.108]                   name <- added[[kk]]
[17:27:48.108]                   NAME <- NAMES[[kk]]
[17:27:48.108]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.108]                     next
[17:27:48.108]                   args[[name]] <- ""
[17:27:48.108]                 }
[17:27:48.108]                 NAMES <- toupper(removed)
[17:27:48.108]                 for (kk in seq_along(NAMES)) {
[17:27:48.108]                   name <- removed[[kk]]
[17:27:48.108]                   NAME <- NAMES[[kk]]
[17:27:48.108]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.108]                     next
[17:27:48.108]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.108]                 }
[17:27:48.108]                 if (length(args) > 0) 
[17:27:48.108]                   base::do.call(base::Sys.setenv, args = args)
[17:27:48.108]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:48.108]             }
[17:27:48.108]             else {
[17:27:48.108]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:48.108]             }
[17:27:48.108]             {
[17:27:48.108]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:48.108]                   0L) {
[17:27:48.108]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:48.108]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:48.108]                   base::options(opts)
[17:27:48.108]                 }
[17:27:48.108]                 {
[17:27:48.108]                   {
[17:27:48.108]                     NULL
[17:27:48.108]                     RNGkind("Mersenne-Twister")
[17:27:48.108]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:48.108]                       inherits = FALSE)
[17:27:48.108]                   }
[17:27:48.108]                   options(future.plan = NULL)
[17:27:48.108]                   if (is.na(NA_character_)) 
[17:27:48.108]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.108]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:48.108]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:48.108]                     .init = FALSE)
[17:27:48.108]                 }
[17:27:48.108]             }
[17:27:48.108]         }
[17:27:48.108]     })
[17:27:48.108]     if (TRUE) {
[17:27:48.108]         base::sink(type = "output", split = FALSE)
[17:27:48.108]         if (TRUE) {
[17:27:48.108]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:48.108]         }
[17:27:48.108]         else {
[17:27:48.108]             ...future.result["stdout"] <- base::list(NULL)
[17:27:48.108]         }
[17:27:48.108]         base::close(...future.stdout)
[17:27:48.108]         ...future.stdout <- NULL
[17:27:48.108]     }
[17:27:48.108]     ...future.result$conditions <- ...future.conditions
[17:27:48.108]     ...future.result$finished <- base::Sys.time()
[17:27:48.108]     ...future.result
[17:27:48.108] }
[17:27:48.116] plan(): Setting new future strategy stack:
[17:27:48.116] List of future strategies:
[17:27:48.116] 1. sequential:
[17:27:48.116]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.116]    - tweaked: FALSE
[17:27:48.116]    - call: NULL
[17:27:48.117] plan(): nbrOfWorkers() = 1
[17:27:48.123] plan(): Setting new future strategy stack:
[17:27:48.124] List of future strategies:
[17:27:48.124] 1. sequential:
[17:27:48.124]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.124]    - tweaked: FALSE
[17:27:48.124]    - call: plan(strategy)
[17:27:48.125] plan(): nbrOfWorkers() = 1
[17:27:48.125] SequentialFuture started (and completed)
[17:27:48.126] - Launch lazy future ... done
[17:27:48.126] run() for 'SequentialFuture' ... done

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  

[17:27:48.132] getGlobalsAndPackages() ...
[17:27:48.132] Searching for globals...
[17:27:48.137] - globals found: [9] '{', 'lm', 'dist', '+', 'speed', 'I', '^', '~', 'cars'
[17:27:48.137] Searching for globals ... DONE
[17:27:48.137] Resolving globals: FALSE
[17:27:48.139] 
[17:27:48.139] - packages: [2] 'stats', 'datasets'
[17:27:48.139] getGlobalsAndPackages() ... DONE
[17:27:48.140] run() for 'Future' ...
[17:27:48.140] - state: 'created'
[17:27:48.141] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:48.141] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:48.142] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:48.142]   - Field: 'label'
[17:27:48.142]   - Field: 'local'
[17:27:48.143]   - Field: 'owner'
[17:27:48.143]   - Field: 'envir'
[17:27:48.143]   - Field: 'packages'
[17:27:48.144]   - Field: 'gc'
[17:27:48.144]   - Field: 'conditions'
[17:27:48.144]   - Field: 'expr'
[17:27:48.145]   - Field: 'uuid'
[17:27:48.145]   - Field: 'seed'
[17:27:48.145]   - Field: 'version'
[17:27:48.145]   - Field: 'result'
[17:27:48.146]   - Field: 'asynchronous'
[17:27:48.146]   - Field: 'calls'
[17:27:48.146]   - Field: 'globals'
[17:27:48.147]   - Field: 'stdout'
[17:27:48.147]   - Field: 'earlySignal'
[17:27:48.147]   - Field: 'lazy'
[17:27:48.148]   - Field: 'state'
[17:27:48.148] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:48.148] - Launch lazy future ...
[17:27:48.149] Packages needed by the future expression (n = 2): 'stats', 'datasets'
[17:27:48.149] Packages needed by future strategies (n = 0): <none>
[17:27:48.150] {
[17:27:48.150]     {
[17:27:48.150]         {
[17:27:48.150]             ...future.startTime <- base::Sys.time()
[17:27:48.150]             {
[17:27:48.150]                 {
[17:27:48.150]                   {
[17:27:48.150]                     {
[17:27:48.150]                       base::local({
[17:27:48.150]                         has_future <- base::requireNamespace("future", 
[17:27:48.150]                           quietly = TRUE)
[17:27:48.150]                         if (has_future) {
[17:27:48.150]                           ns <- base::getNamespace("future")
[17:27:48.150]                           version <- ns[[".package"]][["version"]]
[17:27:48.150]                           if (is.null(version)) 
[17:27:48.150]                             version <- utils::packageVersion("future")
[17:27:48.150]                         }
[17:27:48.150]                         else {
[17:27:48.150]                           version <- NULL
[17:27:48.150]                         }
[17:27:48.150]                         if (!has_future || version < "1.8.0") {
[17:27:48.150]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:48.150]                             "", base::R.version$version.string), 
[17:27:48.150]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:48.150]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:48.150]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:48.150]                               "release", "version")], collapse = " "), 
[17:27:48.150]                             hostname = base::Sys.info()[["nodename"]])
[17:27:48.150]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:48.150]                             info)
[17:27:48.150]                           info <- base::paste(info, collapse = "; ")
[17:27:48.150]                           if (!has_future) {
[17:27:48.150]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:48.150]                               info)
[17:27:48.150]                           }
[17:27:48.150]                           else {
[17:27:48.150]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:48.150]                               info, version)
[17:27:48.150]                           }
[17:27:48.150]                           base::stop(msg)
[17:27:48.150]                         }
[17:27:48.150]                       })
[17:27:48.150]                     }
[17:27:48.150]                     base::local({
[17:27:48.150]                       for (pkg in c("stats", "datasets")) {
[17:27:48.150]                         base::loadNamespace(pkg)
[17:27:48.150]                         base::library(pkg, character.only = TRUE)
[17:27:48.150]                       }
[17:27:48.150]                     })
[17:27:48.150]                   }
[17:27:48.150]                   ...future.strategy.old <- future::plan("list")
[17:27:48.150]                   options(future.plan = NULL)
[17:27:48.150]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.150]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:48.150]                 }
[17:27:48.150]                 ...future.workdir <- getwd()
[17:27:48.150]             }
[17:27:48.150]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:48.150]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:48.150]         }
[17:27:48.150]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:48.150]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:48.150]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:48.150]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:48.150]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:48.150]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:48.150]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:48.150]             base::names(...future.oldOptions))
[17:27:48.150]     }
[17:27:48.150]     if (FALSE) {
[17:27:48.150]     }
[17:27:48.150]     else {
[17:27:48.150]         if (TRUE) {
[17:27:48.150]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:48.150]                 open = "w")
[17:27:48.150]         }
[17:27:48.150]         else {
[17:27:48.150]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:48.150]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:48.150]         }
[17:27:48.150]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:48.150]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:48.150]             base::sink(type = "output", split = FALSE)
[17:27:48.150]             base::close(...future.stdout)
[17:27:48.150]         }, add = TRUE)
[17:27:48.150]     }
[17:27:48.150]     ...future.frame <- base::sys.nframe()
[17:27:48.150]     ...future.conditions <- base::list()
[17:27:48.150]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:48.150]     if (FALSE) {
[17:27:48.150]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:48.150]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:48.150]     }
[17:27:48.150]     ...future.result <- base::tryCatch({
[17:27:48.150]         base::withCallingHandlers({
[17:27:48.150]             ...future.value <- base::withVisible(base::local({
[17:27:48.150]                 lm(dist ~ speed + I(speed^2), data = cars)
[17:27:48.150]             }))
[17:27:48.150]             future::FutureResult(value = ...future.value$value, 
[17:27:48.150]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.150]                   ...future.rng), globalenv = if (FALSE) 
[17:27:48.150]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:48.150]                     ...future.globalenv.names))
[17:27:48.150]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:48.150]         }, condition = base::local({
[17:27:48.150]             c <- base::c
[17:27:48.150]             inherits <- base::inherits
[17:27:48.150]             invokeRestart <- base::invokeRestart
[17:27:48.150]             length <- base::length
[17:27:48.150]             list <- base::list
[17:27:48.150]             seq.int <- base::seq.int
[17:27:48.150]             signalCondition <- base::signalCondition
[17:27:48.150]             sys.calls <- base::sys.calls
[17:27:48.150]             `[[` <- base::`[[`
[17:27:48.150]             `+` <- base::`+`
[17:27:48.150]             `<<-` <- base::`<<-`
[17:27:48.150]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:48.150]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:48.150]                   3L)]
[17:27:48.150]             }
[17:27:48.150]             function(cond) {
[17:27:48.150]                 is_error <- inherits(cond, "error")
[17:27:48.150]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:48.150]                   NULL)
[17:27:48.150]                 if (is_error) {
[17:27:48.150]                   sessionInformation <- function() {
[17:27:48.150]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:48.150]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:48.150]                       search = base::search(), system = base::Sys.info())
[17:27:48.150]                   }
[17:27:48.150]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.150]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:48.150]                     cond$call), session = sessionInformation(), 
[17:27:48.150]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:48.150]                   signalCondition(cond)
[17:27:48.150]                 }
[17:27:48.150]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:48.150]                 "immediateCondition"))) {
[17:27:48.150]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:48.150]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.150]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:48.150]                   if (TRUE && !signal) {
[17:27:48.150]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.150]                     {
[17:27:48.150]                       inherits <- base::inherits
[17:27:48.150]                       invokeRestart <- base::invokeRestart
[17:27:48.150]                       is.null <- base::is.null
[17:27:48.150]                       muffled <- FALSE
[17:27:48.150]                       if (inherits(cond, "message")) {
[17:27:48.150]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.150]                         if (muffled) 
[17:27:48.150]                           invokeRestart("muffleMessage")
[17:27:48.150]                       }
[17:27:48.150]                       else if (inherits(cond, "warning")) {
[17:27:48.150]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.150]                         if (muffled) 
[17:27:48.150]                           invokeRestart("muffleWarning")
[17:27:48.150]                       }
[17:27:48.150]                       else if (inherits(cond, "condition")) {
[17:27:48.150]                         if (!is.null(pattern)) {
[17:27:48.150]                           computeRestarts <- base::computeRestarts
[17:27:48.150]                           grepl <- base::grepl
[17:27:48.150]                           restarts <- computeRestarts(cond)
[17:27:48.150]                           for (restart in restarts) {
[17:27:48.150]                             name <- restart$name
[17:27:48.150]                             if (is.null(name)) 
[17:27:48.150]                               next
[17:27:48.150]                             if (!grepl(pattern, name)) 
[17:27:48.150]                               next
[17:27:48.150]                             invokeRestart(restart)
[17:27:48.150]                             muffled <- TRUE
[17:27:48.150]                             break
[17:27:48.150]                           }
[17:27:48.150]                         }
[17:27:48.150]                       }
[17:27:48.150]                       invisible(muffled)
[17:27:48.150]                     }
[17:27:48.150]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.150]                   }
[17:27:48.150]                 }
[17:27:48.150]                 else {
[17:27:48.150]                   if (TRUE) {
[17:27:48.150]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.150]                     {
[17:27:48.150]                       inherits <- base::inherits
[17:27:48.150]                       invokeRestart <- base::invokeRestart
[17:27:48.150]                       is.null <- base::is.null
[17:27:48.150]                       muffled <- FALSE
[17:27:48.150]                       if (inherits(cond, "message")) {
[17:27:48.150]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.150]                         if (muffled) 
[17:27:48.150]                           invokeRestart("muffleMessage")
[17:27:48.150]                       }
[17:27:48.150]                       else if (inherits(cond, "warning")) {
[17:27:48.150]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.150]                         if (muffled) 
[17:27:48.150]                           invokeRestart("muffleWarning")
[17:27:48.150]                       }
[17:27:48.150]                       else if (inherits(cond, "condition")) {
[17:27:48.150]                         if (!is.null(pattern)) {
[17:27:48.150]                           computeRestarts <- base::computeRestarts
[17:27:48.150]                           grepl <- base::grepl
[17:27:48.150]                           restarts <- computeRestarts(cond)
[17:27:48.150]                           for (restart in restarts) {
[17:27:48.150]                             name <- restart$name
[17:27:48.150]                             if (is.null(name)) 
[17:27:48.150]                               next
[17:27:48.150]                             if (!grepl(pattern, name)) 
[17:27:48.150]                               next
[17:27:48.150]                             invokeRestart(restart)
[17:27:48.150]                             muffled <- TRUE
[17:27:48.150]                             break
[17:27:48.150]                           }
[17:27:48.150]                         }
[17:27:48.150]                       }
[17:27:48.150]                       invisible(muffled)
[17:27:48.150]                     }
[17:27:48.150]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.150]                   }
[17:27:48.150]                 }
[17:27:48.150]             }
[17:27:48.150]         }))
[17:27:48.150]     }, error = function(ex) {
[17:27:48.150]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:48.150]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.150]                 ...future.rng), started = ...future.startTime, 
[17:27:48.150]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:48.150]             version = "1.8"), class = "FutureResult")
[17:27:48.150]     }, finally = {
[17:27:48.150]         if (!identical(...future.workdir, getwd())) 
[17:27:48.150]             setwd(...future.workdir)
[17:27:48.150]         {
[17:27:48.150]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:48.150]                 ...future.oldOptions$nwarnings <- NULL
[17:27:48.150]             }
[17:27:48.150]             base::options(...future.oldOptions)
[17:27:48.150]             if (.Platform$OS.type == "windows") {
[17:27:48.150]                 old_names <- names(...future.oldEnvVars)
[17:27:48.150]                 envs <- base::Sys.getenv()
[17:27:48.150]                 names <- names(envs)
[17:27:48.150]                 common <- intersect(names, old_names)
[17:27:48.150]                 added <- setdiff(names, old_names)
[17:27:48.150]                 removed <- setdiff(old_names, names)
[17:27:48.150]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:48.150]                   envs[common]]
[17:27:48.150]                 NAMES <- toupper(changed)
[17:27:48.150]                 args <- list()
[17:27:48.150]                 for (kk in seq_along(NAMES)) {
[17:27:48.150]                   name <- changed[[kk]]
[17:27:48.150]                   NAME <- NAMES[[kk]]
[17:27:48.150]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.150]                     next
[17:27:48.150]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.150]                 }
[17:27:48.150]                 NAMES <- toupper(added)
[17:27:48.150]                 for (kk in seq_along(NAMES)) {
[17:27:48.150]                   name <- added[[kk]]
[17:27:48.150]                   NAME <- NAMES[[kk]]
[17:27:48.150]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.150]                     next
[17:27:48.150]                   args[[name]] <- ""
[17:27:48.150]                 }
[17:27:48.150]                 NAMES <- toupper(removed)
[17:27:48.150]                 for (kk in seq_along(NAMES)) {
[17:27:48.150]                   name <- removed[[kk]]
[17:27:48.150]                   NAME <- NAMES[[kk]]
[17:27:48.150]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.150]                     next
[17:27:48.150]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.150]                 }
[17:27:48.150]                 if (length(args) > 0) 
[17:27:48.150]                   base::do.call(base::Sys.setenv, args = args)
[17:27:48.150]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:48.150]             }
[17:27:48.150]             else {
[17:27:48.150]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:48.150]             }
[17:27:48.150]             {
[17:27:48.150]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:48.150]                   0L) {
[17:27:48.150]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:48.150]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:48.150]                   base::options(opts)
[17:27:48.150]                 }
[17:27:48.150]                 {
[17:27:48.150]                   {
[17:27:48.150]                     NULL
[17:27:48.150]                     RNGkind("Mersenne-Twister")
[17:27:48.150]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:48.150]                       inherits = FALSE)
[17:27:48.150]                   }
[17:27:48.150]                   options(future.plan = NULL)
[17:27:48.150]                   if (is.na(NA_character_)) 
[17:27:48.150]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.150]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:48.150]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:48.150]                     .init = FALSE)
[17:27:48.150]                 }
[17:27:48.150]             }
[17:27:48.150]         }
[17:27:48.150]     })
[17:27:48.150]     if (TRUE) {
[17:27:48.150]         base::sink(type = "output", split = FALSE)
[17:27:48.150]         if (TRUE) {
[17:27:48.150]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:48.150]         }
[17:27:48.150]         else {
[17:27:48.150]             ...future.result["stdout"] <- base::list(NULL)
[17:27:48.150]         }
[17:27:48.150]         base::close(...future.stdout)
[17:27:48.150]         ...future.stdout <- NULL
[17:27:48.150]     }
[17:27:48.150]     ...future.result$conditions <- ...future.conditions
[17:27:48.150]     ...future.result$finished <- base::Sys.time()
[17:27:48.150]     ...future.result
[17:27:48.150] }
[17:27:48.158] plan(): Setting new future strategy stack:
[17:27:48.159] List of future strategies:
[17:27:48.159] 1. sequential:
[17:27:48.159]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.159]    - tweaked: FALSE
[17:27:48.159]    - call: NULL
[17:27:48.160] plan(): nbrOfWorkers() = 1
[17:27:48.163] plan(): Setting new future strategy stack:
[17:27:48.163] List of future strategies:
[17:27:48.163] 1. sequential:
[17:27:48.163]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.163]    - tweaked: FALSE
[17:27:48.163]    - call: plan(strategy)
[17:27:48.164] plan(): nbrOfWorkers() = 1
[17:27:48.164] SequentialFuture started (and completed)
[17:27:48.165] - Launch lazy future ... done
[17:27:48.165] run() for 'SequentialFuture' ... done

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  

[17:27:48.174] getGlobalsAndPackages() ...
[17:27:48.174] Searching for globals...
[17:27:48.178] - globals found: [7] '{', 'lm', 'dist', 'poly', 'speed', '~', 'cars'
[17:27:48.178] Searching for globals ... DONE
[17:27:48.178] Resolving globals: FALSE
[17:27:48.179] 
[17:27:48.180] - packages: [2] 'stats', 'datasets'
[17:27:48.180] getGlobalsAndPackages() ... DONE
[17:27:48.181] run() for 'Future' ...
[17:27:48.181] - state: 'created'
[17:27:48.181] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:48.182] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:48.182] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:48.183]   - Field: 'label'
[17:27:48.183]   - Field: 'local'
[17:27:48.183]   - Field: 'owner'
[17:27:48.184]   - Field: 'envir'
[17:27:48.184]   - Field: 'packages'
[17:27:48.184]   - Field: 'gc'
[17:27:48.185]   - Field: 'conditions'
[17:27:48.185]   - Field: 'expr'
[17:27:48.185]   - Field: 'uuid'
[17:27:48.186]   - Field: 'seed'
[17:27:48.186]   - Field: 'version'
[17:27:48.186]   - Field: 'result'
[17:27:48.187]   - Field: 'asynchronous'
[17:27:48.187]   - Field: 'calls'
[17:27:48.187]   - Field: 'globals'
[17:27:48.188]   - Field: 'stdout'
[17:27:48.188]   - Field: 'earlySignal'
[17:27:48.188]   - Field: 'lazy'
[17:27:48.188]   - Field: 'state'
[17:27:48.189] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:48.189] - Launch lazy future ...
[17:27:48.190] Packages needed by the future expression (n = 2): 'stats', 'datasets'
[17:27:48.190] Packages needed by future strategies (n = 0): <none>
[17:27:48.191] {
[17:27:48.191]     {
[17:27:48.191]         {
[17:27:48.191]             ...future.startTime <- base::Sys.time()
[17:27:48.191]             {
[17:27:48.191]                 {
[17:27:48.191]                   {
[17:27:48.191]                     {
[17:27:48.191]                       base::local({
[17:27:48.191]                         has_future <- base::requireNamespace("future", 
[17:27:48.191]                           quietly = TRUE)
[17:27:48.191]                         if (has_future) {
[17:27:48.191]                           ns <- base::getNamespace("future")
[17:27:48.191]                           version <- ns[[".package"]][["version"]]
[17:27:48.191]                           if (is.null(version)) 
[17:27:48.191]                             version <- utils::packageVersion("future")
[17:27:48.191]                         }
[17:27:48.191]                         else {
[17:27:48.191]                           version <- NULL
[17:27:48.191]                         }
[17:27:48.191]                         if (!has_future || version < "1.8.0") {
[17:27:48.191]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:48.191]                             "", base::R.version$version.string), 
[17:27:48.191]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:48.191]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:48.191]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:48.191]                               "release", "version")], collapse = " "), 
[17:27:48.191]                             hostname = base::Sys.info()[["nodename"]])
[17:27:48.191]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:48.191]                             info)
[17:27:48.191]                           info <- base::paste(info, collapse = "; ")
[17:27:48.191]                           if (!has_future) {
[17:27:48.191]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:48.191]                               info)
[17:27:48.191]                           }
[17:27:48.191]                           else {
[17:27:48.191]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:48.191]                               info, version)
[17:27:48.191]                           }
[17:27:48.191]                           base::stop(msg)
[17:27:48.191]                         }
[17:27:48.191]                       })
[17:27:48.191]                     }
[17:27:48.191]                     base::local({
[17:27:48.191]                       for (pkg in c("stats", "datasets")) {
[17:27:48.191]                         base::loadNamespace(pkg)
[17:27:48.191]                         base::library(pkg, character.only = TRUE)
[17:27:48.191]                       }
[17:27:48.191]                     })
[17:27:48.191]                   }
[17:27:48.191]                   ...future.strategy.old <- future::plan("list")
[17:27:48.191]                   options(future.plan = NULL)
[17:27:48.191]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.191]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:48.191]                 }
[17:27:48.191]                 ...future.workdir <- getwd()
[17:27:48.191]             }
[17:27:48.191]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:48.191]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:48.191]         }
[17:27:48.191]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:48.191]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:48.191]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:48.191]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:48.191]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:48.191]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:48.191]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:48.191]             base::names(...future.oldOptions))
[17:27:48.191]     }
[17:27:48.191]     if (FALSE) {
[17:27:48.191]     }
[17:27:48.191]     else {
[17:27:48.191]         if (TRUE) {
[17:27:48.191]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:48.191]                 open = "w")
[17:27:48.191]         }
[17:27:48.191]         else {
[17:27:48.191]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:48.191]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:48.191]         }
[17:27:48.191]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:48.191]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:48.191]             base::sink(type = "output", split = FALSE)
[17:27:48.191]             base::close(...future.stdout)
[17:27:48.191]         }, add = TRUE)
[17:27:48.191]     }
[17:27:48.191]     ...future.frame <- base::sys.nframe()
[17:27:48.191]     ...future.conditions <- base::list()
[17:27:48.191]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:48.191]     if (FALSE) {
[17:27:48.191]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:48.191]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:48.191]     }
[17:27:48.191]     ...future.result <- base::tryCatch({
[17:27:48.191]         base::withCallingHandlers({
[17:27:48.191]             ...future.value <- base::withVisible(base::local({
[17:27:48.191]                 lm(dist ~ poly(speed, 2), data = cars)
[17:27:48.191]             }))
[17:27:48.191]             future::FutureResult(value = ...future.value$value, 
[17:27:48.191]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.191]                   ...future.rng), globalenv = if (FALSE) 
[17:27:48.191]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:48.191]                     ...future.globalenv.names))
[17:27:48.191]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:48.191]         }, condition = base::local({
[17:27:48.191]             c <- base::c
[17:27:48.191]             inherits <- base::inherits
[17:27:48.191]             invokeRestart <- base::invokeRestart
[17:27:48.191]             length <- base::length
[17:27:48.191]             list <- base::list
[17:27:48.191]             seq.int <- base::seq.int
[17:27:48.191]             signalCondition <- base::signalCondition
[17:27:48.191]             sys.calls <- base::sys.calls
[17:27:48.191]             `[[` <- base::`[[`
[17:27:48.191]             `+` <- base::`+`
[17:27:48.191]             `<<-` <- base::`<<-`
[17:27:48.191]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:48.191]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:48.191]                   3L)]
[17:27:48.191]             }
[17:27:48.191]             function(cond) {
[17:27:48.191]                 is_error <- inherits(cond, "error")
[17:27:48.191]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:48.191]                   NULL)
[17:27:48.191]                 if (is_error) {
[17:27:48.191]                   sessionInformation <- function() {
[17:27:48.191]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:48.191]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:48.191]                       search = base::search(), system = base::Sys.info())
[17:27:48.191]                   }
[17:27:48.191]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.191]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:48.191]                     cond$call), session = sessionInformation(), 
[17:27:48.191]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:48.191]                   signalCondition(cond)
[17:27:48.191]                 }
[17:27:48.191]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:48.191]                 "immediateCondition"))) {
[17:27:48.191]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:48.191]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.191]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:48.191]                   if (TRUE && !signal) {
[17:27:48.191]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.191]                     {
[17:27:48.191]                       inherits <- base::inherits
[17:27:48.191]                       invokeRestart <- base::invokeRestart
[17:27:48.191]                       is.null <- base::is.null
[17:27:48.191]                       muffled <- FALSE
[17:27:48.191]                       if (inherits(cond, "message")) {
[17:27:48.191]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.191]                         if (muffled) 
[17:27:48.191]                           invokeRestart("muffleMessage")
[17:27:48.191]                       }
[17:27:48.191]                       else if (inherits(cond, "warning")) {
[17:27:48.191]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.191]                         if (muffled) 
[17:27:48.191]                           invokeRestart("muffleWarning")
[17:27:48.191]                       }
[17:27:48.191]                       else if (inherits(cond, "condition")) {
[17:27:48.191]                         if (!is.null(pattern)) {
[17:27:48.191]                           computeRestarts <- base::computeRestarts
[17:27:48.191]                           grepl <- base::grepl
[17:27:48.191]                           restarts <- computeRestarts(cond)
[17:27:48.191]                           for (restart in restarts) {
[17:27:48.191]                             name <- restart$name
[17:27:48.191]                             if (is.null(name)) 
[17:27:48.191]                               next
[17:27:48.191]                             if (!grepl(pattern, name)) 
[17:27:48.191]                               next
[17:27:48.191]                             invokeRestart(restart)
[17:27:48.191]                             muffled <- TRUE
[17:27:48.191]                             break
[17:27:48.191]                           }
[17:27:48.191]                         }
[17:27:48.191]                       }
[17:27:48.191]                       invisible(muffled)
[17:27:48.191]                     }
[17:27:48.191]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.191]                   }
[17:27:48.191]                 }
[17:27:48.191]                 else {
[17:27:48.191]                   if (TRUE) {
[17:27:48.191]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.191]                     {
[17:27:48.191]                       inherits <- base::inherits
[17:27:48.191]                       invokeRestart <- base::invokeRestart
[17:27:48.191]                       is.null <- base::is.null
[17:27:48.191]                       muffled <- FALSE
[17:27:48.191]                       if (inherits(cond, "message")) {
[17:27:48.191]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.191]                         if (muffled) 
[17:27:48.191]                           invokeRestart("muffleMessage")
[17:27:48.191]                       }
[17:27:48.191]                       else if (inherits(cond, "warning")) {
[17:27:48.191]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.191]                         if (muffled) 
[17:27:48.191]                           invokeRestart("muffleWarning")
[17:27:48.191]                       }
[17:27:48.191]                       else if (inherits(cond, "condition")) {
[17:27:48.191]                         if (!is.null(pattern)) {
[17:27:48.191]                           computeRestarts <- base::computeRestarts
[17:27:48.191]                           grepl <- base::grepl
[17:27:48.191]                           restarts <- computeRestarts(cond)
[17:27:48.191]                           for (restart in restarts) {
[17:27:48.191]                             name <- restart$name
[17:27:48.191]                             if (is.null(name)) 
[17:27:48.191]                               next
[17:27:48.191]                             if (!grepl(pattern, name)) 
[17:27:48.191]                               next
[17:27:48.191]                             invokeRestart(restart)
[17:27:48.191]                             muffled <- TRUE
[17:27:48.191]                             break
[17:27:48.191]                           }
[17:27:48.191]                         }
[17:27:48.191]                       }
[17:27:48.191]                       invisible(muffled)
[17:27:48.191]                     }
[17:27:48.191]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.191]                   }
[17:27:48.191]                 }
[17:27:48.191]             }
[17:27:48.191]         }))
[17:27:48.191]     }, error = function(ex) {
[17:27:48.191]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:48.191]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.191]                 ...future.rng), started = ...future.startTime, 
[17:27:48.191]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:48.191]             version = "1.8"), class = "FutureResult")
[17:27:48.191]     }, finally = {
[17:27:48.191]         if (!identical(...future.workdir, getwd())) 
[17:27:48.191]             setwd(...future.workdir)
[17:27:48.191]         {
[17:27:48.191]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:48.191]                 ...future.oldOptions$nwarnings <- NULL
[17:27:48.191]             }
[17:27:48.191]             base::options(...future.oldOptions)
[17:27:48.191]             if (.Platform$OS.type == "windows") {
[17:27:48.191]                 old_names <- names(...future.oldEnvVars)
[17:27:48.191]                 envs <- base::Sys.getenv()
[17:27:48.191]                 names <- names(envs)
[17:27:48.191]                 common <- intersect(names, old_names)
[17:27:48.191]                 added <- setdiff(names, old_names)
[17:27:48.191]                 removed <- setdiff(old_names, names)
[17:27:48.191]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:48.191]                   envs[common]]
[17:27:48.191]                 NAMES <- toupper(changed)
[17:27:48.191]                 args <- list()
[17:27:48.191]                 for (kk in seq_along(NAMES)) {
[17:27:48.191]                   name <- changed[[kk]]
[17:27:48.191]                   NAME <- NAMES[[kk]]
[17:27:48.191]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.191]                     next
[17:27:48.191]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.191]                 }
[17:27:48.191]                 NAMES <- toupper(added)
[17:27:48.191]                 for (kk in seq_along(NAMES)) {
[17:27:48.191]                   name <- added[[kk]]
[17:27:48.191]                   NAME <- NAMES[[kk]]
[17:27:48.191]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.191]                     next
[17:27:48.191]                   args[[name]] <- ""
[17:27:48.191]                 }
[17:27:48.191]                 NAMES <- toupper(removed)
[17:27:48.191]                 for (kk in seq_along(NAMES)) {
[17:27:48.191]                   name <- removed[[kk]]
[17:27:48.191]                   NAME <- NAMES[[kk]]
[17:27:48.191]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.191]                     next
[17:27:48.191]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.191]                 }
[17:27:48.191]                 if (length(args) > 0) 
[17:27:48.191]                   base::do.call(base::Sys.setenv, args = args)
[17:27:48.191]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:48.191]             }
[17:27:48.191]             else {
[17:27:48.191]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:48.191]             }
[17:27:48.191]             {
[17:27:48.191]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:48.191]                   0L) {
[17:27:48.191]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:48.191]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:48.191]                   base::options(opts)
[17:27:48.191]                 }
[17:27:48.191]                 {
[17:27:48.191]                   {
[17:27:48.191]                     NULL
[17:27:48.191]                     RNGkind("Mersenne-Twister")
[17:27:48.191]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:48.191]                       inherits = FALSE)
[17:27:48.191]                   }
[17:27:48.191]                   options(future.plan = NULL)
[17:27:48.191]                   if (is.na(NA_character_)) 
[17:27:48.191]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.191]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:48.191]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:48.191]                     .init = FALSE)
[17:27:48.191]                 }
[17:27:48.191]             }
[17:27:48.191]         }
[17:27:48.191]     })
[17:27:48.191]     if (TRUE) {
[17:27:48.191]         base::sink(type = "output", split = FALSE)
[17:27:48.191]         if (TRUE) {
[17:27:48.191]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:48.191]         }
[17:27:48.191]         else {
[17:27:48.191]             ...future.result["stdout"] <- base::list(NULL)
[17:27:48.191]         }
[17:27:48.191]         base::close(...future.stdout)
[17:27:48.191]         ...future.stdout <- NULL
[17:27:48.191]     }
[17:27:48.191]     ...future.result$conditions <- ...future.conditions
[17:27:48.191]     ...future.result$finished <- base::Sys.time()
[17:27:48.191]     ...future.result
[17:27:48.191] }
[17:27:48.201] plan(): Setting new future strategy stack:
[17:27:48.201] List of future strategies:
[17:27:48.201] 1. sequential:
[17:27:48.201]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.201]    - tweaked: FALSE
[17:27:48.201]    - call: NULL
[17:27:48.203] plan(): nbrOfWorkers() = 1
[17:27:48.207] plan(): Setting new future strategy stack:
[17:27:48.207] List of future strategies:
[17:27:48.207] 1. sequential:
[17:27:48.207]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.207]    - tweaked: FALSE
[17:27:48.207]    - call: plan(strategy)
[17:27:48.209] plan(): nbrOfWorkers() = 1
[17:27:48.209] SequentialFuture started (and completed)
[17:27:48.210] - Launch lazy future ... done
[17:27:48.210] run() for 'SequentialFuture' ... done

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) ...
[17:27:48.215] getGlobalsAndPackages() ...
[17:27:48.216] Searching for globals...
[17:27:48.231] - globals found: [16] '{', 'outer_function', 'map', ':', '~', 'inner_function', '.x', 'if', 'inherits', '<-', '[[', '-', 'eval', 'bquote', 'lapply', '+'
[17:27:48.232] Searching for globals ... DONE
[17:27:48.232] Resolving globals: FALSE
[17:27:48.234] The total size of the 3 globals is 1.22 KiB (1254 bytes)
[17:27:48.235] The total size of the 3 globals exported for future expression ('{; outer_function(1L); }') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'map' (633 bytes of class 'function'), 'inner_function' (371 bytes of class 'function') and 'outer_function' (250 bytes of class 'function')
[17:27:48.235] - globals: [3] 'outer_function', 'map', 'inner_function'
[17:27:48.236] 
[17:27:48.236] getGlobalsAndPackages() ... DONE
[17:27:48.237] run() for 'Future' ...
[17:27:48.237] - state: 'created'
[17:27:48.238] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:48.238] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:48.239] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:48.239]   - Field: 'label'
[17:27:48.240]   - Field: 'local'
[17:27:48.240]   - Field: 'owner'
[17:27:48.240]   - Field: 'envir'
[17:27:48.240]   - Field: 'packages'
[17:27:48.241]   - Field: 'gc'
[17:27:48.241]   - Field: 'conditions'
[17:27:48.241]   - Field: 'expr'
[17:27:48.242]   - Field: 'uuid'
[17:27:48.242]   - Field: 'seed'
[17:27:48.242]   - Field: 'version'
[17:27:48.243]   - Field: 'result'
[17:27:48.243]   - Field: 'asynchronous'
[17:27:48.243]   - Field: 'calls'
[17:27:48.243]   - Field: 'globals'
[17:27:48.244]   - Field: 'stdout'
[17:27:48.244]   - Field: 'earlySignal'
[17:27:48.244]   - Field: 'lazy'
[17:27:48.245]   - Field: 'state'
[17:27:48.245] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:48.245] - Launch lazy future ...
[17:27:48.246] Packages needed by the future expression (n = 0): <none>
[17:27:48.246] Packages needed by future strategies (n = 0): <none>
[17:27:48.247] {
[17:27:48.247]     {
[17:27:48.247]         {
[17:27:48.247]             ...future.startTime <- base::Sys.time()
[17:27:48.247]             {
[17:27:48.247]                 {
[17:27:48.247]                   {
[17:27:48.247]                     base::local({
[17:27:48.247]                       has_future <- base::requireNamespace("future", 
[17:27:48.247]                         quietly = TRUE)
[17:27:48.247]                       if (has_future) {
[17:27:48.247]                         ns <- base::getNamespace("future")
[17:27:48.247]                         version <- ns[[".package"]][["version"]]
[17:27:48.247]                         if (is.null(version)) 
[17:27:48.247]                           version <- utils::packageVersion("future")
[17:27:48.247]                       }
[17:27:48.247]                       else {
[17:27:48.247]                         version <- NULL
[17:27:48.247]                       }
[17:27:48.247]                       if (!has_future || version < "1.8.0") {
[17:27:48.247]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:48.247]                           "", base::R.version$version.string), 
[17:27:48.247]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:48.247]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:48.247]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:48.247]                             "release", "version")], collapse = " "), 
[17:27:48.247]                           hostname = base::Sys.info()[["nodename"]])
[17:27:48.247]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:48.247]                           info)
[17:27:48.247]                         info <- base::paste(info, collapse = "; ")
[17:27:48.247]                         if (!has_future) {
[17:27:48.247]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:48.247]                             info)
[17:27:48.247]                         }
[17:27:48.247]                         else {
[17:27:48.247]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:48.247]                             info, version)
[17:27:48.247]                         }
[17:27:48.247]                         base::stop(msg)
[17:27:48.247]                       }
[17:27:48.247]                     })
[17:27:48.247]                   }
[17:27:48.247]                   ...future.strategy.old <- future::plan("list")
[17:27:48.247]                   options(future.plan = NULL)
[17:27:48.247]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.247]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:48.247]                 }
[17:27:48.247]                 ...future.workdir <- getwd()
[17:27:48.247]             }
[17:27:48.247]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:48.247]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:48.247]         }
[17:27:48.247]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:48.247]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:48.247]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:48.247]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:48.247]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:48.247]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:48.247]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:48.247]             base::names(...future.oldOptions))
[17:27:48.247]     }
[17:27:48.247]     if (FALSE) {
[17:27:48.247]     }
[17:27:48.247]     else {
[17:27:48.247]         if (TRUE) {
[17:27:48.247]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:48.247]                 open = "w")
[17:27:48.247]         }
[17:27:48.247]         else {
[17:27:48.247]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:48.247]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:48.247]         }
[17:27:48.247]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:48.247]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:48.247]             base::sink(type = "output", split = FALSE)
[17:27:48.247]             base::close(...future.stdout)
[17:27:48.247]         }, add = TRUE)
[17:27:48.247]     }
[17:27:48.247]     ...future.frame <- base::sys.nframe()
[17:27:48.247]     ...future.conditions <- base::list()
[17:27:48.247]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:48.247]     if (FALSE) {
[17:27:48.247]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:48.247]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:48.247]     }
[17:27:48.247]     ...future.result <- base::tryCatch({
[17:27:48.247]         base::withCallingHandlers({
[17:27:48.247]             ...future.value <- base::withVisible(base::local({
[17:27:48.247]                 outer_function(1L)
[17:27:48.247]             }))
[17:27:48.247]             future::FutureResult(value = ...future.value$value, 
[17:27:48.247]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.247]                   ...future.rng), globalenv = if (FALSE) 
[17:27:48.247]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:48.247]                     ...future.globalenv.names))
[17:27:48.247]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:48.247]         }, condition = base::local({
[17:27:48.247]             c <- base::c
[17:27:48.247]             inherits <- base::inherits
[17:27:48.247]             invokeRestart <- base::invokeRestart
[17:27:48.247]             length <- base::length
[17:27:48.247]             list <- base::list
[17:27:48.247]             seq.int <- base::seq.int
[17:27:48.247]             signalCondition <- base::signalCondition
[17:27:48.247]             sys.calls <- base::sys.calls
[17:27:48.247]             `[[` <- base::`[[`
[17:27:48.247]             `+` <- base::`+`
[17:27:48.247]             `<<-` <- base::`<<-`
[17:27:48.247]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:48.247]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:48.247]                   3L)]
[17:27:48.247]             }
[17:27:48.247]             function(cond) {
[17:27:48.247]                 is_error <- inherits(cond, "error")
[17:27:48.247]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:48.247]                   NULL)
[17:27:48.247]                 if (is_error) {
[17:27:48.247]                   sessionInformation <- function() {
[17:27:48.247]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:48.247]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:48.247]                       search = base::search(), system = base::Sys.info())
[17:27:48.247]                   }
[17:27:48.247]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.247]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:48.247]                     cond$call), session = sessionInformation(), 
[17:27:48.247]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:48.247]                   signalCondition(cond)
[17:27:48.247]                 }
[17:27:48.247]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:48.247]                 "immediateCondition"))) {
[17:27:48.247]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:48.247]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.247]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:48.247]                   if (TRUE && !signal) {
[17:27:48.247]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.247]                     {
[17:27:48.247]                       inherits <- base::inherits
[17:27:48.247]                       invokeRestart <- base::invokeRestart
[17:27:48.247]                       is.null <- base::is.null
[17:27:48.247]                       muffled <- FALSE
[17:27:48.247]                       if (inherits(cond, "message")) {
[17:27:48.247]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.247]                         if (muffled) 
[17:27:48.247]                           invokeRestart("muffleMessage")
[17:27:48.247]                       }
[17:27:48.247]                       else if (inherits(cond, "warning")) {
[17:27:48.247]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.247]                         if (muffled) 
[17:27:48.247]                           invokeRestart("muffleWarning")
[17:27:48.247]                       }
[17:27:48.247]                       else if (inherits(cond, "condition")) {
[17:27:48.247]                         if (!is.null(pattern)) {
[17:27:48.247]                           computeRestarts <- base::computeRestarts
[17:27:48.247]                           grepl <- base::grepl
[17:27:48.247]                           restarts <- computeRestarts(cond)
[17:27:48.247]                           for (restart in restarts) {
[17:27:48.247]                             name <- restart$name
[17:27:48.247]                             if (is.null(name)) 
[17:27:48.247]                               next
[17:27:48.247]                             if (!grepl(pattern, name)) 
[17:27:48.247]                               next
[17:27:48.247]                             invokeRestart(restart)
[17:27:48.247]                             muffled <- TRUE
[17:27:48.247]                             break
[17:27:48.247]                           }
[17:27:48.247]                         }
[17:27:48.247]                       }
[17:27:48.247]                       invisible(muffled)
[17:27:48.247]                     }
[17:27:48.247]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.247]                   }
[17:27:48.247]                 }
[17:27:48.247]                 else {
[17:27:48.247]                   if (TRUE) {
[17:27:48.247]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.247]                     {
[17:27:48.247]                       inherits <- base::inherits
[17:27:48.247]                       invokeRestart <- base::invokeRestart
[17:27:48.247]                       is.null <- base::is.null
[17:27:48.247]                       muffled <- FALSE
[17:27:48.247]                       if (inherits(cond, "message")) {
[17:27:48.247]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.247]                         if (muffled) 
[17:27:48.247]                           invokeRestart("muffleMessage")
[17:27:48.247]                       }
[17:27:48.247]                       else if (inherits(cond, "warning")) {
[17:27:48.247]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.247]                         if (muffled) 
[17:27:48.247]                           invokeRestart("muffleWarning")
[17:27:48.247]                       }
[17:27:48.247]                       else if (inherits(cond, "condition")) {
[17:27:48.247]                         if (!is.null(pattern)) {
[17:27:48.247]                           computeRestarts <- base::computeRestarts
[17:27:48.247]                           grepl <- base::grepl
[17:27:48.247]                           restarts <- computeRestarts(cond)
[17:27:48.247]                           for (restart in restarts) {
[17:27:48.247]                             name <- restart$name
[17:27:48.247]                             if (is.null(name)) 
[17:27:48.247]                               next
[17:27:48.247]                             if (!grepl(pattern, name)) 
[17:27:48.247]                               next
[17:27:48.247]                             invokeRestart(restart)
[17:27:48.247]                             muffled <- TRUE
[17:27:48.247]                             break
[17:27:48.247]                           }
[17:27:48.247]                         }
[17:27:48.247]                       }
[17:27:48.247]                       invisible(muffled)
[17:27:48.247]                     }
[17:27:48.247]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.247]                   }
[17:27:48.247]                 }
[17:27:48.247]             }
[17:27:48.247]         }))
[17:27:48.247]     }, error = function(ex) {
[17:27:48.247]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:48.247]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.247]                 ...future.rng), started = ...future.startTime, 
[17:27:48.247]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:48.247]             version = "1.8"), class = "FutureResult")
[17:27:48.247]     }, finally = {
[17:27:48.247]         if (!identical(...future.workdir, getwd())) 
[17:27:48.247]             setwd(...future.workdir)
[17:27:48.247]         {
[17:27:48.247]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:48.247]                 ...future.oldOptions$nwarnings <- NULL
[17:27:48.247]             }
[17:27:48.247]             base::options(...future.oldOptions)
[17:27:48.247]             if (.Platform$OS.type == "windows") {
[17:27:48.247]                 old_names <- names(...future.oldEnvVars)
[17:27:48.247]                 envs <- base::Sys.getenv()
[17:27:48.247]                 names <- names(envs)
[17:27:48.247]                 common <- intersect(names, old_names)
[17:27:48.247]                 added <- setdiff(names, old_names)
[17:27:48.247]                 removed <- setdiff(old_names, names)
[17:27:48.247]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:48.247]                   envs[common]]
[17:27:48.247]                 NAMES <- toupper(changed)
[17:27:48.247]                 args <- list()
[17:27:48.247]                 for (kk in seq_along(NAMES)) {
[17:27:48.247]                   name <- changed[[kk]]
[17:27:48.247]                   NAME <- NAMES[[kk]]
[17:27:48.247]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.247]                     next
[17:27:48.247]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.247]                 }
[17:27:48.247]                 NAMES <- toupper(added)
[17:27:48.247]                 for (kk in seq_along(NAMES)) {
[17:27:48.247]                   name <- added[[kk]]
[17:27:48.247]                   NAME <- NAMES[[kk]]
[17:27:48.247]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.247]                     next
[17:27:48.247]                   args[[name]] <- ""
[17:27:48.247]                 }
[17:27:48.247]                 NAMES <- toupper(removed)
[17:27:48.247]                 for (kk in seq_along(NAMES)) {
[17:27:48.247]                   name <- removed[[kk]]
[17:27:48.247]                   NAME <- NAMES[[kk]]
[17:27:48.247]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.247]                     next
[17:27:48.247]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.247]                 }
[17:27:48.247]                 if (length(args) > 0) 
[17:27:48.247]                   base::do.call(base::Sys.setenv, args = args)
[17:27:48.247]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:48.247]             }
[17:27:48.247]             else {
[17:27:48.247]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:48.247]             }
[17:27:48.247]             {
[17:27:48.247]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:48.247]                   0L) {
[17:27:48.247]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:48.247]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:48.247]                   base::options(opts)
[17:27:48.247]                 }
[17:27:48.247]                 {
[17:27:48.247]                   {
[17:27:48.247]                     NULL
[17:27:48.247]                     RNGkind("Mersenne-Twister")
[17:27:48.247]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:48.247]                       inherits = FALSE)
[17:27:48.247]                   }
[17:27:48.247]                   options(future.plan = NULL)
[17:27:48.247]                   if (is.na(NA_character_)) 
[17:27:48.247]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.247]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:48.247]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:48.247]                     .init = FALSE)
[17:27:48.247]                 }
[17:27:48.247]             }
[17:27:48.247]         }
[17:27:48.247]     })
[17:27:48.247]     if (TRUE) {
[17:27:48.247]         base::sink(type = "output", split = FALSE)
[17:27:48.247]         if (TRUE) {
[17:27:48.247]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:48.247]         }
[17:27:48.247]         else {
[17:27:48.247]             ...future.result["stdout"] <- base::list(NULL)
[17:27:48.247]         }
[17:27:48.247]         base::close(...future.stdout)
[17:27:48.247]         ...future.stdout <- NULL
[17:27:48.247]     }
[17:27:48.247]     ...future.result$conditions <- ...future.conditions
[17:27:48.247]     ...future.result$finished <- base::Sys.time()
[17:27:48.247]     ...future.result
[17:27:48.247] }
[17:27:48.253] assign_globals() ...
[17:27:48.254] List of 3
[17:27:48.254]  $ outer_function:function (x)  
[17:27:48.254]  $ map           :function (.x, .f, ...)  
[17:27:48.254]  $ inner_function:function (x)  
[17:27:48.254]  - attr(*, "where")=List of 3
[17:27:48.254]   ..$ outer_function:<environment: R_EmptyEnv> 
[17:27:48.254]   ..$ map           :<environment: R_EmptyEnv> 
[17:27:48.254]   ..$ inner_function:<environment: R_EmptyEnv> 
[17:27:48.254]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:48.254]  - attr(*, "resolved")= logi FALSE
[17:27:48.254]  - attr(*, "total_size")= int 1254
[17:27:48.254]  - attr(*, "already-done")= logi TRUE
[17:27:48.261] - reassign environment for 'outer_function'
[17:27:48.261] - copied 'outer_function' to environment
[17:27:48.261] - reassign environment for 'map'
[17:27:48.261] - copied 'map' to environment
[17:27:48.262] - reassign environment for 'inner_function'
[17:27:48.262] - copied 'inner_function' to environment
[17:27:48.262] assign_globals() ... done
[17:27:48.263] plan(): Setting new future strategy stack:
[17:27:48.263] List of future strategies:
[17:27:48.263] 1. sequential:
[17:27:48.263]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.263]    - tweaked: FALSE
[17:27:48.263]    - call: NULL
[17:27:48.264] plan(): nbrOfWorkers() = 1
[17:27:48.278] plan(): Setting new future strategy stack:
[17:27:48.279] List of future strategies:
[17:27:48.279] 1. sequential:
[17:27:48.279]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.279]    - tweaked: FALSE
[17:27:48.279]    - call: plan(strategy)
[17:27:48.280] plan(): nbrOfWorkers() = 1
[17:27:48.280] SequentialFuture started (and completed)
[17:27:48.281] - Launch lazy future ... done
[17:27:48.281] run() for 'SequentialFuture' ... done
List of 2
 $ : num [1:2] 2 3
 $ : num [1:2] 2 3
[17:27:48.284] getGlobalsAndPackages() ...
[17:27:48.284] Searching for globals...
[17:27:48.293] - globals found: [16] '{', 'outer_function', 'map', ':', '~', 'inner_function', '.x', 'if', 'inherits', '<-', '[[', '-', 'eval', 'bquote', 'lapply', '+'
[17:27:48.293] Searching for globals ... DONE
[17:27:48.294] Resolving globals: FALSE
[17:27:48.295] The total size of the 3 globals is 1.22 KiB (1254 bytes)
[17:27:48.296] The total size of the 3 globals exported for future expression ('{; outer_function(1L); }') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'map' (633 bytes of class 'function'), 'inner_function' (371 bytes of class 'function') and 'outer_function' (250 bytes of class 'function')
[17:27:48.296] - globals: [3] 'outer_function', 'map', 'inner_function'
[17:27:48.296] 
[17:27:48.297] getGlobalsAndPackages() ... DONE
[17:27:48.297] run() for 'Future' ...
[17:27:48.298] - state: 'created'
[17:27:48.298] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:48.299] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:48.299] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:48.299]   - Field: 'label'
[17:27:48.300]   - Field: 'local'
[17:27:48.300]   - Field: 'owner'
[17:27:48.300]   - Field: 'envir'
[17:27:48.301]   - Field: 'packages'
[17:27:48.301]   - Field: 'gc'
[17:27:48.301]   - Field: 'conditions'
[17:27:48.301]   - Field: 'expr'
[17:27:48.302]   - Field: 'uuid'
[17:27:48.302]   - Field: 'seed'
[17:27:48.302]   - Field: 'version'
[17:27:48.303]   - Field: 'result'
[17:27:48.303]   - Field: 'asynchronous'
[17:27:48.303]   - Field: 'calls'
[17:27:48.304]   - Field: 'globals'
[17:27:48.304]   - Field: 'stdout'
[17:27:48.304]   - Field: 'earlySignal'
[17:27:48.304]   - Field: 'lazy'
[17:27:48.305]   - Field: 'state'
[17:27:48.305] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:48.308] - Launch lazy future ...
[17:27:48.309] Packages needed by the future expression (n = 0): <none>
[17:27:48.309] Packages needed by future strategies (n = 0): <none>
[17:27:48.310] {
[17:27:48.310]     {
[17:27:48.310]         {
[17:27:48.310]             ...future.startTime <- base::Sys.time()
[17:27:48.310]             {
[17:27:48.310]                 {
[17:27:48.310]                   {
[17:27:48.310]                     base::local({
[17:27:48.310]                       has_future <- base::requireNamespace("future", 
[17:27:48.310]                         quietly = TRUE)
[17:27:48.310]                       if (has_future) {
[17:27:48.310]                         ns <- base::getNamespace("future")
[17:27:48.310]                         version <- ns[[".package"]][["version"]]
[17:27:48.310]                         if (is.null(version)) 
[17:27:48.310]                           version <- utils::packageVersion("future")
[17:27:48.310]                       }
[17:27:48.310]                       else {
[17:27:48.310]                         version <- NULL
[17:27:48.310]                       }
[17:27:48.310]                       if (!has_future || version < "1.8.0") {
[17:27:48.310]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:48.310]                           "", base::R.version$version.string), 
[17:27:48.310]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:48.310]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:48.310]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:48.310]                             "release", "version")], collapse = " "), 
[17:27:48.310]                           hostname = base::Sys.info()[["nodename"]])
[17:27:48.310]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:48.310]                           info)
[17:27:48.310]                         info <- base::paste(info, collapse = "; ")
[17:27:48.310]                         if (!has_future) {
[17:27:48.310]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:48.310]                             info)
[17:27:48.310]                         }
[17:27:48.310]                         else {
[17:27:48.310]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:48.310]                             info, version)
[17:27:48.310]                         }
[17:27:48.310]                         base::stop(msg)
[17:27:48.310]                       }
[17:27:48.310]                     })
[17:27:48.310]                   }
[17:27:48.310]                   ...future.strategy.old <- future::plan("list")
[17:27:48.310]                   options(future.plan = NULL)
[17:27:48.310]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.310]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:48.310]                 }
[17:27:48.310]                 ...future.workdir <- getwd()
[17:27:48.310]             }
[17:27:48.310]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:48.310]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:48.310]         }
[17:27:48.310]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:48.310]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:48.310]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:48.310]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:48.310]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:48.310]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:48.310]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:48.310]             base::names(...future.oldOptions))
[17:27:48.310]     }
[17:27:48.310]     if (FALSE) {
[17:27:48.310]     }
[17:27:48.310]     else {
[17:27:48.310]         if (TRUE) {
[17:27:48.310]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:48.310]                 open = "w")
[17:27:48.310]         }
[17:27:48.310]         else {
[17:27:48.310]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:48.310]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:48.310]         }
[17:27:48.310]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:48.310]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:48.310]             base::sink(type = "output", split = FALSE)
[17:27:48.310]             base::close(...future.stdout)
[17:27:48.310]         }, add = TRUE)
[17:27:48.310]     }
[17:27:48.310]     ...future.frame <- base::sys.nframe()
[17:27:48.310]     ...future.conditions <- base::list()
[17:27:48.310]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:48.310]     if (FALSE) {
[17:27:48.310]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:48.310]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:48.310]     }
[17:27:48.310]     ...future.result <- base::tryCatch({
[17:27:48.310]         base::withCallingHandlers({
[17:27:48.310]             ...future.value <- base::withVisible(base::local({
[17:27:48.310]                 outer_function(1L)
[17:27:48.310]             }))
[17:27:48.310]             future::FutureResult(value = ...future.value$value, 
[17:27:48.310]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.310]                   ...future.rng), globalenv = if (FALSE) 
[17:27:48.310]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:48.310]                     ...future.globalenv.names))
[17:27:48.310]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:48.310]         }, condition = base::local({
[17:27:48.310]             c <- base::c
[17:27:48.310]             inherits <- base::inherits
[17:27:48.310]             invokeRestart <- base::invokeRestart
[17:27:48.310]             length <- base::length
[17:27:48.310]             list <- base::list
[17:27:48.310]             seq.int <- base::seq.int
[17:27:48.310]             signalCondition <- base::signalCondition
[17:27:48.310]             sys.calls <- base::sys.calls
[17:27:48.310]             `[[` <- base::`[[`
[17:27:48.310]             `+` <- base::`+`
[17:27:48.310]             `<<-` <- base::`<<-`
[17:27:48.310]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:48.310]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:48.310]                   3L)]
[17:27:48.310]             }
[17:27:48.310]             function(cond) {
[17:27:48.310]                 is_error <- inherits(cond, "error")
[17:27:48.310]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:48.310]                   NULL)
[17:27:48.310]                 if (is_error) {
[17:27:48.310]                   sessionInformation <- function() {
[17:27:48.310]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:48.310]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:48.310]                       search = base::search(), system = base::Sys.info())
[17:27:48.310]                   }
[17:27:48.310]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.310]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:48.310]                     cond$call), session = sessionInformation(), 
[17:27:48.310]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:48.310]                   signalCondition(cond)
[17:27:48.310]                 }
[17:27:48.310]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:48.310]                 "immediateCondition"))) {
[17:27:48.310]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:48.310]                   ...future.conditions[[length(...future.conditions) + 
[17:27:48.310]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:48.310]                   if (TRUE && !signal) {
[17:27:48.310]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.310]                     {
[17:27:48.310]                       inherits <- base::inherits
[17:27:48.310]                       invokeRestart <- base::invokeRestart
[17:27:48.310]                       is.null <- base::is.null
[17:27:48.310]                       muffled <- FALSE
[17:27:48.310]                       if (inherits(cond, "message")) {
[17:27:48.310]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.310]                         if (muffled) 
[17:27:48.310]                           invokeRestart("muffleMessage")
[17:27:48.310]                       }
[17:27:48.310]                       else if (inherits(cond, "warning")) {
[17:27:48.310]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.310]                         if (muffled) 
[17:27:48.310]                           invokeRestart("muffleWarning")
[17:27:48.310]                       }
[17:27:48.310]                       else if (inherits(cond, "condition")) {
[17:27:48.310]                         if (!is.null(pattern)) {
[17:27:48.310]                           computeRestarts <- base::computeRestarts
[17:27:48.310]                           grepl <- base::grepl
[17:27:48.310]                           restarts <- computeRestarts(cond)
[17:27:48.310]                           for (restart in restarts) {
[17:27:48.310]                             name <- restart$name
[17:27:48.310]                             if (is.null(name)) 
[17:27:48.310]                               next
[17:27:48.310]                             if (!grepl(pattern, name)) 
[17:27:48.310]                               next
[17:27:48.310]                             invokeRestart(restart)
[17:27:48.310]                             muffled <- TRUE
[17:27:48.310]                             break
[17:27:48.310]                           }
[17:27:48.310]                         }
[17:27:48.310]                       }
[17:27:48.310]                       invisible(muffled)
[17:27:48.310]                     }
[17:27:48.310]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.310]                   }
[17:27:48.310]                 }
[17:27:48.310]                 else {
[17:27:48.310]                   if (TRUE) {
[17:27:48.310]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:48.310]                     {
[17:27:48.310]                       inherits <- base::inherits
[17:27:48.310]                       invokeRestart <- base::invokeRestart
[17:27:48.310]                       is.null <- base::is.null
[17:27:48.310]                       muffled <- FALSE
[17:27:48.310]                       if (inherits(cond, "message")) {
[17:27:48.310]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:48.310]                         if (muffled) 
[17:27:48.310]                           invokeRestart("muffleMessage")
[17:27:48.310]                       }
[17:27:48.310]                       else if (inherits(cond, "warning")) {
[17:27:48.310]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:48.310]                         if (muffled) 
[17:27:48.310]                           invokeRestart("muffleWarning")
[17:27:48.310]                       }
[17:27:48.310]                       else if (inherits(cond, "condition")) {
[17:27:48.310]                         if (!is.null(pattern)) {
[17:27:48.310]                           computeRestarts <- base::computeRestarts
[17:27:48.310]                           grepl <- base::grepl
[17:27:48.310]                           restarts <- computeRestarts(cond)
[17:27:48.310]                           for (restart in restarts) {
[17:27:48.310]                             name <- restart$name
[17:27:48.310]                             if (is.null(name)) 
[17:27:48.310]                               next
[17:27:48.310]                             if (!grepl(pattern, name)) 
[17:27:48.310]                               next
[17:27:48.310]                             invokeRestart(restart)
[17:27:48.310]                             muffled <- TRUE
[17:27:48.310]                             break
[17:27:48.310]                           }
[17:27:48.310]                         }
[17:27:48.310]                       }
[17:27:48.310]                       invisible(muffled)
[17:27:48.310]                     }
[17:27:48.310]                     muffleCondition(cond, pattern = "^muffle")
[17:27:48.310]                   }
[17:27:48.310]                 }
[17:27:48.310]             }
[17:27:48.310]         }))
[17:27:48.310]     }, error = function(ex) {
[17:27:48.310]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:48.310]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:48.310]                 ...future.rng), started = ...future.startTime, 
[17:27:48.310]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:48.310]             version = "1.8"), class = "FutureResult")
[17:27:48.310]     }, finally = {
[17:27:48.310]         if (!identical(...future.workdir, getwd())) 
[17:27:48.310]             setwd(...future.workdir)
[17:27:48.310]         {
[17:27:48.310]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:48.310]                 ...future.oldOptions$nwarnings <- NULL
[17:27:48.310]             }
[17:27:48.310]             base::options(...future.oldOptions)
[17:27:48.310]             if (.Platform$OS.type == "windows") {
[17:27:48.310]                 old_names <- names(...future.oldEnvVars)
[17:27:48.310]                 envs <- base::Sys.getenv()
[17:27:48.310]                 names <- names(envs)
[17:27:48.310]                 common <- intersect(names, old_names)
[17:27:48.310]                 added <- setdiff(names, old_names)
[17:27:48.310]                 removed <- setdiff(old_names, names)
[17:27:48.310]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:48.310]                   envs[common]]
[17:27:48.310]                 NAMES <- toupper(changed)
[17:27:48.310]                 args <- list()
[17:27:48.310]                 for (kk in seq_along(NAMES)) {
[17:27:48.310]                   name <- changed[[kk]]
[17:27:48.310]                   NAME <- NAMES[[kk]]
[17:27:48.310]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.310]                     next
[17:27:48.310]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.310]                 }
[17:27:48.310]                 NAMES <- toupper(added)
[17:27:48.310]                 for (kk in seq_along(NAMES)) {
[17:27:48.310]                   name <- added[[kk]]
[17:27:48.310]                   NAME <- NAMES[[kk]]
[17:27:48.310]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.310]                     next
[17:27:48.310]                   args[[name]] <- ""
[17:27:48.310]                 }
[17:27:48.310]                 NAMES <- toupper(removed)
[17:27:48.310]                 for (kk in seq_along(NAMES)) {
[17:27:48.310]                   name <- removed[[kk]]
[17:27:48.310]                   NAME <- NAMES[[kk]]
[17:27:48.310]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:48.310]                     next
[17:27:48.310]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:48.310]                 }
[17:27:48.310]                 if (length(args) > 0) 
[17:27:48.310]                   base::do.call(base::Sys.setenv, args = args)
[17:27:48.310]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:48.310]             }
[17:27:48.310]             else {
[17:27:48.310]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:48.310]             }
[17:27:48.310]             {
[17:27:48.310]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:48.310]                   0L) {
[17:27:48.310]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:48.310]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:48.310]                   base::options(opts)
[17:27:48.310]                 }
[17:27:48.310]                 {
[17:27:48.310]                   {
[17:27:48.310]                     NULL
[17:27:48.310]                     RNGkind("Mersenne-Twister")
[17:27:48.310]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:48.310]                       inherits = FALSE)
[17:27:48.310]                   }
[17:27:48.310]                   options(future.plan = NULL)
[17:27:48.310]                   if (is.na(NA_character_)) 
[17:27:48.310]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:48.310]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:48.310]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:48.310]                     .init = FALSE)
[17:27:48.310]                 }
[17:27:48.310]             }
[17:27:48.310]         }
[17:27:48.310]     })
[17:27:48.310]     if (TRUE) {
[17:27:48.310]         base::sink(type = "output", split = FALSE)
[17:27:48.310]         if (TRUE) {
[17:27:48.310]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:48.310]         }
[17:27:48.310]         else {
[17:27:48.310]             ...future.result["stdout"] <- base::list(NULL)
[17:27:48.310]         }
[17:27:48.310]         base::close(...future.stdout)
[17:27:48.310]         ...future.stdout <- NULL
[17:27:48.310]     }
[17:27:48.310]     ...future.result$conditions <- ...future.conditions
[17:27:48.310]     ...future.result$finished <- base::Sys.time()
[17:27:48.310]     ...future.result
[17:27:48.310] }
[17:27:48.316] assign_globals() ...
[17:27:48.317] List of 3
[17:27:48.317]  $ outer_function:function (x)  
[17:27:48.317]  $ map           :function (.x, .f, ...)  
[17:27:48.317]  $ inner_function:function (x)  
[17:27:48.317]  - attr(*, "where")=List of 3
[17:27:48.317]   ..$ outer_function:<environment: R_EmptyEnv> 
[17:27:48.317]   ..$ map           :<environment: R_EmptyEnv> 
[17:27:48.317]   ..$ inner_function:<environment: R_EmptyEnv> 
[17:27:48.317]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:48.317]  - attr(*, "resolved")= logi FALSE
[17:27:48.317]  - attr(*, "total_size")= int 1254
[17:27:48.317]  - attr(*, "already-done")= logi TRUE
[17:27:48.323] - reassign environment for 'outer_function'
[17:27:48.324] - copied 'outer_function' to environment
[17:27:48.324] - reassign environment for 'map'
[17:27:48.324] - copied 'map' to environment
[17:27:48.324] - reassign environment for 'inner_function'
[17:27:48.325] - copied 'inner_function' to environment
[17:27:48.325] assign_globals() ... done
[17:27:48.326] plan(): Setting new future strategy stack:
[17:27:48.326] List of future strategies:
[17:27:48.326] 1. sequential:
[17:27:48.326]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.326]    - tweaked: FALSE
[17:27:48.326]    - call: NULL
[17:27:48.327] plan(): nbrOfWorkers() = 1
[17:27:48.329] plan(): Setting new future strategy stack:
[17:27:48.329] List of future strategies:
[17:27:48.329] 1. sequential:
[17:27:48.329]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:48.329]    - tweaked: FALSE
[17:27:48.329]    - call: plan(strategy)
[17:27:48.330] plan(): nbrOfWorkers() = 1
[17:27:48.330] SequentialFuture started (and completed)
[17:27:48.331] - Launch lazy future ... done
[17:27:48.331] run() for 'SequentialFuture' ... done
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('multisession') ...
[17:27:48.347] plan(): Setting new future strategy stack:
[17:27:48.348] List of future strategies:
[17:27:48.348] 1. multisession:
[17:27:48.348]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:27:48.348]    - tweaked: FALSE
[17:27:48.348]    - call: plan(strategy)
[17:27:48.351] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:27:48.351] multisession:
[17:27:48.351] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:27:48.351] - tweaked: FALSE
[17:27:48.351] - call: plan(strategy)
[17:27:48.358] getGlobalsAndPackages() ...
[17:27:48.358] Not searching for globals
[17:27:48.359] - globals: [0] <none>
[17:27:48.359] getGlobalsAndPackages() ... DONE
[17:27:48.360] [local output] makeClusterPSOCK() ...
[17:27:48.414] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:27:48.424] [local output] Base port: 35935
[17:27:48.425] [local output] Getting setup options for 2 cluster nodes ...
[17:27:48.425] [local output]  - Node #1 of 2 ...
[17:27:48.426] [local output] localMachine=TRUE => revtunnel=FALSE

[17:27:48.430] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/Rtmpk1Pt8X/worker.rank=1.parallelly.parent=181068.2c34c5772b71.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/Rtmpk1Pt8X/worker.rank=1.parallelly.parent=181068.2c34c5772b71.pid\")"'
[17:27:48.877] - Possible to infer worker's PID: TRUE
[17:27:48.877] [local output] Rscript port: 35935

[17:27:48.878] [local output]  - Node #2 of 2 ...
[17:27:48.878] [local output] localMachine=TRUE => revtunnel=FALSE

[17:27:48.880] [local output] Rscript port: 35935

[17:27:48.880] [local output] Getting setup options for 2 cluster nodes ... done
[17:27:48.880] [local output]  - Parallel setup requested for some PSOCK nodes
[17:27:48.881] [local output] Setting up PSOCK nodes in parallel
[17:27:48.881] List of 36
[17:27:48.881]  $ worker          : chr "localhost"
[17:27:48.881]   ..- attr(*, "localhost")= logi TRUE
[17:27:48.881]  $ master          : chr "localhost"
[17:27:48.881]  $ port            : int 35935
[17:27:48.881]  $ connectTimeout  : num 120
[17:27:48.881]  $ timeout         : num 120
[17:27:48.881]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:27:48.881]  $ homogeneous     : logi TRUE
[17:27:48.881]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=globals,formulas.R:181068:CRANWI"| __truncated__
[17:27:48.881]  $ rscript_envs    : NULL
[17:27:48.881]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:27:48.881]  $ rscript_startup : NULL
[17:27:48.881]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:27:48.881]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:27:48.881]  $ methods         : logi TRUE
[17:27:48.881]  $ socketOptions   : chr "no-delay"
[17:27:48.881]  $ useXDR          : logi FALSE
[17:27:48.881]  $ outfile         : chr "/dev/null"
[17:27:48.881]  $ renice          : int NA
[17:27:48.881]  $ rshcmd          : NULL
[17:27:48.881]  $ user            : chr(0) 
[17:27:48.881]  $ revtunnel       : logi FALSE
[17:27:48.881]  $ rshlogfile      : NULL
[17:27:48.881]  $ rshopts         : chr(0) 
[17:27:48.881]  $ rank            : int 1
[17:27:48.881]  $ manual          : logi FALSE
[17:27:48.881]  $ dryrun          : logi FALSE
[17:27:48.881]  $ quiet           : logi FALSE
[17:27:48.881]  $ setup_strategy  : chr "parallel"
[17:27:48.881]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:27:48.881]  $ pidfile         : chr "D:/temp/Rtmpk1Pt8X/worker.rank=1.parallelly.parent=181068.2c34c5772b71.pid"
[17:27:48.881]  $ rshcmd_label    : NULL
[17:27:48.881]  $ rsh_call        : NULL
[17:27:48.881]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:27:48.881]  $ localMachine    : logi TRUE
[17:27:48.881]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:27:48.881]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:27:48.881]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:27:48.881]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:27:48.881]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:27:48.881]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:27:48.881]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:27:48.881]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:27:48.881]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:27:48.881]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:27:48.881]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:27:48.881]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:27:48.881]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:27:48.881]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:27:48.881]  $ arguments       :List of 28
[17:27:48.881]   ..$ worker          : chr "localhost"
[17:27:48.881]   ..$ master          : NULL
[17:27:48.881]   ..$ port            : int 35935
[17:27:48.881]   ..$ connectTimeout  : num 120
[17:27:48.881]   ..$ timeout         : num 120
[17:27:48.881]   ..$ rscript         : NULL
[17:27:48.881]   ..$ homogeneous     : NULL
[17:27:48.881]   ..$ rscript_args    : NULL
[17:27:48.881]   ..$ rscript_envs    : NULL
[17:27:48.881]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:27:48.881]   ..$ rscript_startup : NULL
[17:27:48.881]   ..$ rscript_sh      : chr "auto"
[17:27:48.881]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:27:48.881]   ..$ methods         : logi TRUE
[17:27:48.881]   ..$ socketOptions   : chr "no-delay"
[17:27:48.881]   ..$ useXDR          : logi FALSE
[17:27:48.881]   ..$ outfile         : chr "/dev/null"
[17:27:48.881]   ..$ renice          : int NA
[17:27:48.881]   ..$ rshcmd          : NULL
[17:27:48.881]   ..$ user            : NULL
[17:27:48.881]   ..$ revtunnel       : logi NA
[17:27:48.881]   ..$ rshlogfile      : NULL
[17:27:48.881]   ..$ rshopts         : NULL
[17:27:48.881]   ..$ rank            : int 1
[17:27:48.881]   ..$ manual          : logi FALSE
[17:27:48.881]   ..$ dryrun          : logi FALSE
[17:27:48.881]   ..$ quiet           : logi FALSE
[17:27:48.881]   ..$ setup_strategy  : chr "parallel"
[17:27:48.881]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:27:48.908] [local output] System call to launch all workers:
[17:27:48.908] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=globals,formulas.R:181068:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/Rtmpk1Pt8X/worker.rank=1.parallelly.parent=181068.2c34c5772b71.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=35935 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:27:48.908] [local output] Starting PSOCK main server
[17:27:48.918] [local output] Workers launched
[17:27:48.919] [local output] Waiting for workers to connect back
[17:27:48.919]  - [local output] 0 workers out of 2 ready
[17:27:49.157]  - [local output] 0 workers out of 2 ready
[17:27:49.158]  - [local output] 1 workers out of 2 ready
[17:27:49.182]  - [local output] 1 workers out of 2 ready
[17:27:49.183]  - [local output] 2 workers out of 2 ready
[17:27:49.184] [local output] Launching of 2 workers completed
[17:27:49.184] [local output] Number of nodes in cluster: 2
[17:27:49.184] [local output] Collecting session information from 2 workers
[17:27:49.186] [local output]  - Worker #1 of 2
[17:27:49.187] [local output]  - Worker #2 of 2
[17:27:49.188] [local output] makeClusterPSOCK() ... done
[17:27:49.208] Packages needed by the future expression (n = 0): <none>
[17:27:49.208] Packages needed by future strategies (n = 0): <none>
[17:27:49.210] {
[17:27:49.210]     {
[17:27:49.210]         {
[17:27:49.210]             ...future.startTime <- base::Sys.time()
[17:27:49.210]             {
[17:27:49.210]                 {
[17:27:49.210]                   {
[17:27:49.210]                     {
[17:27:49.210]                       base::local({
[17:27:49.210]                         has_future <- base::requireNamespace("future", 
[17:27:49.210]                           quietly = TRUE)
[17:27:49.210]                         if (has_future) {
[17:27:49.210]                           ns <- base::getNamespace("future")
[17:27:49.210]                           version <- ns[[".package"]][["version"]]
[17:27:49.210]                           if (is.null(version)) 
[17:27:49.210]                             version <- utils::packageVersion("future")
[17:27:49.210]                         }
[17:27:49.210]                         else {
[17:27:49.210]                           version <- NULL
[17:27:49.210]                         }
[17:27:49.210]                         if (!has_future || version < "1.8.0") {
[17:27:49.210]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:49.210]                             "", base::R.version$version.string), 
[17:27:49.210]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:49.210]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:49.210]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:49.210]                               "release", "version")], collapse = " "), 
[17:27:49.210]                             hostname = base::Sys.info()[["nodename"]])
[17:27:49.210]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:49.210]                             info)
[17:27:49.210]                           info <- base::paste(info, collapse = "; ")
[17:27:49.210]                           if (!has_future) {
[17:27:49.210]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:49.210]                               info)
[17:27:49.210]                           }
[17:27:49.210]                           else {
[17:27:49.210]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:49.210]                               info, version)
[17:27:49.210]                           }
[17:27:49.210]                           base::stop(msg)
[17:27:49.210]                         }
[17:27:49.210]                       })
[17:27:49.210]                     }
[17:27:49.210]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:49.210]                     base::options(mc.cores = 1L)
[17:27:49.210]                   }
[17:27:49.210]                   ...future.strategy.old <- future::plan("list")
[17:27:49.210]                   options(future.plan = NULL)
[17:27:49.210]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.210]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:49.210]                 }
[17:27:49.210]                 ...future.workdir <- getwd()
[17:27:49.210]             }
[17:27:49.210]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:49.210]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:49.210]         }
[17:27:49.210]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:49.210]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:49.210]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:49.210]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:49.210]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:49.210]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:49.210]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:49.210]             base::names(...future.oldOptions))
[17:27:49.210]     }
[17:27:49.210]     if (FALSE) {
[17:27:49.210]     }
[17:27:49.210]     else {
[17:27:49.210]         if (TRUE) {
[17:27:49.210]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:49.210]                 open = "w")
[17:27:49.210]         }
[17:27:49.210]         else {
[17:27:49.210]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:49.210]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:49.210]         }
[17:27:49.210]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:49.210]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:49.210]             base::sink(type = "output", split = FALSE)
[17:27:49.210]             base::close(...future.stdout)
[17:27:49.210]         }, add = TRUE)
[17:27:49.210]     }
[17:27:49.210]     ...future.frame <- base::sys.nframe()
[17:27:49.210]     ...future.conditions <- base::list()
[17:27:49.210]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:49.210]     if (FALSE) {
[17:27:49.210]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:49.210]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:49.210]     }
[17:27:49.210]     ...future.result <- base::tryCatch({
[17:27:49.210]         base::withCallingHandlers({
[17:27:49.210]             ...future.value <- base::withVisible(base::local({
[17:27:49.210]                 ...future.makeSendCondition <- base::local({
[17:27:49.210]                   sendCondition <- NULL
[17:27:49.210]                   function(frame = 1L) {
[17:27:49.210]                     if (is.function(sendCondition)) 
[17:27:49.210]                       return(sendCondition)
[17:27:49.210]                     ns <- getNamespace("parallel")
[17:27:49.210]                     if (exists("sendData", mode = "function", 
[17:27:49.210]                       envir = ns)) {
[17:27:49.210]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:49.210]                         envir = ns)
[17:27:49.210]                       envir <- sys.frame(frame)
[17:27:49.210]                       master <- NULL
[17:27:49.210]                       while (!identical(envir, .GlobalEnv) && 
[17:27:49.210]                         !identical(envir, emptyenv())) {
[17:27:49.210]                         if (exists("master", mode = "list", envir = envir, 
[17:27:49.210]                           inherits = FALSE)) {
[17:27:49.210]                           master <- get("master", mode = "list", 
[17:27:49.210]                             envir = envir, inherits = FALSE)
[17:27:49.210]                           if (inherits(master, c("SOCKnode", 
[17:27:49.210]                             "SOCK0node"))) {
[17:27:49.210]                             sendCondition <<- function(cond) {
[17:27:49.210]                               data <- list(type = "VALUE", value = cond, 
[17:27:49.210]                                 success = TRUE)
[17:27:49.210]                               parallel_sendData(master, data)
[17:27:49.210]                             }
[17:27:49.210]                             return(sendCondition)
[17:27:49.210]                           }
[17:27:49.210]                         }
[17:27:49.210]                         frame <- frame + 1L
[17:27:49.210]                         envir <- sys.frame(frame)
[17:27:49.210]                       }
[17:27:49.210]                     }
[17:27:49.210]                     sendCondition <<- function(cond) NULL
[17:27:49.210]                   }
[17:27:49.210]                 })
[17:27:49.210]                 withCallingHandlers({
[17:27:49.210]                   NA
[17:27:49.210]                 }, immediateCondition = function(cond) {
[17:27:49.210]                   sendCondition <- ...future.makeSendCondition()
[17:27:49.210]                   sendCondition(cond)
[17:27:49.210]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.210]                   {
[17:27:49.210]                     inherits <- base::inherits
[17:27:49.210]                     invokeRestart <- base::invokeRestart
[17:27:49.210]                     is.null <- base::is.null
[17:27:49.210]                     muffled <- FALSE
[17:27:49.210]                     if (inherits(cond, "message")) {
[17:27:49.210]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:49.210]                       if (muffled) 
[17:27:49.210]                         invokeRestart("muffleMessage")
[17:27:49.210]                     }
[17:27:49.210]                     else if (inherits(cond, "warning")) {
[17:27:49.210]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:49.210]                       if (muffled) 
[17:27:49.210]                         invokeRestart("muffleWarning")
[17:27:49.210]                     }
[17:27:49.210]                     else if (inherits(cond, "condition")) {
[17:27:49.210]                       if (!is.null(pattern)) {
[17:27:49.210]                         computeRestarts <- base::computeRestarts
[17:27:49.210]                         grepl <- base::grepl
[17:27:49.210]                         restarts <- computeRestarts(cond)
[17:27:49.210]                         for (restart in restarts) {
[17:27:49.210]                           name <- restart$name
[17:27:49.210]                           if (is.null(name)) 
[17:27:49.210]                             next
[17:27:49.210]                           if (!grepl(pattern, name)) 
[17:27:49.210]                             next
[17:27:49.210]                           invokeRestart(restart)
[17:27:49.210]                           muffled <- TRUE
[17:27:49.210]                           break
[17:27:49.210]                         }
[17:27:49.210]                       }
[17:27:49.210]                     }
[17:27:49.210]                     invisible(muffled)
[17:27:49.210]                   }
[17:27:49.210]                   muffleCondition(cond)
[17:27:49.210]                 })
[17:27:49.210]             }))
[17:27:49.210]             future::FutureResult(value = ...future.value$value, 
[17:27:49.210]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.210]                   ...future.rng), globalenv = if (FALSE) 
[17:27:49.210]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:49.210]                     ...future.globalenv.names))
[17:27:49.210]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:49.210]         }, condition = base::local({
[17:27:49.210]             c <- base::c
[17:27:49.210]             inherits <- base::inherits
[17:27:49.210]             invokeRestart <- base::invokeRestart
[17:27:49.210]             length <- base::length
[17:27:49.210]             list <- base::list
[17:27:49.210]             seq.int <- base::seq.int
[17:27:49.210]             signalCondition <- base::signalCondition
[17:27:49.210]             sys.calls <- base::sys.calls
[17:27:49.210]             `[[` <- base::`[[`
[17:27:49.210]             `+` <- base::`+`
[17:27:49.210]             `<<-` <- base::`<<-`
[17:27:49.210]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:49.210]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:49.210]                   3L)]
[17:27:49.210]             }
[17:27:49.210]             function(cond) {
[17:27:49.210]                 is_error <- inherits(cond, "error")
[17:27:49.210]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:49.210]                   NULL)
[17:27:49.210]                 if (is_error) {
[17:27:49.210]                   sessionInformation <- function() {
[17:27:49.210]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:49.210]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:49.210]                       search = base::search(), system = base::Sys.info())
[17:27:49.210]                   }
[17:27:49.210]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.210]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:49.210]                     cond$call), session = sessionInformation(), 
[17:27:49.210]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:49.210]                   signalCondition(cond)
[17:27:49.210]                 }
[17:27:49.210]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:49.210]                 "immediateCondition"))) {
[17:27:49.210]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:49.210]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.210]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:49.210]                   if (TRUE && !signal) {
[17:27:49.210]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.210]                     {
[17:27:49.210]                       inherits <- base::inherits
[17:27:49.210]                       invokeRestart <- base::invokeRestart
[17:27:49.210]                       is.null <- base::is.null
[17:27:49.210]                       muffled <- FALSE
[17:27:49.210]                       if (inherits(cond, "message")) {
[17:27:49.210]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.210]                         if (muffled) 
[17:27:49.210]                           invokeRestart("muffleMessage")
[17:27:49.210]                       }
[17:27:49.210]                       else if (inherits(cond, "warning")) {
[17:27:49.210]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.210]                         if (muffled) 
[17:27:49.210]                           invokeRestart("muffleWarning")
[17:27:49.210]                       }
[17:27:49.210]                       else if (inherits(cond, "condition")) {
[17:27:49.210]                         if (!is.null(pattern)) {
[17:27:49.210]                           computeRestarts <- base::computeRestarts
[17:27:49.210]                           grepl <- base::grepl
[17:27:49.210]                           restarts <- computeRestarts(cond)
[17:27:49.210]                           for (restart in restarts) {
[17:27:49.210]                             name <- restart$name
[17:27:49.210]                             if (is.null(name)) 
[17:27:49.210]                               next
[17:27:49.210]                             if (!grepl(pattern, name)) 
[17:27:49.210]                               next
[17:27:49.210]                             invokeRestart(restart)
[17:27:49.210]                             muffled <- TRUE
[17:27:49.210]                             break
[17:27:49.210]                           }
[17:27:49.210]                         }
[17:27:49.210]                       }
[17:27:49.210]                       invisible(muffled)
[17:27:49.210]                     }
[17:27:49.210]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.210]                   }
[17:27:49.210]                 }
[17:27:49.210]                 else {
[17:27:49.210]                   if (TRUE) {
[17:27:49.210]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.210]                     {
[17:27:49.210]                       inherits <- base::inherits
[17:27:49.210]                       invokeRestart <- base::invokeRestart
[17:27:49.210]                       is.null <- base::is.null
[17:27:49.210]                       muffled <- FALSE
[17:27:49.210]                       if (inherits(cond, "message")) {
[17:27:49.210]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.210]                         if (muffled) 
[17:27:49.210]                           invokeRestart("muffleMessage")
[17:27:49.210]                       }
[17:27:49.210]                       else if (inherits(cond, "warning")) {
[17:27:49.210]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.210]                         if (muffled) 
[17:27:49.210]                           invokeRestart("muffleWarning")
[17:27:49.210]                       }
[17:27:49.210]                       else if (inherits(cond, "condition")) {
[17:27:49.210]                         if (!is.null(pattern)) {
[17:27:49.210]                           computeRestarts <- base::computeRestarts
[17:27:49.210]                           grepl <- base::grepl
[17:27:49.210]                           restarts <- computeRestarts(cond)
[17:27:49.210]                           for (restart in restarts) {
[17:27:49.210]                             name <- restart$name
[17:27:49.210]                             if (is.null(name)) 
[17:27:49.210]                               next
[17:27:49.210]                             if (!grepl(pattern, name)) 
[17:27:49.210]                               next
[17:27:49.210]                             invokeRestart(restart)
[17:27:49.210]                             muffled <- TRUE
[17:27:49.210]                             break
[17:27:49.210]                           }
[17:27:49.210]                         }
[17:27:49.210]                       }
[17:27:49.210]                       invisible(muffled)
[17:27:49.210]                     }
[17:27:49.210]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.210]                   }
[17:27:49.210]                 }
[17:27:49.210]             }
[17:27:49.210]         }))
[17:27:49.210]     }, error = function(ex) {
[17:27:49.210]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:49.210]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.210]                 ...future.rng), started = ...future.startTime, 
[17:27:49.210]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:49.210]             version = "1.8"), class = "FutureResult")
[17:27:49.210]     }, finally = {
[17:27:49.210]         if (!identical(...future.workdir, getwd())) 
[17:27:49.210]             setwd(...future.workdir)
[17:27:49.210]         {
[17:27:49.210]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:49.210]                 ...future.oldOptions$nwarnings <- NULL
[17:27:49.210]             }
[17:27:49.210]             base::options(...future.oldOptions)
[17:27:49.210]             if (.Platform$OS.type == "windows") {
[17:27:49.210]                 old_names <- names(...future.oldEnvVars)
[17:27:49.210]                 envs <- base::Sys.getenv()
[17:27:49.210]                 names <- names(envs)
[17:27:49.210]                 common <- intersect(names, old_names)
[17:27:49.210]                 added <- setdiff(names, old_names)
[17:27:49.210]                 removed <- setdiff(old_names, names)
[17:27:49.210]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:49.210]                   envs[common]]
[17:27:49.210]                 NAMES <- toupper(changed)
[17:27:49.210]                 args <- list()
[17:27:49.210]                 for (kk in seq_along(NAMES)) {
[17:27:49.210]                   name <- changed[[kk]]
[17:27:49.210]                   NAME <- NAMES[[kk]]
[17:27:49.210]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.210]                     next
[17:27:49.210]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.210]                 }
[17:27:49.210]                 NAMES <- toupper(added)
[17:27:49.210]                 for (kk in seq_along(NAMES)) {
[17:27:49.210]                   name <- added[[kk]]
[17:27:49.210]                   NAME <- NAMES[[kk]]
[17:27:49.210]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.210]                     next
[17:27:49.210]                   args[[name]] <- ""
[17:27:49.210]                 }
[17:27:49.210]                 NAMES <- toupper(removed)
[17:27:49.210]                 for (kk in seq_along(NAMES)) {
[17:27:49.210]                   name <- removed[[kk]]
[17:27:49.210]                   NAME <- NAMES[[kk]]
[17:27:49.210]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.210]                     next
[17:27:49.210]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.210]                 }
[17:27:49.210]                 if (length(args) > 0) 
[17:27:49.210]                   base::do.call(base::Sys.setenv, args = args)
[17:27:49.210]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:49.210]             }
[17:27:49.210]             else {
[17:27:49.210]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:49.210]             }
[17:27:49.210]             {
[17:27:49.210]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:49.210]                   0L) {
[17:27:49.210]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:49.210]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:49.210]                   base::options(opts)
[17:27:49.210]                 }
[17:27:49.210]                 {
[17:27:49.210]                   {
[17:27:49.210]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:49.210]                     NULL
[17:27:49.210]                   }
[17:27:49.210]                   options(future.plan = NULL)
[17:27:49.210]                   if (is.na(NA_character_)) 
[17:27:49.210]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.210]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:49.210]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:49.210]                     .init = FALSE)
[17:27:49.210]                 }
[17:27:49.210]             }
[17:27:49.210]         }
[17:27:49.210]     })
[17:27:49.210]     if (TRUE) {
[17:27:49.210]         base::sink(type = "output", split = FALSE)
[17:27:49.210]         if (TRUE) {
[17:27:49.210]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:49.210]         }
[17:27:49.210]         else {
[17:27:49.210]             ...future.result["stdout"] <- base::list(NULL)
[17:27:49.210]         }
[17:27:49.210]         base::close(...future.stdout)
[17:27:49.210]         ...future.stdout <- NULL
[17:27:49.210]     }
[17:27:49.210]     ...future.result$conditions <- ...future.conditions
[17:27:49.210]     ...future.result$finished <- base::Sys.time()
[17:27:49.210]     ...future.result
[17:27:49.210] }
[17:27:49.351] MultisessionFuture started
[17:27:49.351] result() for ClusterFuture ...
[17:27:49.352] receiveMessageFromWorker() for ClusterFuture ...
[17:27:49.353] - Validating connection of MultisessionFuture
[17:27:49.419] - received message: FutureResult
[17:27:49.419] - Received FutureResult
[17:27:49.425] - Erased future from FutureRegistry
[17:27:49.426] result() for ClusterFuture ...
[17:27:49.426] - result already collected: FutureResult
[17:27:49.426] result() for ClusterFuture ... done
[17:27:49.426] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:49.427] result() for ClusterFuture ... done
[17:27:49.427] result() for ClusterFuture ...
[17:27:49.427] - result already collected: FutureResult
[17:27:49.428] result() for ClusterFuture ... done
[17:27:49.428] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:27:49.433] plan(): nbrOfWorkers() = 2
- lm(<formula>) ...
[17:27:49.433] getGlobalsAndPackages() ...
[17:27:49.433] Searching for globals...
[17:27:49.437] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
[17:27:49.438] Searching for globals ... DONE
[17:27:49.438] Resolving globals: FALSE
[17:27:49.440] The total size of the 2 globals is 401 bytes (401 bytes)
[17:27:49.441] The total size of the 2 globals exported for future expression ('{; lm(weight ~ group - 1); }') is 401 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'group' (210 bytes of class 'numeric') and 'weight' (191 bytes of class 'numeric')
[17:27:49.442] - globals: [2] 'weight', 'group'
[17:27:49.442] - packages: [1] 'stats'
[17:27:49.442] getGlobalsAndPackages() ... DONE
[17:27:49.443] run() for 'Future' ...
[17:27:49.443] - state: 'created'
[17:27:49.444] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:49.465] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:49.466] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:49.466]   - Field: 'node'
[17:27:49.466]   - Field: 'label'
[17:27:49.466]   - Field: 'local'
[17:27:49.467]   - Field: 'owner'
[17:27:49.467]   - Field: 'envir'
[17:27:49.467]   - Field: 'workers'
[17:27:49.468]   - Field: 'packages'
[17:27:49.468]   - Field: 'gc'
[17:27:49.468]   - Field: 'conditions'
[17:27:49.468]   - Field: 'persistent'
[17:27:49.469]   - Field: 'expr'
[17:27:49.469]   - Field: 'uuid'
[17:27:49.469]   - Field: 'seed'
[17:27:49.470]   - Field: 'version'
[17:27:49.470]   - Field: 'result'
[17:27:49.470]   - Field: 'asynchronous'
[17:27:49.471]   - Field: 'calls'
[17:27:49.471]   - Field: 'globals'
[17:27:49.471]   - Field: 'stdout'
[17:27:49.471]   - Field: 'earlySignal'
[17:27:49.472]   - Field: 'lazy'
[17:27:49.472]   - Field: 'state'
[17:27:49.472] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:49.473] - Launch lazy future ...
[17:27:49.473] Packages needed by the future expression (n = 1): 'stats'
[17:27:49.474] Packages needed by future strategies (n = 0): <none>
[17:27:49.475] {
[17:27:49.475]     {
[17:27:49.475]         {
[17:27:49.475]             ...future.startTime <- base::Sys.time()
[17:27:49.475]             {
[17:27:49.475]                 {
[17:27:49.475]                   {
[17:27:49.475]                     {
[17:27:49.475]                       {
[17:27:49.475]                         base::local({
[17:27:49.475]                           has_future <- base::requireNamespace("future", 
[17:27:49.475]                             quietly = TRUE)
[17:27:49.475]                           if (has_future) {
[17:27:49.475]                             ns <- base::getNamespace("future")
[17:27:49.475]                             version <- ns[[".package"]][["version"]]
[17:27:49.475]                             if (is.null(version)) 
[17:27:49.475]                               version <- utils::packageVersion("future")
[17:27:49.475]                           }
[17:27:49.475]                           else {
[17:27:49.475]                             version <- NULL
[17:27:49.475]                           }
[17:27:49.475]                           if (!has_future || version < "1.8.0") {
[17:27:49.475]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:49.475]                               "", base::R.version$version.string), 
[17:27:49.475]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:49.475]                                 base::R.version$platform, 8 * 
[17:27:49.475]                                   base::.Machine$sizeof.pointer), 
[17:27:49.475]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:49.475]                                 "release", "version")], collapse = " "), 
[17:27:49.475]                               hostname = base::Sys.info()[["nodename"]])
[17:27:49.475]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:49.475]                               info)
[17:27:49.475]                             info <- base::paste(info, collapse = "; ")
[17:27:49.475]                             if (!has_future) {
[17:27:49.475]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:49.475]                                 info)
[17:27:49.475]                             }
[17:27:49.475]                             else {
[17:27:49.475]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:49.475]                                 info, version)
[17:27:49.475]                             }
[17:27:49.475]                             base::stop(msg)
[17:27:49.475]                           }
[17:27:49.475]                         })
[17:27:49.475]                       }
[17:27:49.475]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:49.475]                       base::options(mc.cores = 1L)
[17:27:49.475]                     }
[17:27:49.475]                     base::local({
[17:27:49.475]                       for (pkg in "stats") {
[17:27:49.475]                         base::loadNamespace(pkg)
[17:27:49.475]                         base::library(pkg, character.only = TRUE)
[17:27:49.475]                       }
[17:27:49.475]                     })
[17:27:49.475]                   }
[17:27:49.475]                   ...future.strategy.old <- future::plan("list")
[17:27:49.475]                   options(future.plan = NULL)
[17:27:49.475]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.475]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:49.475]                 }
[17:27:49.475]                 ...future.workdir <- getwd()
[17:27:49.475]             }
[17:27:49.475]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:49.475]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:49.475]         }
[17:27:49.475]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:49.475]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:49.475]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:49.475]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:49.475]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:49.475]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:49.475]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:49.475]             base::names(...future.oldOptions))
[17:27:49.475]     }
[17:27:49.475]     if (FALSE) {
[17:27:49.475]     }
[17:27:49.475]     else {
[17:27:49.475]         if (TRUE) {
[17:27:49.475]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:49.475]                 open = "w")
[17:27:49.475]         }
[17:27:49.475]         else {
[17:27:49.475]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:49.475]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:49.475]         }
[17:27:49.475]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:49.475]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:49.475]             base::sink(type = "output", split = FALSE)
[17:27:49.475]             base::close(...future.stdout)
[17:27:49.475]         }, add = TRUE)
[17:27:49.475]     }
[17:27:49.475]     ...future.frame <- base::sys.nframe()
[17:27:49.475]     ...future.conditions <- base::list()
[17:27:49.475]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:49.475]     if (FALSE) {
[17:27:49.475]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:49.475]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:49.475]     }
[17:27:49.475]     ...future.result <- base::tryCatch({
[17:27:49.475]         base::withCallingHandlers({
[17:27:49.475]             ...future.value <- base::withVisible(base::local({
[17:27:49.475]                 ...future.makeSendCondition <- base::local({
[17:27:49.475]                   sendCondition <- NULL
[17:27:49.475]                   function(frame = 1L) {
[17:27:49.475]                     if (is.function(sendCondition)) 
[17:27:49.475]                       return(sendCondition)
[17:27:49.475]                     ns <- getNamespace("parallel")
[17:27:49.475]                     if (exists("sendData", mode = "function", 
[17:27:49.475]                       envir = ns)) {
[17:27:49.475]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:49.475]                         envir = ns)
[17:27:49.475]                       envir <- sys.frame(frame)
[17:27:49.475]                       master <- NULL
[17:27:49.475]                       while (!identical(envir, .GlobalEnv) && 
[17:27:49.475]                         !identical(envir, emptyenv())) {
[17:27:49.475]                         if (exists("master", mode = "list", envir = envir, 
[17:27:49.475]                           inherits = FALSE)) {
[17:27:49.475]                           master <- get("master", mode = "list", 
[17:27:49.475]                             envir = envir, inherits = FALSE)
[17:27:49.475]                           if (inherits(master, c("SOCKnode", 
[17:27:49.475]                             "SOCK0node"))) {
[17:27:49.475]                             sendCondition <<- function(cond) {
[17:27:49.475]                               data <- list(type = "VALUE", value = cond, 
[17:27:49.475]                                 success = TRUE)
[17:27:49.475]                               parallel_sendData(master, data)
[17:27:49.475]                             }
[17:27:49.475]                             return(sendCondition)
[17:27:49.475]                           }
[17:27:49.475]                         }
[17:27:49.475]                         frame <- frame + 1L
[17:27:49.475]                         envir <- sys.frame(frame)
[17:27:49.475]                       }
[17:27:49.475]                     }
[17:27:49.475]                     sendCondition <<- function(cond) NULL
[17:27:49.475]                   }
[17:27:49.475]                 })
[17:27:49.475]                 withCallingHandlers({
[17:27:49.475]                   {
[17:27:49.475]                     lm(weight ~ group - 1)
[17:27:49.475]                   }
[17:27:49.475]                 }, immediateCondition = function(cond) {
[17:27:49.475]                   sendCondition <- ...future.makeSendCondition()
[17:27:49.475]                   sendCondition(cond)
[17:27:49.475]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.475]                   {
[17:27:49.475]                     inherits <- base::inherits
[17:27:49.475]                     invokeRestart <- base::invokeRestart
[17:27:49.475]                     is.null <- base::is.null
[17:27:49.475]                     muffled <- FALSE
[17:27:49.475]                     if (inherits(cond, "message")) {
[17:27:49.475]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:49.475]                       if (muffled) 
[17:27:49.475]                         invokeRestart("muffleMessage")
[17:27:49.475]                     }
[17:27:49.475]                     else if (inherits(cond, "warning")) {
[17:27:49.475]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:49.475]                       if (muffled) 
[17:27:49.475]                         invokeRestart("muffleWarning")
[17:27:49.475]                     }
[17:27:49.475]                     else if (inherits(cond, "condition")) {
[17:27:49.475]                       if (!is.null(pattern)) {
[17:27:49.475]                         computeRestarts <- base::computeRestarts
[17:27:49.475]                         grepl <- base::grepl
[17:27:49.475]                         restarts <- computeRestarts(cond)
[17:27:49.475]                         for (restart in restarts) {
[17:27:49.475]                           name <- restart$name
[17:27:49.475]                           if (is.null(name)) 
[17:27:49.475]                             next
[17:27:49.475]                           if (!grepl(pattern, name)) 
[17:27:49.475]                             next
[17:27:49.475]                           invokeRestart(restart)
[17:27:49.475]                           muffled <- TRUE
[17:27:49.475]                           break
[17:27:49.475]                         }
[17:27:49.475]                       }
[17:27:49.475]                     }
[17:27:49.475]                     invisible(muffled)
[17:27:49.475]                   }
[17:27:49.475]                   muffleCondition(cond)
[17:27:49.475]                 })
[17:27:49.475]             }))
[17:27:49.475]             future::FutureResult(value = ...future.value$value, 
[17:27:49.475]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.475]                   ...future.rng), globalenv = if (FALSE) 
[17:27:49.475]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:49.475]                     ...future.globalenv.names))
[17:27:49.475]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:49.475]         }, condition = base::local({
[17:27:49.475]             c <- base::c
[17:27:49.475]             inherits <- base::inherits
[17:27:49.475]             invokeRestart <- base::invokeRestart
[17:27:49.475]             length <- base::length
[17:27:49.475]             list <- base::list
[17:27:49.475]             seq.int <- base::seq.int
[17:27:49.475]             signalCondition <- base::signalCondition
[17:27:49.475]             sys.calls <- base::sys.calls
[17:27:49.475]             `[[` <- base::`[[`
[17:27:49.475]             `+` <- base::`+`
[17:27:49.475]             `<<-` <- base::`<<-`
[17:27:49.475]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:49.475]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:49.475]                   3L)]
[17:27:49.475]             }
[17:27:49.475]             function(cond) {
[17:27:49.475]                 is_error <- inherits(cond, "error")
[17:27:49.475]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:49.475]                   NULL)
[17:27:49.475]                 if (is_error) {
[17:27:49.475]                   sessionInformation <- function() {
[17:27:49.475]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:49.475]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:49.475]                       search = base::search(), system = base::Sys.info())
[17:27:49.475]                   }
[17:27:49.475]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.475]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:49.475]                     cond$call), session = sessionInformation(), 
[17:27:49.475]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:49.475]                   signalCondition(cond)
[17:27:49.475]                 }
[17:27:49.475]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:49.475]                 "immediateCondition"))) {
[17:27:49.475]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:49.475]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.475]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:49.475]                   if (TRUE && !signal) {
[17:27:49.475]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.475]                     {
[17:27:49.475]                       inherits <- base::inherits
[17:27:49.475]                       invokeRestart <- base::invokeRestart
[17:27:49.475]                       is.null <- base::is.null
[17:27:49.475]                       muffled <- FALSE
[17:27:49.475]                       if (inherits(cond, "message")) {
[17:27:49.475]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.475]                         if (muffled) 
[17:27:49.475]                           invokeRestart("muffleMessage")
[17:27:49.475]                       }
[17:27:49.475]                       else if (inherits(cond, "warning")) {
[17:27:49.475]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.475]                         if (muffled) 
[17:27:49.475]                           invokeRestart("muffleWarning")
[17:27:49.475]                       }
[17:27:49.475]                       else if (inherits(cond, "condition")) {
[17:27:49.475]                         if (!is.null(pattern)) {
[17:27:49.475]                           computeRestarts <- base::computeRestarts
[17:27:49.475]                           grepl <- base::grepl
[17:27:49.475]                           restarts <- computeRestarts(cond)
[17:27:49.475]                           for (restart in restarts) {
[17:27:49.475]                             name <- restart$name
[17:27:49.475]                             if (is.null(name)) 
[17:27:49.475]                               next
[17:27:49.475]                             if (!grepl(pattern, name)) 
[17:27:49.475]                               next
[17:27:49.475]                             invokeRestart(restart)
[17:27:49.475]                             muffled <- TRUE
[17:27:49.475]                             break
[17:27:49.475]                           }
[17:27:49.475]                         }
[17:27:49.475]                       }
[17:27:49.475]                       invisible(muffled)
[17:27:49.475]                     }
[17:27:49.475]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.475]                   }
[17:27:49.475]                 }
[17:27:49.475]                 else {
[17:27:49.475]                   if (TRUE) {
[17:27:49.475]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.475]                     {
[17:27:49.475]                       inherits <- base::inherits
[17:27:49.475]                       invokeRestart <- base::invokeRestart
[17:27:49.475]                       is.null <- base::is.null
[17:27:49.475]                       muffled <- FALSE
[17:27:49.475]                       if (inherits(cond, "message")) {
[17:27:49.475]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.475]                         if (muffled) 
[17:27:49.475]                           invokeRestart("muffleMessage")
[17:27:49.475]                       }
[17:27:49.475]                       else if (inherits(cond, "warning")) {
[17:27:49.475]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.475]                         if (muffled) 
[17:27:49.475]                           invokeRestart("muffleWarning")
[17:27:49.475]                       }
[17:27:49.475]                       else if (inherits(cond, "condition")) {
[17:27:49.475]                         if (!is.null(pattern)) {
[17:27:49.475]                           computeRestarts <- base::computeRestarts
[17:27:49.475]                           grepl <- base::grepl
[17:27:49.475]                           restarts <- computeRestarts(cond)
[17:27:49.475]                           for (restart in restarts) {
[17:27:49.475]                             name <- restart$name
[17:27:49.475]                             if (is.null(name)) 
[17:27:49.475]                               next
[17:27:49.475]                             if (!grepl(pattern, name)) 
[17:27:49.475]                               next
[17:27:49.475]                             invokeRestart(restart)
[17:27:49.475]                             muffled <- TRUE
[17:27:49.475]                             break
[17:27:49.475]                           }
[17:27:49.475]                         }
[17:27:49.475]                       }
[17:27:49.475]                       invisible(muffled)
[17:27:49.475]                     }
[17:27:49.475]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.475]                   }
[17:27:49.475]                 }
[17:27:49.475]             }
[17:27:49.475]         }))
[17:27:49.475]     }, error = function(ex) {
[17:27:49.475]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:49.475]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.475]                 ...future.rng), started = ...future.startTime, 
[17:27:49.475]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:49.475]             version = "1.8"), class = "FutureResult")
[17:27:49.475]     }, finally = {
[17:27:49.475]         if (!identical(...future.workdir, getwd())) 
[17:27:49.475]             setwd(...future.workdir)
[17:27:49.475]         {
[17:27:49.475]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:49.475]                 ...future.oldOptions$nwarnings <- NULL
[17:27:49.475]             }
[17:27:49.475]             base::options(...future.oldOptions)
[17:27:49.475]             if (.Platform$OS.type == "windows") {
[17:27:49.475]                 old_names <- names(...future.oldEnvVars)
[17:27:49.475]                 envs <- base::Sys.getenv()
[17:27:49.475]                 names <- names(envs)
[17:27:49.475]                 common <- intersect(names, old_names)
[17:27:49.475]                 added <- setdiff(names, old_names)
[17:27:49.475]                 removed <- setdiff(old_names, names)
[17:27:49.475]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:49.475]                   envs[common]]
[17:27:49.475]                 NAMES <- toupper(changed)
[17:27:49.475]                 args <- list()
[17:27:49.475]                 for (kk in seq_along(NAMES)) {
[17:27:49.475]                   name <- changed[[kk]]
[17:27:49.475]                   NAME <- NAMES[[kk]]
[17:27:49.475]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.475]                     next
[17:27:49.475]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.475]                 }
[17:27:49.475]                 NAMES <- toupper(added)
[17:27:49.475]                 for (kk in seq_along(NAMES)) {
[17:27:49.475]                   name <- added[[kk]]
[17:27:49.475]                   NAME <- NAMES[[kk]]
[17:27:49.475]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.475]                     next
[17:27:49.475]                   args[[name]] <- ""
[17:27:49.475]                 }
[17:27:49.475]                 NAMES <- toupper(removed)
[17:27:49.475]                 for (kk in seq_along(NAMES)) {
[17:27:49.475]                   name <- removed[[kk]]
[17:27:49.475]                   NAME <- NAMES[[kk]]
[17:27:49.475]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.475]                     next
[17:27:49.475]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.475]                 }
[17:27:49.475]                 if (length(args) > 0) 
[17:27:49.475]                   base::do.call(base::Sys.setenv, args = args)
[17:27:49.475]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:49.475]             }
[17:27:49.475]             else {
[17:27:49.475]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:49.475]             }
[17:27:49.475]             {
[17:27:49.475]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:49.475]                   0L) {
[17:27:49.475]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:49.475]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:49.475]                   base::options(opts)
[17:27:49.475]                 }
[17:27:49.475]                 {
[17:27:49.475]                   {
[17:27:49.475]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:49.475]                     NULL
[17:27:49.475]                   }
[17:27:49.475]                   options(future.plan = NULL)
[17:27:49.475]                   if (is.na(NA_character_)) 
[17:27:49.475]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.475]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:49.475]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:49.475]                     .init = FALSE)
[17:27:49.475]                 }
[17:27:49.475]             }
[17:27:49.475]         }
[17:27:49.475]     })
[17:27:49.475]     if (TRUE) {
[17:27:49.475]         base::sink(type = "output", split = FALSE)
[17:27:49.475]         if (TRUE) {
[17:27:49.475]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:49.475]         }
[17:27:49.475]         else {
[17:27:49.475]             ...future.result["stdout"] <- base::list(NULL)
[17:27:49.475]         }
[17:27:49.475]         base::close(...future.stdout)
[17:27:49.475]         ...future.stdout <- NULL
[17:27:49.475]     }
[17:27:49.475]     ...future.result$conditions <- ...future.conditions
[17:27:49.475]     ...future.result$finished <- base::Sys.time()
[17:27:49.475]     ...future.result
[17:27:49.475] }
[17:27:49.481] Exporting 2 global objects (708 bytes) to cluster node #1 ...
[17:27:49.481] Exporting 'weight' (191 bytes) to cluster node #1 ...
[17:27:49.482] Exporting 'weight' (191 bytes) to cluster node #1 ... DONE
[17:27:49.482] Exporting 'group' (210 bytes) to cluster node #1 ...
[17:27:49.483] Exporting 'group' (210 bytes) to cluster node #1 ... DONE
[17:27:49.483] Exporting 2 global objects (708 bytes) to cluster node #1 ... DONE
[17:27:49.484] MultisessionFuture started
[17:27:49.484] - Launch lazy future ... done
[17:27:49.485] run() for 'MultisessionFuture' ... done
[17:27:49.485] result() for ClusterFuture ...
[17:27:49.485] receiveMessageFromWorker() for ClusterFuture ...
[17:27:49.486] - Validating connection of MultisessionFuture
[17:27:49.520] - received message: FutureResult
[17:27:49.521] - Received FutureResult
[17:27:49.521] - Erased future from FutureRegistry
[17:27:49.521] result() for ClusterFuture ...
[17:27:49.521] - result already collected: FutureResult
[17:27:49.521] result() for ClusterFuture ... done
[17:27:49.522] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:49.522] result() for ClusterFuture ... done
[17:27:49.522] result() for ClusterFuture ...
[17:27:49.522] - result already collected: FutureResult
[17:27:49.522] result() for ClusterFuture ... done

Call:
lm(formula = weight ~ group - 1)

Coefficients:
groupCtl  groupTrt  
   5.032     4.661  

[17:27:49.525] getGlobalsAndPackages() ...
[17:27:49.525] Searching for globals...
[17:27:49.528] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
[17:27:49.528] Searching for globals ... DONE
[17:27:49.528] Resolving globals: FALSE
[17:27:49.529] The total size of the 2 globals is 401 bytes (401 bytes)
[17:27:49.530] The total size of the 2 globals exported for future expression ('{; lm(weight ~ group - 1); }') is 401 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'group' (210 bytes of class 'numeric') and 'weight' (191 bytes of class 'numeric')
[17:27:49.530] - globals: [2] 'weight', 'group'
[17:27:49.530] - packages: [1] 'stats'
[17:27:49.530] getGlobalsAndPackages() ... DONE
[17:27:49.531] run() for 'Future' ...
[17:27:49.531] - state: 'created'
[17:27:49.531] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:49.548] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:49.549] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:49.549]   - Field: 'node'
[17:27:49.550]   - Field: 'label'
[17:27:49.550]   - Field: 'local'
[17:27:49.550]   - Field: 'owner'
[17:27:49.551]   - Field: 'envir'
[17:27:49.551]   - Field: 'workers'
[17:27:49.551]   - Field: 'packages'
[17:27:49.552]   - Field: 'gc'
[17:27:49.552]   - Field: 'conditions'
[17:27:49.553]   - Field: 'persistent'
[17:27:49.553]   - Field: 'expr'
[17:27:49.553]   - Field: 'uuid'
[17:27:49.554]   - Field: 'seed'
[17:27:49.554]   - Field: 'version'
[17:27:49.554]   - Field: 'result'
[17:27:49.555]   - Field: 'asynchronous'
[17:27:49.555]   - Field: 'calls'
[17:27:49.555]   - Field: 'globals'
[17:27:49.556]   - Field: 'stdout'
[17:27:49.556]   - Field: 'earlySignal'
[17:27:49.557]   - Field: 'lazy'
[17:27:49.557]   - Field: 'state'
[17:27:49.557] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:49.558] - Launch lazy future ...
[17:27:49.558] Packages needed by the future expression (n = 1): 'stats'
[17:27:49.559] Packages needed by future strategies (n = 0): <none>
[17:27:49.560] {
[17:27:49.560]     {
[17:27:49.560]         {
[17:27:49.560]             ...future.startTime <- base::Sys.time()
[17:27:49.560]             {
[17:27:49.560]                 {
[17:27:49.560]                   {
[17:27:49.560]                     {
[17:27:49.560]                       {
[17:27:49.560]                         base::local({
[17:27:49.560]                           has_future <- base::requireNamespace("future", 
[17:27:49.560]                             quietly = TRUE)
[17:27:49.560]                           if (has_future) {
[17:27:49.560]                             ns <- base::getNamespace("future")
[17:27:49.560]                             version <- ns[[".package"]][["version"]]
[17:27:49.560]                             if (is.null(version)) 
[17:27:49.560]                               version <- utils::packageVersion("future")
[17:27:49.560]                           }
[17:27:49.560]                           else {
[17:27:49.560]                             version <- NULL
[17:27:49.560]                           }
[17:27:49.560]                           if (!has_future || version < "1.8.0") {
[17:27:49.560]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:49.560]                               "", base::R.version$version.string), 
[17:27:49.560]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:49.560]                                 base::R.version$platform, 8 * 
[17:27:49.560]                                   base::.Machine$sizeof.pointer), 
[17:27:49.560]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:49.560]                                 "release", "version")], collapse = " "), 
[17:27:49.560]                               hostname = base::Sys.info()[["nodename"]])
[17:27:49.560]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:49.560]                               info)
[17:27:49.560]                             info <- base::paste(info, collapse = "; ")
[17:27:49.560]                             if (!has_future) {
[17:27:49.560]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:49.560]                                 info)
[17:27:49.560]                             }
[17:27:49.560]                             else {
[17:27:49.560]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:49.560]                                 info, version)
[17:27:49.560]                             }
[17:27:49.560]                             base::stop(msg)
[17:27:49.560]                           }
[17:27:49.560]                         })
[17:27:49.560]                       }
[17:27:49.560]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:49.560]                       base::options(mc.cores = 1L)
[17:27:49.560]                     }
[17:27:49.560]                     base::local({
[17:27:49.560]                       for (pkg in "stats") {
[17:27:49.560]                         base::loadNamespace(pkg)
[17:27:49.560]                         base::library(pkg, character.only = TRUE)
[17:27:49.560]                       }
[17:27:49.560]                     })
[17:27:49.560]                   }
[17:27:49.560]                   ...future.strategy.old <- future::plan("list")
[17:27:49.560]                   options(future.plan = NULL)
[17:27:49.560]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.560]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:49.560]                 }
[17:27:49.560]                 ...future.workdir <- getwd()
[17:27:49.560]             }
[17:27:49.560]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:49.560]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:49.560]         }
[17:27:49.560]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:49.560]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:49.560]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:49.560]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:49.560]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:49.560]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:49.560]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:49.560]             base::names(...future.oldOptions))
[17:27:49.560]     }
[17:27:49.560]     if (FALSE) {
[17:27:49.560]     }
[17:27:49.560]     else {
[17:27:49.560]         if (TRUE) {
[17:27:49.560]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:49.560]                 open = "w")
[17:27:49.560]         }
[17:27:49.560]         else {
[17:27:49.560]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:49.560]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:49.560]         }
[17:27:49.560]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:49.560]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:49.560]             base::sink(type = "output", split = FALSE)
[17:27:49.560]             base::close(...future.stdout)
[17:27:49.560]         }, add = TRUE)
[17:27:49.560]     }
[17:27:49.560]     ...future.frame <- base::sys.nframe()
[17:27:49.560]     ...future.conditions <- base::list()
[17:27:49.560]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:49.560]     if (FALSE) {
[17:27:49.560]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:49.560]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:49.560]     }
[17:27:49.560]     ...future.result <- base::tryCatch({
[17:27:49.560]         base::withCallingHandlers({
[17:27:49.560]             ...future.value <- base::withVisible(base::local({
[17:27:49.560]                 ...future.makeSendCondition <- base::local({
[17:27:49.560]                   sendCondition <- NULL
[17:27:49.560]                   function(frame = 1L) {
[17:27:49.560]                     if (is.function(sendCondition)) 
[17:27:49.560]                       return(sendCondition)
[17:27:49.560]                     ns <- getNamespace("parallel")
[17:27:49.560]                     if (exists("sendData", mode = "function", 
[17:27:49.560]                       envir = ns)) {
[17:27:49.560]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:49.560]                         envir = ns)
[17:27:49.560]                       envir <- sys.frame(frame)
[17:27:49.560]                       master <- NULL
[17:27:49.560]                       while (!identical(envir, .GlobalEnv) && 
[17:27:49.560]                         !identical(envir, emptyenv())) {
[17:27:49.560]                         if (exists("master", mode = "list", envir = envir, 
[17:27:49.560]                           inherits = FALSE)) {
[17:27:49.560]                           master <- get("master", mode = "list", 
[17:27:49.560]                             envir = envir, inherits = FALSE)
[17:27:49.560]                           if (inherits(master, c("SOCKnode", 
[17:27:49.560]                             "SOCK0node"))) {
[17:27:49.560]                             sendCondition <<- function(cond) {
[17:27:49.560]                               data <- list(type = "VALUE", value = cond, 
[17:27:49.560]                                 success = TRUE)
[17:27:49.560]                               parallel_sendData(master, data)
[17:27:49.560]                             }
[17:27:49.560]                             return(sendCondition)
[17:27:49.560]                           }
[17:27:49.560]                         }
[17:27:49.560]                         frame <- frame + 1L
[17:27:49.560]                         envir <- sys.frame(frame)
[17:27:49.560]                       }
[17:27:49.560]                     }
[17:27:49.560]                     sendCondition <<- function(cond) NULL
[17:27:49.560]                   }
[17:27:49.560]                 })
[17:27:49.560]                 withCallingHandlers({
[17:27:49.560]                   {
[17:27:49.560]                     lm(weight ~ group - 1)
[17:27:49.560]                   }
[17:27:49.560]                 }, immediateCondition = function(cond) {
[17:27:49.560]                   sendCondition <- ...future.makeSendCondition()
[17:27:49.560]                   sendCondition(cond)
[17:27:49.560]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.560]                   {
[17:27:49.560]                     inherits <- base::inherits
[17:27:49.560]                     invokeRestart <- base::invokeRestart
[17:27:49.560]                     is.null <- base::is.null
[17:27:49.560]                     muffled <- FALSE
[17:27:49.560]                     if (inherits(cond, "message")) {
[17:27:49.560]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:49.560]                       if (muffled) 
[17:27:49.560]                         invokeRestart("muffleMessage")
[17:27:49.560]                     }
[17:27:49.560]                     else if (inherits(cond, "warning")) {
[17:27:49.560]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:49.560]                       if (muffled) 
[17:27:49.560]                         invokeRestart("muffleWarning")
[17:27:49.560]                     }
[17:27:49.560]                     else if (inherits(cond, "condition")) {
[17:27:49.560]                       if (!is.null(pattern)) {
[17:27:49.560]                         computeRestarts <- base::computeRestarts
[17:27:49.560]                         grepl <- base::grepl
[17:27:49.560]                         restarts <- computeRestarts(cond)
[17:27:49.560]                         for (restart in restarts) {
[17:27:49.560]                           name <- restart$name
[17:27:49.560]                           if (is.null(name)) 
[17:27:49.560]                             next
[17:27:49.560]                           if (!grepl(pattern, name)) 
[17:27:49.560]                             next
[17:27:49.560]                           invokeRestart(restart)
[17:27:49.560]                           muffled <- TRUE
[17:27:49.560]                           break
[17:27:49.560]                         }
[17:27:49.560]                       }
[17:27:49.560]                     }
[17:27:49.560]                     invisible(muffled)
[17:27:49.560]                   }
[17:27:49.560]                   muffleCondition(cond)
[17:27:49.560]                 })
[17:27:49.560]             }))
[17:27:49.560]             future::FutureResult(value = ...future.value$value, 
[17:27:49.560]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.560]                   ...future.rng), globalenv = if (FALSE) 
[17:27:49.560]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:49.560]                     ...future.globalenv.names))
[17:27:49.560]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:49.560]         }, condition = base::local({
[17:27:49.560]             c <- base::c
[17:27:49.560]             inherits <- base::inherits
[17:27:49.560]             invokeRestart <- base::invokeRestart
[17:27:49.560]             length <- base::length
[17:27:49.560]             list <- base::list
[17:27:49.560]             seq.int <- base::seq.int
[17:27:49.560]             signalCondition <- base::signalCondition
[17:27:49.560]             sys.calls <- base::sys.calls
[17:27:49.560]             `[[` <- base::`[[`
[17:27:49.560]             `+` <- base::`+`
[17:27:49.560]             `<<-` <- base::`<<-`
[17:27:49.560]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:49.560]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:49.560]                   3L)]
[17:27:49.560]             }
[17:27:49.560]             function(cond) {
[17:27:49.560]                 is_error <- inherits(cond, "error")
[17:27:49.560]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:49.560]                   NULL)
[17:27:49.560]                 if (is_error) {
[17:27:49.560]                   sessionInformation <- function() {
[17:27:49.560]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:49.560]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:49.560]                       search = base::search(), system = base::Sys.info())
[17:27:49.560]                   }
[17:27:49.560]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.560]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:49.560]                     cond$call), session = sessionInformation(), 
[17:27:49.560]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:49.560]                   signalCondition(cond)
[17:27:49.560]                 }
[17:27:49.560]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:49.560]                 "immediateCondition"))) {
[17:27:49.560]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:49.560]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.560]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:49.560]                   if (TRUE && !signal) {
[17:27:49.560]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.560]                     {
[17:27:49.560]                       inherits <- base::inherits
[17:27:49.560]                       invokeRestart <- base::invokeRestart
[17:27:49.560]                       is.null <- base::is.null
[17:27:49.560]                       muffled <- FALSE
[17:27:49.560]                       if (inherits(cond, "message")) {
[17:27:49.560]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.560]                         if (muffled) 
[17:27:49.560]                           invokeRestart("muffleMessage")
[17:27:49.560]                       }
[17:27:49.560]                       else if (inherits(cond, "warning")) {
[17:27:49.560]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.560]                         if (muffled) 
[17:27:49.560]                           invokeRestart("muffleWarning")
[17:27:49.560]                       }
[17:27:49.560]                       else if (inherits(cond, "condition")) {
[17:27:49.560]                         if (!is.null(pattern)) {
[17:27:49.560]                           computeRestarts <- base::computeRestarts
[17:27:49.560]                           grepl <- base::grepl
[17:27:49.560]                           restarts <- computeRestarts(cond)
[17:27:49.560]                           for (restart in restarts) {
[17:27:49.560]                             name <- restart$name
[17:27:49.560]                             if (is.null(name)) 
[17:27:49.560]                               next
[17:27:49.560]                             if (!grepl(pattern, name)) 
[17:27:49.560]                               next
[17:27:49.560]                             invokeRestart(restart)
[17:27:49.560]                             muffled <- TRUE
[17:27:49.560]                             break
[17:27:49.560]                           }
[17:27:49.560]                         }
[17:27:49.560]                       }
[17:27:49.560]                       invisible(muffled)
[17:27:49.560]                     }
[17:27:49.560]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.560]                   }
[17:27:49.560]                 }
[17:27:49.560]                 else {
[17:27:49.560]                   if (TRUE) {
[17:27:49.560]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.560]                     {
[17:27:49.560]                       inherits <- base::inherits
[17:27:49.560]                       invokeRestart <- base::invokeRestart
[17:27:49.560]                       is.null <- base::is.null
[17:27:49.560]                       muffled <- FALSE
[17:27:49.560]                       if (inherits(cond, "message")) {
[17:27:49.560]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.560]                         if (muffled) 
[17:27:49.560]                           invokeRestart("muffleMessage")
[17:27:49.560]                       }
[17:27:49.560]                       else if (inherits(cond, "warning")) {
[17:27:49.560]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.560]                         if (muffled) 
[17:27:49.560]                           invokeRestart("muffleWarning")
[17:27:49.560]                       }
[17:27:49.560]                       else if (inherits(cond, "condition")) {
[17:27:49.560]                         if (!is.null(pattern)) {
[17:27:49.560]                           computeRestarts <- base::computeRestarts
[17:27:49.560]                           grepl <- base::grepl
[17:27:49.560]                           restarts <- computeRestarts(cond)
[17:27:49.560]                           for (restart in restarts) {
[17:27:49.560]                             name <- restart$name
[17:27:49.560]                             if (is.null(name)) 
[17:27:49.560]                               next
[17:27:49.560]                             if (!grepl(pattern, name)) 
[17:27:49.560]                               next
[17:27:49.560]                             invokeRestart(restart)
[17:27:49.560]                             muffled <- TRUE
[17:27:49.560]                             break
[17:27:49.560]                           }
[17:27:49.560]                         }
[17:27:49.560]                       }
[17:27:49.560]                       invisible(muffled)
[17:27:49.560]                     }
[17:27:49.560]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.560]                   }
[17:27:49.560]                 }
[17:27:49.560]             }
[17:27:49.560]         }))
[17:27:49.560]     }, error = function(ex) {
[17:27:49.560]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:49.560]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.560]                 ...future.rng), started = ...future.startTime, 
[17:27:49.560]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:49.560]             version = "1.8"), class = "FutureResult")
[17:27:49.560]     }, finally = {
[17:27:49.560]         if (!identical(...future.workdir, getwd())) 
[17:27:49.560]             setwd(...future.workdir)
[17:27:49.560]         {
[17:27:49.560]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:49.560]                 ...future.oldOptions$nwarnings <- NULL
[17:27:49.560]             }
[17:27:49.560]             base::options(...future.oldOptions)
[17:27:49.560]             if (.Platform$OS.type == "windows") {
[17:27:49.560]                 old_names <- names(...future.oldEnvVars)
[17:27:49.560]                 envs <- base::Sys.getenv()
[17:27:49.560]                 names <- names(envs)
[17:27:49.560]                 common <- intersect(names, old_names)
[17:27:49.560]                 added <- setdiff(names, old_names)
[17:27:49.560]                 removed <- setdiff(old_names, names)
[17:27:49.560]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:49.560]                   envs[common]]
[17:27:49.560]                 NAMES <- toupper(changed)
[17:27:49.560]                 args <- list()
[17:27:49.560]                 for (kk in seq_along(NAMES)) {
[17:27:49.560]                   name <- changed[[kk]]
[17:27:49.560]                   NAME <- NAMES[[kk]]
[17:27:49.560]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.560]                     next
[17:27:49.560]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.560]                 }
[17:27:49.560]                 NAMES <- toupper(added)
[17:27:49.560]                 for (kk in seq_along(NAMES)) {
[17:27:49.560]                   name <- added[[kk]]
[17:27:49.560]                   NAME <- NAMES[[kk]]
[17:27:49.560]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.560]                     next
[17:27:49.560]                   args[[name]] <- ""
[17:27:49.560]                 }
[17:27:49.560]                 NAMES <- toupper(removed)
[17:27:49.560]                 for (kk in seq_along(NAMES)) {
[17:27:49.560]                   name <- removed[[kk]]
[17:27:49.560]                   NAME <- NAMES[[kk]]
[17:27:49.560]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.560]                     next
[17:27:49.560]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.560]                 }
[17:27:49.560]                 if (length(args) > 0) 
[17:27:49.560]                   base::do.call(base::Sys.setenv, args = args)
[17:27:49.560]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:49.560]             }
[17:27:49.560]             else {
[17:27:49.560]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:49.560]             }
[17:27:49.560]             {
[17:27:49.560]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:49.560]                   0L) {
[17:27:49.560]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:49.560]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:49.560]                   base::options(opts)
[17:27:49.560]                 }
[17:27:49.560]                 {
[17:27:49.560]                   {
[17:27:49.560]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:49.560]                     NULL
[17:27:49.560]                   }
[17:27:49.560]                   options(future.plan = NULL)
[17:27:49.560]                   if (is.na(NA_character_)) 
[17:27:49.560]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.560]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:49.560]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:49.560]                     .init = FALSE)
[17:27:49.560]                 }
[17:27:49.560]             }
[17:27:49.560]         }
[17:27:49.560]     })
[17:27:49.560]     if (TRUE) {
[17:27:49.560]         base::sink(type = "output", split = FALSE)
[17:27:49.560]         if (TRUE) {
[17:27:49.560]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:49.560]         }
[17:27:49.560]         else {
[17:27:49.560]             ...future.result["stdout"] <- base::list(NULL)
[17:27:49.560]         }
[17:27:49.560]         base::close(...future.stdout)
[17:27:49.560]         ...future.stdout <- NULL
[17:27:49.560]     }
[17:27:49.560]     ...future.result$conditions <- ...future.conditions
[17:27:49.560]     ...future.result$finished <- base::Sys.time()
[17:27:49.560]     ...future.result
[17:27:49.560] }
[17:27:49.570] Exporting 2 global objects (708 bytes) to cluster node #1 ...
[17:27:49.570] Exporting 'weight' (191 bytes) to cluster node #1 ...
[17:27:49.571] Exporting 'weight' (191 bytes) to cluster node #1 ... DONE
[17:27:49.571] Exporting 'group' (210 bytes) to cluster node #1 ...
[17:27:49.571] Exporting 'group' (210 bytes) to cluster node #1 ... DONE
[17:27:49.572] Exporting 2 global objects (708 bytes) to cluster node #1 ... DONE
[17:27:49.573] MultisessionFuture started
[17:27:49.573] - Launch lazy future ... done
[17:27:49.573] run() for 'MultisessionFuture' ... done
[17:27:49.574] result() for ClusterFuture ...
[17:27:49.574] receiveMessageFromWorker() for ClusterFuture ...
[17:27:49.574] - Validating connection of MultisessionFuture
[17:27:49.594] - received message: FutureResult
[17:27:49.595] - Received FutureResult
[17:27:49.595] - Erased future from FutureRegistry
[17:27:49.595] result() for ClusterFuture ...
[17:27:49.596] - result already collected: FutureResult
[17:27:49.596] result() for ClusterFuture ... done
[17:27:49.596] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:49.597] result() for ClusterFuture ... done
[17:27:49.597] result() for ClusterFuture ...
[17:27:49.597] - result already collected: FutureResult
[17:27:49.598] result() for ClusterFuture ... done

Call:
lm(formula = weight ~ group - 1)

Coefficients:
groupCtl  groupTrt  
   5.032     4.661  

[17:27:49.602] getGlobalsAndPackages() ...
[17:27:49.602] Searching for globals...
[17:27:49.606] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
[17:27:49.607] Searching for globals ... DONE
[17:27:49.607] Resolving globals: FALSE
[17:27:49.608] The total size of the 2 globals is 401 bytes (401 bytes)
[17:27:49.609] The total size of the 2 globals exported for future expression ('{; lm(weight ~ group - 1); }') is 401 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'group' (210 bytes of class 'numeric') and 'weight' (191 bytes of class 'numeric')
[17:27:49.610] - globals: [2] 'weight', 'group'
[17:27:49.610] - packages: [1] 'stats'
[17:27:49.610] getGlobalsAndPackages() ... DONE
[17:27:49.611] run() for 'Future' ...
[17:27:49.612] - state: 'created'
[17:27:49.612] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:49.634] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:49.634] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:49.635]   - Field: 'node'
[17:27:49.635]   - Field: 'label'
[17:27:49.635]   - Field: 'local'
[17:27:49.636]   - Field: 'owner'
[17:27:49.636]   - Field: 'envir'
[17:27:49.636]   - Field: 'workers'
[17:27:49.637]   - Field: 'packages'
[17:27:49.637]   - Field: 'gc'
[17:27:49.637]   - Field: 'conditions'
[17:27:49.638]   - Field: 'persistent'
[17:27:49.638]   - Field: 'expr'
[17:27:49.638]   - Field: 'uuid'
[17:27:49.639]   - Field: 'seed'
[17:27:49.639]   - Field: 'version'
[17:27:49.640]   - Field: 'result'
[17:27:49.640]   - Field: 'asynchronous'
[17:27:49.641]   - Field: 'calls'
[17:27:49.641]   - Field: 'globals'
[17:27:49.641]   - Field: 'stdout'
[17:27:49.642]   - Field: 'earlySignal'
[17:27:49.642]   - Field: 'lazy'
[17:27:49.642]   - Field: 'state'
[17:27:49.643] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:49.643] - Launch lazy future ...
[17:27:49.644] Packages needed by the future expression (n = 1): 'stats'
[17:27:49.644] Packages needed by future strategies (n = 0): <none>
[17:27:49.645] {
[17:27:49.645]     {
[17:27:49.645]         {
[17:27:49.645]             ...future.startTime <- base::Sys.time()
[17:27:49.645]             {
[17:27:49.645]                 {
[17:27:49.645]                   {
[17:27:49.645]                     {
[17:27:49.645]                       {
[17:27:49.645]                         base::local({
[17:27:49.645]                           has_future <- base::requireNamespace("future", 
[17:27:49.645]                             quietly = TRUE)
[17:27:49.645]                           if (has_future) {
[17:27:49.645]                             ns <- base::getNamespace("future")
[17:27:49.645]                             version <- ns[[".package"]][["version"]]
[17:27:49.645]                             if (is.null(version)) 
[17:27:49.645]                               version <- utils::packageVersion("future")
[17:27:49.645]                           }
[17:27:49.645]                           else {
[17:27:49.645]                             version <- NULL
[17:27:49.645]                           }
[17:27:49.645]                           if (!has_future || version < "1.8.0") {
[17:27:49.645]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:49.645]                               "", base::R.version$version.string), 
[17:27:49.645]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:49.645]                                 base::R.version$platform, 8 * 
[17:27:49.645]                                   base::.Machine$sizeof.pointer), 
[17:27:49.645]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:49.645]                                 "release", "version")], collapse = " "), 
[17:27:49.645]                               hostname = base::Sys.info()[["nodename"]])
[17:27:49.645]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:49.645]                               info)
[17:27:49.645]                             info <- base::paste(info, collapse = "; ")
[17:27:49.645]                             if (!has_future) {
[17:27:49.645]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:49.645]                                 info)
[17:27:49.645]                             }
[17:27:49.645]                             else {
[17:27:49.645]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:49.645]                                 info, version)
[17:27:49.645]                             }
[17:27:49.645]                             base::stop(msg)
[17:27:49.645]                           }
[17:27:49.645]                         })
[17:27:49.645]                       }
[17:27:49.645]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:49.645]                       base::options(mc.cores = 1L)
[17:27:49.645]                     }
[17:27:49.645]                     base::local({
[17:27:49.645]                       for (pkg in "stats") {
[17:27:49.645]                         base::loadNamespace(pkg)
[17:27:49.645]                         base::library(pkg, character.only = TRUE)
[17:27:49.645]                       }
[17:27:49.645]                     })
[17:27:49.645]                   }
[17:27:49.645]                   ...future.strategy.old <- future::plan("list")
[17:27:49.645]                   options(future.plan = NULL)
[17:27:49.645]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.645]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:49.645]                 }
[17:27:49.645]                 ...future.workdir <- getwd()
[17:27:49.645]             }
[17:27:49.645]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:49.645]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:49.645]         }
[17:27:49.645]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:49.645]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:49.645]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:49.645]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:49.645]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:49.645]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:49.645]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:49.645]             base::names(...future.oldOptions))
[17:27:49.645]     }
[17:27:49.645]     if (FALSE) {
[17:27:49.645]     }
[17:27:49.645]     else {
[17:27:49.645]         if (TRUE) {
[17:27:49.645]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:49.645]                 open = "w")
[17:27:49.645]         }
[17:27:49.645]         else {
[17:27:49.645]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:49.645]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:49.645]         }
[17:27:49.645]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:49.645]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:49.645]             base::sink(type = "output", split = FALSE)
[17:27:49.645]             base::close(...future.stdout)
[17:27:49.645]         }, add = TRUE)
[17:27:49.645]     }
[17:27:49.645]     ...future.frame <- base::sys.nframe()
[17:27:49.645]     ...future.conditions <- base::list()
[17:27:49.645]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:49.645]     if (FALSE) {
[17:27:49.645]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:49.645]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:49.645]     }
[17:27:49.645]     ...future.result <- base::tryCatch({
[17:27:49.645]         base::withCallingHandlers({
[17:27:49.645]             ...future.value <- base::withVisible(base::local({
[17:27:49.645]                 ...future.makeSendCondition <- base::local({
[17:27:49.645]                   sendCondition <- NULL
[17:27:49.645]                   function(frame = 1L) {
[17:27:49.645]                     if (is.function(sendCondition)) 
[17:27:49.645]                       return(sendCondition)
[17:27:49.645]                     ns <- getNamespace("parallel")
[17:27:49.645]                     if (exists("sendData", mode = "function", 
[17:27:49.645]                       envir = ns)) {
[17:27:49.645]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:49.645]                         envir = ns)
[17:27:49.645]                       envir <- sys.frame(frame)
[17:27:49.645]                       master <- NULL
[17:27:49.645]                       while (!identical(envir, .GlobalEnv) && 
[17:27:49.645]                         !identical(envir, emptyenv())) {
[17:27:49.645]                         if (exists("master", mode = "list", envir = envir, 
[17:27:49.645]                           inherits = FALSE)) {
[17:27:49.645]                           master <- get("master", mode = "list", 
[17:27:49.645]                             envir = envir, inherits = FALSE)
[17:27:49.645]                           if (inherits(master, c("SOCKnode", 
[17:27:49.645]                             "SOCK0node"))) {
[17:27:49.645]                             sendCondition <<- function(cond) {
[17:27:49.645]                               data <- list(type = "VALUE", value = cond, 
[17:27:49.645]                                 success = TRUE)
[17:27:49.645]                               parallel_sendData(master, data)
[17:27:49.645]                             }
[17:27:49.645]                             return(sendCondition)
[17:27:49.645]                           }
[17:27:49.645]                         }
[17:27:49.645]                         frame <- frame + 1L
[17:27:49.645]                         envir <- sys.frame(frame)
[17:27:49.645]                       }
[17:27:49.645]                     }
[17:27:49.645]                     sendCondition <<- function(cond) NULL
[17:27:49.645]                   }
[17:27:49.645]                 })
[17:27:49.645]                 withCallingHandlers({
[17:27:49.645]                   {
[17:27:49.645]                     lm(weight ~ group - 1)
[17:27:49.645]                   }
[17:27:49.645]                 }, immediateCondition = function(cond) {
[17:27:49.645]                   sendCondition <- ...future.makeSendCondition()
[17:27:49.645]                   sendCondition(cond)
[17:27:49.645]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.645]                   {
[17:27:49.645]                     inherits <- base::inherits
[17:27:49.645]                     invokeRestart <- base::invokeRestart
[17:27:49.645]                     is.null <- base::is.null
[17:27:49.645]                     muffled <- FALSE
[17:27:49.645]                     if (inherits(cond, "message")) {
[17:27:49.645]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:49.645]                       if (muffled) 
[17:27:49.645]                         invokeRestart("muffleMessage")
[17:27:49.645]                     }
[17:27:49.645]                     else if (inherits(cond, "warning")) {
[17:27:49.645]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:49.645]                       if (muffled) 
[17:27:49.645]                         invokeRestart("muffleWarning")
[17:27:49.645]                     }
[17:27:49.645]                     else if (inherits(cond, "condition")) {
[17:27:49.645]                       if (!is.null(pattern)) {
[17:27:49.645]                         computeRestarts <- base::computeRestarts
[17:27:49.645]                         grepl <- base::grepl
[17:27:49.645]                         restarts <- computeRestarts(cond)
[17:27:49.645]                         for (restart in restarts) {
[17:27:49.645]                           name <- restart$name
[17:27:49.645]                           if (is.null(name)) 
[17:27:49.645]                             next
[17:27:49.645]                           if (!grepl(pattern, name)) 
[17:27:49.645]                             next
[17:27:49.645]                           invokeRestart(restart)
[17:27:49.645]                           muffled <- TRUE
[17:27:49.645]                           break
[17:27:49.645]                         }
[17:27:49.645]                       }
[17:27:49.645]                     }
[17:27:49.645]                     invisible(muffled)
[17:27:49.645]                   }
[17:27:49.645]                   muffleCondition(cond)
[17:27:49.645]                 })
[17:27:49.645]             }))
[17:27:49.645]             future::FutureResult(value = ...future.value$value, 
[17:27:49.645]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.645]                   ...future.rng), globalenv = if (FALSE) 
[17:27:49.645]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:49.645]                     ...future.globalenv.names))
[17:27:49.645]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:49.645]         }, condition = base::local({
[17:27:49.645]             c <- base::c
[17:27:49.645]             inherits <- base::inherits
[17:27:49.645]             invokeRestart <- base::invokeRestart
[17:27:49.645]             length <- base::length
[17:27:49.645]             list <- base::list
[17:27:49.645]             seq.int <- base::seq.int
[17:27:49.645]             signalCondition <- base::signalCondition
[17:27:49.645]             sys.calls <- base::sys.calls
[17:27:49.645]             `[[` <- base::`[[`
[17:27:49.645]             `+` <- base::`+`
[17:27:49.645]             `<<-` <- base::`<<-`
[17:27:49.645]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:49.645]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:49.645]                   3L)]
[17:27:49.645]             }
[17:27:49.645]             function(cond) {
[17:27:49.645]                 is_error <- inherits(cond, "error")
[17:27:49.645]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:49.645]                   NULL)
[17:27:49.645]                 if (is_error) {
[17:27:49.645]                   sessionInformation <- function() {
[17:27:49.645]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:49.645]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:49.645]                       search = base::search(), system = base::Sys.info())
[17:27:49.645]                   }
[17:27:49.645]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.645]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:49.645]                     cond$call), session = sessionInformation(), 
[17:27:49.645]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:49.645]                   signalCondition(cond)
[17:27:49.645]                 }
[17:27:49.645]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:49.645]                 "immediateCondition"))) {
[17:27:49.645]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:49.645]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.645]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:49.645]                   if (TRUE && !signal) {
[17:27:49.645]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.645]                     {
[17:27:49.645]                       inherits <- base::inherits
[17:27:49.645]                       invokeRestart <- base::invokeRestart
[17:27:49.645]                       is.null <- base::is.null
[17:27:49.645]                       muffled <- FALSE
[17:27:49.645]                       if (inherits(cond, "message")) {
[17:27:49.645]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.645]                         if (muffled) 
[17:27:49.645]                           invokeRestart("muffleMessage")
[17:27:49.645]                       }
[17:27:49.645]                       else if (inherits(cond, "warning")) {
[17:27:49.645]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.645]                         if (muffled) 
[17:27:49.645]                           invokeRestart("muffleWarning")
[17:27:49.645]                       }
[17:27:49.645]                       else if (inherits(cond, "condition")) {
[17:27:49.645]                         if (!is.null(pattern)) {
[17:27:49.645]                           computeRestarts <- base::computeRestarts
[17:27:49.645]                           grepl <- base::grepl
[17:27:49.645]                           restarts <- computeRestarts(cond)
[17:27:49.645]                           for (restart in restarts) {
[17:27:49.645]                             name <- restart$name
[17:27:49.645]                             if (is.null(name)) 
[17:27:49.645]                               next
[17:27:49.645]                             if (!grepl(pattern, name)) 
[17:27:49.645]                               next
[17:27:49.645]                             invokeRestart(restart)
[17:27:49.645]                             muffled <- TRUE
[17:27:49.645]                             break
[17:27:49.645]                           }
[17:27:49.645]                         }
[17:27:49.645]                       }
[17:27:49.645]                       invisible(muffled)
[17:27:49.645]                     }
[17:27:49.645]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.645]                   }
[17:27:49.645]                 }
[17:27:49.645]                 else {
[17:27:49.645]                   if (TRUE) {
[17:27:49.645]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.645]                     {
[17:27:49.645]                       inherits <- base::inherits
[17:27:49.645]                       invokeRestart <- base::invokeRestart
[17:27:49.645]                       is.null <- base::is.null
[17:27:49.645]                       muffled <- FALSE
[17:27:49.645]                       if (inherits(cond, "message")) {
[17:27:49.645]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.645]                         if (muffled) 
[17:27:49.645]                           invokeRestart("muffleMessage")
[17:27:49.645]                       }
[17:27:49.645]                       else if (inherits(cond, "warning")) {
[17:27:49.645]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.645]                         if (muffled) 
[17:27:49.645]                           invokeRestart("muffleWarning")
[17:27:49.645]                       }
[17:27:49.645]                       else if (inherits(cond, "condition")) {
[17:27:49.645]                         if (!is.null(pattern)) {
[17:27:49.645]                           computeRestarts <- base::computeRestarts
[17:27:49.645]                           grepl <- base::grepl
[17:27:49.645]                           restarts <- computeRestarts(cond)
[17:27:49.645]                           for (restart in restarts) {
[17:27:49.645]                             name <- restart$name
[17:27:49.645]                             if (is.null(name)) 
[17:27:49.645]                               next
[17:27:49.645]                             if (!grepl(pattern, name)) 
[17:27:49.645]                               next
[17:27:49.645]                             invokeRestart(restart)
[17:27:49.645]                             muffled <- TRUE
[17:27:49.645]                             break
[17:27:49.645]                           }
[17:27:49.645]                         }
[17:27:49.645]                       }
[17:27:49.645]                       invisible(muffled)
[17:27:49.645]                     }
[17:27:49.645]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.645]                   }
[17:27:49.645]                 }
[17:27:49.645]             }
[17:27:49.645]         }))
[17:27:49.645]     }, error = function(ex) {
[17:27:49.645]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:49.645]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.645]                 ...future.rng), started = ...future.startTime, 
[17:27:49.645]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:49.645]             version = "1.8"), class = "FutureResult")
[17:27:49.645]     }, finally = {
[17:27:49.645]         if (!identical(...future.workdir, getwd())) 
[17:27:49.645]             setwd(...future.workdir)
[17:27:49.645]         {
[17:27:49.645]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:49.645]                 ...future.oldOptions$nwarnings <- NULL
[17:27:49.645]             }
[17:27:49.645]             base::options(...future.oldOptions)
[17:27:49.645]             if (.Platform$OS.type == "windows") {
[17:27:49.645]                 old_names <- names(...future.oldEnvVars)
[17:27:49.645]                 envs <- base::Sys.getenv()
[17:27:49.645]                 names <- names(envs)
[17:27:49.645]                 common <- intersect(names, old_names)
[17:27:49.645]                 added <- setdiff(names, old_names)
[17:27:49.645]                 removed <- setdiff(old_names, names)
[17:27:49.645]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:49.645]                   envs[common]]
[17:27:49.645]                 NAMES <- toupper(changed)
[17:27:49.645]                 args <- list()
[17:27:49.645]                 for (kk in seq_along(NAMES)) {
[17:27:49.645]                   name <- changed[[kk]]
[17:27:49.645]                   NAME <- NAMES[[kk]]
[17:27:49.645]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.645]                     next
[17:27:49.645]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.645]                 }
[17:27:49.645]                 NAMES <- toupper(added)
[17:27:49.645]                 for (kk in seq_along(NAMES)) {
[17:27:49.645]                   name <- added[[kk]]
[17:27:49.645]                   NAME <- NAMES[[kk]]
[17:27:49.645]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.645]                     next
[17:27:49.645]                   args[[name]] <- ""
[17:27:49.645]                 }
[17:27:49.645]                 NAMES <- toupper(removed)
[17:27:49.645]                 for (kk in seq_along(NAMES)) {
[17:27:49.645]                   name <- removed[[kk]]
[17:27:49.645]                   NAME <- NAMES[[kk]]
[17:27:49.645]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.645]                     next
[17:27:49.645]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.645]                 }
[17:27:49.645]                 if (length(args) > 0) 
[17:27:49.645]                   base::do.call(base::Sys.setenv, args = args)
[17:27:49.645]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:49.645]             }
[17:27:49.645]             else {
[17:27:49.645]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:49.645]             }
[17:27:49.645]             {
[17:27:49.645]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:49.645]                   0L) {
[17:27:49.645]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:49.645]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:49.645]                   base::options(opts)
[17:27:49.645]                 }
[17:27:49.645]                 {
[17:27:49.645]                   {
[17:27:49.645]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:49.645]                     NULL
[17:27:49.645]                   }
[17:27:49.645]                   options(future.plan = NULL)
[17:27:49.645]                   if (is.na(NA_character_)) 
[17:27:49.645]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.645]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:49.645]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:49.645]                     .init = FALSE)
[17:27:49.645]                 }
[17:27:49.645]             }
[17:27:49.645]         }
[17:27:49.645]     })
[17:27:49.645]     if (TRUE) {
[17:27:49.645]         base::sink(type = "output", split = FALSE)
[17:27:49.645]         if (TRUE) {
[17:27:49.645]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:49.645]         }
[17:27:49.645]         else {
[17:27:49.645]             ...future.result["stdout"] <- base::list(NULL)
[17:27:49.645]         }
[17:27:49.645]         base::close(...future.stdout)
[17:27:49.645]         ...future.stdout <- NULL
[17:27:49.645]     }
[17:27:49.645]     ...future.result$conditions <- ...future.conditions
[17:27:49.645]     ...future.result$finished <- base::Sys.time()
[17:27:49.645]     ...future.result
[17:27:49.645] }
[17:27:49.655] Exporting 2 global objects (708 bytes) to cluster node #1 ...
[17:27:49.655] Exporting 'weight' (191 bytes) to cluster node #1 ...
[17:27:49.656] Exporting 'weight' (191 bytes) to cluster node #1 ... DONE
[17:27:49.656] Exporting 'group' (210 bytes) to cluster node #1 ...
[17:27:49.657] Exporting 'group' (210 bytes) to cluster node #1 ... DONE
[17:27:49.662] Exporting 2 global objects (708 bytes) to cluster node #1 ... DONE
[17:27:49.663] MultisessionFuture started
[17:27:49.664] - Launch lazy future ... done
[17:27:49.664] run() for 'MultisessionFuture' ... done
[17:27:49.664] result() for ClusterFuture ...
[17:27:49.665] receiveMessageFromWorker() for ClusterFuture ...
[17:27:49.665] - Validating connection of MultisessionFuture
[17:27:49.684] - received message: FutureResult
[17:27:49.685] - Received FutureResult
[17:27:49.685] - Erased future from FutureRegistry
[17:27:49.685] result() for ClusterFuture ...
[17:27:49.685] - result already collected: FutureResult
[17:27:49.685] result() for ClusterFuture ... done
[17:27:49.685] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:49.686] result() for ClusterFuture ... done
[17:27:49.686] result() for ClusterFuture ...
[17:27:49.686] - result already collected: FutureResult
[17:27:49.686] result() for ClusterFuture ... done

Call:
lm(formula = weight ~ group - 1)

Coefficients:
groupCtl  groupTrt  
   5.032     4.661  

[17:27:49.689] getGlobalsAndPackages() ...
[17:27:49.689] Searching for globals...
[17:27:49.692] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
[17:27:49.692] Searching for globals ... DONE
[17:27:49.692] Resolving globals: FALSE
[17:27:49.693] The total size of the 2 globals is 401 bytes (401 bytes)
[17:27:49.694] The total size of the 2 globals exported for future expression ('{; lm(weight ~ group - 1); }') is 401 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'group' (210 bytes of class 'numeric') and 'weight' (191 bytes of class 'numeric')
[17:27:49.694] - globals: [2] 'weight', 'group'
[17:27:49.695] - packages: [1] 'stats'
[17:27:49.695] getGlobalsAndPackages() ... DONE
[17:27:49.695] run() for 'Future' ...
[17:27:49.696] - state: 'created'
[17:27:49.696] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:49.716] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:49.717] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:49.717]   - Field: 'node'
[17:27:49.717]   - Field: 'label'
[17:27:49.718]   - Field: 'local'
[17:27:49.718]   - Field: 'owner'
[17:27:49.718]   - Field: 'envir'
[17:27:49.718]   - Field: 'workers'
[17:27:49.719]   - Field: 'packages'
[17:27:49.719]   - Field: 'gc'
[17:27:49.719]   - Field: 'conditions'
[17:27:49.720]   - Field: 'persistent'
[17:27:49.720]   - Field: 'expr'
[17:27:49.720]   - Field: 'uuid'
[17:27:49.721]   - Field: 'seed'
[17:27:49.721]   - Field: 'version'
[17:27:49.721]   - Field: 'result'
[17:27:49.722]   - Field: 'asynchronous'
[17:27:49.722]   - Field: 'calls'
[17:27:49.722]   - Field: 'globals'
[17:27:49.723]   - Field: 'stdout'
[17:27:49.723]   - Field: 'earlySignal'
[17:27:49.723]   - Field: 'lazy'
[17:27:49.724]   - Field: 'state'
[17:27:49.724] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:49.724] - Launch lazy future ...
[17:27:49.725] Packages needed by the future expression (n = 1): 'stats'
[17:27:49.725] Packages needed by future strategies (n = 0): <none>
[17:27:49.727] {
[17:27:49.727]     {
[17:27:49.727]         {
[17:27:49.727]             ...future.startTime <- base::Sys.time()
[17:27:49.727]             {
[17:27:49.727]                 {
[17:27:49.727]                   {
[17:27:49.727]                     {
[17:27:49.727]                       {
[17:27:49.727]                         base::local({
[17:27:49.727]                           has_future <- base::requireNamespace("future", 
[17:27:49.727]                             quietly = TRUE)
[17:27:49.727]                           if (has_future) {
[17:27:49.727]                             ns <- base::getNamespace("future")
[17:27:49.727]                             version <- ns[[".package"]][["version"]]
[17:27:49.727]                             if (is.null(version)) 
[17:27:49.727]                               version <- utils::packageVersion("future")
[17:27:49.727]                           }
[17:27:49.727]                           else {
[17:27:49.727]                             version <- NULL
[17:27:49.727]                           }
[17:27:49.727]                           if (!has_future || version < "1.8.0") {
[17:27:49.727]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:49.727]                               "", base::R.version$version.string), 
[17:27:49.727]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:49.727]                                 base::R.version$platform, 8 * 
[17:27:49.727]                                   base::.Machine$sizeof.pointer), 
[17:27:49.727]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:49.727]                                 "release", "version")], collapse = " "), 
[17:27:49.727]                               hostname = base::Sys.info()[["nodename"]])
[17:27:49.727]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:49.727]                               info)
[17:27:49.727]                             info <- base::paste(info, collapse = "; ")
[17:27:49.727]                             if (!has_future) {
[17:27:49.727]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:49.727]                                 info)
[17:27:49.727]                             }
[17:27:49.727]                             else {
[17:27:49.727]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:49.727]                                 info, version)
[17:27:49.727]                             }
[17:27:49.727]                             base::stop(msg)
[17:27:49.727]                           }
[17:27:49.727]                         })
[17:27:49.727]                       }
[17:27:49.727]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:49.727]                       base::options(mc.cores = 1L)
[17:27:49.727]                     }
[17:27:49.727]                     base::local({
[17:27:49.727]                       for (pkg in "stats") {
[17:27:49.727]                         base::loadNamespace(pkg)
[17:27:49.727]                         base::library(pkg, character.only = TRUE)
[17:27:49.727]                       }
[17:27:49.727]                     })
[17:27:49.727]                   }
[17:27:49.727]                   ...future.strategy.old <- future::plan("list")
[17:27:49.727]                   options(future.plan = NULL)
[17:27:49.727]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.727]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:49.727]                 }
[17:27:49.727]                 ...future.workdir <- getwd()
[17:27:49.727]             }
[17:27:49.727]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:49.727]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:49.727]         }
[17:27:49.727]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:49.727]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:49.727]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:49.727]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:49.727]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:49.727]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:49.727]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:49.727]             base::names(...future.oldOptions))
[17:27:49.727]     }
[17:27:49.727]     if (FALSE) {
[17:27:49.727]     }
[17:27:49.727]     else {
[17:27:49.727]         if (TRUE) {
[17:27:49.727]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:49.727]                 open = "w")
[17:27:49.727]         }
[17:27:49.727]         else {
[17:27:49.727]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:49.727]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:49.727]         }
[17:27:49.727]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:49.727]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:49.727]             base::sink(type = "output", split = FALSE)
[17:27:49.727]             base::close(...future.stdout)
[17:27:49.727]         }, add = TRUE)
[17:27:49.727]     }
[17:27:49.727]     ...future.frame <- base::sys.nframe()
[17:27:49.727]     ...future.conditions <- base::list()
[17:27:49.727]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:49.727]     if (FALSE) {
[17:27:49.727]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:49.727]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:49.727]     }
[17:27:49.727]     ...future.result <- base::tryCatch({
[17:27:49.727]         base::withCallingHandlers({
[17:27:49.727]             ...future.value <- base::withVisible(base::local({
[17:27:49.727]                 ...future.makeSendCondition <- base::local({
[17:27:49.727]                   sendCondition <- NULL
[17:27:49.727]                   function(frame = 1L) {
[17:27:49.727]                     if (is.function(sendCondition)) 
[17:27:49.727]                       return(sendCondition)
[17:27:49.727]                     ns <- getNamespace("parallel")
[17:27:49.727]                     if (exists("sendData", mode = "function", 
[17:27:49.727]                       envir = ns)) {
[17:27:49.727]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:49.727]                         envir = ns)
[17:27:49.727]                       envir <- sys.frame(frame)
[17:27:49.727]                       master <- NULL
[17:27:49.727]                       while (!identical(envir, .GlobalEnv) && 
[17:27:49.727]                         !identical(envir, emptyenv())) {
[17:27:49.727]                         if (exists("master", mode = "list", envir = envir, 
[17:27:49.727]                           inherits = FALSE)) {
[17:27:49.727]                           master <- get("master", mode = "list", 
[17:27:49.727]                             envir = envir, inherits = FALSE)
[17:27:49.727]                           if (inherits(master, c("SOCKnode", 
[17:27:49.727]                             "SOCK0node"))) {
[17:27:49.727]                             sendCondition <<- function(cond) {
[17:27:49.727]                               data <- list(type = "VALUE", value = cond, 
[17:27:49.727]                                 success = TRUE)
[17:27:49.727]                               parallel_sendData(master, data)
[17:27:49.727]                             }
[17:27:49.727]                             return(sendCondition)
[17:27:49.727]                           }
[17:27:49.727]                         }
[17:27:49.727]                         frame <- frame + 1L
[17:27:49.727]                         envir <- sys.frame(frame)
[17:27:49.727]                       }
[17:27:49.727]                     }
[17:27:49.727]                     sendCondition <<- function(cond) NULL
[17:27:49.727]                   }
[17:27:49.727]                 })
[17:27:49.727]                 withCallingHandlers({
[17:27:49.727]                   {
[17:27:49.727]                     lm(weight ~ group - 1)
[17:27:49.727]                   }
[17:27:49.727]                 }, immediateCondition = function(cond) {
[17:27:49.727]                   sendCondition <- ...future.makeSendCondition()
[17:27:49.727]                   sendCondition(cond)
[17:27:49.727]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.727]                   {
[17:27:49.727]                     inherits <- base::inherits
[17:27:49.727]                     invokeRestart <- base::invokeRestart
[17:27:49.727]                     is.null <- base::is.null
[17:27:49.727]                     muffled <- FALSE
[17:27:49.727]                     if (inherits(cond, "message")) {
[17:27:49.727]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:49.727]                       if (muffled) 
[17:27:49.727]                         invokeRestart("muffleMessage")
[17:27:49.727]                     }
[17:27:49.727]                     else if (inherits(cond, "warning")) {
[17:27:49.727]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:49.727]                       if (muffled) 
[17:27:49.727]                         invokeRestart("muffleWarning")
[17:27:49.727]                     }
[17:27:49.727]                     else if (inherits(cond, "condition")) {
[17:27:49.727]                       if (!is.null(pattern)) {
[17:27:49.727]                         computeRestarts <- base::computeRestarts
[17:27:49.727]                         grepl <- base::grepl
[17:27:49.727]                         restarts <- computeRestarts(cond)
[17:27:49.727]                         for (restart in restarts) {
[17:27:49.727]                           name <- restart$name
[17:27:49.727]                           if (is.null(name)) 
[17:27:49.727]                             next
[17:27:49.727]                           if (!grepl(pattern, name)) 
[17:27:49.727]                             next
[17:27:49.727]                           invokeRestart(restart)
[17:27:49.727]                           muffled <- TRUE
[17:27:49.727]                           break
[17:27:49.727]                         }
[17:27:49.727]                       }
[17:27:49.727]                     }
[17:27:49.727]                     invisible(muffled)
[17:27:49.727]                   }
[17:27:49.727]                   muffleCondition(cond)
[17:27:49.727]                 })
[17:27:49.727]             }))
[17:27:49.727]             future::FutureResult(value = ...future.value$value, 
[17:27:49.727]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.727]                   ...future.rng), globalenv = if (FALSE) 
[17:27:49.727]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:49.727]                     ...future.globalenv.names))
[17:27:49.727]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:49.727]         }, condition = base::local({
[17:27:49.727]             c <- base::c
[17:27:49.727]             inherits <- base::inherits
[17:27:49.727]             invokeRestart <- base::invokeRestart
[17:27:49.727]             length <- base::length
[17:27:49.727]             list <- base::list
[17:27:49.727]             seq.int <- base::seq.int
[17:27:49.727]             signalCondition <- base::signalCondition
[17:27:49.727]             sys.calls <- base::sys.calls
[17:27:49.727]             `[[` <- base::`[[`
[17:27:49.727]             `+` <- base::`+`
[17:27:49.727]             `<<-` <- base::`<<-`
[17:27:49.727]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:49.727]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:49.727]                   3L)]
[17:27:49.727]             }
[17:27:49.727]             function(cond) {
[17:27:49.727]                 is_error <- inherits(cond, "error")
[17:27:49.727]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:49.727]                   NULL)
[17:27:49.727]                 if (is_error) {
[17:27:49.727]                   sessionInformation <- function() {
[17:27:49.727]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:49.727]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:49.727]                       search = base::search(), system = base::Sys.info())
[17:27:49.727]                   }
[17:27:49.727]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.727]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:49.727]                     cond$call), session = sessionInformation(), 
[17:27:49.727]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:49.727]                   signalCondition(cond)
[17:27:49.727]                 }
[17:27:49.727]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:49.727]                 "immediateCondition"))) {
[17:27:49.727]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:49.727]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.727]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:49.727]                   if (TRUE && !signal) {
[17:27:49.727]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.727]                     {
[17:27:49.727]                       inherits <- base::inherits
[17:27:49.727]                       invokeRestart <- base::invokeRestart
[17:27:49.727]                       is.null <- base::is.null
[17:27:49.727]                       muffled <- FALSE
[17:27:49.727]                       if (inherits(cond, "message")) {
[17:27:49.727]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.727]                         if (muffled) 
[17:27:49.727]                           invokeRestart("muffleMessage")
[17:27:49.727]                       }
[17:27:49.727]                       else if (inherits(cond, "warning")) {
[17:27:49.727]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.727]                         if (muffled) 
[17:27:49.727]                           invokeRestart("muffleWarning")
[17:27:49.727]                       }
[17:27:49.727]                       else if (inherits(cond, "condition")) {
[17:27:49.727]                         if (!is.null(pattern)) {
[17:27:49.727]                           computeRestarts <- base::computeRestarts
[17:27:49.727]                           grepl <- base::grepl
[17:27:49.727]                           restarts <- computeRestarts(cond)
[17:27:49.727]                           for (restart in restarts) {
[17:27:49.727]                             name <- restart$name
[17:27:49.727]                             if (is.null(name)) 
[17:27:49.727]                               next
[17:27:49.727]                             if (!grepl(pattern, name)) 
[17:27:49.727]                               next
[17:27:49.727]                             invokeRestart(restart)
[17:27:49.727]                             muffled <- TRUE
[17:27:49.727]                             break
[17:27:49.727]                           }
[17:27:49.727]                         }
[17:27:49.727]                       }
[17:27:49.727]                       invisible(muffled)
[17:27:49.727]                     }
[17:27:49.727]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.727]                   }
[17:27:49.727]                 }
[17:27:49.727]                 else {
[17:27:49.727]                   if (TRUE) {
[17:27:49.727]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.727]                     {
[17:27:49.727]                       inherits <- base::inherits
[17:27:49.727]                       invokeRestart <- base::invokeRestart
[17:27:49.727]                       is.null <- base::is.null
[17:27:49.727]                       muffled <- FALSE
[17:27:49.727]                       if (inherits(cond, "message")) {
[17:27:49.727]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.727]                         if (muffled) 
[17:27:49.727]                           invokeRestart("muffleMessage")
[17:27:49.727]                       }
[17:27:49.727]                       else if (inherits(cond, "warning")) {
[17:27:49.727]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.727]                         if (muffled) 
[17:27:49.727]                           invokeRestart("muffleWarning")
[17:27:49.727]                       }
[17:27:49.727]                       else if (inherits(cond, "condition")) {
[17:27:49.727]                         if (!is.null(pattern)) {
[17:27:49.727]                           computeRestarts <- base::computeRestarts
[17:27:49.727]                           grepl <- base::grepl
[17:27:49.727]                           restarts <- computeRestarts(cond)
[17:27:49.727]                           for (restart in restarts) {
[17:27:49.727]                             name <- restart$name
[17:27:49.727]                             if (is.null(name)) 
[17:27:49.727]                               next
[17:27:49.727]                             if (!grepl(pattern, name)) 
[17:27:49.727]                               next
[17:27:49.727]                             invokeRestart(restart)
[17:27:49.727]                             muffled <- TRUE
[17:27:49.727]                             break
[17:27:49.727]                           }
[17:27:49.727]                         }
[17:27:49.727]                       }
[17:27:49.727]                       invisible(muffled)
[17:27:49.727]                     }
[17:27:49.727]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.727]                   }
[17:27:49.727]                 }
[17:27:49.727]             }
[17:27:49.727]         }))
[17:27:49.727]     }, error = function(ex) {
[17:27:49.727]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:49.727]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.727]                 ...future.rng), started = ...future.startTime, 
[17:27:49.727]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:49.727]             version = "1.8"), class = "FutureResult")
[17:27:49.727]     }, finally = {
[17:27:49.727]         if (!identical(...future.workdir, getwd())) 
[17:27:49.727]             setwd(...future.workdir)
[17:27:49.727]         {
[17:27:49.727]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:49.727]                 ...future.oldOptions$nwarnings <- NULL
[17:27:49.727]             }
[17:27:49.727]             base::options(...future.oldOptions)
[17:27:49.727]             if (.Platform$OS.type == "windows") {
[17:27:49.727]                 old_names <- names(...future.oldEnvVars)
[17:27:49.727]                 envs <- base::Sys.getenv()
[17:27:49.727]                 names <- names(envs)
[17:27:49.727]                 common <- intersect(names, old_names)
[17:27:49.727]                 added <- setdiff(names, old_names)
[17:27:49.727]                 removed <- setdiff(old_names, names)
[17:27:49.727]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:49.727]                   envs[common]]
[17:27:49.727]                 NAMES <- toupper(changed)
[17:27:49.727]                 args <- list()
[17:27:49.727]                 for (kk in seq_along(NAMES)) {
[17:27:49.727]                   name <- changed[[kk]]
[17:27:49.727]                   NAME <- NAMES[[kk]]
[17:27:49.727]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.727]                     next
[17:27:49.727]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.727]                 }
[17:27:49.727]                 NAMES <- toupper(added)
[17:27:49.727]                 for (kk in seq_along(NAMES)) {
[17:27:49.727]                   name <- added[[kk]]
[17:27:49.727]                   NAME <- NAMES[[kk]]
[17:27:49.727]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.727]                     next
[17:27:49.727]                   args[[name]] <- ""
[17:27:49.727]                 }
[17:27:49.727]                 NAMES <- toupper(removed)
[17:27:49.727]                 for (kk in seq_along(NAMES)) {
[17:27:49.727]                   name <- removed[[kk]]
[17:27:49.727]                   NAME <- NAMES[[kk]]
[17:27:49.727]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.727]                     next
[17:27:49.727]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.727]                 }
[17:27:49.727]                 if (length(args) > 0) 
[17:27:49.727]                   base::do.call(base::Sys.setenv, args = args)
[17:27:49.727]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:49.727]             }
[17:27:49.727]             else {
[17:27:49.727]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:49.727]             }
[17:27:49.727]             {
[17:27:49.727]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:49.727]                   0L) {
[17:27:49.727]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:49.727]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:49.727]                   base::options(opts)
[17:27:49.727]                 }
[17:27:49.727]                 {
[17:27:49.727]                   {
[17:27:49.727]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:49.727]                     NULL
[17:27:49.727]                   }
[17:27:49.727]                   options(future.plan = NULL)
[17:27:49.727]                   if (is.na(NA_character_)) 
[17:27:49.727]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.727]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:49.727]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:49.727]                     .init = FALSE)
[17:27:49.727]                 }
[17:27:49.727]             }
[17:27:49.727]         }
[17:27:49.727]     })
[17:27:49.727]     if (TRUE) {
[17:27:49.727]         base::sink(type = "output", split = FALSE)
[17:27:49.727]         if (TRUE) {
[17:27:49.727]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:49.727]         }
[17:27:49.727]         else {
[17:27:49.727]             ...future.result["stdout"] <- base::list(NULL)
[17:27:49.727]         }
[17:27:49.727]         base::close(...future.stdout)
[17:27:49.727]         ...future.stdout <- NULL
[17:27:49.727]     }
[17:27:49.727]     ...future.result$conditions <- ...future.conditions
[17:27:49.727]     ...future.result$finished <- base::Sys.time()
[17:27:49.727]     ...future.result
[17:27:49.727] }
[17:27:49.735] Exporting 2 global objects (708 bytes) to cluster node #1 ...
[17:27:49.735] Exporting 'weight' (191 bytes) to cluster node #1 ...
[17:27:49.736] Exporting 'weight' (191 bytes) to cluster node #1 ... DONE
[17:27:49.737] Exporting 'group' (210 bytes) to cluster node #1 ...
[17:27:49.738] Exporting 'group' (210 bytes) to cluster node #1 ... DONE
[17:27:49.738] Exporting 2 global objects (708 bytes) to cluster node #1 ... DONE
[17:27:49.739] MultisessionFuture started
[17:27:49.739] - Launch lazy future ... done
[17:27:49.740] run() for 'MultisessionFuture' ... done
[17:27:49.741] result() for ClusterFuture ...
[17:27:49.741] receiveMessageFromWorker() for ClusterFuture ...
[17:27:49.741] - Validating connection of MultisessionFuture
[17:27:49.773] - received message: FutureResult
[17:27:49.774] - Received FutureResult
[17:27:49.774] - Erased future from FutureRegistry
[17:27:49.775] result() for ClusterFuture ...
[17:27:49.775] - result already collected: FutureResult
[17:27:49.775] result() for ClusterFuture ... done
[17:27:49.775] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:49.775] result() for ClusterFuture ... done
[17:27:49.776] result() for ClusterFuture ...
[17:27:49.776] - result already collected: FutureResult
[17:27:49.776] result() for ClusterFuture ... done

Call:
lm(formula = weight ~ group - 1)

Coefficients:
groupCtl  groupTrt  
   5.032     4.661  

[17:27:49.780] getGlobalsAndPackages() ...
[17:27:49.780] Searching for globals...
[17:27:49.784] - globals found: [6] '{', 'lm', 'weight', '-', 'group', '~'
[17:27:49.784] Searching for globals ... DONE
[17:27:49.784] Resolving globals: FALSE
[17:27:49.785] The total size of the 2 globals is 401 bytes (401 bytes)
[17:27:49.785] The total size of the 2 globals exported for future expression ('{; lm(weight ~ group - 1); }') is 401 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'group' (210 bytes of class 'numeric') and 'weight' (191 bytes of class 'numeric')
[17:27:49.786] - globals: [2] 'weight', 'group'
[17:27:49.786] - packages: [1] 'stats'
[17:27:49.786] getGlobalsAndPackages() ... DONE
[17:27:49.786] run() for 'Future' ...
[17:27:49.787] - state: 'created'
[17:27:49.787] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:49.804] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:49.805] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:49.805]   - Field: 'node'
[17:27:49.806]   - Field: 'label'
[17:27:49.806]   - Field: 'local'
[17:27:49.807]   - Field: 'owner'
[17:27:49.807]   - Field: 'envir'
[17:27:49.807]   - Field: 'workers'
[17:27:49.808]   - Field: 'packages'
[17:27:49.809]   - Field: 'gc'
[17:27:49.809]   - Field: 'conditions'
[17:27:49.810]   - Field: 'persistent'
[17:27:49.810]   - Field: 'expr'
[17:27:49.810]   - Field: 'uuid'
[17:27:49.811]   - Field: 'seed'
[17:27:49.811]   - Field: 'version'
[17:27:49.812]   - Field: 'result'
[17:27:49.812]   - Field: 'asynchronous'
[17:27:49.812]   - Field: 'calls'
[17:27:49.813]   - Field: 'globals'
[17:27:49.813]   - Field: 'stdout'
[17:27:49.814]   - Field: 'earlySignal'
[17:27:49.814]   - Field: 'lazy'
[17:27:49.814]   - Field: 'state'
[17:27:49.815] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:49.815] - Launch lazy future ...
[17:27:49.816] Packages needed by the future expression (n = 1): 'stats'
[17:27:49.816] Packages needed by future strategies (n = 0): <none>
[17:27:49.818] {
[17:27:49.818]     {
[17:27:49.818]         {
[17:27:49.818]             ...future.startTime <- base::Sys.time()
[17:27:49.818]             {
[17:27:49.818]                 {
[17:27:49.818]                   {
[17:27:49.818]                     {
[17:27:49.818]                       {
[17:27:49.818]                         base::local({
[17:27:49.818]                           has_future <- base::requireNamespace("future", 
[17:27:49.818]                             quietly = TRUE)
[17:27:49.818]                           if (has_future) {
[17:27:49.818]                             ns <- base::getNamespace("future")
[17:27:49.818]                             version <- ns[[".package"]][["version"]]
[17:27:49.818]                             if (is.null(version)) 
[17:27:49.818]                               version <- utils::packageVersion("future")
[17:27:49.818]                           }
[17:27:49.818]                           else {
[17:27:49.818]                             version <- NULL
[17:27:49.818]                           }
[17:27:49.818]                           if (!has_future || version < "1.8.0") {
[17:27:49.818]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:49.818]                               "", base::R.version$version.string), 
[17:27:49.818]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:49.818]                                 base::R.version$platform, 8 * 
[17:27:49.818]                                   base::.Machine$sizeof.pointer), 
[17:27:49.818]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:49.818]                                 "release", "version")], collapse = " "), 
[17:27:49.818]                               hostname = base::Sys.info()[["nodename"]])
[17:27:49.818]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:49.818]                               info)
[17:27:49.818]                             info <- base::paste(info, collapse = "; ")
[17:27:49.818]                             if (!has_future) {
[17:27:49.818]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:49.818]                                 info)
[17:27:49.818]                             }
[17:27:49.818]                             else {
[17:27:49.818]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:49.818]                                 info, version)
[17:27:49.818]                             }
[17:27:49.818]                             base::stop(msg)
[17:27:49.818]                           }
[17:27:49.818]                         })
[17:27:49.818]                       }
[17:27:49.818]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:49.818]                       base::options(mc.cores = 1L)
[17:27:49.818]                     }
[17:27:49.818]                     base::local({
[17:27:49.818]                       for (pkg in "stats") {
[17:27:49.818]                         base::loadNamespace(pkg)
[17:27:49.818]                         base::library(pkg, character.only = TRUE)
[17:27:49.818]                       }
[17:27:49.818]                     })
[17:27:49.818]                   }
[17:27:49.818]                   ...future.strategy.old <- future::plan("list")
[17:27:49.818]                   options(future.plan = NULL)
[17:27:49.818]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.818]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:49.818]                 }
[17:27:49.818]                 ...future.workdir <- getwd()
[17:27:49.818]             }
[17:27:49.818]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:49.818]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:49.818]         }
[17:27:49.818]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:49.818]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:49.818]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:49.818]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:49.818]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:49.818]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:49.818]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:49.818]             base::names(...future.oldOptions))
[17:27:49.818]     }
[17:27:49.818]     if (FALSE) {
[17:27:49.818]     }
[17:27:49.818]     else {
[17:27:49.818]         if (TRUE) {
[17:27:49.818]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:49.818]                 open = "w")
[17:27:49.818]         }
[17:27:49.818]         else {
[17:27:49.818]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:49.818]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:49.818]         }
[17:27:49.818]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:49.818]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:49.818]             base::sink(type = "output", split = FALSE)
[17:27:49.818]             base::close(...future.stdout)
[17:27:49.818]         }, add = TRUE)
[17:27:49.818]     }
[17:27:49.818]     ...future.frame <- base::sys.nframe()
[17:27:49.818]     ...future.conditions <- base::list()
[17:27:49.818]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:49.818]     if (FALSE) {
[17:27:49.818]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:49.818]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:49.818]     }
[17:27:49.818]     ...future.result <- base::tryCatch({
[17:27:49.818]         base::withCallingHandlers({
[17:27:49.818]             ...future.value <- base::withVisible(base::local({
[17:27:49.818]                 ...future.makeSendCondition <- base::local({
[17:27:49.818]                   sendCondition <- NULL
[17:27:49.818]                   function(frame = 1L) {
[17:27:49.818]                     if (is.function(sendCondition)) 
[17:27:49.818]                       return(sendCondition)
[17:27:49.818]                     ns <- getNamespace("parallel")
[17:27:49.818]                     if (exists("sendData", mode = "function", 
[17:27:49.818]                       envir = ns)) {
[17:27:49.818]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:49.818]                         envir = ns)
[17:27:49.818]                       envir <- sys.frame(frame)
[17:27:49.818]                       master <- NULL
[17:27:49.818]                       while (!identical(envir, .GlobalEnv) && 
[17:27:49.818]                         !identical(envir, emptyenv())) {
[17:27:49.818]                         if (exists("master", mode = "list", envir = envir, 
[17:27:49.818]                           inherits = FALSE)) {
[17:27:49.818]                           master <- get("master", mode = "list", 
[17:27:49.818]                             envir = envir, inherits = FALSE)
[17:27:49.818]                           if (inherits(master, c("SOCKnode", 
[17:27:49.818]                             "SOCK0node"))) {
[17:27:49.818]                             sendCondition <<- function(cond) {
[17:27:49.818]                               data <- list(type = "VALUE", value = cond, 
[17:27:49.818]                                 success = TRUE)
[17:27:49.818]                               parallel_sendData(master, data)
[17:27:49.818]                             }
[17:27:49.818]                             return(sendCondition)
[17:27:49.818]                           }
[17:27:49.818]                         }
[17:27:49.818]                         frame <- frame + 1L
[17:27:49.818]                         envir <- sys.frame(frame)
[17:27:49.818]                       }
[17:27:49.818]                     }
[17:27:49.818]                     sendCondition <<- function(cond) NULL
[17:27:49.818]                   }
[17:27:49.818]                 })
[17:27:49.818]                 withCallingHandlers({
[17:27:49.818]                   {
[17:27:49.818]                     lm(weight ~ group - 1)
[17:27:49.818]                   }
[17:27:49.818]                 }, immediateCondition = function(cond) {
[17:27:49.818]                   sendCondition <- ...future.makeSendCondition()
[17:27:49.818]                   sendCondition(cond)
[17:27:49.818]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.818]                   {
[17:27:49.818]                     inherits <- base::inherits
[17:27:49.818]                     invokeRestart <- base::invokeRestart
[17:27:49.818]                     is.null <- base::is.null
[17:27:49.818]                     muffled <- FALSE
[17:27:49.818]                     if (inherits(cond, "message")) {
[17:27:49.818]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:49.818]                       if (muffled) 
[17:27:49.818]                         invokeRestart("muffleMessage")
[17:27:49.818]                     }
[17:27:49.818]                     else if (inherits(cond, "warning")) {
[17:27:49.818]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:49.818]                       if (muffled) 
[17:27:49.818]                         invokeRestart("muffleWarning")
[17:27:49.818]                     }
[17:27:49.818]                     else if (inherits(cond, "condition")) {
[17:27:49.818]                       if (!is.null(pattern)) {
[17:27:49.818]                         computeRestarts <- base::computeRestarts
[17:27:49.818]                         grepl <- base::grepl
[17:27:49.818]                         restarts <- computeRestarts(cond)
[17:27:49.818]                         for (restart in restarts) {
[17:27:49.818]                           name <- restart$name
[17:27:49.818]                           if (is.null(name)) 
[17:27:49.818]                             next
[17:27:49.818]                           if (!grepl(pattern, name)) 
[17:27:49.818]                             next
[17:27:49.818]                           invokeRestart(restart)
[17:27:49.818]                           muffled <- TRUE
[17:27:49.818]                           break
[17:27:49.818]                         }
[17:27:49.818]                       }
[17:27:49.818]                     }
[17:27:49.818]                     invisible(muffled)
[17:27:49.818]                   }
[17:27:49.818]                   muffleCondition(cond)
[17:27:49.818]                 })
[17:27:49.818]             }))
[17:27:49.818]             future::FutureResult(value = ...future.value$value, 
[17:27:49.818]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.818]                   ...future.rng), globalenv = if (FALSE) 
[17:27:49.818]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:49.818]                     ...future.globalenv.names))
[17:27:49.818]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:49.818]         }, condition = base::local({
[17:27:49.818]             c <- base::c
[17:27:49.818]             inherits <- base::inherits
[17:27:49.818]             invokeRestart <- base::invokeRestart
[17:27:49.818]             length <- base::length
[17:27:49.818]             list <- base::list
[17:27:49.818]             seq.int <- base::seq.int
[17:27:49.818]             signalCondition <- base::signalCondition
[17:27:49.818]             sys.calls <- base::sys.calls
[17:27:49.818]             `[[` <- base::`[[`
[17:27:49.818]             `+` <- base::`+`
[17:27:49.818]             `<<-` <- base::`<<-`
[17:27:49.818]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:49.818]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:49.818]                   3L)]
[17:27:49.818]             }
[17:27:49.818]             function(cond) {
[17:27:49.818]                 is_error <- inherits(cond, "error")
[17:27:49.818]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:49.818]                   NULL)
[17:27:49.818]                 if (is_error) {
[17:27:49.818]                   sessionInformation <- function() {
[17:27:49.818]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:49.818]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:49.818]                       search = base::search(), system = base::Sys.info())
[17:27:49.818]                   }
[17:27:49.818]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.818]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:49.818]                     cond$call), session = sessionInformation(), 
[17:27:49.818]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:49.818]                   signalCondition(cond)
[17:27:49.818]                 }
[17:27:49.818]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:49.818]                 "immediateCondition"))) {
[17:27:49.818]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:49.818]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.818]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:49.818]                   if (TRUE && !signal) {
[17:27:49.818]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.818]                     {
[17:27:49.818]                       inherits <- base::inherits
[17:27:49.818]                       invokeRestart <- base::invokeRestart
[17:27:49.818]                       is.null <- base::is.null
[17:27:49.818]                       muffled <- FALSE
[17:27:49.818]                       if (inherits(cond, "message")) {
[17:27:49.818]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.818]                         if (muffled) 
[17:27:49.818]                           invokeRestart("muffleMessage")
[17:27:49.818]                       }
[17:27:49.818]                       else if (inherits(cond, "warning")) {
[17:27:49.818]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.818]                         if (muffled) 
[17:27:49.818]                           invokeRestart("muffleWarning")
[17:27:49.818]                       }
[17:27:49.818]                       else if (inherits(cond, "condition")) {
[17:27:49.818]                         if (!is.null(pattern)) {
[17:27:49.818]                           computeRestarts <- base::computeRestarts
[17:27:49.818]                           grepl <- base::grepl
[17:27:49.818]                           restarts <- computeRestarts(cond)
[17:27:49.818]                           for (restart in restarts) {
[17:27:49.818]                             name <- restart$name
[17:27:49.818]                             if (is.null(name)) 
[17:27:49.818]                               next
[17:27:49.818]                             if (!grepl(pattern, name)) 
[17:27:49.818]                               next
[17:27:49.818]                             invokeRestart(restart)
[17:27:49.818]                             muffled <- TRUE
[17:27:49.818]                             break
[17:27:49.818]                           }
[17:27:49.818]                         }
[17:27:49.818]                       }
[17:27:49.818]                       invisible(muffled)
[17:27:49.818]                     }
[17:27:49.818]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.818]                   }
[17:27:49.818]                 }
[17:27:49.818]                 else {
[17:27:49.818]                   if (TRUE) {
[17:27:49.818]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.818]                     {
[17:27:49.818]                       inherits <- base::inherits
[17:27:49.818]                       invokeRestart <- base::invokeRestart
[17:27:49.818]                       is.null <- base::is.null
[17:27:49.818]                       muffled <- FALSE
[17:27:49.818]                       if (inherits(cond, "message")) {
[17:27:49.818]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.818]                         if (muffled) 
[17:27:49.818]                           invokeRestart("muffleMessage")
[17:27:49.818]                       }
[17:27:49.818]                       else if (inherits(cond, "warning")) {
[17:27:49.818]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.818]                         if (muffled) 
[17:27:49.818]                           invokeRestart("muffleWarning")
[17:27:49.818]                       }
[17:27:49.818]                       else if (inherits(cond, "condition")) {
[17:27:49.818]                         if (!is.null(pattern)) {
[17:27:49.818]                           computeRestarts <- base::computeRestarts
[17:27:49.818]                           grepl <- base::grepl
[17:27:49.818]                           restarts <- computeRestarts(cond)
[17:27:49.818]                           for (restart in restarts) {
[17:27:49.818]                             name <- restart$name
[17:27:49.818]                             if (is.null(name)) 
[17:27:49.818]                               next
[17:27:49.818]                             if (!grepl(pattern, name)) 
[17:27:49.818]                               next
[17:27:49.818]                             invokeRestart(restart)
[17:27:49.818]                             muffled <- TRUE
[17:27:49.818]                             break
[17:27:49.818]                           }
[17:27:49.818]                         }
[17:27:49.818]                       }
[17:27:49.818]                       invisible(muffled)
[17:27:49.818]                     }
[17:27:49.818]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.818]                   }
[17:27:49.818]                 }
[17:27:49.818]             }
[17:27:49.818]         }))
[17:27:49.818]     }, error = function(ex) {
[17:27:49.818]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:49.818]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.818]                 ...future.rng), started = ...future.startTime, 
[17:27:49.818]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:49.818]             version = "1.8"), class = "FutureResult")
[17:27:49.818]     }, finally = {
[17:27:49.818]         if (!identical(...future.workdir, getwd())) 
[17:27:49.818]             setwd(...future.workdir)
[17:27:49.818]         {
[17:27:49.818]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:49.818]                 ...future.oldOptions$nwarnings <- NULL
[17:27:49.818]             }
[17:27:49.818]             base::options(...future.oldOptions)
[17:27:49.818]             if (.Platform$OS.type == "windows") {
[17:27:49.818]                 old_names <- names(...future.oldEnvVars)
[17:27:49.818]                 envs <- base::Sys.getenv()
[17:27:49.818]                 names <- names(envs)
[17:27:49.818]                 common <- intersect(names, old_names)
[17:27:49.818]                 added <- setdiff(names, old_names)
[17:27:49.818]                 removed <- setdiff(old_names, names)
[17:27:49.818]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:49.818]                   envs[common]]
[17:27:49.818]                 NAMES <- toupper(changed)
[17:27:49.818]                 args <- list()
[17:27:49.818]                 for (kk in seq_along(NAMES)) {
[17:27:49.818]                   name <- changed[[kk]]
[17:27:49.818]                   NAME <- NAMES[[kk]]
[17:27:49.818]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.818]                     next
[17:27:49.818]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.818]                 }
[17:27:49.818]                 NAMES <- toupper(added)
[17:27:49.818]                 for (kk in seq_along(NAMES)) {
[17:27:49.818]                   name <- added[[kk]]
[17:27:49.818]                   NAME <- NAMES[[kk]]
[17:27:49.818]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.818]                     next
[17:27:49.818]                   args[[name]] <- ""
[17:27:49.818]                 }
[17:27:49.818]                 NAMES <- toupper(removed)
[17:27:49.818]                 for (kk in seq_along(NAMES)) {
[17:27:49.818]                   name <- removed[[kk]]
[17:27:49.818]                   NAME <- NAMES[[kk]]
[17:27:49.818]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.818]                     next
[17:27:49.818]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.818]                 }
[17:27:49.818]                 if (length(args) > 0) 
[17:27:49.818]                   base::do.call(base::Sys.setenv, args = args)
[17:27:49.818]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:49.818]             }
[17:27:49.818]             else {
[17:27:49.818]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:49.818]             }
[17:27:49.818]             {
[17:27:49.818]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:49.818]                   0L) {
[17:27:49.818]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:49.818]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:49.818]                   base::options(opts)
[17:27:49.818]                 }
[17:27:49.818]                 {
[17:27:49.818]                   {
[17:27:49.818]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:49.818]                     NULL
[17:27:49.818]                   }
[17:27:49.818]                   options(future.plan = NULL)
[17:27:49.818]                   if (is.na(NA_character_)) 
[17:27:49.818]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.818]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:49.818]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:49.818]                     .init = FALSE)
[17:27:49.818]                 }
[17:27:49.818]             }
[17:27:49.818]         }
[17:27:49.818]     })
[17:27:49.818]     if (TRUE) {
[17:27:49.818]         base::sink(type = "output", split = FALSE)
[17:27:49.818]         if (TRUE) {
[17:27:49.818]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:49.818]         }
[17:27:49.818]         else {
[17:27:49.818]             ...future.result["stdout"] <- base::list(NULL)
[17:27:49.818]         }
[17:27:49.818]         base::close(...future.stdout)
[17:27:49.818]         ...future.stdout <- NULL
[17:27:49.818]     }
[17:27:49.818]     ...future.result$conditions <- ...future.conditions
[17:27:49.818]     ...future.result$finished <- base::Sys.time()
[17:27:49.818]     ...future.result
[17:27:49.818] }
[17:27:49.829] Exporting 2 global objects (708 bytes) to cluster node #1 ...
[17:27:49.829] Exporting 'weight' (191 bytes) to cluster node #1 ...
[17:27:49.830] Exporting 'weight' (191 bytes) to cluster node #1 ... DONE
[17:27:49.830] Exporting 'group' (210 bytes) to cluster node #1 ...
[17:27:49.831] Exporting 'group' (210 bytes) to cluster node #1 ... DONE
[17:27:49.831] Exporting 2 global objects (708 bytes) to cluster node #1 ... DONE
[17:27:49.832] MultisessionFuture started
[17:27:49.833] - Launch lazy future ... done
[17:27:49.833] run() for 'MultisessionFuture' ... done
[17:27:49.834] result() for ClusterFuture ...
[17:27:49.834] receiveMessageFromWorker() for ClusterFuture ...
[17:27:49.834] - Validating connection of MultisessionFuture
[17:27:49.859] - received message: FutureResult
[17:27:49.860] - Received FutureResult
[17:27:49.860] - Erased future from FutureRegistry
[17:27:49.861] result() for ClusterFuture ...
[17:27:49.861] - result already collected: FutureResult
[17:27:49.861] result() for ClusterFuture ... done
[17:27:49.861] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:49.862] result() for ClusterFuture ... done
[17:27:49.862] result() for ClusterFuture ...
[17:27:49.862] - result already collected: FutureResult
[17:27:49.863] result() for ClusterFuture ... done

Call:
lm(formula = weight ~ group - 1)

Coefficients:
groupCtl  groupTrt  
   5.032     4.661  

- Globals - one-side formulas, e.g. xtabs(~ x) ...
[17:27:49.867] getGlobalsAndPackages() ...
[17:27:49.867] Searching for globals...
[17:27:49.869] - globals found: [4] '{', 'xtabs', 'x', '~'
[17:27:49.870] Searching for globals ... DONE
[17:27:49.870] Resolving globals: FALSE
[17:27:49.871] The total size of the 1 globals is 71 bytes (71 bytes)
[17:27:49.872] The total size of the 1 globals exported for future expression ('{; xtabs(~x); }') is 71 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (71 bytes of class 'numeric')
[17:27:49.872] - globals: [1] 'x'
[17:27:49.873] - packages: [1] 'stats'
[17:27:49.873] getGlobalsAndPackages() ... DONE
[17:27:49.873] run() for 'Future' ...
[17:27:49.874] - state: 'created'
[17:27:49.874] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:49.894] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:49.894] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:49.895]   - Field: 'node'
[17:27:49.895]   - Field: 'label'
[17:27:49.895]   - Field: 'local'
[17:27:49.896]   - Field: 'owner'
[17:27:49.896]   - Field: 'envir'
[17:27:49.896]   - Field: 'workers'
[17:27:49.897]   - Field: 'packages'
[17:27:49.897]   - Field: 'gc'
[17:27:49.897]   - Field: 'conditions'
[17:27:49.898]   - Field: 'persistent'
[17:27:49.898]   - Field: 'expr'
[17:27:49.898]   - Field: 'uuid'
[17:27:49.899]   - Field: 'seed'
[17:27:49.899]   - Field: 'version'
[17:27:49.899]   - Field: 'result'
[17:27:49.900]   - Field: 'asynchronous'
[17:27:49.900]   - Field: 'calls'
[17:27:49.900]   - Field: 'globals'
[17:27:49.901]   - Field: 'stdout'
[17:27:49.901]   - Field: 'earlySignal'
[17:27:49.901]   - Field: 'lazy'
[17:27:49.902]   - Field: 'state'
[17:27:49.902] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:49.902] - Launch lazy future ...
[17:27:49.903] Packages needed by the future expression (n = 1): 'stats'
[17:27:49.903] Packages needed by future strategies (n = 0): <none>
[17:27:49.904] {
[17:27:49.904]     {
[17:27:49.904]         {
[17:27:49.904]             ...future.startTime <- base::Sys.time()
[17:27:49.904]             {
[17:27:49.904]                 {
[17:27:49.904]                   {
[17:27:49.904]                     {
[17:27:49.904]                       {
[17:27:49.904]                         base::local({
[17:27:49.904]                           has_future <- base::requireNamespace("future", 
[17:27:49.904]                             quietly = TRUE)
[17:27:49.904]                           if (has_future) {
[17:27:49.904]                             ns <- base::getNamespace("future")
[17:27:49.904]                             version <- ns[[".package"]][["version"]]
[17:27:49.904]                             if (is.null(version)) 
[17:27:49.904]                               version <- utils::packageVersion("future")
[17:27:49.904]                           }
[17:27:49.904]                           else {
[17:27:49.904]                             version <- NULL
[17:27:49.904]                           }
[17:27:49.904]                           if (!has_future || version < "1.8.0") {
[17:27:49.904]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:49.904]                               "", base::R.version$version.string), 
[17:27:49.904]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:49.904]                                 base::R.version$platform, 8 * 
[17:27:49.904]                                   base::.Machine$sizeof.pointer), 
[17:27:49.904]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:49.904]                                 "release", "version")], collapse = " "), 
[17:27:49.904]                               hostname = base::Sys.info()[["nodename"]])
[17:27:49.904]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:49.904]                               info)
[17:27:49.904]                             info <- base::paste(info, collapse = "; ")
[17:27:49.904]                             if (!has_future) {
[17:27:49.904]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:49.904]                                 info)
[17:27:49.904]                             }
[17:27:49.904]                             else {
[17:27:49.904]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:49.904]                                 info, version)
[17:27:49.904]                             }
[17:27:49.904]                             base::stop(msg)
[17:27:49.904]                           }
[17:27:49.904]                         })
[17:27:49.904]                       }
[17:27:49.904]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:49.904]                       base::options(mc.cores = 1L)
[17:27:49.904]                     }
[17:27:49.904]                     base::local({
[17:27:49.904]                       for (pkg in "stats") {
[17:27:49.904]                         base::loadNamespace(pkg)
[17:27:49.904]                         base::library(pkg, character.only = TRUE)
[17:27:49.904]                       }
[17:27:49.904]                     })
[17:27:49.904]                   }
[17:27:49.904]                   ...future.strategy.old <- future::plan("list")
[17:27:49.904]                   options(future.plan = NULL)
[17:27:49.904]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.904]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:49.904]                 }
[17:27:49.904]                 ...future.workdir <- getwd()
[17:27:49.904]             }
[17:27:49.904]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:49.904]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:49.904]         }
[17:27:49.904]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:49.904]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:49.904]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:49.904]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:49.904]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:49.904]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:49.904]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:49.904]             base::names(...future.oldOptions))
[17:27:49.904]     }
[17:27:49.904]     if (FALSE) {
[17:27:49.904]     }
[17:27:49.904]     else {
[17:27:49.904]         if (TRUE) {
[17:27:49.904]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:49.904]                 open = "w")
[17:27:49.904]         }
[17:27:49.904]         else {
[17:27:49.904]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:49.904]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:49.904]         }
[17:27:49.904]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:49.904]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:49.904]             base::sink(type = "output", split = FALSE)
[17:27:49.904]             base::close(...future.stdout)
[17:27:49.904]         }, add = TRUE)
[17:27:49.904]     }
[17:27:49.904]     ...future.frame <- base::sys.nframe()
[17:27:49.904]     ...future.conditions <- base::list()
[17:27:49.904]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:49.904]     if (FALSE) {
[17:27:49.904]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:49.904]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:49.904]     }
[17:27:49.904]     ...future.result <- base::tryCatch({
[17:27:49.904]         base::withCallingHandlers({
[17:27:49.904]             ...future.value <- base::withVisible(base::local({
[17:27:49.904]                 ...future.makeSendCondition <- base::local({
[17:27:49.904]                   sendCondition <- NULL
[17:27:49.904]                   function(frame = 1L) {
[17:27:49.904]                     if (is.function(sendCondition)) 
[17:27:49.904]                       return(sendCondition)
[17:27:49.904]                     ns <- getNamespace("parallel")
[17:27:49.904]                     if (exists("sendData", mode = "function", 
[17:27:49.904]                       envir = ns)) {
[17:27:49.904]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:49.904]                         envir = ns)
[17:27:49.904]                       envir <- sys.frame(frame)
[17:27:49.904]                       master <- NULL
[17:27:49.904]                       while (!identical(envir, .GlobalEnv) && 
[17:27:49.904]                         !identical(envir, emptyenv())) {
[17:27:49.904]                         if (exists("master", mode = "list", envir = envir, 
[17:27:49.904]                           inherits = FALSE)) {
[17:27:49.904]                           master <- get("master", mode = "list", 
[17:27:49.904]                             envir = envir, inherits = FALSE)
[17:27:49.904]                           if (inherits(master, c("SOCKnode", 
[17:27:49.904]                             "SOCK0node"))) {
[17:27:49.904]                             sendCondition <<- function(cond) {
[17:27:49.904]                               data <- list(type = "VALUE", value = cond, 
[17:27:49.904]                                 success = TRUE)
[17:27:49.904]                               parallel_sendData(master, data)
[17:27:49.904]                             }
[17:27:49.904]                             return(sendCondition)
[17:27:49.904]                           }
[17:27:49.904]                         }
[17:27:49.904]                         frame <- frame + 1L
[17:27:49.904]                         envir <- sys.frame(frame)
[17:27:49.904]                       }
[17:27:49.904]                     }
[17:27:49.904]                     sendCondition <<- function(cond) NULL
[17:27:49.904]                   }
[17:27:49.904]                 })
[17:27:49.904]                 withCallingHandlers({
[17:27:49.904]                   {
[17:27:49.904]                     xtabs(~x)
[17:27:49.904]                   }
[17:27:49.904]                 }, immediateCondition = function(cond) {
[17:27:49.904]                   sendCondition <- ...future.makeSendCondition()
[17:27:49.904]                   sendCondition(cond)
[17:27:49.904]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.904]                   {
[17:27:49.904]                     inherits <- base::inherits
[17:27:49.904]                     invokeRestart <- base::invokeRestart
[17:27:49.904]                     is.null <- base::is.null
[17:27:49.904]                     muffled <- FALSE
[17:27:49.904]                     if (inherits(cond, "message")) {
[17:27:49.904]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:49.904]                       if (muffled) 
[17:27:49.904]                         invokeRestart("muffleMessage")
[17:27:49.904]                     }
[17:27:49.904]                     else if (inherits(cond, "warning")) {
[17:27:49.904]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:49.904]                       if (muffled) 
[17:27:49.904]                         invokeRestart("muffleWarning")
[17:27:49.904]                     }
[17:27:49.904]                     else if (inherits(cond, "condition")) {
[17:27:49.904]                       if (!is.null(pattern)) {
[17:27:49.904]                         computeRestarts <- base::computeRestarts
[17:27:49.904]                         grepl <- base::grepl
[17:27:49.904]                         restarts <- computeRestarts(cond)
[17:27:49.904]                         for (restart in restarts) {
[17:27:49.904]                           name <- restart$name
[17:27:49.904]                           if (is.null(name)) 
[17:27:49.904]                             next
[17:27:49.904]                           if (!grepl(pattern, name)) 
[17:27:49.904]                             next
[17:27:49.904]                           invokeRestart(restart)
[17:27:49.904]                           muffled <- TRUE
[17:27:49.904]                           break
[17:27:49.904]                         }
[17:27:49.904]                       }
[17:27:49.904]                     }
[17:27:49.904]                     invisible(muffled)
[17:27:49.904]                   }
[17:27:49.904]                   muffleCondition(cond)
[17:27:49.904]                 })
[17:27:49.904]             }))
[17:27:49.904]             future::FutureResult(value = ...future.value$value, 
[17:27:49.904]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.904]                   ...future.rng), globalenv = if (FALSE) 
[17:27:49.904]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:49.904]                     ...future.globalenv.names))
[17:27:49.904]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:49.904]         }, condition = base::local({
[17:27:49.904]             c <- base::c
[17:27:49.904]             inherits <- base::inherits
[17:27:49.904]             invokeRestart <- base::invokeRestart
[17:27:49.904]             length <- base::length
[17:27:49.904]             list <- base::list
[17:27:49.904]             seq.int <- base::seq.int
[17:27:49.904]             signalCondition <- base::signalCondition
[17:27:49.904]             sys.calls <- base::sys.calls
[17:27:49.904]             `[[` <- base::`[[`
[17:27:49.904]             `+` <- base::`+`
[17:27:49.904]             `<<-` <- base::`<<-`
[17:27:49.904]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:49.904]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:49.904]                   3L)]
[17:27:49.904]             }
[17:27:49.904]             function(cond) {
[17:27:49.904]                 is_error <- inherits(cond, "error")
[17:27:49.904]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:49.904]                   NULL)
[17:27:49.904]                 if (is_error) {
[17:27:49.904]                   sessionInformation <- function() {
[17:27:49.904]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:49.904]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:49.904]                       search = base::search(), system = base::Sys.info())
[17:27:49.904]                   }
[17:27:49.904]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.904]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:49.904]                     cond$call), session = sessionInformation(), 
[17:27:49.904]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:49.904]                   signalCondition(cond)
[17:27:49.904]                 }
[17:27:49.904]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:49.904]                 "immediateCondition"))) {
[17:27:49.904]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:49.904]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.904]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:49.904]                   if (TRUE && !signal) {
[17:27:49.904]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.904]                     {
[17:27:49.904]                       inherits <- base::inherits
[17:27:49.904]                       invokeRestart <- base::invokeRestart
[17:27:49.904]                       is.null <- base::is.null
[17:27:49.904]                       muffled <- FALSE
[17:27:49.904]                       if (inherits(cond, "message")) {
[17:27:49.904]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.904]                         if (muffled) 
[17:27:49.904]                           invokeRestart("muffleMessage")
[17:27:49.904]                       }
[17:27:49.904]                       else if (inherits(cond, "warning")) {
[17:27:49.904]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.904]                         if (muffled) 
[17:27:49.904]                           invokeRestart("muffleWarning")
[17:27:49.904]                       }
[17:27:49.904]                       else if (inherits(cond, "condition")) {
[17:27:49.904]                         if (!is.null(pattern)) {
[17:27:49.904]                           computeRestarts <- base::computeRestarts
[17:27:49.904]                           grepl <- base::grepl
[17:27:49.904]                           restarts <- computeRestarts(cond)
[17:27:49.904]                           for (restart in restarts) {
[17:27:49.904]                             name <- restart$name
[17:27:49.904]                             if (is.null(name)) 
[17:27:49.904]                               next
[17:27:49.904]                             if (!grepl(pattern, name)) 
[17:27:49.904]                               next
[17:27:49.904]                             invokeRestart(restart)
[17:27:49.904]                             muffled <- TRUE
[17:27:49.904]                             break
[17:27:49.904]                           }
[17:27:49.904]                         }
[17:27:49.904]                       }
[17:27:49.904]                       invisible(muffled)
[17:27:49.904]                     }
[17:27:49.904]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.904]                   }
[17:27:49.904]                 }
[17:27:49.904]                 else {
[17:27:49.904]                   if (TRUE) {
[17:27:49.904]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.904]                     {
[17:27:49.904]                       inherits <- base::inherits
[17:27:49.904]                       invokeRestart <- base::invokeRestart
[17:27:49.904]                       is.null <- base::is.null
[17:27:49.904]                       muffled <- FALSE
[17:27:49.904]                       if (inherits(cond, "message")) {
[17:27:49.904]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.904]                         if (muffled) 
[17:27:49.904]                           invokeRestart("muffleMessage")
[17:27:49.904]                       }
[17:27:49.904]                       else if (inherits(cond, "warning")) {
[17:27:49.904]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.904]                         if (muffled) 
[17:27:49.904]                           invokeRestart("muffleWarning")
[17:27:49.904]                       }
[17:27:49.904]                       else if (inherits(cond, "condition")) {
[17:27:49.904]                         if (!is.null(pattern)) {
[17:27:49.904]                           computeRestarts <- base::computeRestarts
[17:27:49.904]                           grepl <- base::grepl
[17:27:49.904]                           restarts <- computeRestarts(cond)
[17:27:49.904]                           for (restart in restarts) {
[17:27:49.904]                             name <- restart$name
[17:27:49.904]                             if (is.null(name)) 
[17:27:49.904]                               next
[17:27:49.904]                             if (!grepl(pattern, name)) 
[17:27:49.904]                               next
[17:27:49.904]                             invokeRestart(restart)
[17:27:49.904]                             muffled <- TRUE
[17:27:49.904]                             break
[17:27:49.904]                           }
[17:27:49.904]                         }
[17:27:49.904]                       }
[17:27:49.904]                       invisible(muffled)
[17:27:49.904]                     }
[17:27:49.904]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.904]                   }
[17:27:49.904]                 }
[17:27:49.904]             }
[17:27:49.904]         }))
[17:27:49.904]     }, error = function(ex) {
[17:27:49.904]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:49.904]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.904]                 ...future.rng), started = ...future.startTime, 
[17:27:49.904]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:49.904]             version = "1.8"), class = "FutureResult")
[17:27:49.904]     }, finally = {
[17:27:49.904]         if (!identical(...future.workdir, getwd())) 
[17:27:49.904]             setwd(...future.workdir)
[17:27:49.904]         {
[17:27:49.904]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:49.904]                 ...future.oldOptions$nwarnings <- NULL
[17:27:49.904]             }
[17:27:49.904]             base::options(...future.oldOptions)
[17:27:49.904]             if (.Platform$OS.type == "windows") {
[17:27:49.904]                 old_names <- names(...future.oldEnvVars)
[17:27:49.904]                 envs <- base::Sys.getenv()
[17:27:49.904]                 names <- names(envs)
[17:27:49.904]                 common <- intersect(names, old_names)
[17:27:49.904]                 added <- setdiff(names, old_names)
[17:27:49.904]                 removed <- setdiff(old_names, names)
[17:27:49.904]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:49.904]                   envs[common]]
[17:27:49.904]                 NAMES <- toupper(changed)
[17:27:49.904]                 args <- list()
[17:27:49.904]                 for (kk in seq_along(NAMES)) {
[17:27:49.904]                   name <- changed[[kk]]
[17:27:49.904]                   NAME <- NAMES[[kk]]
[17:27:49.904]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.904]                     next
[17:27:49.904]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.904]                 }
[17:27:49.904]                 NAMES <- toupper(added)
[17:27:49.904]                 for (kk in seq_along(NAMES)) {
[17:27:49.904]                   name <- added[[kk]]
[17:27:49.904]                   NAME <- NAMES[[kk]]
[17:27:49.904]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.904]                     next
[17:27:49.904]                   args[[name]] <- ""
[17:27:49.904]                 }
[17:27:49.904]                 NAMES <- toupper(removed)
[17:27:49.904]                 for (kk in seq_along(NAMES)) {
[17:27:49.904]                   name <- removed[[kk]]
[17:27:49.904]                   NAME <- NAMES[[kk]]
[17:27:49.904]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.904]                     next
[17:27:49.904]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.904]                 }
[17:27:49.904]                 if (length(args) > 0) 
[17:27:49.904]                   base::do.call(base::Sys.setenv, args = args)
[17:27:49.904]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:49.904]             }
[17:27:49.904]             else {
[17:27:49.904]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:49.904]             }
[17:27:49.904]             {
[17:27:49.904]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:49.904]                   0L) {
[17:27:49.904]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:49.904]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:49.904]                   base::options(opts)
[17:27:49.904]                 }
[17:27:49.904]                 {
[17:27:49.904]                   {
[17:27:49.904]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:49.904]                     NULL
[17:27:49.904]                   }
[17:27:49.904]                   options(future.plan = NULL)
[17:27:49.904]                   if (is.na(NA_character_)) 
[17:27:49.904]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.904]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:49.904]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:49.904]                     .init = FALSE)
[17:27:49.904]                 }
[17:27:49.904]             }
[17:27:49.904]         }
[17:27:49.904]     })
[17:27:49.904]     if (TRUE) {
[17:27:49.904]         base::sink(type = "output", split = FALSE)
[17:27:49.904]         if (TRUE) {
[17:27:49.904]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:49.904]         }
[17:27:49.904]         else {
[17:27:49.904]             ...future.result["stdout"] <- base::list(NULL)
[17:27:49.904]         }
[17:27:49.904]         base::close(...future.stdout)
[17:27:49.904]         ...future.stdout <- NULL
[17:27:49.904]     }
[17:27:49.904]     ...future.result$conditions <- ...future.conditions
[17:27:49.904]     ...future.result$finished <- base::Sys.time()
[17:27:49.904]     ...future.result
[17:27:49.904] }
[17:27:49.913] Exporting 1 global objects (374 bytes) to cluster node #1 ...
[17:27:49.913] Exporting 'x' (71 bytes) to cluster node #1 ...
[17:27:49.914] Exporting 'x' (71 bytes) to cluster node #1 ... DONE
[17:27:49.914] Exporting 1 global objects (374 bytes) to cluster node #1 ... DONE
[17:27:49.915] MultisessionFuture started
[17:27:49.915] - Launch lazy future ... done
[17:27:49.916] run() for 'MultisessionFuture' ... done
[17:27:49.916] result() for ClusterFuture ...
[17:27:49.917] receiveMessageFromWorker() for ClusterFuture ...
[17:27:49.917] - Validating connection of MultisessionFuture
[17:27:49.944] - received message: FutureResult
[17:27:49.945] - Received FutureResult
[17:27:49.945] - Erased future from FutureRegistry
[17:27:49.945] result() for ClusterFuture ...
[17:27:49.946] - result already collected: FutureResult
[17:27:49.946] result() for ClusterFuture ... done
[17:27:49.946] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:49.946] result() for ClusterFuture ... done
[17:27:49.947] result() for ClusterFuture ...
[17:27:49.947] - result already collected: FutureResult
[17:27:49.947] result() for ClusterFuture ... done
x
1 2 
2 3 
[17:27:49.949] getGlobalsAndPackages() ...
[17:27:49.949] Searching for globals...
[17:27:49.952] - globals found: [4] '{', 'xtabs', 'x', '~'
[17:27:49.952] Searching for globals ... DONE
[17:27:49.953] Resolving globals: FALSE
[17:27:49.954] The total size of the 1 globals is 71 bytes (71 bytes)
[17:27:49.954] The total size of the 1 globals exported for future expression ('{; xtabs(~x); }') is 71 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (71 bytes of class 'numeric')
[17:27:49.955] - globals: [1] 'x'
[17:27:49.955] - packages: [1] 'stats'
[17:27:49.956] getGlobalsAndPackages() ... DONE
[17:27:49.956] run() for 'Future' ...
[17:27:49.957] - state: 'created'
[17:27:49.957] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:49.975] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:49.976] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:49.976]   - Field: 'node'
[17:27:49.976]   - Field: 'label'
[17:27:49.976]   - Field: 'local'
[17:27:49.976]   - Field: 'owner'
[17:27:49.976]   - Field: 'envir'
[17:27:49.977]   - Field: 'workers'
[17:27:49.977]   - Field: 'packages'
[17:27:49.977]   - Field: 'gc'
[17:27:49.977]   - Field: 'conditions'
[17:27:49.977]   - Field: 'persistent'
[17:27:49.977]   - Field: 'expr'
[17:27:49.978]   - Field: 'uuid'
[17:27:49.978]   - Field: 'seed'
[17:27:49.978]   - Field: 'version'
[17:27:49.978]   - Field: 'result'
[17:27:49.979]   - Field: 'asynchronous'
[17:27:49.979]   - Field: 'calls'
[17:27:49.979]   - Field: 'globals'
[17:27:49.980]   - Field: 'stdout'
[17:27:49.980]   - Field: 'earlySignal'
[17:27:49.980]   - Field: 'lazy'
[17:27:49.980]   - Field: 'state'
[17:27:49.981] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:49.981] - Launch lazy future ...
[17:27:49.981] Packages needed by the future expression (n = 1): 'stats'
[17:27:49.982] Packages needed by future strategies (n = 0): <none>
[17:27:49.982] {
[17:27:49.982]     {
[17:27:49.982]         {
[17:27:49.982]             ...future.startTime <- base::Sys.time()
[17:27:49.982]             {
[17:27:49.982]                 {
[17:27:49.982]                   {
[17:27:49.982]                     {
[17:27:49.982]                       {
[17:27:49.982]                         base::local({
[17:27:49.982]                           has_future <- base::requireNamespace("future", 
[17:27:49.982]                             quietly = TRUE)
[17:27:49.982]                           if (has_future) {
[17:27:49.982]                             ns <- base::getNamespace("future")
[17:27:49.982]                             version <- ns[[".package"]][["version"]]
[17:27:49.982]                             if (is.null(version)) 
[17:27:49.982]                               version <- utils::packageVersion("future")
[17:27:49.982]                           }
[17:27:49.982]                           else {
[17:27:49.982]                             version <- NULL
[17:27:49.982]                           }
[17:27:49.982]                           if (!has_future || version < "1.8.0") {
[17:27:49.982]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:49.982]                               "", base::R.version$version.string), 
[17:27:49.982]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:49.982]                                 base::R.version$platform, 8 * 
[17:27:49.982]                                   base::.Machine$sizeof.pointer), 
[17:27:49.982]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:49.982]                                 "release", "version")], collapse = " "), 
[17:27:49.982]                               hostname = base::Sys.info()[["nodename"]])
[17:27:49.982]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:49.982]                               info)
[17:27:49.982]                             info <- base::paste(info, collapse = "; ")
[17:27:49.982]                             if (!has_future) {
[17:27:49.982]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:49.982]                                 info)
[17:27:49.982]                             }
[17:27:49.982]                             else {
[17:27:49.982]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:49.982]                                 info, version)
[17:27:49.982]                             }
[17:27:49.982]                             base::stop(msg)
[17:27:49.982]                           }
[17:27:49.982]                         })
[17:27:49.982]                       }
[17:27:49.982]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:49.982]                       base::options(mc.cores = 1L)
[17:27:49.982]                     }
[17:27:49.982]                     base::local({
[17:27:49.982]                       for (pkg in "stats") {
[17:27:49.982]                         base::loadNamespace(pkg)
[17:27:49.982]                         base::library(pkg, character.only = TRUE)
[17:27:49.982]                       }
[17:27:49.982]                     })
[17:27:49.982]                   }
[17:27:49.982]                   ...future.strategy.old <- future::plan("list")
[17:27:49.982]                   options(future.plan = NULL)
[17:27:49.982]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.982]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:49.982]                 }
[17:27:49.982]                 ...future.workdir <- getwd()
[17:27:49.982]             }
[17:27:49.982]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:49.982]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:49.982]         }
[17:27:49.982]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:49.982]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:49.982]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:49.982]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:49.982]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:49.982]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:49.982]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:49.982]             base::names(...future.oldOptions))
[17:27:49.982]     }
[17:27:49.982]     if (FALSE) {
[17:27:49.982]     }
[17:27:49.982]     else {
[17:27:49.982]         if (TRUE) {
[17:27:49.982]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:49.982]                 open = "w")
[17:27:49.982]         }
[17:27:49.982]         else {
[17:27:49.982]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:49.982]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:49.982]         }
[17:27:49.982]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:49.982]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:49.982]             base::sink(type = "output", split = FALSE)
[17:27:49.982]             base::close(...future.stdout)
[17:27:49.982]         }, add = TRUE)
[17:27:49.982]     }
[17:27:49.982]     ...future.frame <- base::sys.nframe()
[17:27:49.982]     ...future.conditions <- base::list()
[17:27:49.982]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:49.982]     if (FALSE) {
[17:27:49.982]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:49.982]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:49.982]     }
[17:27:49.982]     ...future.result <- base::tryCatch({
[17:27:49.982]         base::withCallingHandlers({
[17:27:49.982]             ...future.value <- base::withVisible(base::local({
[17:27:49.982]                 ...future.makeSendCondition <- base::local({
[17:27:49.982]                   sendCondition <- NULL
[17:27:49.982]                   function(frame = 1L) {
[17:27:49.982]                     if (is.function(sendCondition)) 
[17:27:49.982]                       return(sendCondition)
[17:27:49.982]                     ns <- getNamespace("parallel")
[17:27:49.982]                     if (exists("sendData", mode = "function", 
[17:27:49.982]                       envir = ns)) {
[17:27:49.982]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:49.982]                         envir = ns)
[17:27:49.982]                       envir <- sys.frame(frame)
[17:27:49.982]                       master <- NULL
[17:27:49.982]                       while (!identical(envir, .GlobalEnv) && 
[17:27:49.982]                         !identical(envir, emptyenv())) {
[17:27:49.982]                         if (exists("master", mode = "list", envir = envir, 
[17:27:49.982]                           inherits = FALSE)) {
[17:27:49.982]                           master <- get("master", mode = "list", 
[17:27:49.982]                             envir = envir, inherits = FALSE)
[17:27:49.982]                           if (inherits(master, c("SOCKnode", 
[17:27:49.982]                             "SOCK0node"))) {
[17:27:49.982]                             sendCondition <<- function(cond) {
[17:27:49.982]                               data <- list(type = "VALUE", value = cond, 
[17:27:49.982]                                 success = TRUE)
[17:27:49.982]                               parallel_sendData(master, data)
[17:27:49.982]                             }
[17:27:49.982]                             return(sendCondition)
[17:27:49.982]                           }
[17:27:49.982]                         }
[17:27:49.982]                         frame <- frame + 1L
[17:27:49.982]                         envir <- sys.frame(frame)
[17:27:49.982]                       }
[17:27:49.982]                     }
[17:27:49.982]                     sendCondition <<- function(cond) NULL
[17:27:49.982]                   }
[17:27:49.982]                 })
[17:27:49.982]                 withCallingHandlers({
[17:27:49.982]                   {
[17:27:49.982]                     xtabs(~x)
[17:27:49.982]                   }
[17:27:49.982]                 }, immediateCondition = function(cond) {
[17:27:49.982]                   sendCondition <- ...future.makeSendCondition()
[17:27:49.982]                   sendCondition(cond)
[17:27:49.982]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.982]                   {
[17:27:49.982]                     inherits <- base::inherits
[17:27:49.982]                     invokeRestart <- base::invokeRestart
[17:27:49.982]                     is.null <- base::is.null
[17:27:49.982]                     muffled <- FALSE
[17:27:49.982]                     if (inherits(cond, "message")) {
[17:27:49.982]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:49.982]                       if (muffled) 
[17:27:49.982]                         invokeRestart("muffleMessage")
[17:27:49.982]                     }
[17:27:49.982]                     else if (inherits(cond, "warning")) {
[17:27:49.982]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:49.982]                       if (muffled) 
[17:27:49.982]                         invokeRestart("muffleWarning")
[17:27:49.982]                     }
[17:27:49.982]                     else if (inherits(cond, "condition")) {
[17:27:49.982]                       if (!is.null(pattern)) {
[17:27:49.982]                         computeRestarts <- base::computeRestarts
[17:27:49.982]                         grepl <- base::grepl
[17:27:49.982]                         restarts <- computeRestarts(cond)
[17:27:49.982]                         for (restart in restarts) {
[17:27:49.982]                           name <- restart$name
[17:27:49.982]                           if (is.null(name)) 
[17:27:49.982]                             next
[17:27:49.982]                           if (!grepl(pattern, name)) 
[17:27:49.982]                             next
[17:27:49.982]                           invokeRestart(restart)
[17:27:49.982]                           muffled <- TRUE
[17:27:49.982]                           break
[17:27:49.982]                         }
[17:27:49.982]                       }
[17:27:49.982]                     }
[17:27:49.982]                     invisible(muffled)
[17:27:49.982]                   }
[17:27:49.982]                   muffleCondition(cond)
[17:27:49.982]                 })
[17:27:49.982]             }))
[17:27:49.982]             future::FutureResult(value = ...future.value$value, 
[17:27:49.982]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.982]                   ...future.rng), globalenv = if (FALSE) 
[17:27:49.982]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:49.982]                     ...future.globalenv.names))
[17:27:49.982]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:49.982]         }, condition = base::local({
[17:27:49.982]             c <- base::c
[17:27:49.982]             inherits <- base::inherits
[17:27:49.982]             invokeRestart <- base::invokeRestart
[17:27:49.982]             length <- base::length
[17:27:49.982]             list <- base::list
[17:27:49.982]             seq.int <- base::seq.int
[17:27:49.982]             signalCondition <- base::signalCondition
[17:27:49.982]             sys.calls <- base::sys.calls
[17:27:49.982]             `[[` <- base::`[[`
[17:27:49.982]             `+` <- base::`+`
[17:27:49.982]             `<<-` <- base::`<<-`
[17:27:49.982]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:49.982]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:49.982]                   3L)]
[17:27:49.982]             }
[17:27:49.982]             function(cond) {
[17:27:49.982]                 is_error <- inherits(cond, "error")
[17:27:49.982]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:49.982]                   NULL)
[17:27:49.982]                 if (is_error) {
[17:27:49.982]                   sessionInformation <- function() {
[17:27:49.982]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:49.982]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:49.982]                       search = base::search(), system = base::Sys.info())
[17:27:49.982]                   }
[17:27:49.982]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.982]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:49.982]                     cond$call), session = sessionInformation(), 
[17:27:49.982]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:49.982]                   signalCondition(cond)
[17:27:49.982]                 }
[17:27:49.982]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:49.982]                 "immediateCondition"))) {
[17:27:49.982]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:49.982]                   ...future.conditions[[length(...future.conditions) + 
[17:27:49.982]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:49.982]                   if (TRUE && !signal) {
[17:27:49.982]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.982]                     {
[17:27:49.982]                       inherits <- base::inherits
[17:27:49.982]                       invokeRestart <- base::invokeRestart
[17:27:49.982]                       is.null <- base::is.null
[17:27:49.982]                       muffled <- FALSE
[17:27:49.982]                       if (inherits(cond, "message")) {
[17:27:49.982]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.982]                         if (muffled) 
[17:27:49.982]                           invokeRestart("muffleMessage")
[17:27:49.982]                       }
[17:27:49.982]                       else if (inherits(cond, "warning")) {
[17:27:49.982]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.982]                         if (muffled) 
[17:27:49.982]                           invokeRestart("muffleWarning")
[17:27:49.982]                       }
[17:27:49.982]                       else if (inherits(cond, "condition")) {
[17:27:49.982]                         if (!is.null(pattern)) {
[17:27:49.982]                           computeRestarts <- base::computeRestarts
[17:27:49.982]                           grepl <- base::grepl
[17:27:49.982]                           restarts <- computeRestarts(cond)
[17:27:49.982]                           for (restart in restarts) {
[17:27:49.982]                             name <- restart$name
[17:27:49.982]                             if (is.null(name)) 
[17:27:49.982]                               next
[17:27:49.982]                             if (!grepl(pattern, name)) 
[17:27:49.982]                               next
[17:27:49.982]                             invokeRestart(restart)
[17:27:49.982]                             muffled <- TRUE
[17:27:49.982]                             break
[17:27:49.982]                           }
[17:27:49.982]                         }
[17:27:49.982]                       }
[17:27:49.982]                       invisible(muffled)
[17:27:49.982]                     }
[17:27:49.982]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.982]                   }
[17:27:49.982]                 }
[17:27:49.982]                 else {
[17:27:49.982]                   if (TRUE) {
[17:27:49.982]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:49.982]                     {
[17:27:49.982]                       inherits <- base::inherits
[17:27:49.982]                       invokeRestart <- base::invokeRestart
[17:27:49.982]                       is.null <- base::is.null
[17:27:49.982]                       muffled <- FALSE
[17:27:49.982]                       if (inherits(cond, "message")) {
[17:27:49.982]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:49.982]                         if (muffled) 
[17:27:49.982]                           invokeRestart("muffleMessage")
[17:27:49.982]                       }
[17:27:49.982]                       else if (inherits(cond, "warning")) {
[17:27:49.982]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:49.982]                         if (muffled) 
[17:27:49.982]                           invokeRestart("muffleWarning")
[17:27:49.982]                       }
[17:27:49.982]                       else if (inherits(cond, "condition")) {
[17:27:49.982]                         if (!is.null(pattern)) {
[17:27:49.982]                           computeRestarts <- base::computeRestarts
[17:27:49.982]                           grepl <- base::grepl
[17:27:49.982]                           restarts <- computeRestarts(cond)
[17:27:49.982]                           for (restart in restarts) {
[17:27:49.982]                             name <- restart$name
[17:27:49.982]                             if (is.null(name)) 
[17:27:49.982]                               next
[17:27:49.982]                             if (!grepl(pattern, name)) 
[17:27:49.982]                               next
[17:27:49.982]                             invokeRestart(restart)
[17:27:49.982]                             muffled <- TRUE
[17:27:49.982]                             break
[17:27:49.982]                           }
[17:27:49.982]                         }
[17:27:49.982]                       }
[17:27:49.982]                       invisible(muffled)
[17:27:49.982]                     }
[17:27:49.982]                     muffleCondition(cond, pattern = "^muffle")
[17:27:49.982]                   }
[17:27:49.982]                 }
[17:27:49.982]             }
[17:27:49.982]         }))
[17:27:49.982]     }, error = function(ex) {
[17:27:49.982]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:49.982]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:49.982]                 ...future.rng), started = ...future.startTime, 
[17:27:49.982]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:49.982]             version = "1.8"), class = "FutureResult")
[17:27:49.982]     }, finally = {
[17:27:49.982]         if (!identical(...future.workdir, getwd())) 
[17:27:49.982]             setwd(...future.workdir)
[17:27:49.982]         {
[17:27:49.982]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:49.982]                 ...future.oldOptions$nwarnings <- NULL
[17:27:49.982]             }
[17:27:49.982]             base::options(...future.oldOptions)
[17:27:49.982]             if (.Platform$OS.type == "windows") {
[17:27:49.982]                 old_names <- names(...future.oldEnvVars)
[17:27:49.982]                 envs <- base::Sys.getenv()
[17:27:49.982]                 names <- names(envs)
[17:27:49.982]                 common <- intersect(names, old_names)
[17:27:49.982]                 added <- setdiff(names, old_names)
[17:27:49.982]                 removed <- setdiff(old_names, names)
[17:27:49.982]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:49.982]                   envs[common]]
[17:27:49.982]                 NAMES <- toupper(changed)
[17:27:49.982]                 args <- list()
[17:27:49.982]                 for (kk in seq_along(NAMES)) {
[17:27:49.982]                   name <- changed[[kk]]
[17:27:49.982]                   NAME <- NAMES[[kk]]
[17:27:49.982]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.982]                     next
[17:27:49.982]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.982]                 }
[17:27:49.982]                 NAMES <- toupper(added)
[17:27:49.982]                 for (kk in seq_along(NAMES)) {
[17:27:49.982]                   name <- added[[kk]]
[17:27:49.982]                   NAME <- NAMES[[kk]]
[17:27:49.982]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.982]                     next
[17:27:49.982]                   args[[name]] <- ""
[17:27:49.982]                 }
[17:27:49.982]                 NAMES <- toupper(removed)
[17:27:49.982]                 for (kk in seq_along(NAMES)) {
[17:27:49.982]                   name <- removed[[kk]]
[17:27:49.982]                   NAME <- NAMES[[kk]]
[17:27:49.982]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:49.982]                     next
[17:27:49.982]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:49.982]                 }
[17:27:49.982]                 if (length(args) > 0) 
[17:27:49.982]                   base::do.call(base::Sys.setenv, args = args)
[17:27:49.982]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:49.982]             }
[17:27:49.982]             else {
[17:27:49.982]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:49.982]             }
[17:27:49.982]             {
[17:27:49.982]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:49.982]                   0L) {
[17:27:49.982]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:49.982]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:49.982]                   base::options(opts)
[17:27:49.982]                 }
[17:27:49.982]                 {
[17:27:49.982]                   {
[17:27:49.982]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:49.982]                     NULL
[17:27:49.982]                   }
[17:27:49.982]                   options(future.plan = NULL)
[17:27:49.982]                   if (is.na(NA_character_)) 
[17:27:49.982]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:49.982]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:49.982]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:49.982]                     .init = FALSE)
[17:27:49.982]                 }
[17:27:49.982]             }
[17:27:49.982]         }
[17:27:49.982]     })
[17:27:49.982]     if (TRUE) {
[17:27:49.982]         base::sink(type = "output", split = FALSE)
[17:27:49.982]         if (TRUE) {
[17:27:49.982]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:49.982]         }
[17:27:49.982]         else {
[17:27:49.982]             ...future.result["stdout"] <- base::list(NULL)
[17:27:49.982]         }
[17:27:49.982]         base::close(...future.stdout)
[17:27:49.982]         ...future.stdout <- NULL
[17:27:49.982]     }
[17:27:49.982]     ...future.result$conditions <- ...future.conditions
[17:27:49.982]     ...future.result$finished <- base::Sys.time()
[17:27:49.982]     ...future.result
[17:27:49.982] }
[17:27:49.989] Exporting 1 global objects (374 bytes) to cluster node #1 ...
[17:27:49.989] Exporting 'x' (71 bytes) to cluster node #1 ...
[17:27:49.990] Exporting 'x' (71 bytes) to cluster node #1 ... DONE
[17:27:49.990] Exporting 1 global objects (374 bytes) to cluster node #1 ... DONE
[17:27:49.991] MultisessionFuture started
[17:27:49.991] - Launch lazy future ... done
[17:27:49.992] run() for 'MultisessionFuture' ... done
[17:27:49.992] result() for ClusterFuture ...
[17:27:49.992] receiveMessageFromWorker() for ClusterFuture ...
[17:27:49.993] - Validating connection of MultisessionFuture
[17:27:50.015] - received message: FutureResult
[17:27:50.015] - Received FutureResult
[17:27:50.015] - Erased future from FutureRegistry
[17:27:50.016] result() for ClusterFuture ...
[17:27:50.016] - result already collected: FutureResult
[17:27:50.016] result() for ClusterFuture ... done
[17:27:50.016] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:50.016] result() for ClusterFuture ... done
[17:27:50.016] result() for ClusterFuture ...
[17:27:50.017] - result already collected: FutureResult
[17:27:50.017] result() for ClusterFuture ... done
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  

[17:27:50.019] getGlobalsAndPackages() ...
[17:27:50.019] Searching for globals...
[17:27:50.022] - globals found: [7] '{', 'lm', 'dist', '-', '.', '~', 'cars'
[17:27:50.023] Searching for globals ... DONE
[17:27:50.023] Resolving globals: FALSE
[17:27:50.024] 
[17:27:50.024] - packages: [2] 'stats', 'datasets'
[17:27:50.024] getGlobalsAndPackages() ... DONE
[17:27:50.025] run() for 'Future' ...
[17:27:50.025] - state: 'created'
[17:27:50.026] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:50.043] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:50.044] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:50.044]   - Field: 'node'
[17:27:50.044]   - Field: 'label'
[17:27:50.045]   - Field: 'local'
[17:27:50.045]   - Field: 'owner'
[17:27:50.045]   - Field: 'envir'
[17:27:50.046]   - Field: 'workers'
[17:27:50.046]   - Field: 'packages'
[17:27:50.046]   - Field: 'gc'
[17:27:50.046]   - Field: 'conditions'
[17:27:50.047]   - Field: 'persistent'
[17:27:50.047]   - Field: 'expr'
[17:27:50.047]   - Field: 'uuid'
[17:27:50.048]   - Field: 'seed'
[17:27:50.048]   - Field: 'version'
[17:27:50.048]   - Field: 'result'
[17:27:50.049]   - Field: 'asynchronous'
[17:27:50.049]   - Field: 'calls'
[17:27:50.050]   - Field: 'globals'
[17:27:50.050]   - Field: 'stdout'
[17:27:50.050]   - Field: 'earlySignal'
[17:27:50.051]   - Field: 'lazy'
[17:27:50.051]   - Field: 'state'
[17:27:50.051] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:50.052] - Launch lazy future ...
[17:27:50.053] Packages needed by the future expression (n = 2): 'stats', 'datasets'
[17:27:50.053] Packages needed by future strategies (n = 0): <none>
[17:27:50.054] {
[17:27:50.054]     {
[17:27:50.054]         {
[17:27:50.054]             ...future.startTime <- base::Sys.time()
[17:27:50.054]             {
[17:27:50.054]                 {
[17:27:50.054]                   {
[17:27:50.054]                     {
[17:27:50.054]                       {
[17:27:50.054]                         base::local({
[17:27:50.054]                           has_future <- base::requireNamespace("future", 
[17:27:50.054]                             quietly = TRUE)
[17:27:50.054]                           if (has_future) {
[17:27:50.054]                             ns <- base::getNamespace("future")
[17:27:50.054]                             version <- ns[[".package"]][["version"]]
[17:27:50.054]                             if (is.null(version)) 
[17:27:50.054]                               version <- utils::packageVersion("future")
[17:27:50.054]                           }
[17:27:50.054]                           else {
[17:27:50.054]                             version <- NULL
[17:27:50.054]                           }
[17:27:50.054]                           if (!has_future || version < "1.8.0") {
[17:27:50.054]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:50.054]                               "", base::R.version$version.string), 
[17:27:50.054]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:50.054]                                 base::R.version$platform, 8 * 
[17:27:50.054]                                   base::.Machine$sizeof.pointer), 
[17:27:50.054]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:50.054]                                 "release", "version")], collapse = " "), 
[17:27:50.054]                               hostname = base::Sys.info()[["nodename"]])
[17:27:50.054]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:50.054]                               info)
[17:27:50.054]                             info <- base::paste(info, collapse = "; ")
[17:27:50.054]                             if (!has_future) {
[17:27:50.054]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:50.054]                                 info)
[17:27:50.054]                             }
[17:27:50.054]                             else {
[17:27:50.054]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:50.054]                                 info, version)
[17:27:50.054]                             }
[17:27:50.054]                             base::stop(msg)
[17:27:50.054]                           }
[17:27:50.054]                         })
[17:27:50.054]                       }
[17:27:50.054]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:50.054]                       base::options(mc.cores = 1L)
[17:27:50.054]                     }
[17:27:50.054]                     base::local({
[17:27:50.054]                       for (pkg in c("stats", "datasets")) {
[17:27:50.054]                         base::loadNamespace(pkg)
[17:27:50.054]                         base::library(pkg, character.only = TRUE)
[17:27:50.054]                       }
[17:27:50.054]                     })
[17:27:50.054]                   }
[17:27:50.054]                   ...future.strategy.old <- future::plan("list")
[17:27:50.054]                   options(future.plan = NULL)
[17:27:50.054]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.054]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:50.054]                 }
[17:27:50.054]                 ...future.workdir <- getwd()
[17:27:50.054]             }
[17:27:50.054]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:50.054]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:50.054]         }
[17:27:50.054]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:50.054]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:50.054]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:50.054]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:50.054]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:50.054]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:50.054]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:50.054]             base::names(...future.oldOptions))
[17:27:50.054]     }
[17:27:50.054]     if (FALSE) {
[17:27:50.054]     }
[17:27:50.054]     else {
[17:27:50.054]         if (TRUE) {
[17:27:50.054]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:50.054]                 open = "w")
[17:27:50.054]         }
[17:27:50.054]         else {
[17:27:50.054]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:50.054]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:50.054]         }
[17:27:50.054]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:50.054]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:50.054]             base::sink(type = "output", split = FALSE)
[17:27:50.054]             base::close(...future.stdout)
[17:27:50.054]         }, add = TRUE)
[17:27:50.054]     }
[17:27:50.054]     ...future.frame <- base::sys.nframe()
[17:27:50.054]     ...future.conditions <- base::list()
[17:27:50.054]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:50.054]     if (FALSE) {
[17:27:50.054]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:50.054]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:50.054]     }
[17:27:50.054]     ...future.result <- base::tryCatch({
[17:27:50.054]         base::withCallingHandlers({
[17:27:50.054]             ...future.value <- base::withVisible(base::local({
[17:27:50.054]                 ...future.makeSendCondition <- base::local({
[17:27:50.054]                   sendCondition <- NULL
[17:27:50.054]                   function(frame = 1L) {
[17:27:50.054]                     if (is.function(sendCondition)) 
[17:27:50.054]                       return(sendCondition)
[17:27:50.054]                     ns <- getNamespace("parallel")
[17:27:50.054]                     if (exists("sendData", mode = "function", 
[17:27:50.054]                       envir = ns)) {
[17:27:50.054]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:50.054]                         envir = ns)
[17:27:50.054]                       envir <- sys.frame(frame)
[17:27:50.054]                       master <- NULL
[17:27:50.054]                       while (!identical(envir, .GlobalEnv) && 
[17:27:50.054]                         !identical(envir, emptyenv())) {
[17:27:50.054]                         if (exists("master", mode = "list", envir = envir, 
[17:27:50.054]                           inherits = FALSE)) {
[17:27:50.054]                           master <- get("master", mode = "list", 
[17:27:50.054]                             envir = envir, inherits = FALSE)
[17:27:50.054]                           if (inherits(master, c("SOCKnode", 
[17:27:50.054]                             "SOCK0node"))) {
[17:27:50.054]                             sendCondition <<- function(cond) {
[17:27:50.054]                               data <- list(type = "VALUE", value = cond, 
[17:27:50.054]                                 success = TRUE)
[17:27:50.054]                               parallel_sendData(master, data)
[17:27:50.054]                             }
[17:27:50.054]                             return(sendCondition)
[17:27:50.054]                           }
[17:27:50.054]                         }
[17:27:50.054]                         frame <- frame + 1L
[17:27:50.054]                         envir <- sys.frame(frame)
[17:27:50.054]                       }
[17:27:50.054]                     }
[17:27:50.054]                     sendCondition <<- function(cond) NULL
[17:27:50.054]                   }
[17:27:50.054]                 })
[17:27:50.054]                 withCallingHandlers({
[17:27:50.054]                   {
[17:27:50.054]                     lm(dist ~ . - 1, data = cars)
[17:27:50.054]                   }
[17:27:50.054]                 }, immediateCondition = function(cond) {
[17:27:50.054]                   sendCondition <- ...future.makeSendCondition()
[17:27:50.054]                   sendCondition(cond)
[17:27:50.054]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.054]                   {
[17:27:50.054]                     inherits <- base::inherits
[17:27:50.054]                     invokeRestart <- base::invokeRestart
[17:27:50.054]                     is.null <- base::is.null
[17:27:50.054]                     muffled <- FALSE
[17:27:50.054]                     if (inherits(cond, "message")) {
[17:27:50.054]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:50.054]                       if (muffled) 
[17:27:50.054]                         invokeRestart("muffleMessage")
[17:27:50.054]                     }
[17:27:50.054]                     else if (inherits(cond, "warning")) {
[17:27:50.054]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:50.054]                       if (muffled) 
[17:27:50.054]                         invokeRestart("muffleWarning")
[17:27:50.054]                     }
[17:27:50.054]                     else if (inherits(cond, "condition")) {
[17:27:50.054]                       if (!is.null(pattern)) {
[17:27:50.054]                         computeRestarts <- base::computeRestarts
[17:27:50.054]                         grepl <- base::grepl
[17:27:50.054]                         restarts <- computeRestarts(cond)
[17:27:50.054]                         for (restart in restarts) {
[17:27:50.054]                           name <- restart$name
[17:27:50.054]                           if (is.null(name)) 
[17:27:50.054]                             next
[17:27:50.054]                           if (!grepl(pattern, name)) 
[17:27:50.054]                             next
[17:27:50.054]                           invokeRestart(restart)
[17:27:50.054]                           muffled <- TRUE
[17:27:50.054]                           break
[17:27:50.054]                         }
[17:27:50.054]                       }
[17:27:50.054]                     }
[17:27:50.054]                     invisible(muffled)
[17:27:50.054]                   }
[17:27:50.054]                   muffleCondition(cond)
[17:27:50.054]                 })
[17:27:50.054]             }))
[17:27:50.054]             future::FutureResult(value = ...future.value$value, 
[17:27:50.054]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.054]                   ...future.rng), globalenv = if (FALSE) 
[17:27:50.054]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:50.054]                     ...future.globalenv.names))
[17:27:50.054]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:50.054]         }, condition = base::local({
[17:27:50.054]             c <- base::c
[17:27:50.054]             inherits <- base::inherits
[17:27:50.054]             invokeRestart <- base::invokeRestart
[17:27:50.054]             length <- base::length
[17:27:50.054]             list <- base::list
[17:27:50.054]             seq.int <- base::seq.int
[17:27:50.054]             signalCondition <- base::signalCondition
[17:27:50.054]             sys.calls <- base::sys.calls
[17:27:50.054]             `[[` <- base::`[[`
[17:27:50.054]             `+` <- base::`+`
[17:27:50.054]             `<<-` <- base::`<<-`
[17:27:50.054]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:50.054]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:50.054]                   3L)]
[17:27:50.054]             }
[17:27:50.054]             function(cond) {
[17:27:50.054]                 is_error <- inherits(cond, "error")
[17:27:50.054]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:50.054]                   NULL)
[17:27:50.054]                 if (is_error) {
[17:27:50.054]                   sessionInformation <- function() {
[17:27:50.054]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:50.054]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:50.054]                       search = base::search(), system = base::Sys.info())
[17:27:50.054]                   }
[17:27:50.054]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.054]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:50.054]                     cond$call), session = sessionInformation(), 
[17:27:50.054]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:50.054]                   signalCondition(cond)
[17:27:50.054]                 }
[17:27:50.054]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:50.054]                 "immediateCondition"))) {
[17:27:50.054]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:50.054]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.054]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:50.054]                   if (TRUE && !signal) {
[17:27:50.054]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.054]                     {
[17:27:50.054]                       inherits <- base::inherits
[17:27:50.054]                       invokeRestart <- base::invokeRestart
[17:27:50.054]                       is.null <- base::is.null
[17:27:50.054]                       muffled <- FALSE
[17:27:50.054]                       if (inherits(cond, "message")) {
[17:27:50.054]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.054]                         if (muffled) 
[17:27:50.054]                           invokeRestart("muffleMessage")
[17:27:50.054]                       }
[17:27:50.054]                       else if (inherits(cond, "warning")) {
[17:27:50.054]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.054]                         if (muffled) 
[17:27:50.054]                           invokeRestart("muffleWarning")
[17:27:50.054]                       }
[17:27:50.054]                       else if (inherits(cond, "condition")) {
[17:27:50.054]                         if (!is.null(pattern)) {
[17:27:50.054]                           computeRestarts <- base::computeRestarts
[17:27:50.054]                           grepl <- base::grepl
[17:27:50.054]                           restarts <- computeRestarts(cond)
[17:27:50.054]                           for (restart in restarts) {
[17:27:50.054]                             name <- restart$name
[17:27:50.054]                             if (is.null(name)) 
[17:27:50.054]                               next
[17:27:50.054]                             if (!grepl(pattern, name)) 
[17:27:50.054]                               next
[17:27:50.054]                             invokeRestart(restart)
[17:27:50.054]                             muffled <- TRUE
[17:27:50.054]                             break
[17:27:50.054]                           }
[17:27:50.054]                         }
[17:27:50.054]                       }
[17:27:50.054]                       invisible(muffled)
[17:27:50.054]                     }
[17:27:50.054]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.054]                   }
[17:27:50.054]                 }
[17:27:50.054]                 else {
[17:27:50.054]                   if (TRUE) {
[17:27:50.054]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.054]                     {
[17:27:50.054]                       inherits <- base::inherits
[17:27:50.054]                       invokeRestart <- base::invokeRestart
[17:27:50.054]                       is.null <- base::is.null
[17:27:50.054]                       muffled <- FALSE
[17:27:50.054]                       if (inherits(cond, "message")) {
[17:27:50.054]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.054]                         if (muffled) 
[17:27:50.054]                           invokeRestart("muffleMessage")
[17:27:50.054]                       }
[17:27:50.054]                       else if (inherits(cond, "warning")) {
[17:27:50.054]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.054]                         if (muffled) 
[17:27:50.054]                           invokeRestart("muffleWarning")
[17:27:50.054]                       }
[17:27:50.054]                       else if (inherits(cond, "condition")) {
[17:27:50.054]                         if (!is.null(pattern)) {
[17:27:50.054]                           computeRestarts <- base::computeRestarts
[17:27:50.054]                           grepl <- base::grepl
[17:27:50.054]                           restarts <- computeRestarts(cond)
[17:27:50.054]                           for (restart in restarts) {
[17:27:50.054]                             name <- restart$name
[17:27:50.054]                             if (is.null(name)) 
[17:27:50.054]                               next
[17:27:50.054]                             if (!grepl(pattern, name)) 
[17:27:50.054]                               next
[17:27:50.054]                             invokeRestart(restart)
[17:27:50.054]                             muffled <- TRUE
[17:27:50.054]                             break
[17:27:50.054]                           }
[17:27:50.054]                         }
[17:27:50.054]                       }
[17:27:50.054]                       invisible(muffled)
[17:27:50.054]                     }
[17:27:50.054]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.054]                   }
[17:27:50.054]                 }
[17:27:50.054]             }
[17:27:50.054]         }))
[17:27:50.054]     }, error = function(ex) {
[17:27:50.054]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:50.054]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.054]                 ...future.rng), started = ...future.startTime, 
[17:27:50.054]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:50.054]             version = "1.8"), class = "FutureResult")
[17:27:50.054]     }, finally = {
[17:27:50.054]         if (!identical(...future.workdir, getwd())) 
[17:27:50.054]             setwd(...future.workdir)
[17:27:50.054]         {
[17:27:50.054]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:50.054]                 ...future.oldOptions$nwarnings <- NULL
[17:27:50.054]             }
[17:27:50.054]             base::options(...future.oldOptions)
[17:27:50.054]             if (.Platform$OS.type == "windows") {
[17:27:50.054]                 old_names <- names(...future.oldEnvVars)
[17:27:50.054]                 envs <- base::Sys.getenv()
[17:27:50.054]                 names <- names(envs)
[17:27:50.054]                 common <- intersect(names, old_names)
[17:27:50.054]                 added <- setdiff(names, old_names)
[17:27:50.054]                 removed <- setdiff(old_names, names)
[17:27:50.054]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:50.054]                   envs[common]]
[17:27:50.054]                 NAMES <- toupper(changed)
[17:27:50.054]                 args <- list()
[17:27:50.054]                 for (kk in seq_along(NAMES)) {
[17:27:50.054]                   name <- changed[[kk]]
[17:27:50.054]                   NAME <- NAMES[[kk]]
[17:27:50.054]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.054]                     next
[17:27:50.054]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.054]                 }
[17:27:50.054]                 NAMES <- toupper(added)
[17:27:50.054]                 for (kk in seq_along(NAMES)) {
[17:27:50.054]                   name <- added[[kk]]
[17:27:50.054]                   NAME <- NAMES[[kk]]
[17:27:50.054]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.054]                     next
[17:27:50.054]                   args[[name]] <- ""
[17:27:50.054]                 }
[17:27:50.054]                 NAMES <- toupper(removed)
[17:27:50.054]                 for (kk in seq_along(NAMES)) {
[17:27:50.054]                   name <- removed[[kk]]
[17:27:50.054]                   NAME <- NAMES[[kk]]
[17:27:50.054]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.054]                     next
[17:27:50.054]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.054]                 }
[17:27:50.054]                 if (length(args) > 0) 
[17:27:50.054]                   base::do.call(base::Sys.setenv, args = args)
[17:27:50.054]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:50.054]             }
[17:27:50.054]             else {
[17:27:50.054]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:50.054]             }
[17:27:50.054]             {
[17:27:50.054]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:50.054]                   0L) {
[17:27:50.054]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:50.054]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:50.054]                   base::options(opts)
[17:27:50.054]                 }
[17:27:50.054]                 {
[17:27:50.054]                   {
[17:27:50.054]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:50.054]                     NULL
[17:27:50.054]                   }
[17:27:50.054]                   options(future.plan = NULL)
[17:27:50.054]                   if (is.na(NA_character_)) 
[17:27:50.054]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.054]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:50.054]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:50.054]                     .init = FALSE)
[17:27:50.054]                 }
[17:27:50.054]             }
[17:27:50.054]         }
[17:27:50.054]     })
[17:27:50.054]     if (TRUE) {
[17:27:50.054]         base::sink(type = "output", split = FALSE)
[17:27:50.054]         if (TRUE) {
[17:27:50.054]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:50.054]         }
[17:27:50.054]         else {
[17:27:50.054]             ...future.result["stdout"] <- base::list(NULL)
[17:27:50.054]         }
[17:27:50.054]         base::close(...future.stdout)
[17:27:50.054]         ...future.stdout <- NULL
[17:27:50.054]     }
[17:27:50.054]     ...future.result$conditions <- ...future.conditions
[17:27:50.054]     ...future.result$finished <- base::Sys.time()
[17:27:50.054]     ...future.result
[17:27:50.054] }
[17:27:50.065] MultisessionFuture started
[17:27:50.066] - Launch lazy future ... done
[17:27:50.066] run() for 'MultisessionFuture' ... done
[17:27:50.066] result() for ClusterFuture ...
[17:27:50.067] receiveMessageFromWorker() for ClusterFuture ...
[17:27:50.067] - Validating connection of MultisessionFuture
[17:27:50.095] - received message: FutureResult
[17:27:50.096] - Received FutureResult
[17:27:50.097] - Erased future from FutureRegistry
[17:27:50.097] result() for ClusterFuture ...
[17:27:50.097] - result already collected: FutureResult
[17:27:50.098] result() for ClusterFuture ... done
[17:27:50.098] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:50.098] result() for ClusterFuture ... done
[17:27:50.098] result() for ClusterFuture ...
[17:27:50.098] - result already collected: FutureResult
[17:27:50.099] result() for ClusterFuture ... done

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  

[17:27:50.102] getGlobalsAndPackages() ...
[17:27:50.103] Searching for globals...
[17:27:50.110] - globals found: [7] '{', 'lm', 'dist', '+', '.', '~', 'cars'
[17:27:50.110] Searching for globals ... DONE
[17:27:50.110] Resolving globals: FALSE
[17:27:50.111] 
[17:27:50.112] - packages: [2] 'stats', 'datasets'
[17:27:50.112] getGlobalsAndPackages() ... DONE
[17:27:50.112] run() for 'Future' ...
[17:27:50.113] - state: 'created'
[17:27:50.113] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:50.132] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:50.132] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:50.133]   - Field: 'node'
[17:27:50.133]   - Field: 'label'
[17:27:50.134]   - Field: 'local'
[17:27:50.134]   - Field: 'owner'
[17:27:50.135]   - Field: 'envir'
[17:27:50.135]   - Field: 'workers'
[17:27:50.135]   - Field: 'packages'
[17:27:50.136]   - Field: 'gc'
[17:27:50.136]   - Field: 'conditions'
[17:27:50.136]   - Field: 'persistent'
[17:27:50.137]   - Field: 'expr'
[17:27:50.137]   - Field: 'uuid'
[17:27:50.137]   - Field: 'seed'
[17:27:50.138]   - Field: 'version'
[17:27:50.138]   - Field: 'result'
[17:27:50.138]   - Field: 'asynchronous'
[17:27:50.138]   - Field: 'calls'
[17:27:50.139]   - Field: 'globals'
[17:27:50.139]   - Field: 'stdout'
[17:27:50.139]   - Field: 'earlySignal'
[17:27:50.140]   - Field: 'lazy'
[17:27:50.140]   - Field: 'state'
[17:27:50.140] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:50.141] - Launch lazy future ...
[17:27:50.141] Packages needed by the future expression (n = 2): 'stats', 'datasets'
[17:27:50.142] Packages needed by future strategies (n = 0): <none>
[17:27:50.143] {
[17:27:50.143]     {
[17:27:50.143]         {
[17:27:50.143]             ...future.startTime <- base::Sys.time()
[17:27:50.143]             {
[17:27:50.143]                 {
[17:27:50.143]                   {
[17:27:50.143]                     {
[17:27:50.143]                       {
[17:27:50.143]                         base::local({
[17:27:50.143]                           has_future <- base::requireNamespace("future", 
[17:27:50.143]                             quietly = TRUE)
[17:27:50.143]                           if (has_future) {
[17:27:50.143]                             ns <- base::getNamespace("future")
[17:27:50.143]                             version <- ns[[".package"]][["version"]]
[17:27:50.143]                             if (is.null(version)) 
[17:27:50.143]                               version <- utils::packageVersion("future")
[17:27:50.143]                           }
[17:27:50.143]                           else {
[17:27:50.143]                             version <- NULL
[17:27:50.143]                           }
[17:27:50.143]                           if (!has_future || version < "1.8.0") {
[17:27:50.143]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:50.143]                               "", base::R.version$version.string), 
[17:27:50.143]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:50.143]                                 base::R.version$platform, 8 * 
[17:27:50.143]                                   base::.Machine$sizeof.pointer), 
[17:27:50.143]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:50.143]                                 "release", "version")], collapse = " "), 
[17:27:50.143]                               hostname = base::Sys.info()[["nodename"]])
[17:27:50.143]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:50.143]                               info)
[17:27:50.143]                             info <- base::paste(info, collapse = "; ")
[17:27:50.143]                             if (!has_future) {
[17:27:50.143]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:50.143]                                 info)
[17:27:50.143]                             }
[17:27:50.143]                             else {
[17:27:50.143]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:50.143]                                 info, version)
[17:27:50.143]                             }
[17:27:50.143]                             base::stop(msg)
[17:27:50.143]                           }
[17:27:50.143]                         })
[17:27:50.143]                       }
[17:27:50.143]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:50.143]                       base::options(mc.cores = 1L)
[17:27:50.143]                     }
[17:27:50.143]                     base::local({
[17:27:50.143]                       for (pkg in c("stats", "datasets")) {
[17:27:50.143]                         base::loadNamespace(pkg)
[17:27:50.143]                         base::library(pkg, character.only = TRUE)
[17:27:50.143]                       }
[17:27:50.143]                     })
[17:27:50.143]                   }
[17:27:50.143]                   ...future.strategy.old <- future::plan("list")
[17:27:50.143]                   options(future.plan = NULL)
[17:27:50.143]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.143]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:50.143]                 }
[17:27:50.143]                 ...future.workdir <- getwd()
[17:27:50.143]             }
[17:27:50.143]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:50.143]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:50.143]         }
[17:27:50.143]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:50.143]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:50.143]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:50.143]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:50.143]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:50.143]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:50.143]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:50.143]             base::names(...future.oldOptions))
[17:27:50.143]     }
[17:27:50.143]     if (FALSE) {
[17:27:50.143]     }
[17:27:50.143]     else {
[17:27:50.143]         if (TRUE) {
[17:27:50.143]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:50.143]                 open = "w")
[17:27:50.143]         }
[17:27:50.143]         else {
[17:27:50.143]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:50.143]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:50.143]         }
[17:27:50.143]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:50.143]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:50.143]             base::sink(type = "output", split = FALSE)
[17:27:50.143]             base::close(...future.stdout)
[17:27:50.143]         }, add = TRUE)
[17:27:50.143]     }
[17:27:50.143]     ...future.frame <- base::sys.nframe()
[17:27:50.143]     ...future.conditions <- base::list()
[17:27:50.143]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:50.143]     if (FALSE) {
[17:27:50.143]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:50.143]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:50.143]     }
[17:27:50.143]     ...future.result <- base::tryCatch({
[17:27:50.143]         base::withCallingHandlers({
[17:27:50.143]             ...future.value <- base::withVisible(base::local({
[17:27:50.143]                 ...future.makeSendCondition <- base::local({
[17:27:50.143]                   sendCondition <- NULL
[17:27:50.143]                   function(frame = 1L) {
[17:27:50.143]                     if (is.function(sendCondition)) 
[17:27:50.143]                       return(sendCondition)
[17:27:50.143]                     ns <- getNamespace("parallel")
[17:27:50.143]                     if (exists("sendData", mode = "function", 
[17:27:50.143]                       envir = ns)) {
[17:27:50.143]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:50.143]                         envir = ns)
[17:27:50.143]                       envir <- sys.frame(frame)
[17:27:50.143]                       master <- NULL
[17:27:50.143]                       while (!identical(envir, .GlobalEnv) && 
[17:27:50.143]                         !identical(envir, emptyenv())) {
[17:27:50.143]                         if (exists("master", mode = "list", envir = envir, 
[17:27:50.143]                           inherits = FALSE)) {
[17:27:50.143]                           master <- get("master", mode = "list", 
[17:27:50.143]                             envir = envir, inherits = FALSE)
[17:27:50.143]                           if (inherits(master, c("SOCKnode", 
[17:27:50.143]                             "SOCK0node"))) {
[17:27:50.143]                             sendCondition <<- function(cond) {
[17:27:50.143]                               data <- list(type = "VALUE", value = cond, 
[17:27:50.143]                                 success = TRUE)
[17:27:50.143]                               parallel_sendData(master, data)
[17:27:50.143]                             }
[17:27:50.143]                             return(sendCondition)
[17:27:50.143]                           }
[17:27:50.143]                         }
[17:27:50.143]                         frame <- frame + 1L
[17:27:50.143]                         envir <- sys.frame(frame)
[17:27:50.143]                       }
[17:27:50.143]                     }
[17:27:50.143]                     sendCondition <<- function(cond) NULL
[17:27:50.143]                   }
[17:27:50.143]                 })
[17:27:50.143]                 withCallingHandlers({
[17:27:50.143]                   {
[17:27:50.143]                     lm(dist ~ . + 0, data = cars)
[17:27:50.143]                   }
[17:27:50.143]                 }, immediateCondition = function(cond) {
[17:27:50.143]                   sendCondition <- ...future.makeSendCondition()
[17:27:50.143]                   sendCondition(cond)
[17:27:50.143]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.143]                   {
[17:27:50.143]                     inherits <- base::inherits
[17:27:50.143]                     invokeRestart <- base::invokeRestart
[17:27:50.143]                     is.null <- base::is.null
[17:27:50.143]                     muffled <- FALSE
[17:27:50.143]                     if (inherits(cond, "message")) {
[17:27:50.143]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:50.143]                       if (muffled) 
[17:27:50.143]                         invokeRestart("muffleMessage")
[17:27:50.143]                     }
[17:27:50.143]                     else if (inherits(cond, "warning")) {
[17:27:50.143]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:50.143]                       if (muffled) 
[17:27:50.143]                         invokeRestart("muffleWarning")
[17:27:50.143]                     }
[17:27:50.143]                     else if (inherits(cond, "condition")) {
[17:27:50.143]                       if (!is.null(pattern)) {
[17:27:50.143]                         computeRestarts <- base::computeRestarts
[17:27:50.143]                         grepl <- base::grepl
[17:27:50.143]                         restarts <- computeRestarts(cond)
[17:27:50.143]                         for (restart in restarts) {
[17:27:50.143]                           name <- restart$name
[17:27:50.143]                           if (is.null(name)) 
[17:27:50.143]                             next
[17:27:50.143]                           if (!grepl(pattern, name)) 
[17:27:50.143]                             next
[17:27:50.143]                           invokeRestart(restart)
[17:27:50.143]                           muffled <- TRUE
[17:27:50.143]                           break
[17:27:50.143]                         }
[17:27:50.143]                       }
[17:27:50.143]                     }
[17:27:50.143]                     invisible(muffled)
[17:27:50.143]                   }
[17:27:50.143]                   muffleCondition(cond)
[17:27:50.143]                 })
[17:27:50.143]             }))
[17:27:50.143]             future::FutureResult(value = ...future.value$value, 
[17:27:50.143]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.143]                   ...future.rng), globalenv = if (FALSE) 
[17:27:50.143]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:50.143]                     ...future.globalenv.names))
[17:27:50.143]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:50.143]         }, condition = base::local({
[17:27:50.143]             c <- base::c
[17:27:50.143]             inherits <- base::inherits
[17:27:50.143]             invokeRestart <- base::invokeRestart
[17:27:50.143]             length <- base::length
[17:27:50.143]             list <- base::list
[17:27:50.143]             seq.int <- base::seq.int
[17:27:50.143]             signalCondition <- base::signalCondition
[17:27:50.143]             sys.calls <- base::sys.calls
[17:27:50.143]             `[[` <- base::`[[`
[17:27:50.143]             `+` <- base::`+`
[17:27:50.143]             `<<-` <- base::`<<-`
[17:27:50.143]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:50.143]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:50.143]                   3L)]
[17:27:50.143]             }
[17:27:50.143]             function(cond) {
[17:27:50.143]                 is_error <- inherits(cond, "error")
[17:27:50.143]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:50.143]                   NULL)
[17:27:50.143]                 if (is_error) {
[17:27:50.143]                   sessionInformation <- function() {
[17:27:50.143]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:50.143]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:50.143]                       search = base::search(), system = base::Sys.info())
[17:27:50.143]                   }
[17:27:50.143]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.143]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:50.143]                     cond$call), session = sessionInformation(), 
[17:27:50.143]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:50.143]                   signalCondition(cond)
[17:27:50.143]                 }
[17:27:50.143]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:50.143]                 "immediateCondition"))) {
[17:27:50.143]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:50.143]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.143]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:50.143]                   if (TRUE && !signal) {
[17:27:50.143]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.143]                     {
[17:27:50.143]                       inherits <- base::inherits
[17:27:50.143]                       invokeRestart <- base::invokeRestart
[17:27:50.143]                       is.null <- base::is.null
[17:27:50.143]                       muffled <- FALSE
[17:27:50.143]                       if (inherits(cond, "message")) {
[17:27:50.143]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.143]                         if (muffled) 
[17:27:50.143]                           invokeRestart("muffleMessage")
[17:27:50.143]                       }
[17:27:50.143]                       else if (inherits(cond, "warning")) {
[17:27:50.143]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.143]                         if (muffled) 
[17:27:50.143]                           invokeRestart("muffleWarning")
[17:27:50.143]                       }
[17:27:50.143]                       else if (inherits(cond, "condition")) {
[17:27:50.143]                         if (!is.null(pattern)) {
[17:27:50.143]                           computeRestarts <- base::computeRestarts
[17:27:50.143]                           grepl <- base::grepl
[17:27:50.143]                           restarts <- computeRestarts(cond)
[17:27:50.143]                           for (restart in restarts) {
[17:27:50.143]                             name <- restart$name
[17:27:50.143]                             if (is.null(name)) 
[17:27:50.143]                               next
[17:27:50.143]                             if (!grepl(pattern, name)) 
[17:27:50.143]                               next
[17:27:50.143]                             invokeRestart(restart)
[17:27:50.143]                             muffled <- TRUE
[17:27:50.143]                             break
[17:27:50.143]                           }
[17:27:50.143]                         }
[17:27:50.143]                       }
[17:27:50.143]                       invisible(muffled)
[17:27:50.143]                     }
[17:27:50.143]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.143]                   }
[17:27:50.143]                 }
[17:27:50.143]                 else {
[17:27:50.143]                   if (TRUE) {
[17:27:50.143]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.143]                     {
[17:27:50.143]                       inherits <- base::inherits
[17:27:50.143]                       invokeRestart <- base::invokeRestart
[17:27:50.143]                       is.null <- base::is.null
[17:27:50.143]                       muffled <- FALSE
[17:27:50.143]                       if (inherits(cond, "message")) {
[17:27:50.143]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.143]                         if (muffled) 
[17:27:50.143]                           invokeRestart("muffleMessage")
[17:27:50.143]                       }
[17:27:50.143]                       else if (inherits(cond, "warning")) {
[17:27:50.143]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.143]                         if (muffled) 
[17:27:50.143]                           invokeRestart("muffleWarning")
[17:27:50.143]                       }
[17:27:50.143]                       else if (inherits(cond, "condition")) {
[17:27:50.143]                         if (!is.null(pattern)) {
[17:27:50.143]                           computeRestarts <- base::computeRestarts
[17:27:50.143]                           grepl <- base::grepl
[17:27:50.143]                           restarts <- computeRestarts(cond)
[17:27:50.143]                           for (restart in restarts) {
[17:27:50.143]                             name <- restart$name
[17:27:50.143]                             if (is.null(name)) 
[17:27:50.143]                               next
[17:27:50.143]                             if (!grepl(pattern, name)) 
[17:27:50.143]                               next
[17:27:50.143]                             invokeRestart(restart)
[17:27:50.143]                             muffled <- TRUE
[17:27:50.143]                             break
[17:27:50.143]                           }
[17:27:50.143]                         }
[17:27:50.143]                       }
[17:27:50.143]                       invisible(muffled)
[17:27:50.143]                     }
[17:27:50.143]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.143]                   }
[17:27:50.143]                 }
[17:27:50.143]             }
[17:27:50.143]         }))
[17:27:50.143]     }, error = function(ex) {
[17:27:50.143]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:50.143]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.143]                 ...future.rng), started = ...future.startTime, 
[17:27:50.143]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:50.143]             version = "1.8"), class = "FutureResult")
[17:27:50.143]     }, finally = {
[17:27:50.143]         if (!identical(...future.workdir, getwd())) 
[17:27:50.143]             setwd(...future.workdir)
[17:27:50.143]         {
[17:27:50.143]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:50.143]                 ...future.oldOptions$nwarnings <- NULL
[17:27:50.143]             }
[17:27:50.143]             base::options(...future.oldOptions)
[17:27:50.143]             if (.Platform$OS.type == "windows") {
[17:27:50.143]                 old_names <- names(...future.oldEnvVars)
[17:27:50.143]                 envs <- base::Sys.getenv()
[17:27:50.143]                 names <- names(envs)
[17:27:50.143]                 common <- intersect(names, old_names)
[17:27:50.143]                 added <- setdiff(names, old_names)
[17:27:50.143]                 removed <- setdiff(old_names, names)
[17:27:50.143]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:50.143]                   envs[common]]
[17:27:50.143]                 NAMES <- toupper(changed)
[17:27:50.143]                 args <- list()
[17:27:50.143]                 for (kk in seq_along(NAMES)) {
[17:27:50.143]                   name <- changed[[kk]]
[17:27:50.143]                   NAME <- NAMES[[kk]]
[17:27:50.143]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.143]                     next
[17:27:50.143]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.143]                 }
[17:27:50.143]                 NAMES <- toupper(added)
[17:27:50.143]                 for (kk in seq_along(NAMES)) {
[17:27:50.143]                   name <- added[[kk]]
[17:27:50.143]                   NAME <- NAMES[[kk]]
[17:27:50.143]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.143]                     next
[17:27:50.143]                   args[[name]] <- ""
[17:27:50.143]                 }
[17:27:50.143]                 NAMES <- toupper(removed)
[17:27:50.143]                 for (kk in seq_along(NAMES)) {
[17:27:50.143]                   name <- removed[[kk]]
[17:27:50.143]                   NAME <- NAMES[[kk]]
[17:27:50.143]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.143]                     next
[17:27:50.143]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.143]                 }
[17:27:50.143]                 if (length(args) > 0) 
[17:27:50.143]                   base::do.call(base::Sys.setenv, args = args)
[17:27:50.143]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:50.143]             }
[17:27:50.143]             else {
[17:27:50.143]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:50.143]             }
[17:27:50.143]             {
[17:27:50.143]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:50.143]                   0L) {
[17:27:50.143]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:50.143]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:50.143]                   base::options(opts)
[17:27:50.143]                 }
[17:27:50.143]                 {
[17:27:50.143]                   {
[17:27:50.143]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:50.143]                     NULL
[17:27:50.143]                   }
[17:27:50.143]                   options(future.plan = NULL)
[17:27:50.143]                   if (is.na(NA_character_)) 
[17:27:50.143]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.143]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:50.143]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:50.143]                     .init = FALSE)
[17:27:50.143]                 }
[17:27:50.143]             }
[17:27:50.143]         }
[17:27:50.143]     })
[17:27:50.143]     if (TRUE) {
[17:27:50.143]         base::sink(type = "output", split = FALSE)
[17:27:50.143]         if (TRUE) {
[17:27:50.143]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:50.143]         }
[17:27:50.143]         else {
[17:27:50.143]             ...future.result["stdout"] <- base::list(NULL)
[17:27:50.143]         }
[17:27:50.143]         base::close(...future.stdout)
[17:27:50.143]         ...future.stdout <- NULL
[17:27:50.143]     }
[17:27:50.143]     ...future.result$conditions <- ...future.conditions
[17:27:50.143]     ...future.result$finished <- base::Sys.time()
[17:27:50.143]     ...future.result
[17:27:50.143] }
[17:27:50.153] MultisessionFuture started
[17:27:50.153] - Launch lazy future ... done
[17:27:50.154] run() for 'MultisessionFuture' ... done
[17:27:50.155] result() for ClusterFuture ...
[17:27:50.155] receiveMessageFromWorker() for ClusterFuture ...
[17:27:50.155] - Validating connection of MultisessionFuture
[17:27:50.186] - received message: FutureResult
[17:27:50.186] - Received FutureResult
[17:27:50.187] - Erased future from FutureRegistry
[17:27:50.187] result() for ClusterFuture ...
[17:27:50.188] - result already collected: FutureResult
[17:27:50.188] result() for ClusterFuture ... done
[17:27:50.188] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:50.189] result() for ClusterFuture ... done
[17:27:50.189] result() for ClusterFuture ...
[17:27:50.190] - result already collected: FutureResult
[17:27:50.190] result() for ClusterFuture ... done

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  

[17:27:50.195] getGlobalsAndPackages() ...
[17:27:50.196] Searching for globals...
[17:27:50.200] - globals found: [8] '{', 'lm', 'dist', '+', 'speed', '^', '~', 'cars'
[17:27:50.200] Searching for globals ... DONE
[17:27:50.200] Resolving globals: FALSE
[17:27:50.201] 
[17:27:50.202] - packages: [2] 'stats', 'datasets'
[17:27:50.202] getGlobalsAndPackages() ... DONE
[17:27:50.203] run() for 'Future' ...
[17:27:50.203] - state: 'created'
[17:27:50.203] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:50.227] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:50.227] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:50.228]   - Field: 'node'
[17:27:50.228]   - Field: 'label'
[17:27:50.229]   - Field: 'local'
[17:27:50.229]   - Field: 'owner'
[17:27:50.229]   - Field: 'envir'
[17:27:50.230]   - Field: 'workers'
[17:27:50.230]   - Field: 'packages'
[17:27:50.230]   - Field: 'gc'
[17:27:50.231]   - Field: 'conditions'
[17:27:50.231]   - Field: 'persistent'
[17:27:50.231]   - Field: 'expr'
[17:27:50.232]   - Field: 'uuid'
[17:27:50.232]   - Field: 'seed'
[17:27:50.232]   - Field: 'version'
[17:27:50.233]   - Field: 'result'
[17:27:50.233]   - Field: 'asynchronous'
[17:27:50.233]   - Field: 'calls'
[17:27:50.234]   - Field: 'globals'
[17:27:50.234]   - Field: 'stdout'
[17:27:50.234]   - Field: 'earlySignal'
[17:27:50.235]   - Field: 'lazy'
[17:27:50.235]   - Field: 'state'
[17:27:50.236] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:50.236] - Launch lazy future ...
[17:27:50.237] Packages needed by the future expression (n = 2): 'stats', 'datasets'
[17:27:50.237] Packages needed by future strategies (n = 0): <none>
[17:27:50.238] {
[17:27:50.238]     {
[17:27:50.238]         {
[17:27:50.238]             ...future.startTime <- base::Sys.time()
[17:27:50.238]             {
[17:27:50.238]                 {
[17:27:50.238]                   {
[17:27:50.238]                     {
[17:27:50.238]                       {
[17:27:50.238]                         base::local({
[17:27:50.238]                           has_future <- base::requireNamespace("future", 
[17:27:50.238]                             quietly = TRUE)
[17:27:50.238]                           if (has_future) {
[17:27:50.238]                             ns <- base::getNamespace("future")
[17:27:50.238]                             version <- ns[[".package"]][["version"]]
[17:27:50.238]                             if (is.null(version)) 
[17:27:50.238]                               version <- utils::packageVersion("future")
[17:27:50.238]                           }
[17:27:50.238]                           else {
[17:27:50.238]                             version <- NULL
[17:27:50.238]                           }
[17:27:50.238]                           if (!has_future || version < "1.8.0") {
[17:27:50.238]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:50.238]                               "", base::R.version$version.string), 
[17:27:50.238]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:50.238]                                 base::R.version$platform, 8 * 
[17:27:50.238]                                   base::.Machine$sizeof.pointer), 
[17:27:50.238]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:50.238]                                 "release", "version")], collapse = " "), 
[17:27:50.238]                               hostname = base::Sys.info()[["nodename"]])
[17:27:50.238]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:50.238]                               info)
[17:27:50.238]                             info <- base::paste(info, collapse = "; ")
[17:27:50.238]                             if (!has_future) {
[17:27:50.238]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:50.238]                                 info)
[17:27:50.238]                             }
[17:27:50.238]                             else {
[17:27:50.238]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:50.238]                                 info, version)
[17:27:50.238]                             }
[17:27:50.238]                             base::stop(msg)
[17:27:50.238]                           }
[17:27:50.238]                         })
[17:27:50.238]                       }
[17:27:50.238]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:50.238]                       base::options(mc.cores = 1L)
[17:27:50.238]                     }
[17:27:50.238]                     base::local({
[17:27:50.238]                       for (pkg in c("stats", "datasets")) {
[17:27:50.238]                         base::loadNamespace(pkg)
[17:27:50.238]                         base::library(pkg, character.only = TRUE)
[17:27:50.238]                       }
[17:27:50.238]                     })
[17:27:50.238]                   }
[17:27:50.238]                   ...future.strategy.old <- future::plan("list")
[17:27:50.238]                   options(future.plan = NULL)
[17:27:50.238]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.238]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:50.238]                 }
[17:27:50.238]                 ...future.workdir <- getwd()
[17:27:50.238]             }
[17:27:50.238]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:50.238]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:50.238]         }
[17:27:50.238]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:50.238]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:50.238]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:50.238]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:50.238]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:50.238]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:50.238]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:50.238]             base::names(...future.oldOptions))
[17:27:50.238]     }
[17:27:50.238]     if (FALSE) {
[17:27:50.238]     }
[17:27:50.238]     else {
[17:27:50.238]         if (TRUE) {
[17:27:50.238]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:50.238]                 open = "w")
[17:27:50.238]         }
[17:27:50.238]         else {
[17:27:50.238]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:50.238]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:50.238]         }
[17:27:50.238]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:50.238]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:50.238]             base::sink(type = "output", split = FALSE)
[17:27:50.238]             base::close(...future.stdout)
[17:27:50.238]         }, add = TRUE)
[17:27:50.238]     }
[17:27:50.238]     ...future.frame <- base::sys.nframe()
[17:27:50.238]     ...future.conditions <- base::list()
[17:27:50.238]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:50.238]     if (FALSE) {
[17:27:50.238]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:50.238]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:50.238]     }
[17:27:50.238]     ...future.result <- base::tryCatch({
[17:27:50.238]         base::withCallingHandlers({
[17:27:50.238]             ...future.value <- base::withVisible(base::local({
[17:27:50.238]                 ...future.makeSendCondition <- base::local({
[17:27:50.238]                   sendCondition <- NULL
[17:27:50.238]                   function(frame = 1L) {
[17:27:50.238]                     if (is.function(sendCondition)) 
[17:27:50.238]                       return(sendCondition)
[17:27:50.238]                     ns <- getNamespace("parallel")
[17:27:50.238]                     if (exists("sendData", mode = "function", 
[17:27:50.238]                       envir = ns)) {
[17:27:50.238]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:50.238]                         envir = ns)
[17:27:50.238]                       envir <- sys.frame(frame)
[17:27:50.238]                       master <- NULL
[17:27:50.238]                       while (!identical(envir, .GlobalEnv) && 
[17:27:50.238]                         !identical(envir, emptyenv())) {
[17:27:50.238]                         if (exists("master", mode = "list", envir = envir, 
[17:27:50.238]                           inherits = FALSE)) {
[17:27:50.238]                           master <- get("master", mode = "list", 
[17:27:50.238]                             envir = envir, inherits = FALSE)
[17:27:50.238]                           if (inherits(master, c("SOCKnode", 
[17:27:50.238]                             "SOCK0node"))) {
[17:27:50.238]                             sendCondition <<- function(cond) {
[17:27:50.238]                               data <- list(type = "VALUE", value = cond, 
[17:27:50.238]                                 success = TRUE)
[17:27:50.238]                               parallel_sendData(master, data)
[17:27:50.238]                             }
[17:27:50.238]                             return(sendCondition)
[17:27:50.238]                           }
[17:27:50.238]                         }
[17:27:50.238]                         frame <- frame + 1L
[17:27:50.238]                         envir <- sys.frame(frame)
[17:27:50.238]                       }
[17:27:50.238]                     }
[17:27:50.238]                     sendCondition <<- function(cond) NULL
[17:27:50.238]                   }
[17:27:50.238]                 })
[17:27:50.238]                 withCallingHandlers({
[17:27:50.238]                   {
[17:27:50.238]                     lm(dist ~ speed + speed^2, data = cars)
[17:27:50.238]                   }
[17:27:50.238]                 }, immediateCondition = function(cond) {
[17:27:50.238]                   sendCondition <- ...future.makeSendCondition()
[17:27:50.238]                   sendCondition(cond)
[17:27:50.238]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.238]                   {
[17:27:50.238]                     inherits <- base::inherits
[17:27:50.238]                     invokeRestart <- base::invokeRestart
[17:27:50.238]                     is.null <- base::is.null
[17:27:50.238]                     muffled <- FALSE
[17:27:50.238]                     if (inherits(cond, "message")) {
[17:27:50.238]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:50.238]                       if (muffled) 
[17:27:50.238]                         invokeRestart("muffleMessage")
[17:27:50.238]                     }
[17:27:50.238]                     else if (inherits(cond, "warning")) {
[17:27:50.238]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:50.238]                       if (muffled) 
[17:27:50.238]                         invokeRestart("muffleWarning")
[17:27:50.238]                     }
[17:27:50.238]                     else if (inherits(cond, "condition")) {
[17:27:50.238]                       if (!is.null(pattern)) {
[17:27:50.238]                         computeRestarts <- base::computeRestarts
[17:27:50.238]                         grepl <- base::grepl
[17:27:50.238]                         restarts <- computeRestarts(cond)
[17:27:50.238]                         for (restart in restarts) {
[17:27:50.238]                           name <- restart$name
[17:27:50.238]                           if (is.null(name)) 
[17:27:50.238]                             next
[17:27:50.238]                           if (!grepl(pattern, name)) 
[17:27:50.238]                             next
[17:27:50.238]                           invokeRestart(restart)
[17:27:50.238]                           muffled <- TRUE
[17:27:50.238]                           break
[17:27:50.238]                         }
[17:27:50.238]                       }
[17:27:50.238]                     }
[17:27:50.238]                     invisible(muffled)
[17:27:50.238]                   }
[17:27:50.238]                   muffleCondition(cond)
[17:27:50.238]                 })
[17:27:50.238]             }))
[17:27:50.238]             future::FutureResult(value = ...future.value$value, 
[17:27:50.238]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.238]                   ...future.rng), globalenv = if (FALSE) 
[17:27:50.238]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:50.238]                     ...future.globalenv.names))
[17:27:50.238]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:50.238]         }, condition = base::local({
[17:27:50.238]             c <- base::c
[17:27:50.238]             inherits <- base::inherits
[17:27:50.238]             invokeRestart <- base::invokeRestart
[17:27:50.238]             length <- base::length
[17:27:50.238]             list <- base::list
[17:27:50.238]             seq.int <- base::seq.int
[17:27:50.238]             signalCondition <- base::signalCondition
[17:27:50.238]             sys.calls <- base::sys.calls
[17:27:50.238]             `[[` <- base::`[[`
[17:27:50.238]             `+` <- base::`+`
[17:27:50.238]             `<<-` <- base::`<<-`
[17:27:50.238]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:50.238]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:50.238]                   3L)]
[17:27:50.238]             }
[17:27:50.238]             function(cond) {
[17:27:50.238]                 is_error <- inherits(cond, "error")
[17:27:50.238]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:50.238]                   NULL)
[17:27:50.238]                 if (is_error) {
[17:27:50.238]                   sessionInformation <- function() {
[17:27:50.238]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:50.238]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:50.238]                       search = base::search(), system = base::Sys.info())
[17:27:50.238]                   }
[17:27:50.238]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.238]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:50.238]                     cond$call), session = sessionInformation(), 
[17:27:50.238]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:50.238]                   signalCondition(cond)
[17:27:50.238]                 }
[17:27:50.238]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:50.238]                 "immediateCondition"))) {
[17:27:50.238]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:50.238]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.238]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:50.238]                   if (TRUE && !signal) {
[17:27:50.238]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.238]                     {
[17:27:50.238]                       inherits <- base::inherits
[17:27:50.238]                       invokeRestart <- base::invokeRestart
[17:27:50.238]                       is.null <- base::is.null
[17:27:50.238]                       muffled <- FALSE
[17:27:50.238]                       if (inherits(cond, "message")) {
[17:27:50.238]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.238]                         if (muffled) 
[17:27:50.238]                           invokeRestart("muffleMessage")
[17:27:50.238]                       }
[17:27:50.238]                       else if (inherits(cond, "warning")) {
[17:27:50.238]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.238]                         if (muffled) 
[17:27:50.238]                           invokeRestart("muffleWarning")
[17:27:50.238]                       }
[17:27:50.238]                       else if (inherits(cond, "condition")) {
[17:27:50.238]                         if (!is.null(pattern)) {
[17:27:50.238]                           computeRestarts <- base::computeRestarts
[17:27:50.238]                           grepl <- base::grepl
[17:27:50.238]                           restarts <- computeRestarts(cond)
[17:27:50.238]                           for (restart in restarts) {
[17:27:50.238]                             name <- restart$name
[17:27:50.238]                             if (is.null(name)) 
[17:27:50.238]                               next
[17:27:50.238]                             if (!grepl(pattern, name)) 
[17:27:50.238]                               next
[17:27:50.238]                             invokeRestart(restart)
[17:27:50.238]                             muffled <- TRUE
[17:27:50.238]                             break
[17:27:50.238]                           }
[17:27:50.238]                         }
[17:27:50.238]                       }
[17:27:50.238]                       invisible(muffled)
[17:27:50.238]                     }
[17:27:50.238]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.238]                   }
[17:27:50.238]                 }
[17:27:50.238]                 else {
[17:27:50.238]                   if (TRUE) {
[17:27:50.238]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.238]                     {
[17:27:50.238]                       inherits <- base::inherits
[17:27:50.238]                       invokeRestart <- base::invokeRestart
[17:27:50.238]                       is.null <- base::is.null
[17:27:50.238]                       muffled <- FALSE
[17:27:50.238]                       if (inherits(cond, "message")) {
[17:27:50.238]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.238]                         if (muffled) 
[17:27:50.238]                           invokeRestart("muffleMessage")
[17:27:50.238]                       }
[17:27:50.238]                       else if (inherits(cond, "warning")) {
[17:27:50.238]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.238]                         if (muffled) 
[17:27:50.238]                           invokeRestart("muffleWarning")
[17:27:50.238]                       }
[17:27:50.238]                       else if (inherits(cond, "condition")) {
[17:27:50.238]                         if (!is.null(pattern)) {
[17:27:50.238]                           computeRestarts <- base::computeRestarts
[17:27:50.238]                           grepl <- base::grepl
[17:27:50.238]                           restarts <- computeRestarts(cond)
[17:27:50.238]                           for (restart in restarts) {
[17:27:50.238]                             name <- restart$name
[17:27:50.238]                             if (is.null(name)) 
[17:27:50.238]                               next
[17:27:50.238]                             if (!grepl(pattern, name)) 
[17:27:50.238]                               next
[17:27:50.238]                             invokeRestart(restart)
[17:27:50.238]                             muffled <- TRUE
[17:27:50.238]                             break
[17:27:50.238]                           }
[17:27:50.238]                         }
[17:27:50.238]                       }
[17:27:50.238]                       invisible(muffled)
[17:27:50.238]                     }
[17:27:50.238]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.238]                   }
[17:27:50.238]                 }
[17:27:50.238]             }
[17:27:50.238]         }))
[17:27:50.238]     }, error = function(ex) {
[17:27:50.238]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:50.238]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.238]                 ...future.rng), started = ...future.startTime, 
[17:27:50.238]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:50.238]             version = "1.8"), class = "FutureResult")
[17:27:50.238]     }, finally = {
[17:27:50.238]         if (!identical(...future.workdir, getwd())) 
[17:27:50.238]             setwd(...future.workdir)
[17:27:50.238]         {
[17:27:50.238]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:50.238]                 ...future.oldOptions$nwarnings <- NULL
[17:27:50.238]             }
[17:27:50.238]             base::options(...future.oldOptions)
[17:27:50.238]             if (.Platform$OS.type == "windows") {
[17:27:50.238]                 old_names <- names(...future.oldEnvVars)
[17:27:50.238]                 envs <- base::Sys.getenv()
[17:27:50.238]                 names <- names(envs)
[17:27:50.238]                 common <- intersect(names, old_names)
[17:27:50.238]                 added <- setdiff(names, old_names)
[17:27:50.238]                 removed <- setdiff(old_names, names)
[17:27:50.238]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:50.238]                   envs[common]]
[17:27:50.238]                 NAMES <- toupper(changed)
[17:27:50.238]                 args <- list()
[17:27:50.238]                 for (kk in seq_along(NAMES)) {
[17:27:50.238]                   name <- changed[[kk]]
[17:27:50.238]                   NAME <- NAMES[[kk]]
[17:27:50.238]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.238]                     next
[17:27:50.238]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.238]                 }
[17:27:50.238]                 NAMES <- toupper(added)
[17:27:50.238]                 for (kk in seq_along(NAMES)) {
[17:27:50.238]                   name <- added[[kk]]
[17:27:50.238]                   NAME <- NAMES[[kk]]
[17:27:50.238]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.238]                     next
[17:27:50.238]                   args[[name]] <- ""
[17:27:50.238]                 }
[17:27:50.238]                 NAMES <- toupper(removed)
[17:27:50.238]                 for (kk in seq_along(NAMES)) {
[17:27:50.238]                   name <- removed[[kk]]
[17:27:50.238]                   NAME <- NAMES[[kk]]
[17:27:50.238]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.238]                     next
[17:27:50.238]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.238]                 }
[17:27:50.238]                 if (length(args) > 0) 
[17:27:50.238]                   base::do.call(base::Sys.setenv, args = args)
[17:27:50.238]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:50.238]             }
[17:27:50.238]             else {
[17:27:50.238]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:50.238]             }
[17:27:50.238]             {
[17:27:50.238]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:50.238]                   0L) {
[17:27:50.238]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:50.238]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:50.238]                   base::options(opts)
[17:27:50.238]                 }
[17:27:50.238]                 {
[17:27:50.238]                   {
[17:27:50.238]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:50.238]                     NULL
[17:27:50.238]                   }
[17:27:50.238]                   options(future.plan = NULL)
[17:27:50.238]                   if (is.na(NA_character_)) 
[17:27:50.238]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.238]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:50.238]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:50.238]                     .init = FALSE)
[17:27:50.238]                 }
[17:27:50.238]             }
[17:27:50.238]         }
[17:27:50.238]     })
[17:27:50.238]     if (TRUE) {
[17:27:50.238]         base::sink(type = "output", split = FALSE)
[17:27:50.238]         if (TRUE) {
[17:27:50.238]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:50.238]         }
[17:27:50.238]         else {
[17:27:50.238]             ...future.result["stdout"] <- base::list(NULL)
[17:27:50.238]         }
[17:27:50.238]         base::close(...future.stdout)
[17:27:50.238]         ...future.stdout <- NULL
[17:27:50.238]     }
[17:27:50.238]     ...future.result$conditions <- ...future.conditions
[17:27:50.238]     ...future.result$finished <- base::Sys.time()
[17:27:50.238]     ...future.result
[17:27:50.238] }
[17:27:50.250] MultisessionFuture started
[17:27:50.250] - Launch lazy future ... done
[17:27:50.250] run() for 'MultisessionFuture' ... done
[17:27:50.251] result() for ClusterFuture ...
[17:27:50.251] receiveMessageFromWorker() for ClusterFuture ...
[17:27:50.252] - Validating connection of MultisessionFuture
[17:27:50.279] - received message: FutureResult
[17:27:50.279] - Received FutureResult
[17:27:50.280] - Erased future from FutureRegistry
[17:27:50.280] result() for ClusterFuture ...
[17:27:50.280] - result already collected: FutureResult
[17:27:50.281] result() for ClusterFuture ... done
[17:27:50.281] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:50.281] result() for ClusterFuture ... done
[17:27:50.282] result() for ClusterFuture ...
[17:27:50.282] - result already collected: FutureResult
[17:27:50.282] result() for ClusterFuture ... done

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  

[17:27:50.288] getGlobalsAndPackages() ...
[17:27:50.289] Searching for globals...
[17:27:50.294] - globals found: [9] '{', 'lm', 'dist', '+', 'speed', 'I', '^', '~', 'cars'
[17:27:50.294] Searching for globals ... DONE
[17:27:50.294] Resolving globals: FALSE
[17:27:50.296] 
[17:27:50.296] - packages: [2] 'stats', 'datasets'
[17:27:50.296] getGlobalsAndPackages() ... DONE
[17:27:50.297] run() for 'Future' ...
[17:27:50.297] - state: 'created'
[17:27:50.298] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:50.321] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:50.321] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:50.322]   - Field: 'node'
[17:27:50.322]   - Field: 'label'
[17:27:50.322]   - Field: 'local'
[17:27:50.323]   - Field: 'owner'
[17:27:50.323]   - Field: 'envir'
[17:27:50.323]   - Field: 'workers'
[17:27:50.324]   - Field: 'packages'
[17:27:50.324]   - Field: 'gc'
[17:27:50.324]   - Field: 'conditions'
[17:27:50.325]   - Field: 'persistent'
[17:27:50.325]   - Field: 'expr'
[17:27:50.325]   - Field: 'uuid'
[17:27:50.326]   - Field: 'seed'
[17:27:50.326]   - Field: 'version'
[17:27:50.326]   - Field: 'result'
[17:27:50.327]   - Field: 'asynchronous'
[17:27:50.327]   - Field: 'calls'
[17:27:50.327]   - Field: 'globals'
[17:27:50.328]   - Field: 'stdout'
[17:27:50.328]   - Field: 'earlySignal'
[17:27:50.328]   - Field: 'lazy'
[17:27:50.329]   - Field: 'state'
[17:27:50.329] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:50.329] - Launch lazy future ...
[17:27:50.330] Packages needed by the future expression (n = 2): 'stats', 'datasets'
[17:27:50.331] Packages needed by future strategies (n = 0): <none>
[17:27:50.332] {
[17:27:50.332]     {
[17:27:50.332]         {
[17:27:50.332]             ...future.startTime <- base::Sys.time()
[17:27:50.332]             {
[17:27:50.332]                 {
[17:27:50.332]                   {
[17:27:50.332]                     {
[17:27:50.332]                       {
[17:27:50.332]                         base::local({
[17:27:50.332]                           has_future <- base::requireNamespace("future", 
[17:27:50.332]                             quietly = TRUE)
[17:27:50.332]                           if (has_future) {
[17:27:50.332]                             ns <- base::getNamespace("future")
[17:27:50.332]                             version <- ns[[".package"]][["version"]]
[17:27:50.332]                             if (is.null(version)) 
[17:27:50.332]                               version <- utils::packageVersion("future")
[17:27:50.332]                           }
[17:27:50.332]                           else {
[17:27:50.332]                             version <- NULL
[17:27:50.332]                           }
[17:27:50.332]                           if (!has_future || version < "1.8.0") {
[17:27:50.332]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:50.332]                               "", base::R.version$version.string), 
[17:27:50.332]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:50.332]                                 base::R.version$platform, 8 * 
[17:27:50.332]                                   base::.Machine$sizeof.pointer), 
[17:27:50.332]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:50.332]                                 "release", "version")], collapse = " "), 
[17:27:50.332]                               hostname = base::Sys.info()[["nodename"]])
[17:27:50.332]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:50.332]                               info)
[17:27:50.332]                             info <- base::paste(info, collapse = "; ")
[17:27:50.332]                             if (!has_future) {
[17:27:50.332]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:50.332]                                 info)
[17:27:50.332]                             }
[17:27:50.332]                             else {
[17:27:50.332]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:50.332]                                 info, version)
[17:27:50.332]                             }
[17:27:50.332]                             base::stop(msg)
[17:27:50.332]                           }
[17:27:50.332]                         })
[17:27:50.332]                       }
[17:27:50.332]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:50.332]                       base::options(mc.cores = 1L)
[17:27:50.332]                     }
[17:27:50.332]                     base::local({
[17:27:50.332]                       for (pkg in c("stats", "datasets")) {
[17:27:50.332]                         base::loadNamespace(pkg)
[17:27:50.332]                         base::library(pkg, character.only = TRUE)
[17:27:50.332]                       }
[17:27:50.332]                     })
[17:27:50.332]                   }
[17:27:50.332]                   ...future.strategy.old <- future::plan("list")
[17:27:50.332]                   options(future.plan = NULL)
[17:27:50.332]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.332]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:50.332]                 }
[17:27:50.332]                 ...future.workdir <- getwd()
[17:27:50.332]             }
[17:27:50.332]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:50.332]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:50.332]         }
[17:27:50.332]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:50.332]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:50.332]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:50.332]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:50.332]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:50.332]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:50.332]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:50.332]             base::names(...future.oldOptions))
[17:27:50.332]     }
[17:27:50.332]     if (FALSE) {
[17:27:50.332]     }
[17:27:50.332]     else {
[17:27:50.332]         if (TRUE) {
[17:27:50.332]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:50.332]                 open = "w")
[17:27:50.332]         }
[17:27:50.332]         else {
[17:27:50.332]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:50.332]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:50.332]         }
[17:27:50.332]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:50.332]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:50.332]             base::sink(type = "output", split = FALSE)
[17:27:50.332]             base::close(...future.stdout)
[17:27:50.332]         }, add = TRUE)
[17:27:50.332]     }
[17:27:50.332]     ...future.frame <- base::sys.nframe()
[17:27:50.332]     ...future.conditions <- base::list()
[17:27:50.332]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:50.332]     if (FALSE) {
[17:27:50.332]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:50.332]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:50.332]     }
[17:27:50.332]     ...future.result <- base::tryCatch({
[17:27:50.332]         base::withCallingHandlers({
[17:27:50.332]             ...future.value <- base::withVisible(base::local({
[17:27:50.332]                 ...future.makeSendCondition <- base::local({
[17:27:50.332]                   sendCondition <- NULL
[17:27:50.332]                   function(frame = 1L) {
[17:27:50.332]                     if (is.function(sendCondition)) 
[17:27:50.332]                       return(sendCondition)
[17:27:50.332]                     ns <- getNamespace("parallel")
[17:27:50.332]                     if (exists("sendData", mode = "function", 
[17:27:50.332]                       envir = ns)) {
[17:27:50.332]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:50.332]                         envir = ns)
[17:27:50.332]                       envir <- sys.frame(frame)
[17:27:50.332]                       master <- NULL
[17:27:50.332]                       while (!identical(envir, .GlobalEnv) && 
[17:27:50.332]                         !identical(envir, emptyenv())) {
[17:27:50.332]                         if (exists("master", mode = "list", envir = envir, 
[17:27:50.332]                           inherits = FALSE)) {
[17:27:50.332]                           master <- get("master", mode = "list", 
[17:27:50.332]                             envir = envir, inherits = FALSE)
[17:27:50.332]                           if (inherits(master, c("SOCKnode", 
[17:27:50.332]                             "SOCK0node"))) {
[17:27:50.332]                             sendCondition <<- function(cond) {
[17:27:50.332]                               data <- list(type = "VALUE", value = cond, 
[17:27:50.332]                                 success = TRUE)
[17:27:50.332]                               parallel_sendData(master, data)
[17:27:50.332]                             }
[17:27:50.332]                             return(sendCondition)
[17:27:50.332]                           }
[17:27:50.332]                         }
[17:27:50.332]                         frame <- frame + 1L
[17:27:50.332]                         envir <- sys.frame(frame)
[17:27:50.332]                       }
[17:27:50.332]                     }
[17:27:50.332]                     sendCondition <<- function(cond) NULL
[17:27:50.332]                   }
[17:27:50.332]                 })
[17:27:50.332]                 withCallingHandlers({
[17:27:50.332]                   {
[17:27:50.332]                     lm(dist ~ speed + I(speed^2), data = cars)
[17:27:50.332]                   }
[17:27:50.332]                 }, immediateCondition = function(cond) {
[17:27:50.332]                   sendCondition <- ...future.makeSendCondition()
[17:27:50.332]                   sendCondition(cond)
[17:27:50.332]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.332]                   {
[17:27:50.332]                     inherits <- base::inherits
[17:27:50.332]                     invokeRestart <- base::invokeRestart
[17:27:50.332]                     is.null <- base::is.null
[17:27:50.332]                     muffled <- FALSE
[17:27:50.332]                     if (inherits(cond, "message")) {
[17:27:50.332]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:50.332]                       if (muffled) 
[17:27:50.332]                         invokeRestart("muffleMessage")
[17:27:50.332]                     }
[17:27:50.332]                     else if (inherits(cond, "warning")) {
[17:27:50.332]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:50.332]                       if (muffled) 
[17:27:50.332]                         invokeRestart("muffleWarning")
[17:27:50.332]                     }
[17:27:50.332]                     else if (inherits(cond, "condition")) {
[17:27:50.332]                       if (!is.null(pattern)) {
[17:27:50.332]                         computeRestarts <- base::computeRestarts
[17:27:50.332]                         grepl <- base::grepl
[17:27:50.332]                         restarts <- computeRestarts(cond)
[17:27:50.332]                         for (restart in restarts) {
[17:27:50.332]                           name <- restart$name
[17:27:50.332]                           if (is.null(name)) 
[17:27:50.332]                             next
[17:27:50.332]                           if (!grepl(pattern, name)) 
[17:27:50.332]                             next
[17:27:50.332]                           invokeRestart(restart)
[17:27:50.332]                           muffled <- TRUE
[17:27:50.332]                           break
[17:27:50.332]                         }
[17:27:50.332]                       }
[17:27:50.332]                     }
[17:27:50.332]                     invisible(muffled)
[17:27:50.332]                   }
[17:27:50.332]                   muffleCondition(cond)
[17:27:50.332]                 })
[17:27:50.332]             }))
[17:27:50.332]             future::FutureResult(value = ...future.value$value, 
[17:27:50.332]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.332]                   ...future.rng), globalenv = if (FALSE) 
[17:27:50.332]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:50.332]                     ...future.globalenv.names))
[17:27:50.332]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:50.332]         }, condition = base::local({
[17:27:50.332]             c <- base::c
[17:27:50.332]             inherits <- base::inherits
[17:27:50.332]             invokeRestart <- base::invokeRestart
[17:27:50.332]             length <- base::length
[17:27:50.332]             list <- base::list
[17:27:50.332]             seq.int <- base::seq.int
[17:27:50.332]             signalCondition <- base::signalCondition
[17:27:50.332]             sys.calls <- base::sys.calls
[17:27:50.332]             `[[` <- base::`[[`
[17:27:50.332]             `+` <- base::`+`
[17:27:50.332]             `<<-` <- base::`<<-`
[17:27:50.332]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:50.332]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:50.332]                   3L)]
[17:27:50.332]             }
[17:27:50.332]             function(cond) {
[17:27:50.332]                 is_error <- inherits(cond, "error")
[17:27:50.332]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:50.332]                   NULL)
[17:27:50.332]                 if (is_error) {
[17:27:50.332]                   sessionInformation <- function() {
[17:27:50.332]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:50.332]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:50.332]                       search = base::search(), system = base::Sys.info())
[17:27:50.332]                   }
[17:27:50.332]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.332]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:50.332]                     cond$call), session = sessionInformation(), 
[17:27:50.332]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:50.332]                   signalCondition(cond)
[17:27:50.332]                 }
[17:27:50.332]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:50.332]                 "immediateCondition"))) {
[17:27:50.332]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:50.332]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.332]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:50.332]                   if (TRUE && !signal) {
[17:27:50.332]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.332]                     {
[17:27:50.332]                       inherits <- base::inherits
[17:27:50.332]                       invokeRestart <- base::invokeRestart
[17:27:50.332]                       is.null <- base::is.null
[17:27:50.332]                       muffled <- FALSE
[17:27:50.332]                       if (inherits(cond, "message")) {
[17:27:50.332]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.332]                         if (muffled) 
[17:27:50.332]                           invokeRestart("muffleMessage")
[17:27:50.332]                       }
[17:27:50.332]                       else if (inherits(cond, "warning")) {
[17:27:50.332]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.332]                         if (muffled) 
[17:27:50.332]                           invokeRestart("muffleWarning")
[17:27:50.332]                       }
[17:27:50.332]                       else if (inherits(cond, "condition")) {
[17:27:50.332]                         if (!is.null(pattern)) {
[17:27:50.332]                           computeRestarts <- base::computeRestarts
[17:27:50.332]                           grepl <- base::grepl
[17:27:50.332]                           restarts <- computeRestarts(cond)
[17:27:50.332]                           for (restart in restarts) {
[17:27:50.332]                             name <- restart$name
[17:27:50.332]                             if (is.null(name)) 
[17:27:50.332]                               next
[17:27:50.332]                             if (!grepl(pattern, name)) 
[17:27:50.332]                               next
[17:27:50.332]                             invokeRestart(restart)
[17:27:50.332]                             muffled <- TRUE
[17:27:50.332]                             break
[17:27:50.332]                           }
[17:27:50.332]                         }
[17:27:50.332]                       }
[17:27:50.332]                       invisible(muffled)
[17:27:50.332]                     }
[17:27:50.332]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.332]                   }
[17:27:50.332]                 }
[17:27:50.332]                 else {
[17:27:50.332]                   if (TRUE) {
[17:27:50.332]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.332]                     {
[17:27:50.332]                       inherits <- base::inherits
[17:27:50.332]                       invokeRestart <- base::invokeRestart
[17:27:50.332]                       is.null <- base::is.null
[17:27:50.332]                       muffled <- FALSE
[17:27:50.332]                       if (inherits(cond, "message")) {
[17:27:50.332]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.332]                         if (muffled) 
[17:27:50.332]                           invokeRestart("muffleMessage")
[17:27:50.332]                       }
[17:27:50.332]                       else if (inherits(cond, "warning")) {
[17:27:50.332]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.332]                         if (muffled) 
[17:27:50.332]                           invokeRestart("muffleWarning")
[17:27:50.332]                       }
[17:27:50.332]                       else if (inherits(cond, "condition")) {
[17:27:50.332]                         if (!is.null(pattern)) {
[17:27:50.332]                           computeRestarts <- base::computeRestarts
[17:27:50.332]                           grepl <- base::grepl
[17:27:50.332]                           restarts <- computeRestarts(cond)
[17:27:50.332]                           for (restart in restarts) {
[17:27:50.332]                             name <- restart$name
[17:27:50.332]                             if (is.null(name)) 
[17:27:50.332]                               next
[17:27:50.332]                             if (!grepl(pattern, name)) 
[17:27:50.332]                               next
[17:27:50.332]                             invokeRestart(restart)
[17:27:50.332]                             muffled <- TRUE
[17:27:50.332]                             break
[17:27:50.332]                           }
[17:27:50.332]                         }
[17:27:50.332]                       }
[17:27:50.332]                       invisible(muffled)
[17:27:50.332]                     }
[17:27:50.332]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.332]                   }
[17:27:50.332]                 }
[17:27:50.332]             }
[17:27:50.332]         }))
[17:27:50.332]     }, error = function(ex) {
[17:27:50.332]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:50.332]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.332]                 ...future.rng), started = ...future.startTime, 
[17:27:50.332]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:50.332]             version = "1.8"), class = "FutureResult")
[17:27:50.332]     }, finally = {
[17:27:50.332]         if (!identical(...future.workdir, getwd())) 
[17:27:50.332]             setwd(...future.workdir)
[17:27:50.332]         {
[17:27:50.332]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:50.332]                 ...future.oldOptions$nwarnings <- NULL
[17:27:50.332]             }
[17:27:50.332]             base::options(...future.oldOptions)
[17:27:50.332]             if (.Platform$OS.type == "windows") {
[17:27:50.332]                 old_names <- names(...future.oldEnvVars)
[17:27:50.332]                 envs <- base::Sys.getenv()
[17:27:50.332]                 names <- names(envs)
[17:27:50.332]                 common <- intersect(names, old_names)
[17:27:50.332]                 added <- setdiff(names, old_names)
[17:27:50.332]                 removed <- setdiff(old_names, names)
[17:27:50.332]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:50.332]                   envs[common]]
[17:27:50.332]                 NAMES <- toupper(changed)
[17:27:50.332]                 args <- list()
[17:27:50.332]                 for (kk in seq_along(NAMES)) {
[17:27:50.332]                   name <- changed[[kk]]
[17:27:50.332]                   NAME <- NAMES[[kk]]
[17:27:50.332]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.332]                     next
[17:27:50.332]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.332]                 }
[17:27:50.332]                 NAMES <- toupper(added)
[17:27:50.332]                 for (kk in seq_along(NAMES)) {
[17:27:50.332]                   name <- added[[kk]]
[17:27:50.332]                   NAME <- NAMES[[kk]]
[17:27:50.332]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.332]                     next
[17:27:50.332]                   args[[name]] <- ""
[17:27:50.332]                 }
[17:27:50.332]                 NAMES <- toupper(removed)
[17:27:50.332]                 for (kk in seq_along(NAMES)) {
[17:27:50.332]                   name <- removed[[kk]]
[17:27:50.332]                   NAME <- NAMES[[kk]]
[17:27:50.332]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.332]                     next
[17:27:50.332]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.332]                 }
[17:27:50.332]                 if (length(args) > 0) 
[17:27:50.332]                   base::do.call(base::Sys.setenv, args = args)
[17:27:50.332]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:50.332]             }
[17:27:50.332]             else {
[17:27:50.332]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:50.332]             }
[17:27:50.332]             {
[17:27:50.332]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:50.332]                   0L) {
[17:27:50.332]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:50.332]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:50.332]                   base::options(opts)
[17:27:50.332]                 }
[17:27:50.332]                 {
[17:27:50.332]                   {
[17:27:50.332]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:50.332]                     NULL
[17:27:50.332]                   }
[17:27:50.332]                   options(future.plan = NULL)
[17:27:50.332]                   if (is.na(NA_character_)) 
[17:27:50.332]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.332]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:50.332]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:50.332]                     .init = FALSE)
[17:27:50.332]                 }
[17:27:50.332]             }
[17:27:50.332]         }
[17:27:50.332]     })
[17:27:50.332]     if (TRUE) {
[17:27:50.332]         base::sink(type = "output", split = FALSE)
[17:27:50.332]         if (TRUE) {
[17:27:50.332]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:50.332]         }
[17:27:50.332]         else {
[17:27:50.332]             ...future.result["stdout"] <- base::list(NULL)
[17:27:50.332]         }
[17:27:50.332]         base::close(...future.stdout)
[17:27:50.332]         ...future.stdout <- NULL
[17:27:50.332]     }
[17:27:50.332]     ...future.result$conditions <- ...future.conditions
[17:27:50.332]     ...future.result$finished <- base::Sys.time()
[17:27:50.332]     ...future.result
[17:27:50.332] }
[17:27:50.343] MultisessionFuture started
[17:27:50.344] - Launch lazy future ... done
[17:27:50.344] run() for 'MultisessionFuture' ... done
[17:27:50.344] result() for ClusterFuture ...
[17:27:50.345] receiveMessageFromWorker() for ClusterFuture ...
[17:27:50.345] - Validating connection of MultisessionFuture
[17:27:50.379] - received message: FutureResult
[17:27:50.380] - Received FutureResult
[17:27:50.380] - Erased future from FutureRegistry
[17:27:50.381] result() for ClusterFuture ...
[17:27:50.381] - result already collected: FutureResult
[17:27:50.381] result() for ClusterFuture ... done
[17:27:50.382] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:50.382] result() for ClusterFuture ... done
[17:27:50.382] result() for ClusterFuture ...
[17:27:50.383] - result already collected: FutureResult
[17:27:50.383] result() for ClusterFuture ... done

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  

[17:27:50.389] getGlobalsAndPackages() ...
[17:27:50.389] Searching for globals...
[17:27:50.393] - globals found: [7] '{', 'lm', 'dist', 'poly', 'speed', '~', 'cars'
[17:27:50.394] Searching for globals ... DONE
[17:27:50.394] Resolving globals: FALSE
[17:27:50.395] 
[17:27:50.395] - packages: [2] 'stats', 'datasets'
[17:27:50.396] getGlobalsAndPackages() ... DONE
[17:27:50.396] run() for 'Future' ...
[17:27:50.397] - state: 'created'
[17:27:50.397] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:50.421] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:50.422] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:50.422]   - Field: 'node'
[17:27:50.423]   - Field: 'label'
[17:27:50.423]   - Field: 'local'
[17:27:50.423]   - Field: 'owner'
[17:27:50.424]   - Field: 'envir'
[17:27:50.424]   - Field: 'workers'
[17:27:50.425]   - Field: 'packages'
[17:27:50.425]   - Field: 'gc'
[17:27:50.425]   - Field: 'conditions'
[17:27:50.426]   - Field: 'persistent'
[17:27:50.426]   - Field: 'expr'
[17:27:50.427]   - Field: 'uuid'
[17:27:50.427]   - Field: 'seed'
[17:27:50.427]   - Field: 'version'
[17:27:50.428]   - Field: 'result'
[17:27:50.428]   - Field: 'asynchronous'
[17:27:50.429]   - Field: 'calls'
[17:27:50.429]   - Field: 'globals'
[17:27:50.429]   - Field: 'stdout'
[17:27:50.430]   - Field: 'earlySignal'
[17:27:50.430]   - Field: 'lazy'
[17:27:50.431]   - Field: 'state'
[17:27:50.431] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:50.431] - Launch lazy future ...
[17:27:50.432] Packages needed by the future expression (n = 2): 'stats', 'datasets'
[17:27:50.433] Packages needed by future strategies (n = 0): <none>
[17:27:50.434] {
[17:27:50.434]     {
[17:27:50.434]         {
[17:27:50.434]             ...future.startTime <- base::Sys.time()
[17:27:50.434]             {
[17:27:50.434]                 {
[17:27:50.434]                   {
[17:27:50.434]                     {
[17:27:50.434]                       {
[17:27:50.434]                         base::local({
[17:27:50.434]                           has_future <- base::requireNamespace("future", 
[17:27:50.434]                             quietly = TRUE)
[17:27:50.434]                           if (has_future) {
[17:27:50.434]                             ns <- base::getNamespace("future")
[17:27:50.434]                             version <- ns[[".package"]][["version"]]
[17:27:50.434]                             if (is.null(version)) 
[17:27:50.434]                               version <- utils::packageVersion("future")
[17:27:50.434]                           }
[17:27:50.434]                           else {
[17:27:50.434]                             version <- NULL
[17:27:50.434]                           }
[17:27:50.434]                           if (!has_future || version < "1.8.0") {
[17:27:50.434]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:50.434]                               "", base::R.version$version.string), 
[17:27:50.434]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:50.434]                                 base::R.version$platform, 8 * 
[17:27:50.434]                                   base::.Machine$sizeof.pointer), 
[17:27:50.434]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:50.434]                                 "release", "version")], collapse = " "), 
[17:27:50.434]                               hostname = base::Sys.info()[["nodename"]])
[17:27:50.434]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:50.434]                               info)
[17:27:50.434]                             info <- base::paste(info, collapse = "; ")
[17:27:50.434]                             if (!has_future) {
[17:27:50.434]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:50.434]                                 info)
[17:27:50.434]                             }
[17:27:50.434]                             else {
[17:27:50.434]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:50.434]                                 info, version)
[17:27:50.434]                             }
[17:27:50.434]                             base::stop(msg)
[17:27:50.434]                           }
[17:27:50.434]                         })
[17:27:50.434]                       }
[17:27:50.434]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:50.434]                       base::options(mc.cores = 1L)
[17:27:50.434]                     }
[17:27:50.434]                     base::local({
[17:27:50.434]                       for (pkg in c("stats", "datasets")) {
[17:27:50.434]                         base::loadNamespace(pkg)
[17:27:50.434]                         base::library(pkg, character.only = TRUE)
[17:27:50.434]                       }
[17:27:50.434]                     })
[17:27:50.434]                   }
[17:27:50.434]                   ...future.strategy.old <- future::plan("list")
[17:27:50.434]                   options(future.plan = NULL)
[17:27:50.434]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.434]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:50.434]                 }
[17:27:50.434]                 ...future.workdir <- getwd()
[17:27:50.434]             }
[17:27:50.434]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:50.434]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:50.434]         }
[17:27:50.434]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:50.434]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:50.434]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:50.434]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:50.434]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:50.434]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:50.434]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:50.434]             base::names(...future.oldOptions))
[17:27:50.434]     }
[17:27:50.434]     if (FALSE) {
[17:27:50.434]     }
[17:27:50.434]     else {
[17:27:50.434]         if (TRUE) {
[17:27:50.434]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:50.434]                 open = "w")
[17:27:50.434]         }
[17:27:50.434]         else {
[17:27:50.434]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:50.434]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:50.434]         }
[17:27:50.434]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:50.434]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:50.434]             base::sink(type = "output", split = FALSE)
[17:27:50.434]             base::close(...future.stdout)
[17:27:50.434]         }, add = TRUE)
[17:27:50.434]     }
[17:27:50.434]     ...future.frame <- base::sys.nframe()
[17:27:50.434]     ...future.conditions <- base::list()
[17:27:50.434]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:50.434]     if (FALSE) {
[17:27:50.434]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:50.434]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:50.434]     }
[17:27:50.434]     ...future.result <- base::tryCatch({
[17:27:50.434]         base::withCallingHandlers({
[17:27:50.434]             ...future.value <- base::withVisible(base::local({
[17:27:50.434]                 ...future.makeSendCondition <- base::local({
[17:27:50.434]                   sendCondition <- NULL
[17:27:50.434]                   function(frame = 1L) {
[17:27:50.434]                     if (is.function(sendCondition)) 
[17:27:50.434]                       return(sendCondition)
[17:27:50.434]                     ns <- getNamespace("parallel")
[17:27:50.434]                     if (exists("sendData", mode = "function", 
[17:27:50.434]                       envir = ns)) {
[17:27:50.434]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:50.434]                         envir = ns)
[17:27:50.434]                       envir <- sys.frame(frame)
[17:27:50.434]                       master <- NULL
[17:27:50.434]                       while (!identical(envir, .GlobalEnv) && 
[17:27:50.434]                         !identical(envir, emptyenv())) {
[17:27:50.434]                         if (exists("master", mode = "list", envir = envir, 
[17:27:50.434]                           inherits = FALSE)) {
[17:27:50.434]                           master <- get("master", mode = "list", 
[17:27:50.434]                             envir = envir, inherits = FALSE)
[17:27:50.434]                           if (inherits(master, c("SOCKnode", 
[17:27:50.434]                             "SOCK0node"))) {
[17:27:50.434]                             sendCondition <<- function(cond) {
[17:27:50.434]                               data <- list(type = "VALUE", value = cond, 
[17:27:50.434]                                 success = TRUE)
[17:27:50.434]                               parallel_sendData(master, data)
[17:27:50.434]                             }
[17:27:50.434]                             return(sendCondition)
[17:27:50.434]                           }
[17:27:50.434]                         }
[17:27:50.434]                         frame <- frame + 1L
[17:27:50.434]                         envir <- sys.frame(frame)
[17:27:50.434]                       }
[17:27:50.434]                     }
[17:27:50.434]                     sendCondition <<- function(cond) NULL
[17:27:50.434]                   }
[17:27:50.434]                 })
[17:27:50.434]                 withCallingHandlers({
[17:27:50.434]                   {
[17:27:50.434]                     lm(dist ~ poly(speed, 2), data = cars)
[17:27:50.434]                   }
[17:27:50.434]                 }, immediateCondition = function(cond) {
[17:27:50.434]                   sendCondition <- ...future.makeSendCondition()
[17:27:50.434]                   sendCondition(cond)
[17:27:50.434]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.434]                   {
[17:27:50.434]                     inherits <- base::inherits
[17:27:50.434]                     invokeRestart <- base::invokeRestart
[17:27:50.434]                     is.null <- base::is.null
[17:27:50.434]                     muffled <- FALSE
[17:27:50.434]                     if (inherits(cond, "message")) {
[17:27:50.434]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:50.434]                       if (muffled) 
[17:27:50.434]                         invokeRestart("muffleMessage")
[17:27:50.434]                     }
[17:27:50.434]                     else if (inherits(cond, "warning")) {
[17:27:50.434]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:50.434]                       if (muffled) 
[17:27:50.434]                         invokeRestart("muffleWarning")
[17:27:50.434]                     }
[17:27:50.434]                     else if (inherits(cond, "condition")) {
[17:27:50.434]                       if (!is.null(pattern)) {
[17:27:50.434]                         computeRestarts <- base::computeRestarts
[17:27:50.434]                         grepl <- base::grepl
[17:27:50.434]                         restarts <- computeRestarts(cond)
[17:27:50.434]                         for (restart in restarts) {
[17:27:50.434]                           name <- restart$name
[17:27:50.434]                           if (is.null(name)) 
[17:27:50.434]                             next
[17:27:50.434]                           if (!grepl(pattern, name)) 
[17:27:50.434]                             next
[17:27:50.434]                           invokeRestart(restart)
[17:27:50.434]                           muffled <- TRUE
[17:27:50.434]                           break
[17:27:50.434]                         }
[17:27:50.434]                       }
[17:27:50.434]                     }
[17:27:50.434]                     invisible(muffled)
[17:27:50.434]                   }
[17:27:50.434]                   muffleCondition(cond)
[17:27:50.434]                 })
[17:27:50.434]             }))
[17:27:50.434]             future::FutureResult(value = ...future.value$value, 
[17:27:50.434]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.434]                   ...future.rng), globalenv = if (FALSE) 
[17:27:50.434]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:50.434]                     ...future.globalenv.names))
[17:27:50.434]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:50.434]         }, condition = base::local({
[17:27:50.434]             c <- base::c
[17:27:50.434]             inherits <- base::inherits
[17:27:50.434]             invokeRestart <- base::invokeRestart
[17:27:50.434]             length <- base::length
[17:27:50.434]             list <- base::list
[17:27:50.434]             seq.int <- base::seq.int
[17:27:50.434]             signalCondition <- base::signalCondition
[17:27:50.434]             sys.calls <- base::sys.calls
[17:27:50.434]             `[[` <- base::`[[`
[17:27:50.434]             `+` <- base::`+`
[17:27:50.434]             `<<-` <- base::`<<-`
[17:27:50.434]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:50.434]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:50.434]                   3L)]
[17:27:50.434]             }
[17:27:50.434]             function(cond) {
[17:27:50.434]                 is_error <- inherits(cond, "error")
[17:27:50.434]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:50.434]                   NULL)
[17:27:50.434]                 if (is_error) {
[17:27:50.434]                   sessionInformation <- function() {
[17:27:50.434]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:50.434]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:50.434]                       search = base::search(), system = base::Sys.info())
[17:27:50.434]                   }
[17:27:50.434]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.434]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:50.434]                     cond$call), session = sessionInformation(), 
[17:27:50.434]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:50.434]                   signalCondition(cond)
[17:27:50.434]                 }
[17:27:50.434]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:50.434]                 "immediateCondition"))) {
[17:27:50.434]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:50.434]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.434]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:50.434]                   if (TRUE && !signal) {
[17:27:50.434]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.434]                     {
[17:27:50.434]                       inherits <- base::inherits
[17:27:50.434]                       invokeRestart <- base::invokeRestart
[17:27:50.434]                       is.null <- base::is.null
[17:27:50.434]                       muffled <- FALSE
[17:27:50.434]                       if (inherits(cond, "message")) {
[17:27:50.434]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.434]                         if (muffled) 
[17:27:50.434]                           invokeRestart("muffleMessage")
[17:27:50.434]                       }
[17:27:50.434]                       else if (inherits(cond, "warning")) {
[17:27:50.434]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.434]                         if (muffled) 
[17:27:50.434]                           invokeRestart("muffleWarning")
[17:27:50.434]                       }
[17:27:50.434]                       else if (inherits(cond, "condition")) {
[17:27:50.434]                         if (!is.null(pattern)) {
[17:27:50.434]                           computeRestarts <- base::computeRestarts
[17:27:50.434]                           grepl <- base::grepl
[17:27:50.434]                           restarts <- computeRestarts(cond)
[17:27:50.434]                           for (restart in restarts) {
[17:27:50.434]                             name <- restart$name
[17:27:50.434]                             if (is.null(name)) 
[17:27:50.434]                               next
[17:27:50.434]                             if (!grepl(pattern, name)) 
[17:27:50.434]                               next
[17:27:50.434]                             invokeRestart(restart)
[17:27:50.434]                             muffled <- TRUE
[17:27:50.434]                             break
[17:27:50.434]                           }
[17:27:50.434]                         }
[17:27:50.434]                       }
[17:27:50.434]                       invisible(muffled)
[17:27:50.434]                     }
[17:27:50.434]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.434]                   }
[17:27:50.434]                 }
[17:27:50.434]                 else {
[17:27:50.434]                   if (TRUE) {
[17:27:50.434]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.434]                     {
[17:27:50.434]                       inherits <- base::inherits
[17:27:50.434]                       invokeRestart <- base::invokeRestart
[17:27:50.434]                       is.null <- base::is.null
[17:27:50.434]                       muffled <- FALSE
[17:27:50.434]                       if (inherits(cond, "message")) {
[17:27:50.434]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.434]                         if (muffled) 
[17:27:50.434]                           invokeRestart("muffleMessage")
[17:27:50.434]                       }
[17:27:50.434]                       else if (inherits(cond, "warning")) {
[17:27:50.434]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.434]                         if (muffled) 
[17:27:50.434]                           invokeRestart("muffleWarning")
[17:27:50.434]                       }
[17:27:50.434]                       else if (inherits(cond, "condition")) {
[17:27:50.434]                         if (!is.null(pattern)) {
[17:27:50.434]                           computeRestarts <- base::computeRestarts
[17:27:50.434]                           grepl <- base::grepl
[17:27:50.434]                           restarts <- computeRestarts(cond)
[17:27:50.434]                           for (restart in restarts) {
[17:27:50.434]                             name <- restart$name
[17:27:50.434]                             if (is.null(name)) 
[17:27:50.434]                               next
[17:27:50.434]                             if (!grepl(pattern, name)) 
[17:27:50.434]                               next
[17:27:50.434]                             invokeRestart(restart)
[17:27:50.434]                             muffled <- TRUE
[17:27:50.434]                             break
[17:27:50.434]                           }
[17:27:50.434]                         }
[17:27:50.434]                       }
[17:27:50.434]                       invisible(muffled)
[17:27:50.434]                     }
[17:27:50.434]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.434]                   }
[17:27:50.434]                 }
[17:27:50.434]             }
[17:27:50.434]         }))
[17:27:50.434]     }, error = function(ex) {
[17:27:50.434]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:50.434]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.434]                 ...future.rng), started = ...future.startTime, 
[17:27:50.434]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:50.434]             version = "1.8"), class = "FutureResult")
[17:27:50.434]     }, finally = {
[17:27:50.434]         if (!identical(...future.workdir, getwd())) 
[17:27:50.434]             setwd(...future.workdir)
[17:27:50.434]         {
[17:27:50.434]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:50.434]                 ...future.oldOptions$nwarnings <- NULL
[17:27:50.434]             }
[17:27:50.434]             base::options(...future.oldOptions)
[17:27:50.434]             if (.Platform$OS.type == "windows") {
[17:27:50.434]                 old_names <- names(...future.oldEnvVars)
[17:27:50.434]                 envs <- base::Sys.getenv()
[17:27:50.434]                 names <- names(envs)
[17:27:50.434]                 common <- intersect(names, old_names)
[17:27:50.434]                 added <- setdiff(names, old_names)
[17:27:50.434]                 removed <- setdiff(old_names, names)
[17:27:50.434]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:50.434]                   envs[common]]
[17:27:50.434]                 NAMES <- toupper(changed)
[17:27:50.434]                 args <- list()
[17:27:50.434]                 for (kk in seq_along(NAMES)) {
[17:27:50.434]                   name <- changed[[kk]]
[17:27:50.434]                   NAME <- NAMES[[kk]]
[17:27:50.434]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.434]                     next
[17:27:50.434]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.434]                 }
[17:27:50.434]                 NAMES <- toupper(added)
[17:27:50.434]                 for (kk in seq_along(NAMES)) {
[17:27:50.434]                   name <- added[[kk]]
[17:27:50.434]                   NAME <- NAMES[[kk]]
[17:27:50.434]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.434]                     next
[17:27:50.434]                   args[[name]] <- ""
[17:27:50.434]                 }
[17:27:50.434]                 NAMES <- toupper(removed)
[17:27:50.434]                 for (kk in seq_along(NAMES)) {
[17:27:50.434]                   name <- removed[[kk]]
[17:27:50.434]                   NAME <- NAMES[[kk]]
[17:27:50.434]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.434]                     next
[17:27:50.434]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.434]                 }
[17:27:50.434]                 if (length(args) > 0) 
[17:27:50.434]                   base::do.call(base::Sys.setenv, args = args)
[17:27:50.434]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:50.434]             }
[17:27:50.434]             else {
[17:27:50.434]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:50.434]             }
[17:27:50.434]             {
[17:27:50.434]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:50.434]                   0L) {
[17:27:50.434]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:50.434]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:50.434]                   base::options(opts)
[17:27:50.434]                 }
[17:27:50.434]                 {
[17:27:50.434]                   {
[17:27:50.434]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:50.434]                     NULL
[17:27:50.434]                   }
[17:27:50.434]                   options(future.plan = NULL)
[17:27:50.434]                   if (is.na(NA_character_)) 
[17:27:50.434]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.434]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:50.434]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:50.434]                     .init = FALSE)
[17:27:50.434]                 }
[17:27:50.434]             }
[17:27:50.434]         }
[17:27:50.434]     })
[17:27:50.434]     if (TRUE) {
[17:27:50.434]         base::sink(type = "output", split = FALSE)
[17:27:50.434]         if (TRUE) {
[17:27:50.434]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:50.434]         }
[17:27:50.434]         else {
[17:27:50.434]             ...future.result["stdout"] <- base::list(NULL)
[17:27:50.434]         }
[17:27:50.434]         base::close(...future.stdout)
[17:27:50.434]         ...future.stdout <- NULL
[17:27:50.434]     }
[17:27:50.434]     ...future.result$conditions <- ...future.conditions
[17:27:50.434]     ...future.result$finished <- base::Sys.time()
[17:27:50.434]     ...future.result
[17:27:50.434] }
[17:27:50.445] MultisessionFuture started
[17:27:50.445] - Launch lazy future ... done
[17:27:50.446] run() for 'MultisessionFuture' ... done
[17:27:50.446] result() for ClusterFuture ...
[17:27:50.447] receiveMessageFromWorker() for ClusterFuture ...
[17:27:50.447] - Validating connection of MultisessionFuture
[17:27:50.476] - received message: FutureResult
[17:27:50.477] - Received FutureResult
[17:27:50.477] - Erased future from FutureRegistry
[17:27:50.478] result() for ClusterFuture ...
[17:27:50.478] - result already collected: FutureResult
[17:27:50.478] result() for ClusterFuture ... done
[17:27:50.479] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:50.479] result() for ClusterFuture ... done
[17:27:50.479] result() for ClusterFuture ...
[17:27:50.479] - result already collected: FutureResult
[17:27:50.480] result() for ClusterFuture ... done

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) ...
[17:27:50.484] getGlobalsAndPackages() ...
[17:27:50.484] Searching for globals...
[17:27:50.494] - globals found: [16] '{', 'outer_function', 'map', ':', '~', 'inner_function', '.x', 'if', 'inherits', '<-', '[[', '-', 'eval', 'bquote', 'lapply', '+'
[17:27:50.495] Searching for globals ... DONE
[17:27:50.495] Resolving globals: FALSE
[17:27:50.497] The total size of the 3 globals is 1.22 KiB (1254 bytes)
[17:27:50.497] The total size of the 3 globals exported for future expression ('{; outer_function(1L); }') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'map' (633 bytes of class 'function'), 'inner_function' (371 bytes of class 'function') and 'outer_function' (250 bytes of class 'function')
[17:27:50.498] - globals: [3] 'outer_function', 'map', 'inner_function'
[17:27:50.498] 
[17:27:50.498] getGlobalsAndPackages() ... DONE
[17:27:50.499] run() for 'Future' ...
[17:27:50.499] - state: 'created'
[17:27:50.500] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:50.518] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:50.518] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:50.518]   - Field: 'node'
[17:27:50.518]   - Field: 'label'
[17:27:50.519]   - Field: 'local'
[17:27:50.519]   - Field: 'owner'
[17:27:50.519]   - Field: 'envir'
[17:27:50.519]   - Field: 'workers'
[17:27:50.519]   - Field: 'packages'
[17:27:50.519]   - Field: 'gc'
[17:27:50.520]   - Field: 'conditions'
[17:27:50.520]   - Field: 'persistent'
[17:27:50.520]   - Field: 'expr'
[17:27:50.520]   - Field: 'uuid'
[17:27:50.520]   - Field: 'seed'
[17:27:50.521]   - Field: 'version'
[17:27:50.521]   - Field: 'result'
[17:27:50.521]   - Field: 'asynchronous'
[17:27:50.521]   - Field: 'calls'
[17:27:50.521]   - Field: 'globals'
[17:27:50.521]   - Field: 'stdout'
[17:27:50.522]   - Field: 'earlySignal'
[17:27:50.522]   - Field: 'lazy'
[17:27:50.522]   - Field: 'state'
[17:27:50.522] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:50.522] - Launch lazy future ...
[17:27:50.523] Packages needed by the future expression (n = 0): <none>
[17:27:50.523] Packages needed by future strategies (n = 0): <none>
[17:27:50.524] {
[17:27:50.524]     {
[17:27:50.524]         {
[17:27:50.524]             ...future.startTime <- base::Sys.time()
[17:27:50.524]             {
[17:27:50.524]                 {
[17:27:50.524]                   {
[17:27:50.524]                     {
[17:27:50.524]                       base::local({
[17:27:50.524]                         has_future <- base::requireNamespace("future", 
[17:27:50.524]                           quietly = TRUE)
[17:27:50.524]                         if (has_future) {
[17:27:50.524]                           ns <- base::getNamespace("future")
[17:27:50.524]                           version <- ns[[".package"]][["version"]]
[17:27:50.524]                           if (is.null(version)) 
[17:27:50.524]                             version <- utils::packageVersion("future")
[17:27:50.524]                         }
[17:27:50.524]                         else {
[17:27:50.524]                           version <- NULL
[17:27:50.524]                         }
[17:27:50.524]                         if (!has_future || version < "1.8.0") {
[17:27:50.524]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:50.524]                             "", base::R.version$version.string), 
[17:27:50.524]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:50.524]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:50.524]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:50.524]                               "release", "version")], collapse = " "), 
[17:27:50.524]                             hostname = base::Sys.info()[["nodename"]])
[17:27:50.524]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:50.524]                             info)
[17:27:50.524]                           info <- base::paste(info, collapse = "; ")
[17:27:50.524]                           if (!has_future) {
[17:27:50.524]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:50.524]                               info)
[17:27:50.524]                           }
[17:27:50.524]                           else {
[17:27:50.524]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:50.524]                               info, version)
[17:27:50.524]                           }
[17:27:50.524]                           base::stop(msg)
[17:27:50.524]                         }
[17:27:50.524]                       })
[17:27:50.524]                     }
[17:27:50.524]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:50.524]                     base::options(mc.cores = 1L)
[17:27:50.524]                   }
[17:27:50.524]                   ...future.strategy.old <- future::plan("list")
[17:27:50.524]                   options(future.plan = NULL)
[17:27:50.524]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.524]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:50.524]                 }
[17:27:50.524]                 ...future.workdir <- getwd()
[17:27:50.524]             }
[17:27:50.524]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:50.524]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:50.524]         }
[17:27:50.524]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:50.524]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:50.524]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:50.524]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:50.524]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:50.524]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:50.524]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:50.524]             base::names(...future.oldOptions))
[17:27:50.524]     }
[17:27:50.524]     if (FALSE) {
[17:27:50.524]     }
[17:27:50.524]     else {
[17:27:50.524]         if (TRUE) {
[17:27:50.524]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:50.524]                 open = "w")
[17:27:50.524]         }
[17:27:50.524]         else {
[17:27:50.524]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:50.524]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:50.524]         }
[17:27:50.524]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:50.524]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:50.524]             base::sink(type = "output", split = FALSE)
[17:27:50.524]             base::close(...future.stdout)
[17:27:50.524]         }, add = TRUE)
[17:27:50.524]     }
[17:27:50.524]     ...future.frame <- base::sys.nframe()
[17:27:50.524]     ...future.conditions <- base::list()
[17:27:50.524]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:50.524]     if (FALSE) {
[17:27:50.524]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:50.524]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:50.524]     }
[17:27:50.524]     ...future.result <- base::tryCatch({
[17:27:50.524]         base::withCallingHandlers({
[17:27:50.524]             ...future.value <- base::withVisible(base::local({
[17:27:50.524]                 ...future.makeSendCondition <- base::local({
[17:27:50.524]                   sendCondition <- NULL
[17:27:50.524]                   function(frame = 1L) {
[17:27:50.524]                     if (is.function(sendCondition)) 
[17:27:50.524]                       return(sendCondition)
[17:27:50.524]                     ns <- getNamespace("parallel")
[17:27:50.524]                     if (exists("sendData", mode = "function", 
[17:27:50.524]                       envir = ns)) {
[17:27:50.524]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:50.524]                         envir = ns)
[17:27:50.524]                       envir <- sys.frame(frame)
[17:27:50.524]                       master <- NULL
[17:27:50.524]                       while (!identical(envir, .GlobalEnv) && 
[17:27:50.524]                         !identical(envir, emptyenv())) {
[17:27:50.524]                         if (exists("master", mode = "list", envir = envir, 
[17:27:50.524]                           inherits = FALSE)) {
[17:27:50.524]                           master <- get("master", mode = "list", 
[17:27:50.524]                             envir = envir, inherits = FALSE)
[17:27:50.524]                           if (inherits(master, c("SOCKnode", 
[17:27:50.524]                             "SOCK0node"))) {
[17:27:50.524]                             sendCondition <<- function(cond) {
[17:27:50.524]                               data <- list(type = "VALUE", value = cond, 
[17:27:50.524]                                 success = TRUE)
[17:27:50.524]                               parallel_sendData(master, data)
[17:27:50.524]                             }
[17:27:50.524]                             return(sendCondition)
[17:27:50.524]                           }
[17:27:50.524]                         }
[17:27:50.524]                         frame <- frame + 1L
[17:27:50.524]                         envir <- sys.frame(frame)
[17:27:50.524]                       }
[17:27:50.524]                     }
[17:27:50.524]                     sendCondition <<- function(cond) NULL
[17:27:50.524]                   }
[17:27:50.524]                 })
[17:27:50.524]                 withCallingHandlers({
[17:27:50.524]                   {
[17:27:50.524]                     outer_function(1L)
[17:27:50.524]                   }
[17:27:50.524]                 }, immediateCondition = function(cond) {
[17:27:50.524]                   sendCondition <- ...future.makeSendCondition()
[17:27:50.524]                   sendCondition(cond)
[17:27:50.524]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.524]                   {
[17:27:50.524]                     inherits <- base::inherits
[17:27:50.524]                     invokeRestart <- base::invokeRestart
[17:27:50.524]                     is.null <- base::is.null
[17:27:50.524]                     muffled <- FALSE
[17:27:50.524]                     if (inherits(cond, "message")) {
[17:27:50.524]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:50.524]                       if (muffled) 
[17:27:50.524]                         invokeRestart("muffleMessage")
[17:27:50.524]                     }
[17:27:50.524]                     else if (inherits(cond, "warning")) {
[17:27:50.524]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:50.524]                       if (muffled) 
[17:27:50.524]                         invokeRestart("muffleWarning")
[17:27:50.524]                     }
[17:27:50.524]                     else if (inherits(cond, "condition")) {
[17:27:50.524]                       if (!is.null(pattern)) {
[17:27:50.524]                         computeRestarts <- base::computeRestarts
[17:27:50.524]                         grepl <- base::grepl
[17:27:50.524]                         restarts <- computeRestarts(cond)
[17:27:50.524]                         for (restart in restarts) {
[17:27:50.524]                           name <- restart$name
[17:27:50.524]                           if (is.null(name)) 
[17:27:50.524]                             next
[17:27:50.524]                           if (!grepl(pattern, name)) 
[17:27:50.524]                             next
[17:27:50.524]                           invokeRestart(restart)
[17:27:50.524]                           muffled <- TRUE
[17:27:50.524]                           break
[17:27:50.524]                         }
[17:27:50.524]                       }
[17:27:50.524]                     }
[17:27:50.524]                     invisible(muffled)
[17:27:50.524]                   }
[17:27:50.524]                   muffleCondition(cond)
[17:27:50.524]                 })
[17:27:50.524]             }))
[17:27:50.524]             future::FutureResult(value = ...future.value$value, 
[17:27:50.524]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.524]                   ...future.rng), globalenv = if (FALSE) 
[17:27:50.524]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:50.524]                     ...future.globalenv.names))
[17:27:50.524]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:50.524]         }, condition = base::local({
[17:27:50.524]             c <- base::c
[17:27:50.524]             inherits <- base::inherits
[17:27:50.524]             invokeRestart <- base::invokeRestart
[17:27:50.524]             length <- base::length
[17:27:50.524]             list <- base::list
[17:27:50.524]             seq.int <- base::seq.int
[17:27:50.524]             signalCondition <- base::signalCondition
[17:27:50.524]             sys.calls <- base::sys.calls
[17:27:50.524]             `[[` <- base::`[[`
[17:27:50.524]             `+` <- base::`+`
[17:27:50.524]             `<<-` <- base::`<<-`
[17:27:50.524]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:50.524]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:50.524]                   3L)]
[17:27:50.524]             }
[17:27:50.524]             function(cond) {
[17:27:50.524]                 is_error <- inherits(cond, "error")
[17:27:50.524]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:50.524]                   NULL)
[17:27:50.524]                 if (is_error) {
[17:27:50.524]                   sessionInformation <- function() {
[17:27:50.524]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:50.524]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:50.524]                       search = base::search(), system = base::Sys.info())
[17:27:50.524]                   }
[17:27:50.524]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.524]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:50.524]                     cond$call), session = sessionInformation(), 
[17:27:50.524]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:50.524]                   signalCondition(cond)
[17:27:50.524]                 }
[17:27:50.524]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:50.524]                 "immediateCondition"))) {
[17:27:50.524]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:50.524]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.524]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:50.524]                   if (TRUE && !signal) {
[17:27:50.524]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.524]                     {
[17:27:50.524]                       inherits <- base::inherits
[17:27:50.524]                       invokeRestart <- base::invokeRestart
[17:27:50.524]                       is.null <- base::is.null
[17:27:50.524]                       muffled <- FALSE
[17:27:50.524]                       if (inherits(cond, "message")) {
[17:27:50.524]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.524]                         if (muffled) 
[17:27:50.524]                           invokeRestart("muffleMessage")
[17:27:50.524]                       }
[17:27:50.524]                       else if (inherits(cond, "warning")) {
[17:27:50.524]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.524]                         if (muffled) 
[17:27:50.524]                           invokeRestart("muffleWarning")
[17:27:50.524]                       }
[17:27:50.524]                       else if (inherits(cond, "condition")) {
[17:27:50.524]                         if (!is.null(pattern)) {
[17:27:50.524]                           computeRestarts <- base::computeRestarts
[17:27:50.524]                           grepl <- base::grepl
[17:27:50.524]                           restarts <- computeRestarts(cond)
[17:27:50.524]                           for (restart in restarts) {
[17:27:50.524]                             name <- restart$name
[17:27:50.524]                             if (is.null(name)) 
[17:27:50.524]                               next
[17:27:50.524]                             if (!grepl(pattern, name)) 
[17:27:50.524]                               next
[17:27:50.524]                             invokeRestart(restart)
[17:27:50.524]                             muffled <- TRUE
[17:27:50.524]                             break
[17:27:50.524]                           }
[17:27:50.524]                         }
[17:27:50.524]                       }
[17:27:50.524]                       invisible(muffled)
[17:27:50.524]                     }
[17:27:50.524]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.524]                   }
[17:27:50.524]                 }
[17:27:50.524]                 else {
[17:27:50.524]                   if (TRUE) {
[17:27:50.524]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.524]                     {
[17:27:50.524]                       inherits <- base::inherits
[17:27:50.524]                       invokeRestart <- base::invokeRestart
[17:27:50.524]                       is.null <- base::is.null
[17:27:50.524]                       muffled <- FALSE
[17:27:50.524]                       if (inherits(cond, "message")) {
[17:27:50.524]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.524]                         if (muffled) 
[17:27:50.524]                           invokeRestart("muffleMessage")
[17:27:50.524]                       }
[17:27:50.524]                       else if (inherits(cond, "warning")) {
[17:27:50.524]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.524]                         if (muffled) 
[17:27:50.524]                           invokeRestart("muffleWarning")
[17:27:50.524]                       }
[17:27:50.524]                       else if (inherits(cond, "condition")) {
[17:27:50.524]                         if (!is.null(pattern)) {
[17:27:50.524]                           computeRestarts <- base::computeRestarts
[17:27:50.524]                           grepl <- base::grepl
[17:27:50.524]                           restarts <- computeRestarts(cond)
[17:27:50.524]                           for (restart in restarts) {
[17:27:50.524]                             name <- restart$name
[17:27:50.524]                             if (is.null(name)) 
[17:27:50.524]                               next
[17:27:50.524]                             if (!grepl(pattern, name)) 
[17:27:50.524]                               next
[17:27:50.524]                             invokeRestart(restart)
[17:27:50.524]                             muffled <- TRUE
[17:27:50.524]                             break
[17:27:50.524]                           }
[17:27:50.524]                         }
[17:27:50.524]                       }
[17:27:50.524]                       invisible(muffled)
[17:27:50.524]                     }
[17:27:50.524]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.524]                   }
[17:27:50.524]                 }
[17:27:50.524]             }
[17:27:50.524]         }))
[17:27:50.524]     }, error = function(ex) {
[17:27:50.524]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:50.524]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.524]                 ...future.rng), started = ...future.startTime, 
[17:27:50.524]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:50.524]             version = "1.8"), class = "FutureResult")
[17:27:50.524]     }, finally = {
[17:27:50.524]         if (!identical(...future.workdir, getwd())) 
[17:27:50.524]             setwd(...future.workdir)
[17:27:50.524]         {
[17:27:50.524]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:50.524]                 ...future.oldOptions$nwarnings <- NULL
[17:27:50.524]             }
[17:27:50.524]             base::options(...future.oldOptions)
[17:27:50.524]             if (.Platform$OS.type == "windows") {
[17:27:50.524]                 old_names <- names(...future.oldEnvVars)
[17:27:50.524]                 envs <- base::Sys.getenv()
[17:27:50.524]                 names <- names(envs)
[17:27:50.524]                 common <- intersect(names, old_names)
[17:27:50.524]                 added <- setdiff(names, old_names)
[17:27:50.524]                 removed <- setdiff(old_names, names)
[17:27:50.524]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:50.524]                   envs[common]]
[17:27:50.524]                 NAMES <- toupper(changed)
[17:27:50.524]                 args <- list()
[17:27:50.524]                 for (kk in seq_along(NAMES)) {
[17:27:50.524]                   name <- changed[[kk]]
[17:27:50.524]                   NAME <- NAMES[[kk]]
[17:27:50.524]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.524]                     next
[17:27:50.524]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.524]                 }
[17:27:50.524]                 NAMES <- toupper(added)
[17:27:50.524]                 for (kk in seq_along(NAMES)) {
[17:27:50.524]                   name <- added[[kk]]
[17:27:50.524]                   NAME <- NAMES[[kk]]
[17:27:50.524]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.524]                     next
[17:27:50.524]                   args[[name]] <- ""
[17:27:50.524]                 }
[17:27:50.524]                 NAMES <- toupper(removed)
[17:27:50.524]                 for (kk in seq_along(NAMES)) {
[17:27:50.524]                   name <- removed[[kk]]
[17:27:50.524]                   NAME <- NAMES[[kk]]
[17:27:50.524]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.524]                     next
[17:27:50.524]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.524]                 }
[17:27:50.524]                 if (length(args) > 0) 
[17:27:50.524]                   base::do.call(base::Sys.setenv, args = args)
[17:27:50.524]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:50.524]             }
[17:27:50.524]             else {
[17:27:50.524]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:50.524]             }
[17:27:50.524]             {
[17:27:50.524]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:50.524]                   0L) {
[17:27:50.524]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:50.524]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:50.524]                   base::options(opts)
[17:27:50.524]                 }
[17:27:50.524]                 {
[17:27:50.524]                   {
[17:27:50.524]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:50.524]                     NULL
[17:27:50.524]                   }
[17:27:50.524]                   options(future.plan = NULL)
[17:27:50.524]                   if (is.na(NA_character_)) 
[17:27:50.524]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.524]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:50.524]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:50.524]                     .init = FALSE)
[17:27:50.524]                 }
[17:27:50.524]             }
[17:27:50.524]         }
[17:27:50.524]     })
[17:27:50.524]     if (TRUE) {
[17:27:50.524]         base::sink(type = "output", split = FALSE)
[17:27:50.524]         if (TRUE) {
[17:27:50.524]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:50.524]         }
[17:27:50.524]         else {
[17:27:50.524]             ...future.result["stdout"] <- base::list(NULL)
[17:27:50.524]         }
[17:27:50.524]         base::close(...future.stdout)
[17:27:50.524]         ...future.stdout <- NULL
[17:27:50.524]     }
[17:27:50.524]     ...future.result$conditions <- ...future.conditions
[17:27:50.524]     ...future.result$finished <- base::Sys.time()
[17:27:50.524]     ...future.result
[17:27:50.524] }
[17:27:50.529] Exporting 3 global objects (1.52 KiB) to cluster node #1 ...
[17:27:50.529] Exporting 'outer_function' (250 bytes) to cluster node #1 ...
[17:27:50.530] Exporting 'outer_function' (250 bytes) to cluster node #1 ... DONE
[17:27:50.530] Exporting 'map' (633 bytes) to cluster node #1 ...
[17:27:50.530] Exporting 'map' (633 bytes) to cluster node #1 ... DONE
[17:27:50.531] Exporting 'inner_function' (371 bytes) to cluster node #1 ...
[17:27:50.531] Exporting 'inner_function' (371 bytes) to cluster node #1 ... DONE
[17:27:50.531] Exporting 3 global objects (1.52 KiB) to cluster node #1 ... DONE
[17:27:50.532] MultisessionFuture started
[17:27:50.532] - Launch lazy future ... done
[17:27:50.533] run() for 'MultisessionFuture' ... done
[17:27:50.533] result() for ClusterFuture ...
[17:27:50.533] receiveMessageFromWorker() for ClusterFuture ...
[17:27:50.533] - Validating connection of MultisessionFuture
[17:27:50.555] - received message: FutureResult
[17:27:50.556] - Received FutureResult
[17:27:50.556] - Erased future from FutureRegistry
[17:27:50.557] result() for ClusterFuture ...
[17:27:50.557] - result already collected: FutureResult
[17:27:50.557] result() for ClusterFuture ... done
[17:27:50.557] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:50.558] result() for ClusterFuture ... done
[17:27:50.558] result() for ClusterFuture ...
[17:27:50.558] - result already collected: FutureResult
[17:27:50.558] result() for ClusterFuture ... done
List of 2
 $ : num [1:2] 2 3
 $ : num [1:2] 2 3
[17:27:50.564] getGlobalsAndPackages() ...
[17:27:50.564] Searching for globals...
[17:27:50.569] - globals found: [16] '{', 'outer_function', 'map', ':', '~', 'inner_function', '.x', 'if', 'inherits', '<-', '[[', '-', 'eval', 'bquote', 'lapply', '+'
[17:27:50.569] Searching for globals ... DONE
[17:27:50.570] Resolving globals: FALSE
[17:27:50.570] The total size of the 3 globals is 1.22 KiB (1254 bytes)
[17:27:50.571] The total size of the 3 globals exported for future expression ('{; outer_function(1L); }') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'map' (633 bytes of class 'function'), 'inner_function' (371 bytes of class 'function') and 'outer_function' (250 bytes of class 'function')
[17:27:50.571] - globals: [3] 'outer_function', 'map', 'inner_function'
[17:27:50.571] 
[17:27:50.572] getGlobalsAndPackages() ... DONE
[17:27:50.572] run() for 'Future' ...
[17:27:50.572] - state: 'created'
[17:27:50.572] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:50.589] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:50.590] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:50.590]   - Field: 'node'
[17:27:50.590]   - Field: 'label'
[17:27:50.590]   - Field: 'local'
[17:27:50.591]   - Field: 'owner'
[17:27:50.591]   - Field: 'envir'
[17:27:50.591]   - Field: 'workers'
[17:27:50.591]   - Field: 'packages'
[17:27:50.591]   - Field: 'gc'
[17:27:50.591]   - Field: 'conditions'
[17:27:50.592]   - Field: 'persistent'
[17:27:50.592]   - Field: 'expr'
[17:27:50.592]   - Field: 'uuid'
[17:27:50.592]   - Field: 'seed'
[17:27:50.592]   - Field: 'version'
[17:27:50.593]   - Field: 'result'
[17:27:50.593]   - Field: 'asynchronous'
[17:27:50.593]   - Field: 'calls'
[17:27:50.593]   - Field: 'globals'
[17:27:50.593]   - Field: 'stdout'
[17:27:50.593]   - Field: 'earlySignal'
[17:27:50.594]   - Field: 'lazy'
[17:27:50.594]   - Field: 'state'
[17:27:50.594] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:50.594] - Launch lazy future ...
[17:27:50.595] Packages needed by the future expression (n = 0): <none>
[17:27:50.595] Packages needed by future strategies (n = 0): <none>
[17:27:50.596] {
[17:27:50.596]     {
[17:27:50.596]         {
[17:27:50.596]             ...future.startTime <- base::Sys.time()
[17:27:50.596]             {
[17:27:50.596]                 {
[17:27:50.596]                   {
[17:27:50.596]                     {
[17:27:50.596]                       base::local({
[17:27:50.596]                         has_future <- base::requireNamespace("future", 
[17:27:50.596]                           quietly = TRUE)
[17:27:50.596]                         if (has_future) {
[17:27:50.596]                           ns <- base::getNamespace("future")
[17:27:50.596]                           version <- ns[[".package"]][["version"]]
[17:27:50.596]                           if (is.null(version)) 
[17:27:50.596]                             version <- utils::packageVersion("future")
[17:27:50.596]                         }
[17:27:50.596]                         else {
[17:27:50.596]                           version <- NULL
[17:27:50.596]                         }
[17:27:50.596]                         if (!has_future || version < "1.8.0") {
[17:27:50.596]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:50.596]                             "", base::R.version$version.string), 
[17:27:50.596]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:50.596]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:50.596]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:50.596]                               "release", "version")], collapse = " "), 
[17:27:50.596]                             hostname = base::Sys.info()[["nodename"]])
[17:27:50.596]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:50.596]                             info)
[17:27:50.596]                           info <- base::paste(info, collapse = "; ")
[17:27:50.596]                           if (!has_future) {
[17:27:50.596]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:50.596]                               info)
[17:27:50.596]                           }
[17:27:50.596]                           else {
[17:27:50.596]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:50.596]                               info, version)
[17:27:50.596]                           }
[17:27:50.596]                           base::stop(msg)
[17:27:50.596]                         }
[17:27:50.596]                       })
[17:27:50.596]                     }
[17:27:50.596]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:50.596]                     base::options(mc.cores = 1L)
[17:27:50.596]                   }
[17:27:50.596]                   ...future.strategy.old <- future::plan("list")
[17:27:50.596]                   options(future.plan = NULL)
[17:27:50.596]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.596]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:50.596]                 }
[17:27:50.596]                 ...future.workdir <- getwd()
[17:27:50.596]             }
[17:27:50.596]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:50.596]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:50.596]         }
[17:27:50.596]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:50.596]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:50.596]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:50.596]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:50.596]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:50.596]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:50.596]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:50.596]             base::names(...future.oldOptions))
[17:27:50.596]     }
[17:27:50.596]     if (FALSE) {
[17:27:50.596]     }
[17:27:50.596]     else {
[17:27:50.596]         if (TRUE) {
[17:27:50.596]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:50.596]                 open = "w")
[17:27:50.596]         }
[17:27:50.596]         else {
[17:27:50.596]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:50.596]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:50.596]         }
[17:27:50.596]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:50.596]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:50.596]             base::sink(type = "output", split = FALSE)
[17:27:50.596]             base::close(...future.stdout)
[17:27:50.596]         }, add = TRUE)
[17:27:50.596]     }
[17:27:50.596]     ...future.frame <- base::sys.nframe()
[17:27:50.596]     ...future.conditions <- base::list()
[17:27:50.596]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:50.596]     if (FALSE) {
[17:27:50.596]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:50.596]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:50.596]     }
[17:27:50.596]     ...future.result <- base::tryCatch({
[17:27:50.596]         base::withCallingHandlers({
[17:27:50.596]             ...future.value <- base::withVisible(base::local({
[17:27:50.596]                 ...future.makeSendCondition <- base::local({
[17:27:50.596]                   sendCondition <- NULL
[17:27:50.596]                   function(frame = 1L) {
[17:27:50.596]                     if (is.function(sendCondition)) 
[17:27:50.596]                       return(sendCondition)
[17:27:50.596]                     ns <- getNamespace("parallel")
[17:27:50.596]                     if (exists("sendData", mode = "function", 
[17:27:50.596]                       envir = ns)) {
[17:27:50.596]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:50.596]                         envir = ns)
[17:27:50.596]                       envir <- sys.frame(frame)
[17:27:50.596]                       master <- NULL
[17:27:50.596]                       while (!identical(envir, .GlobalEnv) && 
[17:27:50.596]                         !identical(envir, emptyenv())) {
[17:27:50.596]                         if (exists("master", mode = "list", envir = envir, 
[17:27:50.596]                           inherits = FALSE)) {
[17:27:50.596]                           master <- get("master", mode = "list", 
[17:27:50.596]                             envir = envir, inherits = FALSE)
[17:27:50.596]                           if (inherits(master, c("SOCKnode", 
[17:27:50.596]                             "SOCK0node"))) {
[17:27:50.596]                             sendCondition <<- function(cond) {
[17:27:50.596]                               data <- list(type = "VALUE", value = cond, 
[17:27:50.596]                                 success = TRUE)
[17:27:50.596]                               parallel_sendData(master, data)
[17:27:50.596]                             }
[17:27:50.596]                             return(sendCondition)
[17:27:50.596]                           }
[17:27:50.596]                         }
[17:27:50.596]                         frame <- frame + 1L
[17:27:50.596]                         envir <- sys.frame(frame)
[17:27:50.596]                       }
[17:27:50.596]                     }
[17:27:50.596]                     sendCondition <<- function(cond) NULL
[17:27:50.596]                   }
[17:27:50.596]                 })
[17:27:50.596]                 withCallingHandlers({
[17:27:50.596]                   {
[17:27:50.596]                     outer_function(1L)
[17:27:50.596]                   }
[17:27:50.596]                 }, immediateCondition = function(cond) {
[17:27:50.596]                   sendCondition <- ...future.makeSendCondition()
[17:27:50.596]                   sendCondition(cond)
[17:27:50.596]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.596]                   {
[17:27:50.596]                     inherits <- base::inherits
[17:27:50.596]                     invokeRestart <- base::invokeRestart
[17:27:50.596]                     is.null <- base::is.null
[17:27:50.596]                     muffled <- FALSE
[17:27:50.596]                     if (inherits(cond, "message")) {
[17:27:50.596]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:50.596]                       if (muffled) 
[17:27:50.596]                         invokeRestart("muffleMessage")
[17:27:50.596]                     }
[17:27:50.596]                     else if (inherits(cond, "warning")) {
[17:27:50.596]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:50.596]                       if (muffled) 
[17:27:50.596]                         invokeRestart("muffleWarning")
[17:27:50.596]                     }
[17:27:50.596]                     else if (inherits(cond, "condition")) {
[17:27:50.596]                       if (!is.null(pattern)) {
[17:27:50.596]                         computeRestarts <- base::computeRestarts
[17:27:50.596]                         grepl <- base::grepl
[17:27:50.596]                         restarts <- computeRestarts(cond)
[17:27:50.596]                         for (restart in restarts) {
[17:27:50.596]                           name <- restart$name
[17:27:50.596]                           if (is.null(name)) 
[17:27:50.596]                             next
[17:27:50.596]                           if (!grepl(pattern, name)) 
[17:27:50.596]                             next
[17:27:50.596]                           invokeRestart(restart)
[17:27:50.596]                           muffled <- TRUE
[17:27:50.596]                           break
[17:27:50.596]                         }
[17:27:50.596]                       }
[17:27:50.596]                     }
[17:27:50.596]                     invisible(muffled)
[17:27:50.596]                   }
[17:27:50.596]                   muffleCondition(cond)
[17:27:50.596]                 })
[17:27:50.596]             }))
[17:27:50.596]             future::FutureResult(value = ...future.value$value, 
[17:27:50.596]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.596]                   ...future.rng), globalenv = if (FALSE) 
[17:27:50.596]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:50.596]                     ...future.globalenv.names))
[17:27:50.596]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:50.596]         }, condition = base::local({
[17:27:50.596]             c <- base::c
[17:27:50.596]             inherits <- base::inherits
[17:27:50.596]             invokeRestart <- base::invokeRestart
[17:27:50.596]             length <- base::length
[17:27:50.596]             list <- base::list
[17:27:50.596]             seq.int <- base::seq.int
[17:27:50.596]             signalCondition <- base::signalCondition
[17:27:50.596]             sys.calls <- base::sys.calls
[17:27:50.596]             `[[` <- base::`[[`
[17:27:50.596]             `+` <- base::`+`
[17:27:50.596]             `<<-` <- base::`<<-`
[17:27:50.596]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:50.596]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:50.596]                   3L)]
[17:27:50.596]             }
[17:27:50.596]             function(cond) {
[17:27:50.596]                 is_error <- inherits(cond, "error")
[17:27:50.596]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:50.596]                   NULL)
[17:27:50.596]                 if (is_error) {
[17:27:50.596]                   sessionInformation <- function() {
[17:27:50.596]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:50.596]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:50.596]                       search = base::search(), system = base::Sys.info())
[17:27:50.596]                   }
[17:27:50.596]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.596]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:50.596]                     cond$call), session = sessionInformation(), 
[17:27:50.596]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:50.596]                   signalCondition(cond)
[17:27:50.596]                 }
[17:27:50.596]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:50.596]                 "immediateCondition"))) {
[17:27:50.596]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:50.596]                   ...future.conditions[[length(...future.conditions) + 
[17:27:50.596]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:50.596]                   if (TRUE && !signal) {
[17:27:50.596]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.596]                     {
[17:27:50.596]                       inherits <- base::inherits
[17:27:50.596]                       invokeRestart <- base::invokeRestart
[17:27:50.596]                       is.null <- base::is.null
[17:27:50.596]                       muffled <- FALSE
[17:27:50.596]                       if (inherits(cond, "message")) {
[17:27:50.596]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.596]                         if (muffled) 
[17:27:50.596]                           invokeRestart("muffleMessage")
[17:27:50.596]                       }
[17:27:50.596]                       else if (inherits(cond, "warning")) {
[17:27:50.596]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.596]                         if (muffled) 
[17:27:50.596]                           invokeRestart("muffleWarning")
[17:27:50.596]                       }
[17:27:50.596]                       else if (inherits(cond, "condition")) {
[17:27:50.596]                         if (!is.null(pattern)) {
[17:27:50.596]                           computeRestarts <- base::computeRestarts
[17:27:50.596]                           grepl <- base::grepl
[17:27:50.596]                           restarts <- computeRestarts(cond)
[17:27:50.596]                           for (restart in restarts) {
[17:27:50.596]                             name <- restart$name
[17:27:50.596]                             if (is.null(name)) 
[17:27:50.596]                               next
[17:27:50.596]                             if (!grepl(pattern, name)) 
[17:27:50.596]                               next
[17:27:50.596]                             invokeRestart(restart)
[17:27:50.596]                             muffled <- TRUE
[17:27:50.596]                             break
[17:27:50.596]                           }
[17:27:50.596]                         }
[17:27:50.596]                       }
[17:27:50.596]                       invisible(muffled)
[17:27:50.596]                     }
[17:27:50.596]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.596]                   }
[17:27:50.596]                 }
[17:27:50.596]                 else {
[17:27:50.596]                   if (TRUE) {
[17:27:50.596]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:50.596]                     {
[17:27:50.596]                       inherits <- base::inherits
[17:27:50.596]                       invokeRestart <- base::invokeRestart
[17:27:50.596]                       is.null <- base::is.null
[17:27:50.596]                       muffled <- FALSE
[17:27:50.596]                       if (inherits(cond, "message")) {
[17:27:50.596]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:50.596]                         if (muffled) 
[17:27:50.596]                           invokeRestart("muffleMessage")
[17:27:50.596]                       }
[17:27:50.596]                       else if (inherits(cond, "warning")) {
[17:27:50.596]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:50.596]                         if (muffled) 
[17:27:50.596]                           invokeRestart("muffleWarning")
[17:27:50.596]                       }
[17:27:50.596]                       else if (inherits(cond, "condition")) {
[17:27:50.596]                         if (!is.null(pattern)) {
[17:27:50.596]                           computeRestarts <- base::computeRestarts
[17:27:50.596]                           grepl <- base::grepl
[17:27:50.596]                           restarts <- computeRestarts(cond)
[17:27:50.596]                           for (restart in restarts) {
[17:27:50.596]                             name <- restart$name
[17:27:50.596]                             if (is.null(name)) 
[17:27:50.596]                               next
[17:27:50.596]                             if (!grepl(pattern, name)) 
[17:27:50.596]                               next
[17:27:50.596]                             invokeRestart(restart)
[17:27:50.596]                             muffled <- TRUE
[17:27:50.596]                             break
[17:27:50.596]                           }
[17:27:50.596]                         }
[17:27:50.596]                       }
[17:27:50.596]                       invisible(muffled)
[17:27:50.596]                     }
[17:27:50.596]                     muffleCondition(cond, pattern = "^muffle")
[17:27:50.596]                   }
[17:27:50.596]                 }
[17:27:50.596]             }
[17:27:50.596]         }))
[17:27:50.596]     }, error = function(ex) {
[17:27:50.596]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:50.596]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:50.596]                 ...future.rng), started = ...future.startTime, 
[17:27:50.596]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:50.596]             version = "1.8"), class = "FutureResult")
[17:27:50.596]     }, finally = {
[17:27:50.596]         if (!identical(...future.workdir, getwd())) 
[17:27:50.596]             setwd(...future.workdir)
[17:27:50.596]         {
[17:27:50.596]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:50.596]                 ...future.oldOptions$nwarnings <- NULL
[17:27:50.596]             }
[17:27:50.596]             base::options(...future.oldOptions)
[17:27:50.596]             if (.Platform$OS.type == "windows") {
[17:27:50.596]                 old_names <- names(...future.oldEnvVars)
[17:27:50.596]                 envs <- base::Sys.getenv()
[17:27:50.596]                 names <- names(envs)
[17:27:50.596]                 common <- intersect(names, old_names)
[17:27:50.596]                 added <- setdiff(names, old_names)
[17:27:50.596]                 removed <- setdiff(old_names, names)
[17:27:50.596]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:50.596]                   envs[common]]
[17:27:50.596]                 NAMES <- toupper(changed)
[17:27:50.596]                 args <- list()
[17:27:50.596]                 for (kk in seq_along(NAMES)) {
[17:27:50.596]                   name <- changed[[kk]]
[17:27:50.596]                   NAME <- NAMES[[kk]]
[17:27:50.596]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.596]                     next
[17:27:50.596]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.596]                 }
[17:27:50.596]                 NAMES <- toupper(added)
[17:27:50.596]                 for (kk in seq_along(NAMES)) {
[17:27:50.596]                   name <- added[[kk]]
[17:27:50.596]                   NAME <- NAMES[[kk]]
[17:27:50.596]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.596]                     next
[17:27:50.596]                   args[[name]] <- ""
[17:27:50.596]                 }
[17:27:50.596]                 NAMES <- toupper(removed)
[17:27:50.596]                 for (kk in seq_along(NAMES)) {
[17:27:50.596]                   name <- removed[[kk]]
[17:27:50.596]                   NAME <- NAMES[[kk]]
[17:27:50.596]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:50.596]                     next
[17:27:50.596]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:50.596]                 }
[17:27:50.596]                 if (length(args) > 0) 
[17:27:50.596]                   base::do.call(base::Sys.setenv, args = args)
[17:27:50.596]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:50.596]             }
[17:27:50.596]             else {
[17:27:50.596]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:50.596]             }
[17:27:50.596]             {
[17:27:50.596]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:50.596]                   0L) {
[17:27:50.596]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:50.596]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:50.596]                   base::options(opts)
[17:27:50.596]                 }
[17:27:50.596]                 {
[17:27:50.596]                   {
[17:27:50.596]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:50.596]                     NULL
[17:27:50.596]                   }
[17:27:50.596]                   options(future.plan = NULL)
[17:27:50.596]                   if (is.na(NA_character_)) 
[17:27:50.596]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:50.596]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:50.596]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:50.596]                     .init = FALSE)
[17:27:50.596]                 }
[17:27:50.596]             }
[17:27:50.596]         }
[17:27:50.596]     })
[17:27:50.596]     if (TRUE) {
[17:27:50.596]         base::sink(type = "output", split = FALSE)
[17:27:50.596]         if (TRUE) {
[17:27:50.596]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:50.596]         }
[17:27:50.596]         else {
[17:27:50.596]             ...future.result["stdout"] <- base::list(NULL)
[17:27:50.596]         }
[17:27:50.596]         base::close(...future.stdout)
[17:27:50.596]         ...future.stdout <- NULL
[17:27:50.596]     }
[17:27:50.596]     ...future.result$conditions <- ...future.conditions
[17:27:50.596]     ...future.result$finished <- base::Sys.time()
[17:27:50.596]     ...future.result
[17:27:50.596] }
[17:27:50.605] Exporting 3 global objects (1.52 KiB) to cluster node #1 ...
[17:27:50.606] Exporting 'outer_function' (250 bytes) to cluster node #1 ...
[17:27:50.607] Exporting 'outer_function' (250 bytes) to cluster node #1 ... DONE
[17:27:50.607] Exporting 'map' (633 bytes) to cluster node #1 ...
[17:27:50.608] Exporting 'map' (633 bytes) to cluster node #1 ... DONE
[17:27:50.608] Exporting 'inner_function' (371 bytes) to cluster node #1 ...
[17:27:50.609] Exporting 'inner_function' (371 bytes) to cluster node #1 ... DONE
[17:27:50.609] Exporting 3 global objects (1.52 KiB) to cluster node #1 ... DONE
[17:27:50.610] MultisessionFuture started
[17:27:50.611] - Launch lazy future ... done
[17:27:50.611] run() for 'MultisessionFuture' ... done
[17:27:50.612] result() for ClusterFuture ...
[17:27:50.612] receiveMessageFromWorker() for ClusterFuture ...
[17:27:50.613] - Validating connection of MultisessionFuture
[17:27:50.639] - received message: FutureResult
[17:27:50.640] - Received FutureResult
[17:27:50.640] - Erased future from FutureRegistry
[17:27:50.641] result() for ClusterFuture ...
[17:27:50.641] - result already collected: FutureResult
[17:27:50.641] result() for ClusterFuture ... done
[17:27:50.641] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:50.642] result() for ClusterFuture ... done
[17:27:50.642] result() for ClusterFuture ...
[17:27:50.642] - result already collected: FutureResult
[17:27:50.642] result() for ClusterFuture ... done
List of 2
 $ : num [1:2] 2 3
 $ : num [1:2] 2 3
Testing with 2 cores ... DONE
> 
> message("*** Globals - formulas ... DONE")
*** Globals - formulas ... DONE
> 
> source("incl/end.R")
[17:27:50.646] plan(): Setting new future strategy stack:
[17:27:50.647] List of future strategies:
[17:27:50.647] 1. FutureStrategy:
[17:27:50.647]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:50.647]    - tweaked: FALSE
[17:27:50.647]    - call: future::plan(oplan)
[17:27:50.658] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=205] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'RTOOLS44_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS44_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_NOTE_MISSING_PACKAGE_ANCHORS_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_DEPRECATED_IS_R_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   2.07    0.12    3.43