R Under development (unstable) (2023-06-30 r84625 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2023 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")
[18:01:25.621] plan(): Setting new future strategy stack:
[18:01:25.622] List of future strategies:
[18:01:25.622] 1. sequential:
[18:01:25.622]    - args: function (..., envir = parent.frame())
[18:01:25.622]    - tweaked: FALSE
[18:01:25.622]    - call: future::plan("sequential")
[18:01:25.638] plan(): nbrOfWorkers() = 1
> 
> message("*** Futures - labels ...")
*** Futures - labels ...
> 
> strategies <- supportedStrategies()
> 
> ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
> if (!fullTest && isWin32) strategies <- NULL
> 
> for (strategy in strategies) {
+   message(sprintf("- plan('%s') ...", strategy))
+   plan(strategy)
+ 
+   for (label in list(NULL, sprintf("strategy = %s", strategy))) {
+     fcn <- get(strategy, mode = "function")
+     stopifnot(inherits(fcn, strategy))
+     f <- fcn(42, label = label)
+     print(f)
+     stopifnot(identical(f$label, label))
+     v <- value(f)
+     stopifnot(v == 42)
+     
+     f <- future(42, label = label)
+     print(f)
+     stopifnot(identical(f$label, label))
+     v <- value(f)
+     stopifnot(v == 42)
+ 
+     v %<-% { 42 } %label% label
+     f <- futureOf(v)
+     print(f)
+     stopifnot(identical(f$label, label))
+     stopifnot(v == 42)
+ 
+   } ## for (label ...)
+ 
+   message(sprintf("- plan('%s') ... DONE", strategy))
+ } ## for (strategy ...)
- plan('sequential') ...
[18:01:25.661] plan(): Setting new future strategy stack:
[18:01:25.661] List of future strategies:
[18:01:25.661] 1. sequential:
[18:01:25.661]    - args: function (..., envir = parent.frame())
[18:01:25.661]    - tweaked: FALSE
[18:01:25.661]    - call: plan(strategy)
[18:01:25.675] plan(): nbrOfWorkers() = 1
[18:01:25.677] getGlobalsAndPackages() ...
[18:01:25.677] Searching for globals...
[18:01:25.680] 
[18:01:25.680] Searching for globals ... DONE
[18:01:25.680] - globals: [0] <none>
[18:01:25.680] getGlobalsAndPackages() ... DONE
[18:01:25.681] Packages needed by the future expression (n = 0): <none>
[18:01:25.681] Packages needed by future strategies (n = 0): <none>
[18:01:25.682] {
[18:01:25.682]     {
[18:01:25.682]         {
[18:01:25.682]             ...future.startTime <- base::Sys.time()
[18:01:25.682]             {
[18:01:25.682]                 {
[18:01:25.682]                   {
[18:01:25.682]                     base::local({
[18:01:25.682]                       has_future <- base::requireNamespace("future", 
[18:01:25.682]                         quietly = TRUE)
[18:01:25.682]                       if (has_future) {
[18:01:25.682]                         ns <- base::getNamespace("future")
[18:01:25.682]                         version <- ns[[".package"]][["version"]]
[18:01:25.682]                         if (is.null(version)) 
[18:01:25.682]                           version <- utils::packageVersion("future")
[18:01:25.682]                       }
[18:01:25.682]                       else {
[18:01:25.682]                         version <- NULL
[18:01:25.682]                       }
[18:01:25.682]                       if (!has_future || version < "1.8.0") {
[18:01:25.682]                         info <- base::c(r_version = base::gsub("R version ", 
[18:01:25.682]                           "", base::R.version$version.string), 
[18:01:25.682]                           platform = base::sprintf("%s (%s-bit)", 
[18:01:25.682]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:25.682]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:25.682]                             "release", "version")], collapse = " "), 
[18:01:25.682]                           hostname = base::Sys.info()[["nodename"]])
[18:01:25.682]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:01:25.682]                           info)
[18:01:25.682]                         info <- base::paste(info, collapse = "; ")
[18:01:25.682]                         if (!has_future) {
[18:01:25.682]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:25.682]                             info)
[18:01:25.682]                         }
[18:01:25.682]                         else {
[18:01:25.682]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:25.682]                             info, version)
[18:01:25.682]                         }
[18:01:25.682]                         base::stop(msg)
[18:01:25.682]                       }
[18:01:25.682]                     })
[18:01:25.682]                   }
[18:01:25.682]                   options(future.plan = NULL)
[18:01:25.682]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:25.682]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:25.682]                 }
[18:01:25.682]                 ...future.workdir <- getwd()
[18:01:25.682]             }
[18:01:25.682]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:25.682]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:25.682]         }
[18:01:25.682]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:25.682]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:25.682]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:25.682]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:25.682]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:25.682]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:25.682]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:25.682]             base::names(...future.oldOptions))
[18:01:25.682]     }
[18:01:25.682]     if (FALSE) {
[18:01:25.682]     }
[18:01:25.682]     else {
[18:01:25.682]         if (TRUE) {
[18:01:25.682]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:25.682]                 open = "w")
[18:01:25.682]         }
[18:01:25.682]         else {
[18:01:25.682]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:25.682]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:25.682]         }
[18:01:25.682]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:25.682]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:25.682]             base::sink(type = "output", split = FALSE)
[18:01:25.682]             base::close(...future.stdout)
[18:01:25.682]         }, add = TRUE)
[18:01:25.682]     }
[18:01:25.682]     ...future.frame <- base::sys.nframe()
[18:01:25.682]     ...future.conditions <- base::list()
[18:01:25.682]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:25.682]     if (FALSE) {
[18:01:25.682]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:25.682]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:25.682]     }
[18:01:25.682]     ...future.result <- base::tryCatch({
[18:01:25.682]         base::withCallingHandlers({
[18:01:25.682]             ...future.value <- base::withVisible(base::local(42))
[18:01:25.682]             future::FutureResult(value = ...future.value$value, 
[18:01:25.682]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:25.682]                   ...future.rng), globalenv = if (FALSE) 
[18:01:25.682]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:25.682]                     ...future.globalenv.names))
[18:01:25.682]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:25.682]         }, condition = base::local({
[18:01:25.682]             c <- base::c
[18:01:25.682]             inherits <- base::inherits
[18:01:25.682]             invokeRestart <- base::invokeRestart
[18:01:25.682]             length <- base::length
[18:01:25.682]             list <- base::list
[18:01:25.682]             seq.int <- base::seq.int
[18:01:25.682]             signalCondition <- base::signalCondition
[18:01:25.682]             sys.calls <- base::sys.calls
[18:01:25.682]             `[[` <- base::`[[`
[18:01:25.682]             `+` <- base::`+`
[18:01:25.682]             `<<-` <- base::`<<-`
[18:01:25.682]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:25.682]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:25.682]                   3L)]
[18:01:25.682]             }
[18:01:25.682]             function(cond) {
[18:01:25.682]                 is_error <- inherits(cond, "error")
[18:01:25.682]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:25.682]                   NULL)
[18:01:25.682]                 if (is_error) {
[18:01:25.682]                   sessionInformation <- function() {
[18:01:25.682]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:25.682]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:25.682]                       search = base::search(), system = base::Sys.info())
[18:01:25.682]                   }
[18:01:25.682]                   ...future.conditions[[length(...future.conditions) + 
[18:01:25.682]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:25.682]                     cond$call), session = sessionInformation(), 
[18:01:25.682]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:25.682]                   signalCondition(cond)
[18:01:25.682]                 }
[18:01:25.682]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:25.682]                 "immediateCondition"))) {
[18:01:25.682]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:25.682]                   ...future.conditions[[length(...future.conditions) + 
[18:01:25.682]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:25.682]                   if (TRUE && !signal) {
[18:01:25.682]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:25.682]                     {
[18:01:25.682]                       inherits <- base::inherits
[18:01:25.682]                       invokeRestart <- base::invokeRestart
[18:01:25.682]                       is.null <- base::is.null
[18:01:25.682]                       muffled <- FALSE
[18:01:25.682]                       if (inherits(cond, "message")) {
[18:01:25.682]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:25.682]                         if (muffled) 
[18:01:25.682]                           invokeRestart("muffleMessage")
[18:01:25.682]                       }
[18:01:25.682]                       else if (inherits(cond, "warning")) {
[18:01:25.682]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:25.682]                         if (muffled) 
[18:01:25.682]                           invokeRestart("muffleWarning")
[18:01:25.682]                       }
[18:01:25.682]                       else if (inherits(cond, "condition")) {
[18:01:25.682]                         if (!is.null(pattern)) {
[18:01:25.682]                           computeRestarts <- base::computeRestarts
[18:01:25.682]                           grepl <- base::grepl
[18:01:25.682]                           restarts <- computeRestarts(cond)
[18:01:25.682]                           for (restart in restarts) {
[18:01:25.682]                             name <- restart$name
[18:01:25.682]                             if (is.null(name)) 
[18:01:25.682]                               next
[18:01:25.682]                             if (!grepl(pattern, name)) 
[18:01:25.682]                               next
[18:01:25.682]                             invokeRestart(restart)
[18:01:25.682]                             muffled <- TRUE
[18:01:25.682]                             break
[18:01:25.682]                           }
[18:01:25.682]                         }
[18:01:25.682]                       }
[18:01:25.682]                       invisible(muffled)
[18:01:25.682]                     }
[18:01:25.682]                     muffleCondition(cond, pattern = "^muffle")
[18:01:25.682]                   }
[18:01:25.682]                 }
[18:01:25.682]                 else {
[18:01:25.682]                   if (TRUE) {
[18:01:25.682]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:25.682]                     {
[18:01:25.682]                       inherits <- base::inherits
[18:01:25.682]                       invokeRestart <- base::invokeRestart
[18:01:25.682]                       is.null <- base::is.null
[18:01:25.682]                       muffled <- FALSE
[18:01:25.682]                       if (inherits(cond, "message")) {
[18:01:25.682]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:25.682]                         if (muffled) 
[18:01:25.682]                           invokeRestart("muffleMessage")
[18:01:25.682]                       }
[18:01:25.682]                       else if (inherits(cond, "warning")) {
[18:01:25.682]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:25.682]                         if (muffled) 
[18:01:25.682]                           invokeRestart("muffleWarning")
[18:01:25.682]                       }
[18:01:25.682]                       else if (inherits(cond, "condition")) {
[18:01:25.682]                         if (!is.null(pattern)) {
[18:01:25.682]                           computeRestarts <- base::computeRestarts
[18:01:25.682]                           grepl <- base::grepl
[18:01:25.682]                           restarts <- computeRestarts(cond)
[18:01:25.682]                           for (restart in restarts) {
[18:01:25.682]                             name <- restart$name
[18:01:25.682]                             if (is.null(name)) 
[18:01:25.682]                               next
[18:01:25.682]                             if (!grepl(pattern, name)) 
[18:01:25.682]                               next
[18:01:25.682]                             invokeRestart(restart)
[18:01:25.682]                             muffled <- TRUE
[18:01:25.682]                             break
[18:01:25.682]                           }
[18:01:25.682]                         }
[18:01:25.682]                       }
[18:01:25.682]                       invisible(muffled)
[18:01:25.682]                     }
[18:01:25.682]                     muffleCondition(cond, pattern = "^muffle")
[18:01:25.682]                   }
[18:01:25.682]                 }
[18:01:25.682]             }
[18:01:25.682]         }))
[18:01:25.682]     }, error = function(ex) {
[18:01:25.682]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:25.682]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:25.682]                 ...future.rng), started = ...future.startTime, 
[18:01:25.682]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:25.682]             version = "1.8"), class = "FutureResult")
[18:01:25.682]     }, finally = {
[18:01:25.682]         if (!identical(...future.workdir, getwd())) 
[18:01:25.682]             setwd(...future.workdir)
[18:01:25.682]         {
[18:01:25.682]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:25.682]                 ...future.oldOptions$nwarnings <- NULL
[18:01:25.682]             }
[18:01:25.682]             base::options(...future.oldOptions)
[18:01:25.682]             if (.Platform$OS.type == "windows") {
[18:01:25.682]                 old_names <- names(...future.oldEnvVars)
[18:01:25.682]                 envs <- base::Sys.getenv()
[18:01:25.682]                 names <- names(envs)
[18:01:25.682]                 common <- intersect(names, old_names)
[18:01:25.682]                 added <- setdiff(names, old_names)
[18:01:25.682]                 removed <- setdiff(old_names, names)
[18:01:25.682]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:25.682]                   envs[common]]
[18:01:25.682]                 NAMES <- toupper(changed)
[18:01:25.682]                 args <- list()
[18:01:25.682]                 for (kk in seq_along(NAMES)) {
[18:01:25.682]                   name <- changed[[kk]]
[18:01:25.682]                   NAME <- NAMES[[kk]]
[18:01:25.682]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.682]                     next
[18:01:25.682]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:25.682]                 }
[18:01:25.682]                 NAMES <- toupper(added)
[18:01:25.682]                 for (kk in seq_along(NAMES)) {
[18:01:25.682]                   name <- added[[kk]]
[18:01:25.682]                   NAME <- NAMES[[kk]]
[18:01:25.682]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.682]                     next
[18:01:25.682]                   args[[name]] <- ""
[18:01:25.682]                 }
[18:01:25.682]                 NAMES <- toupper(removed)
[18:01:25.682]                 for (kk in seq_along(NAMES)) {
[18:01:25.682]                   name <- removed[[kk]]
[18:01:25.682]                   NAME <- NAMES[[kk]]
[18:01:25.682]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.682]                     next
[18:01:25.682]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:25.682]                 }
[18:01:25.682]                 if (length(args) > 0) 
[18:01:25.682]                   base::do.call(base::Sys.setenv, args = args)
[18:01:25.682]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:25.682]             }
[18:01:25.682]             else {
[18:01:25.682]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:25.682]             }
[18:01:25.682]             {
[18:01:25.682]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:25.682]                   0L) {
[18:01:25.682]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:25.682]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:25.682]                   base::options(opts)
[18:01:25.682]                 }
[18:01:25.682]                 {
[18:01:25.682]                   {
[18:01:25.682]                     NULL
[18:01:25.682]                     RNGkind("Mersenne-Twister")
[18:01:25.682]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:01:25.682]                       inherits = FALSE)
[18:01:25.682]                   }
[18:01:25.682]                   options(future.plan = NULL)
[18:01:25.682]                   if (is.na(NA_character_)) 
[18:01:25.682]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:25.682]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:25.682]                   future::plan(list(function (..., envir = parent.frame()) 
[18:01:25.682]                   {
[18:01:25.682]                     future <- SequentialFuture(..., envir = envir)
[18:01:25.682]                     if (!future$lazy) 
[18:01:25.682]                       future <- run(future)
[18:01:25.682]                     invisible(future)
[18:01:25.682]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:25.682]                 }
[18:01:25.682]             }
[18:01:25.682]         }
[18:01:25.682]     })
[18:01:25.682]     if (TRUE) {
[18:01:25.682]         base::sink(type = "output", split = FALSE)
[18:01:25.682]         if (TRUE) {
[18:01:25.682]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:25.682]         }
[18:01:25.682]         else {
[18:01:25.682]             ...future.result["stdout"] <- base::list(NULL)
[18:01:25.682]         }
[18:01:25.682]         base::close(...future.stdout)
[18:01:25.682]         ...future.stdout <- NULL
[18:01:25.682]     }
[18:01:25.682]     ...future.result$conditions <- ...future.conditions
[18:01:25.682]     ...future.result$finished <- base::Sys.time()
[18:01:25.682]     ...future.result
[18:01:25.682] }
[18:01:25.687] plan(): Setting new future strategy stack:
[18:01:25.687] List of future strategies:
[18:01:25.687] 1. sequential:
[18:01:25.687]    - args: function (..., envir = parent.frame())
[18:01:25.687]    - tweaked: FALSE
[18:01:25.687]    - call: NULL
[18:01:25.687] plan(): nbrOfWorkers() = 1
[18:01:25.689] plan(): Setting new future strategy stack:
[18:01:25.690] List of future strategies:
[18:01:25.690] 1. sequential:
[18:01:25.690]    - args: function (..., envir = parent.frame())
[18:01:25.690]    - tweaked: FALSE
[18:01:25.690]    - call: plan(strategy)
[18:01:25.690] plan(): nbrOfWorkers() = 1
[18:01:25.690] SequentialFuture started (and completed)
SequentialFuture:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'numeric'
Early signaling: FALSE
Owner process: fd4a23fd-3f1e-941b-f00a-64835db9cc52
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:01:25.693] getGlobalsAndPackages() ...
[18:01:25.693] Searching for globals...
[18:01:25.693] 
[18:01:25.693] Searching for globals ... DONE
[18:01:25.693] - globals: [0] <none>
[18:01:25.694] getGlobalsAndPackages() ... DONE
[18:01:25.694] run() for 'Future' ...
[18:01:25.694] - state: 'created'
[18:01:25.695] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:01:25.695] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:01:25.695] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:01:25.695]   - Field: 'label'
[18:01:25.695]   - Field: 'local'
[18:01:25.696]   - Field: 'owner'
[18:01:25.696]   - Field: 'envir'
[18:01:25.696]   - Field: 'packages'
[18:01:25.696]   - Field: 'gc'
[18:01:25.696]   - Field: 'conditions'
[18:01:25.697]   - Field: 'expr'
[18:01:25.697]   - Field: 'uuid'
[18:01:25.697]   - Field: 'seed'
[18:01:25.697]   - Field: 'version'
[18:01:25.697]   - Field: 'result'
[18:01:25.697]   - Field: 'asynchronous'
[18:01:25.698]   - Field: 'calls'
[18:01:25.698]   - Field: 'globals'
[18:01:25.698]   - Field: 'stdout'
[18:01:25.698]   - Field: 'earlySignal'
[18:01:25.698]   - Field: 'lazy'
[18:01:25.699]   - Field: 'state'
[18:01:25.699] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:01:25.699] - Launch lazy future ...
[18:01:25.699] Packages needed by the future expression (n = 0): <none>
[18:01:25.699] Packages needed by future strategies (n = 0): <none>
[18:01:25.700] {
[18:01:25.700]     {
[18:01:25.700]         {
[18:01:25.700]             ...future.startTime <- base::Sys.time()
[18:01:25.700]             {
[18:01:25.700]                 {
[18:01:25.700]                   {
[18:01:25.700]                     base::local({
[18:01:25.700]                       has_future <- base::requireNamespace("future", 
[18:01:25.700]                         quietly = TRUE)
[18:01:25.700]                       if (has_future) {
[18:01:25.700]                         ns <- base::getNamespace("future")
[18:01:25.700]                         version <- ns[[".package"]][["version"]]
[18:01:25.700]                         if (is.null(version)) 
[18:01:25.700]                           version <- utils::packageVersion("future")
[18:01:25.700]                       }
[18:01:25.700]                       else {
[18:01:25.700]                         version <- NULL
[18:01:25.700]                       }
[18:01:25.700]                       if (!has_future || version < "1.8.0") {
[18:01:25.700]                         info <- base::c(r_version = base::gsub("R version ", 
[18:01:25.700]                           "", base::R.version$version.string), 
[18:01:25.700]                           platform = base::sprintf("%s (%s-bit)", 
[18:01:25.700]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:25.700]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:25.700]                             "release", "version")], collapse = " "), 
[18:01:25.700]                           hostname = base::Sys.info()[["nodename"]])
[18:01:25.700]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:01:25.700]                           info)
[18:01:25.700]                         info <- base::paste(info, collapse = "; ")
[18:01:25.700]                         if (!has_future) {
[18:01:25.700]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:25.700]                             info)
[18:01:25.700]                         }
[18:01:25.700]                         else {
[18:01:25.700]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:25.700]                             info, version)
[18:01:25.700]                         }
[18:01:25.700]                         base::stop(msg)
[18:01:25.700]                       }
[18:01:25.700]                     })
[18:01:25.700]                   }
[18:01:25.700]                   options(future.plan = NULL)
[18:01:25.700]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:25.700]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:25.700]                 }
[18:01:25.700]                 ...future.workdir <- getwd()
[18:01:25.700]             }
[18:01:25.700]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:25.700]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:25.700]         }
[18:01:25.700]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:25.700]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:25.700]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:25.700]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:25.700]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:25.700]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:25.700]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:25.700]             base::names(...future.oldOptions))
[18:01:25.700]     }
[18:01:25.700]     if (FALSE) {
[18:01:25.700]     }
[18:01:25.700]     else {
[18:01:25.700]         if (TRUE) {
[18:01:25.700]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:25.700]                 open = "w")
[18:01:25.700]         }
[18:01:25.700]         else {
[18:01:25.700]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:25.700]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:25.700]         }
[18:01:25.700]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:25.700]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:25.700]             base::sink(type = "output", split = FALSE)
[18:01:25.700]             base::close(...future.stdout)
[18:01:25.700]         }, add = TRUE)
[18:01:25.700]     }
[18:01:25.700]     ...future.frame <- base::sys.nframe()
[18:01:25.700]     ...future.conditions <- base::list()
[18:01:25.700]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:25.700]     if (FALSE) {
[18:01:25.700]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:25.700]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:25.700]     }
[18:01:25.700]     ...future.result <- base::tryCatch({
[18:01:25.700]         base::withCallingHandlers({
[18:01:25.700]             ...future.value <- base::withVisible(base::local(42))
[18:01:25.700]             future::FutureResult(value = ...future.value$value, 
[18:01:25.700]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:25.700]                   ...future.rng), globalenv = if (FALSE) 
[18:01:25.700]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:25.700]                     ...future.globalenv.names))
[18:01:25.700]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:25.700]         }, condition = base::local({
[18:01:25.700]             c <- base::c
[18:01:25.700]             inherits <- base::inherits
[18:01:25.700]             invokeRestart <- base::invokeRestart
[18:01:25.700]             length <- base::length
[18:01:25.700]             list <- base::list
[18:01:25.700]             seq.int <- base::seq.int
[18:01:25.700]             signalCondition <- base::signalCondition
[18:01:25.700]             sys.calls <- base::sys.calls
[18:01:25.700]             `[[` <- base::`[[`
[18:01:25.700]             `+` <- base::`+`
[18:01:25.700]             `<<-` <- base::`<<-`
[18:01:25.700]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:25.700]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:25.700]                   3L)]
[18:01:25.700]             }
[18:01:25.700]             function(cond) {
[18:01:25.700]                 is_error <- inherits(cond, "error")
[18:01:25.700]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:25.700]                   NULL)
[18:01:25.700]                 if (is_error) {
[18:01:25.700]                   sessionInformation <- function() {
[18:01:25.700]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:25.700]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:25.700]                       search = base::search(), system = base::Sys.info())
[18:01:25.700]                   }
[18:01:25.700]                   ...future.conditions[[length(...future.conditions) + 
[18:01:25.700]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:25.700]                     cond$call), session = sessionInformation(), 
[18:01:25.700]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:25.700]                   signalCondition(cond)
[18:01:25.700]                 }
[18:01:25.700]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:25.700]                 "immediateCondition"))) {
[18:01:25.700]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:25.700]                   ...future.conditions[[length(...future.conditions) + 
[18:01:25.700]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:25.700]                   if (TRUE && !signal) {
[18:01:25.700]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:25.700]                     {
[18:01:25.700]                       inherits <- base::inherits
[18:01:25.700]                       invokeRestart <- base::invokeRestart
[18:01:25.700]                       is.null <- base::is.null
[18:01:25.700]                       muffled <- FALSE
[18:01:25.700]                       if (inherits(cond, "message")) {
[18:01:25.700]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:25.700]                         if (muffled) 
[18:01:25.700]                           invokeRestart("muffleMessage")
[18:01:25.700]                       }
[18:01:25.700]                       else if (inherits(cond, "warning")) {
[18:01:25.700]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:25.700]                         if (muffled) 
[18:01:25.700]                           invokeRestart("muffleWarning")
[18:01:25.700]                       }
[18:01:25.700]                       else if (inherits(cond, "condition")) {
[18:01:25.700]                         if (!is.null(pattern)) {
[18:01:25.700]                           computeRestarts <- base::computeRestarts
[18:01:25.700]                           grepl <- base::grepl
[18:01:25.700]                           restarts <- computeRestarts(cond)
[18:01:25.700]                           for (restart in restarts) {
[18:01:25.700]                             name <- restart$name
[18:01:25.700]                             if (is.null(name)) 
[18:01:25.700]                               next
[18:01:25.700]                             if (!grepl(pattern, name)) 
[18:01:25.700]                               next
[18:01:25.700]                             invokeRestart(restart)
[18:01:25.700]                             muffled <- TRUE
[18:01:25.700]                             break
[18:01:25.700]                           }
[18:01:25.700]                         }
[18:01:25.700]                       }
[18:01:25.700]                       invisible(muffled)
[18:01:25.700]                     }
[18:01:25.700]                     muffleCondition(cond, pattern = "^muffle")
[18:01:25.700]                   }
[18:01:25.700]                 }
[18:01:25.700]                 else {
[18:01:25.700]                   if (TRUE) {
[18:01:25.700]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:25.700]                     {
[18:01:25.700]                       inherits <- base::inherits
[18:01:25.700]                       invokeRestart <- base::invokeRestart
[18:01:25.700]                       is.null <- base::is.null
[18:01:25.700]                       muffled <- FALSE
[18:01:25.700]                       if (inherits(cond, "message")) {
[18:01:25.700]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:25.700]                         if (muffled) 
[18:01:25.700]                           invokeRestart("muffleMessage")
[18:01:25.700]                       }
[18:01:25.700]                       else if (inherits(cond, "warning")) {
[18:01:25.700]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:25.700]                         if (muffled) 
[18:01:25.700]                           invokeRestart("muffleWarning")
[18:01:25.700]                       }
[18:01:25.700]                       else if (inherits(cond, "condition")) {
[18:01:25.700]                         if (!is.null(pattern)) {
[18:01:25.700]                           computeRestarts <- base::computeRestarts
[18:01:25.700]                           grepl <- base::grepl
[18:01:25.700]                           restarts <- computeRestarts(cond)
[18:01:25.700]                           for (restart in restarts) {
[18:01:25.700]                             name <- restart$name
[18:01:25.700]                             if (is.null(name)) 
[18:01:25.700]                               next
[18:01:25.700]                             if (!grepl(pattern, name)) 
[18:01:25.700]                               next
[18:01:25.700]                             invokeRestart(restart)
[18:01:25.700]                             muffled <- TRUE
[18:01:25.700]                             break
[18:01:25.700]                           }
[18:01:25.700]                         }
[18:01:25.700]                       }
[18:01:25.700]                       invisible(muffled)
[18:01:25.700]                     }
[18:01:25.700]                     muffleCondition(cond, pattern = "^muffle")
[18:01:25.700]                   }
[18:01:25.700]                 }
[18:01:25.700]             }
[18:01:25.700]         }))
[18:01:25.700]     }, error = function(ex) {
[18:01:25.700]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:25.700]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:25.700]                 ...future.rng), started = ...future.startTime, 
[18:01:25.700]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:25.700]             version = "1.8"), class = "FutureResult")
[18:01:25.700]     }, finally = {
[18:01:25.700]         if (!identical(...future.workdir, getwd())) 
[18:01:25.700]             setwd(...future.workdir)
[18:01:25.700]         {
[18:01:25.700]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:25.700]                 ...future.oldOptions$nwarnings <- NULL
[18:01:25.700]             }
[18:01:25.700]             base::options(...future.oldOptions)
[18:01:25.700]             if (.Platform$OS.type == "windows") {
[18:01:25.700]                 old_names <- names(...future.oldEnvVars)
[18:01:25.700]                 envs <- base::Sys.getenv()
[18:01:25.700]                 names <- names(envs)
[18:01:25.700]                 common <- intersect(names, old_names)
[18:01:25.700]                 added <- setdiff(names, old_names)
[18:01:25.700]                 removed <- setdiff(old_names, names)
[18:01:25.700]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:25.700]                   envs[common]]
[18:01:25.700]                 NAMES <- toupper(changed)
[18:01:25.700]                 args <- list()
[18:01:25.700]                 for (kk in seq_along(NAMES)) {
[18:01:25.700]                   name <- changed[[kk]]
[18:01:25.700]                   NAME <- NAMES[[kk]]
[18:01:25.700]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.700]                     next
[18:01:25.700]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:25.700]                 }
[18:01:25.700]                 NAMES <- toupper(added)
[18:01:25.700]                 for (kk in seq_along(NAMES)) {
[18:01:25.700]                   name <- added[[kk]]
[18:01:25.700]                   NAME <- NAMES[[kk]]
[18:01:25.700]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.700]                     next
[18:01:25.700]                   args[[name]] <- ""
[18:01:25.700]                 }
[18:01:25.700]                 NAMES <- toupper(removed)
[18:01:25.700]                 for (kk in seq_along(NAMES)) {
[18:01:25.700]                   name <- removed[[kk]]
[18:01:25.700]                   NAME <- NAMES[[kk]]
[18:01:25.700]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.700]                     next
[18:01:25.700]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:25.700]                 }
[18:01:25.700]                 if (length(args) > 0) 
[18:01:25.700]                   base::do.call(base::Sys.setenv, args = args)
[18:01:25.700]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:25.700]             }
[18:01:25.700]             else {
[18:01:25.700]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:25.700]             }
[18:01:25.700]             {
[18:01:25.700]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:25.700]                   0L) {
[18:01:25.700]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:25.700]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:25.700]                   base::options(opts)
[18:01:25.700]                 }
[18:01:25.700]                 {
[18:01:25.700]                   {
[18:01:25.700]                     NULL
[18:01:25.700]                     RNGkind("Mersenne-Twister")
[18:01:25.700]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:01:25.700]                       inherits = FALSE)
[18:01:25.700]                   }
[18:01:25.700]                   options(future.plan = NULL)
[18:01:25.700]                   if (is.na(NA_character_)) 
[18:01:25.700]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:25.700]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:25.700]                   future::plan(list(function (..., envir = parent.frame()) 
[18:01:25.700]                   {
[18:01:25.700]                     future <- SequentialFuture(..., envir = envir)
[18:01:25.700]                     if (!future$lazy) 
[18:01:25.700]                       future <- run(future)
[18:01:25.700]                     invisible(future)
[18:01:25.700]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:25.700]                 }
[18:01:25.700]             }
[18:01:25.700]         }
[18:01:25.700]     })
[18:01:25.700]     if (TRUE) {
[18:01:25.700]         base::sink(type = "output", split = FALSE)
[18:01:25.700]         if (TRUE) {
[18:01:25.700]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:25.700]         }
[18:01:25.700]         else {
[18:01:25.700]             ...future.result["stdout"] <- base::list(NULL)
[18:01:25.700]         }
[18:01:25.700]         base::close(...future.stdout)
[18:01:25.700]         ...future.stdout <- NULL
[18:01:25.700]     }
[18:01:25.700]     ...future.result$conditions <- ...future.conditions
[18:01:25.700]     ...future.result$finished <- base::Sys.time()
[18:01:25.700]     ...future.result
[18:01:25.700] }
[18:01:25.704] plan(): Setting new future strategy stack:
[18:01:25.704] List of future strategies:
[18:01:25.704] 1. sequential:
[18:01:25.704]    - args: function (..., envir = parent.frame())
[18:01:25.704]    - tweaked: FALSE
[18:01:25.704]    - call: NULL
[18:01:25.705] plan(): nbrOfWorkers() = 1
[18:01:25.706] plan(): Setting new future strategy stack:
[18:01:25.706] List of future strategies:
[18:01:25.706] 1. sequential:
[18:01:25.706]    - args: function (..., envir = parent.frame())
[18:01:25.706]    - tweaked: FALSE
[18:01:25.706]    - call: plan(strategy)
[18:01:25.706] plan(): nbrOfWorkers() = 1
[18:01:25.707] SequentialFuture started (and completed)
[18:01:25.707] - Launch lazy future ... done
[18:01:25.707] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'numeric'
Early signaling: FALSE
Owner process: fd4a23fd-3f1e-941b-f00a-64835db9cc52
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:01:25.709] getGlobalsAndPackages() ...
[18:01:25.709] Searching for globals...
[18:01:25.711] - globals found: [1] '{'
[18:01:25.711] Searching for globals ... DONE
[18:01:25.711] Resolving globals: FALSE
[18:01:25.712] 
[18:01:25.712] 
[18:01:25.712] getGlobalsAndPackages() ... DONE
[18:01:25.712] run() for 'Future' ...
[18:01:25.713] - state: 'created'
[18:01:25.713] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:01:25.713] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:01:25.713] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:01:25.713]   - Field: 'label'
[18:01:25.714]   - Field: 'local'
[18:01:25.714]   - Field: 'owner'
[18:01:25.714]   - Field: 'envir'
[18:01:25.714]   - Field: 'packages'
[18:01:25.714]   - Field: 'gc'
[18:01:25.715]   - Field: 'conditions'
[18:01:25.715]   - Field: 'expr'
[18:01:25.715]   - Field: 'uuid'
[18:01:25.715]   - Field: 'seed'
[18:01:25.715]   - Field: 'version'
[18:01:25.715]   - Field: 'result'
[18:01:25.716]   - Field: 'asynchronous'
[18:01:25.716]   - Field: 'calls'
[18:01:25.716]   - Field: 'globals'
[18:01:25.716]   - Field: 'stdout'
[18:01:25.716]   - Field: 'earlySignal'
[18:01:25.717]   - Field: 'lazy'
[18:01:25.717]   - Field: 'state'
[18:01:25.717] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:01:25.717] - Launch lazy future ...
[18:01:25.717] Packages needed by the future expression (n = 0): <none>
[18:01:25.717] Packages needed by future strategies (n = 0): <none>
[18:01:25.718] {
[18:01:25.718]     {
[18:01:25.718]         {
[18:01:25.718]             ...future.startTime <- base::Sys.time()
[18:01:25.718]             {
[18:01:25.718]                 {
[18:01:25.718]                   {
[18:01:25.718]                     base::local({
[18:01:25.718]                       has_future <- base::requireNamespace("future", 
[18:01:25.718]                         quietly = TRUE)
[18:01:25.718]                       if (has_future) {
[18:01:25.718]                         ns <- base::getNamespace("future")
[18:01:25.718]                         version <- ns[[".package"]][["version"]]
[18:01:25.718]                         if (is.null(version)) 
[18:01:25.718]                           version <- utils::packageVersion("future")
[18:01:25.718]                       }
[18:01:25.718]                       else {
[18:01:25.718]                         version <- NULL
[18:01:25.718]                       }
[18:01:25.718]                       if (!has_future || version < "1.8.0") {
[18:01:25.718]                         info <- base::c(r_version = base::gsub("R version ", 
[18:01:25.718]                           "", base::R.version$version.string), 
[18:01:25.718]                           platform = base::sprintf("%s (%s-bit)", 
[18:01:25.718]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:25.718]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:25.718]                             "release", "version")], collapse = " "), 
[18:01:25.718]                           hostname = base::Sys.info()[["nodename"]])
[18:01:25.718]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:01:25.718]                           info)
[18:01:25.718]                         info <- base::paste(info, collapse = "; ")
[18:01:25.718]                         if (!has_future) {
[18:01:25.718]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:25.718]                             info)
[18:01:25.718]                         }
[18:01:25.718]                         else {
[18:01:25.718]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:25.718]                             info, version)
[18:01:25.718]                         }
[18:01:25.718]                         base::stop(msg)
[18:01:25.718]                       }
[18:01:25.718]                     })
[18:01:25.718]                   }
[18:01:25.718]                   options(future.plan = NULL)
[18:01:25.718]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:25.718]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:25.718]                 }
[18:01:25.718]                 ...future.workdir <- getwd()
[18:01:25.718]             }
[18:01:25.718]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:25.718]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:25.718]         }
[18:01:25.718]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:25.718]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:25.718]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:25.718]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:25.718]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:25.718]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:25.718]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:25.718]             base::names(...future.oldOptions))
[18:01:25.718]     }
[18:01:25.718]     if (FALSE) {
[18:01:25.718]     }
[18:01:25.718]     else {
[18:01:25.718]         if (TRUE) {
[18:01:25.718]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:25.718]                 open = "w")
[18:01:25.718]         }
[18:01:25.718]         else {
[18:01:25.718]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:25.718]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:25.718]         }
[18:01:25.718]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:25.718]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:25.718]             base::sink(type = "output", split = FALSE)
[18:01:25.718]             base::close(...future.stdout)
[18:01:25.718]         }, add = TRUE)
[18:01:25.718]     }
[18:01:25.718]     ...future.frame <- base::sys.nframe()
[18:01:25.718]     ...future.conditions <- base::list()
[18:01:25.718]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:25.718]     if (FALSE) {
[18:01:25.718]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:25.718]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:25.718]     }
[18:01:25.718]     ...future.result <- base::tryCatch({
[18:01:25.718]         base::withCallingHandlers({
[18:01:25.718]             ...future.value <- base::withVisible(base::local({
[18:01:25.718]                 42
[18:01:25.718]             }))
[18:01:25.718]             future::FutureResult(value = ...future.value$value, 
[18:01:25.718]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:25.718]                   ...future.rng), globalenv = if (FALSE) 
[18:01:25.718]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:25.718]                     ...future.globalenv.names))
[18:01:25.718]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:25.718]         }, condition = base::local({
[18:01:25.718]             c <- base::c
[18:01:25.718]             inherits <- base::inherits
[18:01:25.718]             invokeRestart <- base::invokeRestart
[18:01:25.718]             length <- base::length
[18:01:25.718]             list <- base::list
[18:01:25.718]             seq.int <- base::seq.int
[18:01:25.718]             signalCondition <- base::signalCondition
[18:01:25.718]             sys.calls <- base::sys.calls
[18:01:25.718]             `[[` <- base::`[[`
[18:01:25.718]             `+` <- base::`+`
[18:01:25.718]             `<<-` <- base::`<<-`
[18:01:25.718]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:25.718]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:25.718]                   3L)]
[18:01:25.718]             }
[18:01:25.718]             function(cond) {
[18:01:25.718]                 is_error <- inherits(cond, "error")
[18:01:25.718]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:25.718]                   NULL)
[18:01:25.718]                 if (is_error) {
[18:01:25.718]                   sessionInformation <- function() {
[18:01:25.718]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:25.718]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:25.718]                       search = base::search(), system = base::Sys.info())
[18:01:25.718]                   }
[18:01:25.718]                   ...future.conditions[[length(...future.conditions) + 
[18:01:25.718]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:25.718]                     cond$call), session = sessionInformation(), 
[18:01:25.718]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:25.718]                   signalCondition(cond)
[18:01:25.718]                 }
[18:01:25.718]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:25.718]                 "immediateCondition"))) {
[18:01:25.718]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:25.718]                   ...future.conditions[[length(...future.conditions) + 
[18:01:25.718]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:25.718]                   if (TRUE && !signal) {
[18:01:25.718]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:25.718]                     {
[18:01:25.718]                       inherits <- base::inherits
[18:01:25.718]                       invokeRestart <- base::invokeRestart
[18:01:25.718]                       is.null <- base::is.null
[18:01:25.718]                       muffled <- FALSE
[18:01:25.718]                       if (inherits(cond, "message")) {
[18:01:25.718]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:25.718]                         if (muffled) 
[18:01:25.718]                           invokeRestart("muffleMessage")
[18:01:25.718]                       }
[18:01:25.718]                       else if (inherits(cond, "warning")) {
[18:01:25.718]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:25.718]                         if (muffled) 
[18:01:25.718]                           invokeRestart("muffleWarning")
[18:01:25.718]                       }
[18:01:25.718]                       else if (inherits(cond, "condition")) {
[18:01:25.718]                         if (!is.null(pattern)) {
[18:01:25.718]                           computeRestarts <- base::computeRestarts
[18:01:25.718]                           grepl <- base::grepl
[18:01:25.718]                           restarts <- computeRestarts(cond)
[18:01:25.718]                           for (restart in restarts) {
[18:01:25.718]                             name <- restart$name
[18:01:25.718]                             if (is.null(name)) 
[18:01:25.718]                               next
[18:01:25.718]                             if (!grepl(pattern, name)) 
[18:01:25.718]                               next
[18:01:25.718]                             invokeRestart(restart)
[18:01:25.718]                             muffled <- TRUE
[18:01:25.718]                             break
[18:01:25.718]                           }
[18:01:25.718]                         }
[18:01:25.718]                       }
[18:01:25.718]                       invisible(muffled)
[18:01:25.718]                     }
[18:01:25.718]                     muffleCondition(cond, pattern = "^muffle")
[18:01:25.718]                   }
[18:01:25.718]                 }
[18:01:25.718]                 else {
[18:01:25.718]                   if (TRUE) {
[18:01:25.718]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:25.718]                     {
[18:01:25.718]                       inherits <- base::inherits
[18:01:25.718]                       invokeRestart <- base::invokeRestart
[18:01:25.718]                       is.null <- base::is.null
[18:01:25.718]                       muffled <- FALSE
[18:01:25.718]                       if (inherits(cond, "message")) {
[18:01:25.718]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:25.718]                         if (muffled) 
[18:01:25.718]                           invokeRestart("muffleMessage")
[18:01:25.718]                       }
[18:01:25.718]                       else if (inherits(cond, "warning")) {
[18:01:25.718]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:25.718]                         if (muffled) 
[18:01:25.718]                           invokeRestart("muffleWarning")
[18:01:25.718]                       }
[18:01:25.718]                       else if (inherits(cond, "condition")) {
[18:01:25.718]                         if (!is.null(pattern)) {
[18:01:25.718]                           computeRestarts <- base::computeRestarts
[18:01:25.718]                           grepl <- base::grepl
[18:01:25.718]                           restarts <- computeRestarts(cond)
[18:01:25.718]                           for (restart in restarts) {
[18:01:25.718]                             name <- restart$name
[18:01:25.718]                             if (is.null(name)) 
[18:01:25.718]                               next
[18:01:25.718]                             if (!grepl(pattern, name)) 
[18:01:25.718]                               next
[18:01:25.718]                             invokeRestart(restart)
[18:01:25.718]                             muffled <- TRUE
[18:01:25.718]                             break
[18:01:25.718]                           }
[18:01:25.718]                         }
[18:01:25.718]                       }
[18:01:25.718]                       invisible(muffled)
[18:01:25.718]                     }
[18:01:25.718]                     muffleCondition(cond, pattern = "^muffle")
[18:01:25.718]                   }
[18:01:25.718]                 }
[18:01:25.718]             }
[18:01:25.718]         }))
[18:01:25.718]     }, error = function(ex) {
[18:01:25.718]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:25.718]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:25.718]                 ...future.rng), started = ...future.startTime, 
[18:01:25.718]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:25.718]             version = "1.8"), class = "FutureResult")
[18:01:25.718]     }, finally = {
[18:01:25.718]         if (!identical(...future.workdir, getwd())) 
[18:01:25.718]             setwd(...future.workdir)
[18:01:25.718]         {
[18:01:25.718]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:25.718]                 ...future.oldOptions$nwarnings <- NULL
[18:01:25.718]             }
[18:01:25.718]             base::options(...future.oldOptions)
[18:01:25.718]             if (.Platform$OS.type == "windows") {
[18:01:25.718]                 old_names <- names(...future.oldEnvVars)
[18:01:25.718]                 envs <- base::Sys.getenv()
[18:01:25.718]                 names <- names(envs)
[18:01:25.718]                 common <- intersect(names, old_names)
[18:01:25.718]                 added <- setdiff(names, old_names)
[18:01:25.718]                 removed <- setdiff(old_names, names)
[18:01:25.718]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:25.718]                   envs[common]]
[18:01:25.718]                 NAMES <- toupper(changed)
[18:01:25.718]                 args <- list()
[18:01:25.718]                 for (kk in seq_along(NAMES)) {
[18:01:25.718]                   name <- changed[[kk]]
[18:01:25.718]                   NAME <- NAMES[[kk]]
[18:01:25.718]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.718]                     next
[18:01:25.718]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:25.718]                 }
[18:01:25.718]                 NAMES <- toupper(added)
[18:01:25.718]                 for (kk in seq_along(NAMES)) {
[18:01:25.718]                   name <- added[[kk]]
[18:01:25.718]                   NAME <- NAMES[[kk]]
[18:01:25.718]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.718]                     next
[18:01:25.718]                   args[[name]] <- ""
[18:01:25.718]                 }
[18:01:25.718]                 NAMES <- toupper(removed)
[18:01:25.718]                 for (kk in seq_along(NAMES)) {
[18:01:25.718]                   name <- removed[[kk]]
[18:01:25.718]                   NAME <- NAMES[[kk]]
[18:01:25.718]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.718]                     next
[18:01:25.718]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:25.718]                 }
[18:01:25.718]                 if (length(args) > 0) 
[18:01:25.718]                   base::do.call(base::Sys.setenv, args = args)
[18:01:25.718]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:25.718]             }
[18:01:25.718]             else {
[18:01:25.718]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:25.718]             }
[18:01:25.718]             {
[18:01:25.718]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:25.718]                   0L) {
[18:01:25.718]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:25.718]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:25.718]                   base::options(opts)
[18:01:25.718]                 }
[18:01:25.718]                 {
[18:01:25.718]                   {
[18:01:25.718]                     NULL
[18:01:25.718]                     RNGkind("Mersenne-Twister")
[18:01:25.718]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:01:25.718]                       inherits = FALSE)
[18:01:25.718]                   }
[18:01:25.718]                   options(future.plan = NULL)
[18:01:25.718]                   if (is.na(NA_character_)) 
[18:01:25.718]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:25.718]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:25.718]                   future::plan(list(function (..., envir = parent.frame()) 
[18:01:25.718]                   {
[18:01:25.718]                     future <- SequentialFuture(..., envir = envir)
[18:01:25.718]                     if (!future$lazy) 
[18:01:25.718]                       future <- run(future)
[18:01:25.718]                     invisible(future)
[18:01:25.718]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:25.718]                 }
[18:01:25.718]             }
[18:01:25.718]         }
[18:01:25.718]     })
[18:01:25.718]     if (TRUE) {
[18:01:25.718]         base::sink(type = "output", split = FALSE)
[18:01:25.718]         if (TRUE) {
[18:01:25.718]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:25.718]         }
[18:01:25.718]         else {
[18:01:25.718]             ...future.result["stdout"] <- base::list(NULL)
[18:01:25.718]         }
[18:01:25.718]         base::close(...future.stdout)
[18:01:25.718]         ...future.stdout <- NULL
[18:01:25.718]     }
[18:01:25.718]     ...future.result$conditions <- ...future.conditions
[18:01:25.718]     ...future.result$finished <- base::Sys.time()
[18:01:25.718]     ...future.result
[18:01:25.718] }
[18:01:25.722] plan(): Setting new future strategy stack:
[18:01:25.722] List of future strategies:
[18:01:25.722] 1. sequential:
[18:01:25.722]    - args: function (..., envir = parent.frame())
[18:01:25.722]    - tweaked: FALSE
[18:01:25.722]    - call: NULL
[18:01:25.723] plan(): nbrOfWorkers() = 1
[18:01:25.726] plan(): Setting new future strategy stack:
[18:01:25.726] List of future strategies:
[18:01:25.726] 1. sequential:
[18:01:25.726]    - args: function (..., envir = parent.frame())
[18:01:25.726]    - tweaked: FALSE
[18:01:25.726]    - call: plan(strategy)
[18:01:25.726] plan(): nbrOfWorkers() = 1
[18:01:25.727] SequentialFuture started (and completed)
[18:01:25.727] - Launch lazy future ... done
[18:01:25.727] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: '<none>'
Expression:
{
    42
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'numeric'
Early signaling: FALSE
Owner process: fd4a23fd-3f1e-941b-f00a-64835db9cc52
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:01:25.728] getGlobalsAndPackages() ...
[18:01:25.728] Searching for globals...
[18:01:25.728] 
[18:01:25.729] Searching for globals ... DONE
[18:01:25.729] - globals: [0] <none>
[18:01:25.729] getGlobalsAndPackages() ... DONE
[18:01:25.729] Packages needed by the future expression (n = 0): <none>
[18:01:25.729] Packages needed by future strategies (n = 0): <none>
[18:01:25.730] {
[18:01:25.730]     {
[18:01:25.730]         {
[18:01:25.730]             ...future.startTime <- base::Sys.time()
[18:01:25.730]             {
[18:01:25.730]                 {
[18:01:25.730]                   {
[18:01:25.730]                     base::local({
[18:01:25.730]                       has_future <- base::requireNamespace("future", 
[18:01:25.730]                         quietly = TRUE)
[18:01:25.730]                       if (has_future) {
[18:01:25.730]                         ns <- base::getNamespace("future")
[18:01:25.730]                         version <- ns[[".package"]][["version"]]
[18:01:25.730]                         if (is.null(version)) 
[18:01:25.730]                           version <- utils::packageVersion("future")
[18:01:25.730]                       }
[18:01:25.730]                       else {
[18:01:25.730]                         version <- NULL
[18:01:25.730]                       }
[18:01:25.730]                       if (!has_future || version < "1.8.0") {
[18:01:25.730]                         info <- base::c(r_version = base::gsub("R version ", 
[18:01:25.730]                           "", base::R.version$version.string), 
[18:01:25.730]                           platform = base::sprintf("%s (%s-bit)", 
[18:01:25.730]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:25.730]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:25.730]                             "release", "version")], collapse = " "), 
[18:01:25.730]                           hostname = base::Sys.info()[["nodename"]])
[18:01:25.730]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:01:25.730]                           info)
[18:01:25.730]                         info <- base::paste(info, collapse = "; ")
[18:01:25.730]                         if (!has_future) {
[18:01:25.730]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:25.730]                             info)
[18:01:25.730]                         }
[18:01:25.730]                         else {
[18:01:25.730]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:25.730]                             info, version)
[18:01:25.730]                         }
[18:01:25.730]                         base::stop(msg)
[18:01:25.730]                       }
[18:01:25.730]                     })
[18:01:25.730]                   }
[18:01:25.730]                   options(future.plan = NULL)
[18:01:25.730]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:25.730]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:25.730]                 }
[18:01:25.730]                 ...future.workdir <- getwd()
[18:01:25.730]             }
[18:01:25.730]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:25.730]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:25.730]         }
[18:01:25.730]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:25.730]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:25.730]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:25.730]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:25.730]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:25.730]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:25.730]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:25.730]             base::names(...future.oldOptions))
[18:01:25.730]     }
[18:01:25.730]     if (FALSE) {
[18:01:25.730]     }
[18:01:25.730]     else {
[18:01:25.730]         if (TRUE) {
[18:01:25.730]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:25.730]                 open = "w")
[18:01:25.730]         }
[18:01:25.730]         else {
[18:01:25.730]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:25.730]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:25.730]         }
[18:01:25.730]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:25.730]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:25.730]             base::sink(type = "output", split = FALSE)
[18:01:25.730]             base::close(...future.stdout)
[18:01:25.730]         }, add = TRUE)
[18:01:25.730]     }
[18:01:25.730]     ...future.frame <- base::sys.nframe()
[18:01:25.730]     ...future.conditions <- base::list()
[18:01:25.730]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:25.730]     if (FALSE) {
[18:01:25.730]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:25.730]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:25.730]     }
[18:01:25.730]     ...future.result <- base::tryCatch({
[18:01:25.730]         base::withCallingHandlers({
[18:01:25.730]             ...future.value <- base::withVisible(base::local(42))
[18:01:25.730]             future::FutureResult(value = ...future.value$value, 
[18:01:25.730]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:25.730]                   ...future.rng), globalenv = if (FALSE) 
[18:01:25.730]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:25.730]                     ...future.globalenv.names))
[18:01:25.730]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:25.730]         }, condition = base::local({
[18:01:25.730]             c <- base::c
[18:01:25.730]             inherits <- base::inherits
[18:01:25.730]             invokeRestart <- base::invokeRestart
[18:01:25.730]             length <- base::length
[18:01:25.730]             list <- base::list
[18:01:25.730]             seq.int <- base::seq.int
[18:01:25.730]             signalCondition <- base::signalCondition
[18:01:25.730]             sys.calls <- base::sys.calls
[18:01:25.730]             `[[` <- base::`[[`
[18:01:25.730]             `+` <- base::`+`
[18:01:25.730]             `<<-` <- base::`<<-`
[18:01:25.730]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:25.730]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:25.730]                   3L)]
[18:01:25.730]             }
[18:01:25.730]             function(cond) {
[18:01:25.730]                 is_error <- inherits(cond, "error")
[18:01:25.730]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:25.730]                   NULL)
[18:01:25.730]                 if (is_error) {
[18:01:25.730]                   sessionInformation <- function() {
[18:01:25.730]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:25.730]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:25.730]                       search = base::search(), system = base::Sys.info())
[18:01:25.730]                   }
[18:01:25.730]                   ...future.conditions[[length(...future.conditions) + 
[18:01:25.730]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:25.730]                     cond$call), session = sessionInformation(), 
[18:01:25.730]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:25.730]                   signalCondition(cond)
[18:01:25.730]                 }
[18:01:25.730]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:25.730]                 "immediateCondition"))) {
[18:01:25.730]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:25.730]                   ...future.conditions[[length(...future.conditions) + 
[18:01:25.730]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:25.730]                   if (TRUE && !signal) {
[18:01:25.730]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:25.730]                     {
[18:01:25.730]                       inherits <- base::inherits
[18:01:25.730]                       invokeRestart <- base::invokeRestart
[18:01:25.730]                       is.null <- base::is.null
[18:01:25.730]                       muffled <- FALSE
[18:01:25.730]                       if (inherits(cond, "message")) {
[18:01:25.730]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:25.730]                         if (muffled) 
[18:01:25.730]                           invokeRestart("muffleMessage")
[18:01:25.730]                       }
[18:01:25.730]                       else if (inherits(cond, "warning")) {
[18:01:25.730]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:25.730]                         if (muffled) 
[18:01:25.730]                           invokeRestart("muffleWarning")
[18:01:25.730]                       }
[18:01:25.730]                       else if (inherits(cond, "condition")) {
[18:01:25.730]                         if (!is.null(pattern)) {
[18:01:25.730]                           computeRestarts <- base::computeRestarts
[18:01:25.730]                           grepl <- base::grepl
[18:01:25.730]                           restarts <- computeRestarts(cond)
[18:01:25.730]                           for (restart in restarts) {
[18:01:25.730]                             name <- restart$name
[18:01:25.730]                             if (is.null(name)) 
[18:01:25.730]                               next
[18:01:25.730]                             if (!grepl(pattern, name)) 
[18:01:25.730]                               next
[18:01:25.730]                             invokeRestart(restart)
[18:01:25.730]                             muffled <- TRUE
[18:01:25.730]                             break
[18:01:25.730]                           }
[18:01:25.730]                         }
[18:01:25.730]                       }
[18:01:25.730]                       invisible(muffled)
[18:01:25.730]                     }
[18:01:25.730]                     muffleCondition(cond, pattern = "^muffle")
[18:01:25.730]                   }
[18:01:25.730]                 }
[18:01:25.730]                 else {
[18:01:25.730]                   if (TRUE) {
[18:01:25.730]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:25.730]                     {
[18:01:25.730]                       inherits <- base::inherits
[18:01:25.730]                       invokeRestart <- base::invokeRestart
[18:01:25.730]                       is.null <- base::is.null
[18:01:25.730]                       muffled <- FALSE
[18:01:25.730]                       if (inherits(cond, "message")) {
[18:01:25.730]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:25.730]                         if (muffled) 
[18:01:25.730]                           invokeRestart("muffleMessage")
[18:01:25.730]                       }
[18:01:25.730]                       else if (inherits(cond, "warning")) {
[18:01:25.730]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:25.730]                         if (muffled) 
[18:01:25.730]                           invokeRestart("muffleWarning")
[18:01:25.730]                       }
[18:01:25.730]                       else if (inherits(cond, "condition")) {
[18:01:25.730]                         if (!is.null(pattern)) {
[18:01:25.730]                           computeRestarts <- base::computeRestarts
[18:01:25.730]                           grepl <- base::grepl
[18:01:25.730]                           restarts <- computeRestarts(cond)
[18:01:25.730]                           for (restart in restarts) {
[18:01:25.730]                             name <- restart$name
[18:01:25.730]                             if (is.null(name)) 
[18:01:25.730]                               next
[18:01:25.730]                             if (!grepl(pattern, name)) 
[18:01:25.730]                               next
[18:01:25.730]                             invokeRestart(restart)
[18:01:25.730]                             muffled <- TRUE
[18:01:25.730]                             break
[18:01:25.730]                           }
[18:01:25.730]                         }
[18:01:25.730]                       }
[18:01:25.730]                       invisible(muffled)
[18:01:25.730]                     }
[18:01:25.730]                     muffleCondition(cond, pattern = "^muffle")
[18:01:25.730]                   }
[18:01:25.730]                 }
[18:01:25.730]             }
[18:01:25.730]         }))
[18:01:25.730]     }, error = function(ex) {
[18:01:25.730]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:25.730]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:25.730]                 ...future.rng), started = ...future.startTime, 
[18:01:25.730]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:25.730]             version = "1.8"), class = "FutureResult")
[18:01:25.730]     }, finally = {
[18:01:25.730]         if (!identical(...future.workdir, getwd())) 
[18:01:25.730]             setwd(...future.workdir)
[18:01:25.730]         {
[18:01:25.730]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:25.730]                 ...future.oldOptions$nwarnings <- NULL
[18:01:25.730]             }
[18:01:25.730]             base::options(...future.oldOptions)
[18:01:25.730]             if (.Platform$OS.type == "windows") {
[18:01:25.730]                 old_names <- names(...future.oldEnvVars)
[18:01:25.730]                 envs <- base::Sys.getenv()
[18:01:25.730]                 names <- names(envs)
[18:01:25.730]                 common <- intersect(names, old_names)
[18:01:25.730]                 added <- setdiff(names, old_names)
[18:01:25.730]                 removed <- setdiff(old_names, names)
[18:01:25.730]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:25.730]                   envs[common]]
[18:01:25.730]                 NAMES <- toupper(changed)
[18:01:25.730]                 args <- list()
[18:01:25.730]                 for (kk in seq_along(NAMES)) {
[18:01:25.730]                   name <- changed[[kk]]
[18:01:25.730]                   NAME <- NAMES[[kk]]
[18:01:25.730]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.730]                     next
[18:01:25.730]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:25.730]                 }
[18:01:25.730]                 NAMES <- toupper(added)
[18:01:25.730]                 for (kk in seq_along(NAMES)) {
[18:01:25.730]                   name <- added[[kk]]
[18:01:25.730]                   NAME <- NAMES[[kk]]
[18:01:25.730]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.730]                     next
[18:01:25.730]                   args[[name]] <- ""
[18:01:25.730]                 }
[18:01:25.730]                 NAMES <- toupper(removed)
[18:01:25.730]                 for (kk in seq_along(NAMES)) {
[18:01:25.730]                   name <- removed[[kk]]
[18:01:25.730]                   NAME <- NAMES[[kk]]
[18:01:25.730]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.730]                     next
[18:01:25.730]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:25.730]                 }
[18:01:25.730]                 if (length(args) > 0) 
[18:01:25.730]                   base::do.call(base::Sys.setenv, args = args)
[18:01:25.730]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:25.730]             }
[18:01:25.730]             else {
[18:01:25.730]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:25.730]             }
[18:01:25.730]             {
[18:01:25.730]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:25.730]                   0L) {
[18:01:25.730]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:25.730]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:25.730]                   base::options(opts)
[18:01:25.730]                 }
[18:01:25.730]                 {
[18:01:25.730]                   {
[18:01:25.730]                     NULL
[18:01:25.730]                     RNGkind("Mersenne-Twister")
[18:01:25.730]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:01:25.730]                       inherits = FALSE)
[18:01:25.730]                   }
[18:01:25.730]                   options(future.plan = NULL)
[18:01:25.730]                   if (is.na(NA_character_)) 
[18:01:25.730]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:25.730]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:25.730]                   future::plan(list(function (..., envir = parent.frame()) 
[18:01:25.730]                   {
[18:01:25.730]                     future <- SequentialFuture(..., envir = envir)
[18:01:25.730]                     if (!future$lazy) 
[18:01:25.730]                       future <- run(future)
[18:01:25.730]                     invisible(future)
[18:01:25.730]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:25.730]                 }
[18:01:25.730]             }
[18:01:25.730]         }
[18:01:25.730]     })
[18:01:25.730]     if (TRUE) {
[18:01:25.730]         base::sink(type = "output", split = FALSE)
[18:01:25.730]         if (TRUE) {
[18:01:25.730]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:25.730]         }
[18:01:25.730]         else {
[18:01:25.730]             ...future.result["stdout"] <- base::list(NULL)
[18:01:25.730]         }
[18:01:25.730]         base::close(...future.stdout)
[18:01:25.730]         ...future.stdout <- NULL
[18:01:25.730]     }
[18:01:25.730]     ...future.result$conditions <- ...future.conditions
[18:01:25.730]     ...future.result$finished <- base::Sys.time()
[18:01:25.730]     ...future.result
[18:01:25.730] }
[18:01:25.734] plan(): Setting new future strategy stack:
[18:01:25.734] List of future strategies:
[18:01:25.734] 1. sequential:
[18:01:25.734]    - args: function (..., envir = parent.frame())
[18:01:25.734]    - tweaked: FALSE
[18:01:25.734]    - call: NULL
[18:01:25.735] plan(): nbrOfWorkers() = 1
[18:01:25.736] plan(): Setting new future strategy stack:
[18:01:25.736] List of future strategies:
[18:01:25.736] 1. sequential:
[18:01:25.736]    - args: function (..., envir = parent.frame())
[18:01:25.736]    - tweaked: FALSE
[18:01:25.736]    - call: plan(strategy)
[18:01:25.736] plan(): nbrOfWorkers() = 1
[18:01:25.737] SequentialFuture started (and completed)
SequentialFuture:
Label: 'strategy = sequential'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'numeric'
Early signaling: FALSE
Owner process: fd4a23fd-3f1e-941b-f00a-64835db9cc52
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:01:25.737] getGlobalsAndPackages() ...
[18:01:25.737] Searching for globals...
[18:01:25.738] 
[18:01:25.738] Searching for globals ... DONE
[18:01:25.738] - globals: [0] <none>
[18:01:25.738] getGlobalsAndPackages() ... DONE
[18:01:25.739] run() for 'Future' ...
[18:01:25.739] - state: 'created'
[18:01:25.739] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:01:25.739] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:01:25.740] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:01:25.740]   - Field: 'label'
[18:01:25.740]   - Field: 'local'
[18:01:25.740]   - Field: 'owner'
[18:01:25.740]   - Field: 'envir'
[18:01:25.740]   - Field: 'packages'
[18:01:25.741]   - Field: 'gc'
[18:01:25.741]   - Field: 'conditions'
[18:01:25.741]   - Field: 'expr'
[18:01:25.741]   - Field: 'uuid'
[18:01:25.741]   - Field: 'seed'
[18:01:25.742]   - Field: 'version'
[18:01:25.742]   - Field: 'result'
[18:01:25.742]   - Field: 'asynchronous'
[18:01:25.742]   - Field: 'calls'
[18:01:25.742]   - Field: 'globals'
[18:01:25.742]   - Field: 'stdout'
[18:01:25.743]   - Field: 'earlySignal'
[18:01:25.743]   - Field: 'lazy'
[18:01:25.743]   - Field: 'state'
[18:01:25.743] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:01:25.743] - Launch lazy future ...
[18:01:25.744] Packages needed by the future expression (n = 0): <none>
[18:01:25.744] Packages needed by future strategies (n = 0): <none>
[18:01:25.744] {
[18:01:25.744]     {
[18:01:25.744]         {
[18:01:25.744]             ...future.startTime <- base::Sys.time()
[18:01:25.744]             {
[18:01:25.744]                 {
[18:01:25.744]                   {
[18:01:25.744]                     base::local({
[18:01:25.744]                       has_future <- base::requireNamespace("future", 
[18:01:25.744]                         quietly = TRUE)
[18:01:25.744]                       if (has_future) {
[18:01:25.744]                         ns <- base::getNamespace("future")
[18:01:25.744]                         version <- ns[[".package"]][["version"]]
[18:01:25.744]                         if (is.null(version)) 
[18:01:25.744]                           version <- utils::packageVersion("future")
[18:01:25.744]                       }
[18:01:25.744]                       else {
[18:01:25.744]                         version <- NULL
[18:01:25.744]                       }
[18:01:25.744]                       if (!has_future || version < "1.8.0") {
[18:01:25.744]                         info <- base::c(r_version = base::gsub("R version ", 
[18:01:25.744]                           "", base::R.version$version.string), 
[18:01:25.744]                           platform = base::sprintf("%s (%s-bit)", 
[18:01:25.744]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:25.744]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:25.744]                             "release", "version")], collapse = " "), 
[18:01:25.744]                           hostname = base::Sys.info()[["nodename"]])
[18:01:25.744]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:01:25.744]                           info)
[18:01:25.744]                         info <- base::paste(info, collapse = "; ")
[18:01:25.744]                         if (!has_future) {
[18:01:25.744]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:25.744]                             info)
[18:01:25.744]                         }
[18:01:25.744]                         else {
[18:01:25.744]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:25.744]                             info, version)
[18:01:25.744]                         }
[18:01:25.744]                         base::stop(msg)
[18:01:25.744]                       }
[18:01:25.744]                     })
[18:01:25.744]                   }
[18:01:25.744]                   options(future.plan = NULL)
[18:01:25.744]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:25.744]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:25.744]                 }
[18:01:25.744]                 ...future.workdir <- getwd()
[18:01:25.744]             }
[18:01:25.744]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:25.744]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:25.744]         }
[18:01:25.744]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:25.744]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:25.744]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:25.744]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:25.744]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:25.744]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:25.744]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:25.744]             base::names(...future.oldOptions))
[18:01:25.744]     }
[18:01:25.744]     if (FALSE) {
[18:01:25.744]     }
[18:01:25.744]     else {
[18:01:25.744]         if (TRUE) {
[18:01:25.744]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:25.744]                 open = "w")
[18:01:25.744]         }
[18:01:25.744]         else {
[18:01:25.744]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:25.744]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:25.744]         }
[18:01:25.744]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:25.744]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:25.744]             base::sink(type = "output", split = FALSE)
[18:01:25.744]             base::close(...future.stdout)
[18:01:25.744]         }, add = TRUE)
[18:01:25.744]     }
[18:01:25.744]     ...future.frame <- base::sys.nframe()
[18:01:25.744]     ...future.conditions <- base::list()
[18:01:25.744]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:25.744]     if (FALSE) {
[18:01:25.744]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:25.744]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:25.744]     }
[18:01:25.744]     ...future.result <- base::tryCatch({
[18:01:25.744]         base::withCallingHandlers({
[18:01:25.744]             ...future.value <- base::withVisible(base::local(42))
[18:01:25.744]             future::FutureResult(value = ...future.value$value, 
[18:01:25.744]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:25.744]                   ...future.rng), globalenv = if (FALSE) 
[18:01:25.744]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:25.744]                     ...future.globalenv.names))
[18:01:25.744]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:25.744]         }, condition = base::local({
[18:01:25.744]             c <- base::c
[18:01:25.744]             inherits <- base::inherits
[18:01:25.744]             invokeRestart <- base::invokeRestart
[18:01:25.744]             length <- base::length
[18:01:25.744]             list <- base::list
[18:01:25.744]             seq.int <- base::seq.int
[18:01:25.744]             signalCondition <- base::signalCondition
[18:01:25.744]             sys.calls <- base::sys.calls
[18:01:25.744]             `[[` <- base::`[[`
[18:01:25.744]             `+` <- base::`+`
[18:01:25.744]             `<<-` <- base::`<<-`
[18:01:25.744]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:25.744]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:25.744]                   3L)]
[18:01:25.744]             }
[18:01:25.744]             function(cond) {
[18:01:25.744]                 is_error <- inherits(cond, "error")
[18:01:25.744]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:25.744]                   NULL)
[18:01:25.744]                 if (is_error) {
[18:01:25.744]                   sessionInformation <- function() {
[18:01:25.744]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:25.744]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:25.744]                       search = base::search(), system = base::Sys.info())
[18:01:25.744]                   }
[18:01:25.744]                   ...future.conditions[[length(...future.conditions) + 
[18:01:25.744]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:25.744]                     cond$call), session = sessionInformation(), 
[18:01:25.744]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:25.744]                   signalCondition(cond)
[18:01:25.744]                 }
[18:01:25.744]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:25.744]                 "immediateCondition"))) {
[18:01:25.744]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:25.744]                   ...future.conditions[[length(...future.conditions) + 
[18:01:25.744]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:25.744]                   if (TRUE && !signal) {
[18:01:25.744]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:25.744]                     {
[18:01:25.744]                       inherits <- base::inherits
[18:01:25.744]                       invokeRestart <- base::invokeRestart
[18:01:25.744]                       is.null <- base::is.null
[18:01:25.744]                       muffled <- FALSE
[18:01:25.744]                       if (inherits(cond, "message")) {
[18:01:25.744]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:25.744]                         if (muffled) 
[18:01:25.744]                           invokeRestart("muffleMessage")
[18:01:25.744]                       }
[18:01:25.744]                       else if (inherits(cond, "warning")) {
[18:01:25.744]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:25.744]                         if (muffled) 
[18:01:25.744]                           invokeRestart("muffleWarning")
[18:01:25.744]                       }
[18:01:25.744]                       else if (inherits(cond, "condition")) {
[18:01:25.744]                         if (!is.null(pattern)) {
[18:01:25.744]                           computeRestarts <- base::computeRestarts
[18:01:25.744]                           grepl <- base::grepl
[18:01:25.744]                           restarts <- computeRestarts(cond)
[18:01:25.744]                           for (restart in restarts) {
[18:01:25.744]                             name <- restart$name
[18:01:25.744]                             if (is.null(name)) 
[18:01:25.744]                               next
[18:01:25.744]                             if (!grepl(pattern, name)) 
[18:01:25.744]                               next
[18:01:25.744]                             invokeRestart(restart)
[18:01:25.744]                             muffled <- TRUE
[18:01:25.744]                             break
[18:01:25.744]                           }
[18:01:25.744]                         }
[18:01:25.744]                       }
[18:01:25.744]                       invisible(muffled)
[18:01:25.744]                     }
[18:01:25.744]                     muffleCondition(cond, pattern = "^muffle")
[18:01:25.744]                   }
[18:01:25.744]                 }
[18:01:25.744]                 else {
[18:01:25.744]                   if (TRUE) {
[18:01:25.744]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:25.744]                     {
[18:01:25.744]                       inherits <- base::inherits
[18:01:25.744]                       invokeRestart <- base::invokeRestart
[18:01:25.744]                       is.null <- base::is.null
[18:01:25.744]                       muffled <- FALSE
[18:01:25.744]                       if (inherits(cond, "message")) {
[18:01:25.744]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:25.744]                         if (muffled) 
[18:01:25.744]                           invokeRestart("muffleMessage")
[18:01:25.744]                       }
[18:01:25.744]                       else if (inherits(cond, "warning")) {
[18:01:25.744]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:25.744]                         if (muffled) 
[18:01:25.744]                           invokeRestart("muffleWarning")
[18:01:25.744]                       }
[18:01:25.744]                       else if (inherits(cond, "condition")) {
[18:01:25.744]                         if (!is.null(pattern)) {
[18:01:25.744]                           computeRestarts <- base::computeRestarts
[18:01:25.744]                           grepl <- base::grepl
[18:01:25.744]                           restarts <- computeRestarts(cond)
[18:01:25.744]                           for (restart in restarts) {
[18:01:25.744]                             name <- restart$name
[18:01:25.744]                             if (is.null(name)) 
[18:01:25.744]                               next
[18:01:25.744]                             if (!grepl(pattern, name)) 
[18:01:25.744]                               next
[18:01:25.744]                             invokeRestart(restart)
[18:01:25.744]                             muffled <- TRUE
[18:01:25.744]                             break
[18:01:25.744]                           }
[18:01:25.744]                         }
[18:01:25.744]                       }
[18:01:25.744]                       invisible(muffled)
[18:01:25.744]                     }
[18:01:25.744]                     muffleCondition(cond, pattern = "^muffle")
[18:01:25.744]                   }
[18:01:25.744]                 }
[18:01:25.744]             }
[18:01:25.744]         }))
[18:01:25.744]     }, error = function(ex) {
[18:01:25.744]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:25.744]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:25.744]                 ...future.rng), started = ...future.startTime, 
[18:01:25.744]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:25.744]             version = "1.8"), class = "FutureResult")
[18:01:25.744]     }, finally = {
[18:01:25.744]         if (!identical(...future.workdir, getwd())) 
[18:01:25.744]             setwd(...future.workdir)
[18:01:25.744]         {
[18:01:25.744]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:25.744]                 ...future.oldOptions$nwarnings <- NULL
[18:01:25.744]             }
[18:01:25.744]             base::options(...future.oldOptions)
[18:01:25.744]             if (.Platform$OS.type == "windows") {
[18:01:25.744]                 old_names <- names(...future.oldEnvVars)
[18:01:25.744]                 envs <- base::Sys.getenv()
[18:01:25.744]                 names <- names(envs)
[18:01:25.744]                 common <- intersect(names, old_names)
[18:01:25.744]                 added <- setdiff(names, old_names)
[18:01:25.744]                 removed <- setdiff(old_names, names)
[18:01:25.744]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:25.744]                   envs[common]]
[18:01:25.744]                 NAMES <- toupper(changed)
[18:01:25.744]                 args <- list()
[18:01:25.744]                 for (kk in seq_along(NAMES)) {
[18:01:25.744]                   name <- changed[[kk]]
[18:01:25.744]                   NAME <- NAMES[[kk]]
[18:01:25.744]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.744]                     next
[18:01:25.744]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:25.744]                 }
[18:01:25.744]                 NAMES <- toupper(added)
[18:01:25.744]                 for (kk in seq_along(NAMES)) {
[18:01:25.744]                   name <- added[[kk]]
[18:01:25.744]                   NAME <- NAMES[[kk]]
[18:01:25.744]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.744]                     next
[18:01:25.744]                   args[[name]] <- ""
[18:01:25.744]                 }
[18:01:25.744]                 NAMES <- toupper(removed)
[18:01:25.744]                 for (kk in seq_along(NAMES)) {
[18:01:25.744]                   name <- removed[[kk]]
[18:01:25.744]                   NAME <- NAMES[[kk]]
[18:01:25.744]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.744]                     next
[18:01:25.744]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:25.744]                 }
[18:01:25.744]                 if (length(args) > 0) 
[18:01:25.744]                   base::do.call(base::Sys.setenv, args = args)
[18:01:25.744]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:25.744]             }
[18:01:25.744]             else {
[18:01:25.744]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:25.744]             }
[18:01:25.744]             {
[18:01:25.744]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:25.744]                   0L) {
[18:01:25.744]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:25.744]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:25.744]                   base::options(opts)
[18:01:25.744]                 }
[18:01:25.744]                 {
[18:01:25.744]                   {
[18:01:25.744]                     NULL
[18:01:25.744]                     RNGkind("Mersenne-Twister")
[18:01:25.744]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:01:25.744]                       inherits = FALSE)
[18:01:25.744]                   }
[18:01:25.744]                   options(future.plan = NULL)
[18:01:25.744]                   if (is.na(NA_character_)) 
[18:01:25.744]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:25.744]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:25.744]                   future::plan(list(function (..., envir = parent.frame()) 
[18:01:25.744]                   {
[18:01:25.744]                     future <- SequentialFuture(..., envir = envir)
[18:01:25.744]                     if (!future$lazy) 
[18:01:25.744]                       future <- run(future)
[18:01:25.744]                     invisible(future)
[18:01:25.744]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:25.744]                 }
[18:01:25.744]             }
[18:01:25.744]         }
[18:01:25.744]     })
[18:01:25.744]     if (TRUE) {
[18:01:25.744]         base::sink(type = "output", split = FALSE)
[18:01:25.744]         if (TRUE) {
[18:01:25.744]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:25.744]         }
[18:01:25.744]         else {
[18:01:25.744]             ...future.result["stdout"] <- base::list(NULL)
[18:01:25.744]         }
[18:01:25.744]         base::close(...future.stdout)
[18:01:25.744]         ...future.stdout <- NULL
[18:01:25.744]     }
[18:01:25.744]     ...future.result$conditions <- ...future.conditions
[18:01:25.744]     ...future.result$finished <- base::Sys.time()
[18:01:25.744]     ...future.result
[18:01:25.744] }
[18:01:25.748] plan(): Setting new future strategy stack:
[18:01:25.748] List of future strategies:
[18:01:25.748] 1. sequential:
[18:01:25.748]    - args: function (..., envir = parent.frame())
[18:01:25.748]    - tweaked: FALSE
[18:01:25.748]    - call: NULL
[18:01:25.749] plan(): nbrOfWorkers() = 1
[18:01:25.750] plan(): Setting new future strategy stack:
[18:01:25.750] List of future strategies:
[18:01:25.750] 1. sequential:
[18:01:25.750]    - args: function (..., envir = parent.frame())
[18:01:25.750]    - tweaked: FALSE
[18:01:25.750]    - call: plan(strategy)
[18:01:25.751] plan(): nbrOfWorkers() = 1
[18:01:25.751] SequentialFuture started (and completed)
[18:01:25.751] - Launch lazy future ... done
[18:01:25.751] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'strategy = sequential'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'numeric'
Early signaling: FALSE
Owner process: fd4a23fd-3f1e-941b-f00a-64835db9cc52
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:01:25.752] getGlobalsAndPackages() ...
[18:01:25.752] Searching for globals...
[18:01:25.753] - globals found: [1] '{'
[18:01:25.753] Searching for globals ... DONE
[18:01:25.753] Resolving globals: FALSE
[18:01:25.754] 
[18:01:25.754] 
[18:01:25.754] getGlobalsAndPackages() ... DONE
[18:01:25.754] run() for 'Future' ...
[18:01:25.754] - state: 'created'
[18:01:25.755] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:01:25.755] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:01:25.755] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:01:25.755]   - Field: 'label'
[18:01:25.756]   - Field: 'local'
[18:01:25.756]   - Field: 'owner'
[18:01:25.756]   - Field: 'envir'
[18:01:25.756]   - Field: 'packages'
[18:01:25.756]   - Field: 'gc'
[18:01:25.756]   - Field: 'conditions'
[18:01:25.757]   - Field: 'expr'
[18:01:25.757]   - Field: 'uuid'
[18:01:25.757]   - Field: 'seed'
[18:01:25.757]   - Field: 'version'
[18:01:25.758]   - Field: 'result'
[18:01:25.758]   - Field: 'asynchronous'
[18:01:25.758]   - Field: 'calls'
[18:01:25.758]   - Field: 'globals'
[18:01:25.758]   - Field: 'stdout'
[18:01:25.758]   - Field: 'earlySignal'
[18:01:25.759]   - Field: 'lazy'
[18:01:25.759]   - Field: 'state'
[18:01:25.759] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:01:25.759] - Launch lazy future ...
[18:01:25.759] Packages needed by the future expression (n = 0): <none>
[18:01:25.760] Packages needed by future strategies (n = 0): <none>
[18:01:25.760] {
[18:01:25.760]     {
[18:01:25.760]         {
[18:01:25.760]             ...future.startTime <- base::Sys.time()
[18:01:25.760]             {
[18:01:25.760]                 {
[18:01:25.760]                   {
[18:01:25.760]                     base::local({
[18:01:25.760]                       has_future <- base::requireNamespace("future", 
[18:01:25.760]                         quietly = TRUE)
[18:01:25.760]                       if (has_future) {
[18:01:25.760]                         ns <- base::getNamespace("future")
[18:01:25.760]                         version <- ns[[".package"]][["version"]]
[18:01:25.760]                         if (is.null(version)) 
[18:01:25.760]                           version <- utils::packageVersion("future")
[18:01:25.760]                       }
[18:01:25.760]                       else {
[18:01:25.760]                         version <- NULL
[18:01:25.760]                       }
[18:01:25.760]                       if (!has_future || version < "1.8.0") {
[18:01:25.760]                         info <- base::c(r_version = base::gsub("R version ", 
[18:01:25.760]                           "", base::R.version$version.string), 
[18:01:25.760]                           platform = base::sprintf("%s (%s-bit)", 
[18:01:25.760]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:25.760]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:25.760]                             "release", "version")], collapse = " "), 
[18:01:25.760]                           hostname = base::Sys.info()[["nodename"]])
[18:01:25.760]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:01:25.760]                           info)
[18:01:25.760]                         info <- base::paste(info, collapse = "; ")
[18:01:25.760]                         if (!has_future) {
[18:01:25.760]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:25.760]                             info)
[18:01:25.760]                         }
[18:01:25.760]                         else {
[18:01:25.760]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:25.760]                             info, version)
[18:01:25.760]                         }
[18:01:25.760]                         base::stop(msg)
[18:01:25.760]                       }
[18:01:25.760]                     })
[18:01:25.760]                   }
[18:01:25.760]                   options(future.plan = NULL)
[18:01:25.760]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:25.760]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:25.760]                 }
[18:01:25.760]                 ...future.workdir <- getwd()
[18:01:25.760]             }
[18:01:25.760]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:25.760]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:25.760]         }
[18:01:25.760]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:25.760]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:25.760]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:25.760]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:25.760]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:25.760]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:25.760]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:25.760]             base::names(...future.oldOptions))
[18:01:25.760]     }
[18:01:25.760]     if (FALSE) {
[18:01:25.760]     }
[18:01:25.760]     else {
[18:01:25.760]         if (TRUE) {
[18:01:25.760]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:25.760]                 open = "w")
[18:01:25.760]         }
[18:01:25.760]         else {
[18:01:25.760]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:25.760]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:25.760]         }
[18:01:25.760]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:25.760]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:25.760]             base::sink(type = "output", split = FALSE)
[18:01:25.760]             base::close(...future.stdout)
[18:01:25.760]         }, add = TRUE)
[18:01:25.760]     }
[18:01:25.760]     ...future.frame <- base::sys.nframe()
[18:01:25.760]     ...future.conditions <- base::list()
[18:01:25.760]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:25.760]     if (FALSE) {
[18:01:25.760]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:25.760]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:25.760]     }
[18:01:25.760]     ...future.result <- base::tryCatch({
[18:01:25.760]         base::withCallingHandlers({
[18:01:25.760]             ...future.value <- base::withVisible(base::local({
[18:01:25.760]                 42
[18:01:25.760]             }))
[18:01:25.760]             future::FutureResult(value = ...future.value$value, 
[18:01:25.760]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:25.760]                   ...future.rng), globalenv = if (FALSE) 
[18:01:25.760]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:25.760]                     ...future.globalenv.names))
[18:01:25.760]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:25.760]         }, condition = base::local({
[18:01:25.760]             c <- base::c
[18:01:25.760]             inherits <- base::inherits
[18:01:25.760]             invokeRestart <- base::invokeRestart
[18:01:25.760]             length <- base::length
[18:01:25.760]             list <- base::list
[18:01:25.760]             seq.int <- base::seq.int
[18:01:25.760]             signalCondition <- base::signalCondition
[18:01:25.760]             sys.calls <- base::sys.calls
[18:01:25.760]             `[[` <- base::`[[`
[18:01:25.760]             `+` <- base::`+`
[18:01:25.760]             `<<-` <- base::`<<-`
[18:01:25.760]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:25.760]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:25.760]                   3L)]
[18:01:25.760]             }
[18:01:25.760]             function(cond) {
[18:01:25.760]                 is_error <- inherits(cond, "error")
[18:01:25.760]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:25.760]                   NULL)
[18:01:25.760]                 if (is_error) {
[18:01:25.760]                   sessionInformation <- function() {
[18:01:25.760]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:25.760]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:25.760]                       search = base::search(), system = base::Sys.info())
[18:01:25.760]                   }
[18:01:25.760]                   ...future.conditions[[length(...future.conditions) + 
[18:01:25.760]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:25.760]                     cond$call), session = sessionInformation(), 
[18:01:25.760]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:25.760]                   signalCondition(cond)
[18:01:25.760]                 }
[18:01:25.760]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:25.760]                 "immediateCondition"))) {
[18:01:25.760]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:25.760]                   ...future.conditions[[length(...future.conditions) + 
[18:01:25.760]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:25.760]                   if (TRUE && !signal) {
[18:01:25.760]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:25.760]                     {
[18:01:25.760]                       inherits <- base::inherits
[18:01:25.760]                       invokeRestart <- base::invokeRestart
[18:01:25.760]                       is.null <- base::is.null
[18:01:25.760]                       muffled <- FALSE
[18:01:25.760]                       if (inherits(cond, "message")) {
[18:01:25.760]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:25.760]                         if (muffled) 
[18:01:25.760]                           invokeRestart("muffleMessage")
[18:01:25.760]                       }
[18:01:25.760]                       else if (inherits(cond, "warning")) {
[18:01:25.760]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:25.760]                         if (muffled) 
[18:01:25.760]                           invokeRestart("muffleWarning")
[18:01:25.760]                       }
[18:01:25.760]                       else if (inherits(cond, "condition")) {
[18:01:25.760]                         if (!is.null(pattern)) {
[18:01:25.760]                           computeRestarts <- base::computeRestarts
[18:01:25.760]                           grepl <- base::grepl
[18:01:25.760]                           restarts <- computeRestarts(cond)
[18:01:25.760]                           for (restart in restarts) {
[18:01:25.760]                             name <- restart$name
[18:01:25.760]                             if (is.null(name)) 
[18:01:25.760]                               next
[18:01:25.760]                             if (!grepl(pattern, name)) 
[18:01:25.760]                               next
[18:01:25.760]                             invokeRestart(restart)
[18:01:25.760]                             muffled <- TRUE
[18:01:25.760]                             break
[18:01:25.760]                           }
[18:01:25.760]                         }
[18:01:25.760]                       }
[18:01:25.760]                       invisible(muffled)
[18:01:25.760]                     }
[18:01:25.760]                     muffleCondition(cond, pattern = "^muffle")
[18:01:25.760]                   }
[18:01:25.760]                 }
[18:01:25.760]                 else {
[18:01:25.760]                   if (TRUE) {
[18:01:25.760]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:25.760]                     {
[18:01:25.760]                       inherits <- base::inherits
[18:01:25.760]                       invokeRestart <- base::invokeRestart
[18:01:25.760]                       is.null <- base::is.null
[18:01:25.760]                       muffled <- FALSE
[18:01:25.760]                       if (inherits(cond, "message")) {
[18:01:25.760]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:25.760]                         if (muffled) 
[18:01:25.760]                           invokeRestart("muffleMessage")
[18:01:25.760]                       }
[18:01:25.760]                       else if (inherits(cond, "warning")) {
[18:01:25.760]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:25.760]                         if (muffled) 
[18:01:25.760]                           invokeRestart("muffleWarning")
[18:01:25.760]                       }
[18:01:25.760]                       else if (inherits(cond, "condition")) {
[18:01:25.760]                         if (!is.null(pattern)) {
[18:01:25.760]                           computeRestarts <- base::computeRestarts
[18:01:25.760]                           grepl <- base::grepl
[18:01:25.760]                           restarts <- computeRestarts(cond)
[18:01:25.760]                           for (restart in restarts) {
[18:01:25.760]                             name <- restart$name
[18:01:25.760]                             if (is.null(name)) 
[18:01:25.760]                               next
[18:01:25.760]                             if (!grepl(pattern, name)) 
[18:01:25.760]                               next
[18:01:25.760]                             invokeRestart(restart)
[18:01:25.760]                             muffled <- TRUE
[18:01:25.760]                             break
[18:01:25.760]                           }
[18:01:25.760]                         }
[18:01:25.760]                       }
[18:01:25.760]                       invisible(muffled)
[18:01:25.760]                     }
[18:01:25.760]                     muffleCondition(cond, pattern = "^muffle")
[18:01:25.760]                   }
[18:01:25.760]                 }
[18:01:25.760]             }
[18:01:25.760]         }))
[18:01:25.760]     }, error = function(ex) {
[18:01:25.760]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:25.760]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:25.760]                 ...future.rng), started = ...future.startTime, 
[18:01:25.760]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:25.760]             version = "1.8"), class = "FutureResult")
[18:01:25.760]     }, finally = {
[18:01:25.760]         if (!identical(...future.workdir, getwd())) 
[18:01:25.760]             setwd(...future.workdir)
[18:01:25.760]         {
[18:01:25.760]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:25.760]                 ...future.oldOptions$nwarnings <- NULL
[18:01:25.760]             }
[18:01:25.760]             base::options(...future.oldOptions)
[18:01:25.760]             if (.Platform$OS.type == "windows") {
[18:01:25.760]                 old_names <- names(...future.oldEnvVars)
[18:01:25.760]                 envs <- base::Sys.getenv()
[18:01:25.760]                 names <- names(envs)
[18:01:25.760]                 common <- intersect(names, old_names)
[18:01:25.760]                 added <- setdiff(names, old_names)
[18:01:25.760]                 removed <- setdiff(old_names, names)
[18:01:25.760]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:25.760]                   envs[common]]
[18:01:25.760]                 NAMES <- toupper(changed)
[18:01:25.760]                 args <- list()
[18:01:25.760]                 for (kk in seq_along(NAMES)) {
[18:01:25.760]                   name <- changed[[kk]]
[18:01:25.760]                   NAME <- NAMES[[kk]]
[18:01:25.760]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.760]                     next
[18:01:25.760]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:25.760]                 }
[18:01:25.760]                 NAMES <- toupper(added)
[18:01:25.760]                 for (kk in seq_along(NAMES)) {
[18:01:25.760]                   name <- added[[kk]]
[18:01:25.760]                   NAME <- NAMES[[kk]]
[18:01:25.760]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.760]                     next
[18:01:25.760]                   args[[name]] <- ""
[18:01:25.760]                 }
[18:01:25.760]                 NAMES <- toupper(removed)
[18:01:25.760]                 for (kk in seq_along(NAMES)) {
[18:01:25.760]                   name <- removed[[kk]]
[18:01:25.760]                   NAME <- NAMES[[kk]]
[18:01:25.760]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:25.760]                     next
[18:01:25.760]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:25.760]                 }
[18:01:25.760]                 if (length(args) > 0) 
[18:01:25.760]                   base::do.call(base::Sys.setenv, args = args)
[18:01:25.760]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:25.760]             }
[18:01:25.760]             else {
[18:01:25.760]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:25.760]             }
[18:01:25.760]             {
[18:01:25.760]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:25.760]                   0L) {
[18:01:25.760]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:25.760]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:25.760]                   base::options(opts)
[18:01:25.760]                 }
[18:01:25.760]                 {
[18:01:25.760]                   {
[18:01:25.760]                     NULL
[18:01:25.760]                     RNGkind("Mersenne-Twister")
[18:01:25.760]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:01:25.760]                       inherits = FALSE)
[18:01:25.760]                   }
[18:01:25.760]                   options(future.plan = NULL)
[18:01:25.760]                   if (is.na(NA_character_)) 
[18:01:25.760]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:25.760]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:25.760]                   future::plan(list(function (..., envir = parent.frame()) 
[18:01:25.760]                   {
[18:01:25.760]                     future <- SequentialFuture(..., envir = envir)
[18:01:25.760]                     if (!future$lazy) 
[18:01:25.760]                       future <- run(future)
[18:01:25.760]                     invisible(future)
[18:01:25.760]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:25.760]                 }
[18:01:25.760]             }
[18:01:25.760]         }
[18:01:25.760]     })
[18:01:25.760]     if (TRUE) {
[18:01:25.760]         base::sink(type = "output", split = FALSE)
[18:01:25.760]         if (TRUE) {
[18:01:25.760]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:25.760]         }
[18:01:25.760]         else {
[18:01:25.760]             ...future.result["stdout"] <- base::list(NULL)
[18:01:25.760]         }
[18:01:25.760]         base::close(...future.stdout)
[18:01:25.760]         ...future.stdout <- NULL
[18:01:25.760]     }
[18:01:25.760]     ...future.result$conditions <- ...future.conditions
[18:01:25.760]     ...future.result$finished <- base::Sys.time()
[18:01:25.760]     ...future.result
[18:01:25.760] }
[18:01:25.764] plan(): Setting new future strategy stack:
[18:01:25.764] List of future strategies:
[18:01:25.764] 1. sequential:
[18:01:25.764]    - args: function (..., envir = parent.frame())
[18:01:25.764]    - tweaked: FALSE
[18:01:25.764]    - call: NULL
[18:01:25.765] plan(): nbrOfWorkers() = 1
[18:01:25.766] plan(): Setting new future strategy stack:
[18:01:25.766] List of future strategies:
[18:01:25.766] 1. sequential:
[18:01:25.766]    - args: function (..., envir = parent.frame())
[18:01:25.766]    - tweaked: FALSE
[18:01:25.766]    - call: plan(strategy)
[18:01:25.766] plan(): nbrOfWorkers() = 1
[18:01:25.767] SequentialFuture started (and completed)
[18:01:25.767] - Launch lazy future ... done
[18:01:25.767] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'strategy = sequential'
Expression:
{
    42
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'numeric'
Early signaling: FALSE
Owner process: fd4a23fd-3f1e-941b-f00a-64835db9cc52
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
- plan('sequential') ... DONE
- plan('multisession') ...
[18:01:25.768] plan(): Setting new future strategy stack:
[18:01:25.769] List of future strategies:
[18:01:25.769] 1. multisession:
[18:01:25.769]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:01:25.769]    - tweaked: FALSE
[18:01:25.769]    - call: plan(strategy)
[18:01:25.769] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[18:01:25.769] multisession:
[18:01:25.769] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:01:25.769] - tweaked: FALSE
[18:01:25.769] - call: plan(strategy)
[18:01:25.774] getGlobalsAndPackages() ...
[18:01:25.774] Not searching for globals
[18:01:25.775] - globals: [0] <none>
[18:01:25.775] getGlobalsAndPackages() ... DONE
[18:01:25.775] [local output] makeClusterPSOCK() ...
[18:01:25.804] [local output] Workers: [n = 2] 'localhost', 'localhost'
[18:01:25.812] [local output] Base port: 31854
[18:01:25.812] [local output] Getting setup options for 2 cluster nodes ...
[18:01:25.812] [local output]  - Node 1 of 2 ...
[18:01:25.813] [local output] localMachine=TRUE => revtunnel=FALSE

[18:01:25.814] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpmS69Rn/worker.rank=1.parallelly.parent=78212.131844f255fce.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpmS69Rn/worker.rank=1.parallelly.parent=78212.131844f255fce.pid\")"'
[18:01:26.258] - Possible to infer worker's PID: TRUE
[18:01:26.259] [local output] Rscript port: 31854

[18:01:26.259] [local output]  - Node 2 of 2 ...
[18:01:26.260] [local output] localMachine=TRUE => revtunnel=FALSE

[18:01:26.261] [local output] Rscript port: 31854

[18:01:26.262] [local output] Getting setup options for 2 cluster nodes ... done
[18:01:26.262] [local output]  - Parallel setup requested for some PSOCK nodes
[18:01:26.263] [local output] Setting up PSOCK nodes in parallel
[18:01:26.263] List of 36
[18:01:26.263]  $ worker          : chr "localhost"
[18:01:26.263]   ..- attr(*, "localhost")= logi TRUE
[18:01:26.263]  $ master          : chr "localhost"
[18:01:26.263]  $ port            : int 31854
[18:01:26.263]  $ connectTimeout  : num 120
[18:01:26.263]  $ timeout         : num 120
[18:01:26.263]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:01:26.263]  $ homogeneous     : logi TRUE
[18:01:26.263]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=future,labels.R:78212:CRANWIN3:C"| __truncated__
[18:01:26.263]  $ rscript_envs    : NULL
[18:01:26.263]  $ rscript_libs    : chr [1:2] "D:/temp/Rtmp67Lu9b/RLIBS_19fe819742e2c" "D:/RCompile/recent/R/library"
[18:01:26.263]  $ rscript_startup : NULL
[18:01:26.263]  $ rscript_sh      : chr "cmd"
[18:01:26.263]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:01:26.263]  $ methods         : logi TRUE
[18:01:26.263]  $ socketOptions   : chr "no-delay"
[18:01:26.263]  $ useXDR          : logi FALSE
[18:01:26.263]  $ outfile         : chr "/dev/null"
[18:01:26.263]  $ renice          : int NA
[18:01:26.263]  $ rshcmd          : NULL
[18:01:26.263]  $ user            : chr(0) 
[18:01:26.263]  $ revtunnel       : logi FALSE
[18:01:26.263]  $ rshlogfile      : NULL
[18:01:26.263]  $ rshopts         : chr(0) 
[18:01:26.263]  $ rank            : int 1
[18:01:26.263]  $ manual          : logi FALSE
[18:01:26.263]  $ dryrun          : logi FALSE
[18:01:26.263]  $ quiet           : logi FALSE
[18:01:26.263]  $ setup_strategy  : chr "parallel"
[18:01:26.263]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:01:26.263]  $ pidfile         : chr "D:/temp/RtmpmS69Rn/worker.rank=1.parallelly.parent=78212.131844f255fce.pid"
[18:01:26.263]  $ rshcmd_label    : NULL
[18:01:26.263]  $ rsh_call        : NULL
[18:01:26.263]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:01:26.263]  $ localMachine    : logi TRUE
[18:01:26.263]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:01:26.263]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:01:26.263]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:01:26.263]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:01:26.263]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:01:26.263]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[18:01:26.263]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:01:26.263]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:01:26.263]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:01:26.263]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:01:26.263]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:01:26.263]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:01:26.263]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:01:26.263]  $ arguments       :List of 28
[18:01:26.263]   ..$ worker          : chr "localhost"
[18:01:26.263]   ..$ master          : NULL
[18:01:26.263]   ..$ port            : int 31854
[18:01:26.263]   ..$ connectTimeout  : num 120
[18:01:26.263]   ..$ timeout         : num 120
[18:01:26.263]   ..$ rscript         : NULL
[18:01:26.263]   ..$ homogeneous     : NULL
[18:01:26.263]   ..$ rscript_args    : NULL
[18:01:26.263]   ..$ rscript_envs    : NULL
[18:01:26.263]   ..$ rscript_libs    : chr [1:2] "D:/temp/Rtmp67Lu9b/RLIBS_19fe819742e2c" "D:/RCompile/recent/R/library"
[18:01:26.263]   ..$ rscript_startup : NULL
[18:01:26.263]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[18:01:26.263]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:01:26.263]   ..$ methods         : logi TRUE
[18:01:26.263]   ..$ socketOptions   : chr "no-delay"
[18:01:26.263]   ..$ useXDR          : logi FALSE
[18:01:26.263]   ..$ outfile         : chr "/dev/null"
[18:01:26.263]   ..$ renice          : int NA
[18:01:26.263]   ..$ rshcmd          : NULL
[18:01:26.263]   ..$ user            : NULL
[18:01:26.263]   ..$ revtunnel       : logi NA
[18:01:26.263]   ..$ rshlogfile      : NULL
[18:01:26.263]   ..$ rshopts         : NULL
[18:01:26.263]   ..$ rank            : int 1
[18:01:26.263]   ..$ manual          : logi FALSE
[18:01:26.263]   ..$ dryrun          : logi FALSE
[18:01:26.263]   ..$ quiet           : logi FALSE
[18:01:26.263]   ..$ setup_strategy  : chr "parallel"
[18:01:26.263]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:01:26.288] [local output] System call to launch all workers:
[18:01:26.288] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=future,labels.R:78212:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpmS69Rn/worker.rank=1.parallelly.parent=78212.131844f255fce.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/Rtmp67Lu9b/RLIBS_19fe819742e2c\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=31854 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:01:26.288] [local output] Starting PSOCK main server
[18:01:26.297] [local output] Workers launched
[18:01:26.298] [local output] Waiting for workers to connect back
[18:01:26.298]  - [local output] 0 workers out of 2 ready
[18:01:26.469]  - [local output] 0 workers out of 2 ready
[18:01:26.470]  - [local output] 1 workers out of 2 ready
[18:01:26.470]  - [local output] 2 workers out of 2 ready
[18:01:26.470] [local output] Launching of workers completed
[18:01:26.471] [local output] Collecting session information from workers
[18:01:26.472] [local output]  - Worker #1 of 2
[18:01:26.472] [local output]  - Worker #2 of 2
[18:01:26.473] [local output] makeClusterPSOCK() ... done
[18:01:26.485] Packages needed by the future expression (n = 0): <none>
[18:01:26.486] Packages needed by future strategies (n = 0): <none>
[18:01:26.486] {
[18:01:26.486]     {
[18:01:26.486]         {
[18:01:26.486]             ...future.startTime <- base::Sys.time()
[18:01:26.486]             {
[18:01:26.486]                 {
[18:01:26.486]                   {
[18:01:26.486]                     {
[18:01:26.486]                       base::local({
[18:01:26.486]                         has_future <- base::requireNamespace("future", 
[18:01:26.486]                           quietly = TRUE)
[18:01:26.486]                         if (has_future) {
[18:01:26.486]                           ns <- base::getNamespace("future")
[18:01:26.486]                           version <- ns[[".package"]][["version"]]
[18:01:26.486]                           if (is.null(version)) 
[18:01:26.486]                             version <- utils::packageVersion("future")
[18:01:26.486]                         }
[18:01:26.486]                         else {
[18:01:26.486]                           version <- NULL
[18:01:26.486]                         }
[18:01:26.486]                         if (!has_future || version < "1.8.0") {
[18:01:26.486]                           info <- base::c(r_version = base::gsub("R version ", 
[18:01:26.486]                             "", base::R.version$version.string), 
[18:01:26.486]                             platform = base::sprintf("%s (%s-bit)", 
[18:01:26.486]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:26.486]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:26.486]                               "release", "version")], collapse = " "), 
[18:01:26.486]                             hostname = base::Sys.info()[["nodename"]])
[18:01:26.486]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:01:26.486]                             info)
[18:01:26.486]                           info <- base::paste(info, collapse = "; ")
[18:01:26.486]                           if (!has_future) {
[18:01:26.486]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:26.486]                               info)
[18:01:26.486]                           }
[18:01:26.486]                           else {
[18:01:26.486]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:26.486]                               info, version)
[18:01:26.486]                           }
[18:01:26.486]                           base::stop(msg)
[18:01:26.486]                         }
[18:01:26.486]                       })
[18:01:26.486]                     }
[18:01:26.486]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:01:26.486]                     base::options(mc.cores = 1L)
[18:01:26.486]                   }
[18:01:26.486]                   options(future.plan = NULL)
[18:01:26.486]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.486]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:26.486]                 }
[18:01:26.486]                 ...future.workdir <- getwd()
[18:01:26.486]             }
[18:01:26.486]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:26.486]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:26.486]         }
[18:01:26.486]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:26.486]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:26.486]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:26.486]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:26.486]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:26.486]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:26.486]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:26.486]             base::names(...future.oldOptions))
[18:01:26.486]     }
[18:01:26.486]     if (FALSE) {
[18:01:26.486]     }
[18:01:26.486]     else {
[18:01:26.486]         if (TRUE) {
[18:01:26.486]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:26.486]                 open = "w")
[18:01:26.486]         }
[18:01:26.486]         else {
[18:01:26.486]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:26.486]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:26.486]         }
[18:01:26.486]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:26.486]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:26.486]             base::sink(type = "output", split = FALSE)
[18:01:26.486]             base::close(...future.stdout)
[18:01:26.486]         }, add = TRUE)
[18:01:26.486]     }
[18:01:26.486]     ...future.frame <- base::sys.nframe()
[18:01:26.486]     ...future.conditions <- base::list()
[18:01:26.486]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:26.486]     if (FALSE) {
[18:01:26.486]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:26.486]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:26.486]     }
[18:01:26.486]     ...future.result <- base::tryCatch({
[18:01:26.486]         base::withCallingHandlers({
[18:01:26.486]             ...future.value <- base::withVisible(base::local({
[18:01:26.486]                 ...future.makeSendCondition <- local({
[18:01:26.486]                   sendCondition <- NULL
[18:01:26.486]                   function(frame = 1L) {
[18:01:26.486]                     if (is.function(sendCondition)) 
[18:01:26.486]                       return(sendCondition)
[18:01:26.486]                     ns <- getNamespace("parallel")
[18:01:26.486]                     if (exists("sendData", mode = "function", 
[18:01:26.486]                       envir = ns)) {
[18:01:26.486]                       parallel_sendData <- get("sendData", mode = "function", 
[18:01:26.486]                         envir = ns)
[18:01:26.486]                       envir <- sys.frame(frame)
[18:01:26.486]                       master <- NULL
[18:01:26.486]                       while (!identical(envir, .GlobalEnv) && 
[18:01:26.486]                         !identical(envir, emptyenv())) {
[18:01:26.486]                         if (exists("master", mode = "list", envir = envir, 
[18:01:26.486]                           inherits = FALSE)) {
[18:01:26.486]                           master <- get("master", mode = "list", 
[18:01:26.486]                             envir = envir, inherits = FALSE)
[18:01:26.486]                           if (inherits(master, c("SOCKnode", 
[18:01:26.486]                             "SOCK0node"))) {
[18:01:26.486]                             sendCondition <<- function(cond) {
[18:01:26.486]                               data <- list(type = "VALUE", value = cond, 
[18:01:26.486]                                 success = TRUE)
[18:01:26.486]                               parallel_sendData(master, data)
[18:01:26.486]                             }
[18:01:26.486]                             return(sendCondition)
[18:01:26.486]                           }
[18:01:26.486]                         }
[18:01:26.486]                         frame <- frame + 1L
[18:01:26.486]                         envir <- sys.frame(frame)
[18:01:26.486]                       }
[18:01:26.486]                     }
[18:01:26.486]                     sendCondition <<- function(cond) NULL
[18:01:26.486]                   }
[18:01:26.486]                 })
[18:01:26.486]                 withCallingHandlers({
[18:01:26.486]                   NA
[18:01:26.486]                 }, immediateCondition = function(cond) {
[18:01:26.486]                   sendCondition <- ...future.makeSendCondition()
[18:01:26.486]                   sendCondition(cond)
[18:01:26.486]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.486]                   {
[18:01:26.486]                     inherits <- base::inherits
[18:01:26.486]                     invokeRestart <- base::invokeRestart
[18:01:26.486]                     is.null <- base::is.null
[18:01:26.486]                     muffled <- FALSE
[18:01:26.486]                     if (inherits(cond, "message")) {
[18:01:26.486]                       muffled <- grepl(pattern, "muffleMessage")
[18:01:26.486]                       if (muffled) 
[18:01:26.486]                         invokeRestart("muffleMessage")
[18:01:26.486]                     }
[18:01:26.486]                     else if (inherits(cond, "warning")) {
[18:01:26.486]                       muffled <- grepl(pattern, "muffleWarning")
[18:01:26.486]                       if (muffled) 
[18:01:26.486]                         invokeRestart("muffleWarning")
[18:01:26.486]                     }
[18:01:26.486]                     else if (inherits(cond, "condition")) {
[18:01:26.486]                       if (!is.null(pattern)) {
[18:01:26.486]                         computeRestarts <- base::computeRestarts
[18:01:26.486]                         grepl <- base::grepl
[18:01:26.486]                         restarts <- computeRestarts(cond)
[18:01:26.486]                         for (restart in restarts) {
[18:01:26.486]                           name <- restart$name
[18:01:26.486]                           if (is.null(name)) 
[18:01:26.486]                             next
[18:01:26.486]                           if (!grepl(pattern, name)) 
[18:01:26.486]                             next
[18:01:26.486]                           invokeRestart(restart)
[18:01:26.486]                           muffled <- TRUE
[18:01:26.486]                           break
[18:01:26.486]                         }
[18:01:26.486]                       }
[18:01:26.486]                     }
[18:01:26.486]                     invisible(muffled)
[18:01:26.486]                   }
[18:01:26.486]                   muffleCondition(cond)
[18:01:26.486]                 })
[18:01:26.486]             }))
[18:01:26.486]             future::FutureResult(value = ...future.value$value, 
[18:01:26.486]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.486]                   ...future.rng), globalenv = if (FALSE) 
[18:01:26.486]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:26.486]                     ...future.globalenv.names))
[18:01:26.486]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:26.486]         }, condition = base::local({
[18:01:26.486]             c <- base::c
[18:01:26.486]             inherits <- base::inherits
[18:01:26.486]             invokeRestart <- base::invokeRestart
[18:01:26.486]             length <- base::length
[18:01:26.486]             list <- base::list
[18:01:26.486]             seq.int <- base::seq.int
[18:01:26.486]             signalCondition <- base::signalCondition
[18:01:26.486]             sys.calls <- base::sys.calls
[18:01:26.486]             `[[` <- base::`[[`
[18:01:26.486]             `+` <- base::`+`
[18:01:26.486]             `<<-` <- base::`<<-`
[18:01:26.486]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:26.486]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:26.486]                   3L)]
[18:01:26.486]             }
[18:01:26.486]             function(cond) {
[18:01:26.486]                 is_error <- inherits(cond, "error")
[18:01:26.486]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:26.486]                   NULL)
[18:01:26.486]                 if (is_error) {
[18:01:26.486]                   sessionInformation <- function() {
[18:01:26.486]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:26.486]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:26.486]                       search = base::search(), system = base::Sys.info())
[18:01:26.486]                   }
[18:01:26.486]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.486]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:26.486]                     cond$call), session = sessionInformation(), 
[18:01:26.486]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:26.486]                   signalCondition(cond)
[18:01:26.486]                 }
[18:01:26.486]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:26.486]                 "immediateCondition"))) {
[18:01:26.486]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:26.486]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.486]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:26.486]                   if (TRUE && !signal) {
[18:01:26.486]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.486]                     {
[18:01:26.486]                       inherits <- base::inherits
[18:01:26.486]                       invokeRestart <- base::invokeRestart
[18:01:26.486]                       is.null <- base::is.null
[18:01:26.486]                       muffled <- FALSE
[18:01:26.486]                       if (inherits(cond, "message")) {
[18:01:26.486]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.486]                         if (muffled) 
[18:01:26.486]                           invokeRestart("muffleMessage")
[18:01:26.486]                       }
[18:01:26.486]                       else if (inherits(cond, "warning")) {
[18:01:26.486]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.486]                         if (muffled) 
[18:01:26.486]                           invokeRestart("muffleWarning")
[18:01:26.486]                       }
[18:01:26.486]                       else if (inherits(cond, "condition")) {
[18:01:26.486]                         if (!is.null(pattern)) {
[18:01:26.486]                           computeRestarts <- base::computeRestarts
[18:01:26.486]                           grepl <- base::grepl
[18:01:26.486]                           restarts <- computeRestarts(cond)
[18:01:26.486]                           for (restart in restarts) {
[18:01:26.486]                             name <- restart$name
[18:01:26.486]                             if (is.null(name)) 
[18:01:26.486]                               next
[18:01:26.486]                             if (!grepl(pattern, name)) 
[18:01:26.486]                               next
[18:01:26.486]                             invokeRestart(restart)
[18:01:26.486]                             muffled <- TRUE
[18:01:26.486]                             break
[18:01:26.486]                           }
[18:01:26.486]                         }
[18:01:26.486]                       }
[18:01:26.486]                       invisible(muffled)
[18:01:26.486]                     }
[18:01:26.486]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.486]                   }
[18:01:26.486]                 }
[18:01:26.486]                 else {
[18:01:26.486]                   if (TRUE) {
[18:01:26.486]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.486]                     {
[18:01:26.486]                       inherits <- base::inherits
[18:01:26.486]                       invokeRestart <- base::invokeRestart
[18:01:26.486]                       is.null <- base::is.null
[18:01:26.486]                       muffled <- FALSE
[18:01:26.486]                       if (inherits(cond, "message")) {
[18:01:26.486]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.486]                         if (muffled) 
[18:01:26.486]                           invokeRestart("muffleMessage")
[18:01:26.486]                       }
[18:01:26.486]                       else if (inherits(cond, "warning")) {
[18:01:26.486]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.486]                         if (muffled) 
[18:01:26.486]                           invokeRestart("muffleWarning")
[18:01:26.486]                       }
[18:01:26.486]                       else if (inherits(cond, "condition")) {
[18:01:26.486]                         if (!is.null(pattern)) {
[18:01:26.486]                           computeRestarts <- base::computeRestarts
[18:01:26.486]                           grepl <- base::grepl
[18:01:26.486]                           restarts <- computeRestarts(cond)
[18:01:26.486]                           for (restart in restarts) {
[18:01:26.486]                             name <- restart$name
[18:01:26.486]                             if (is.null(name)) 
[18:01:26.486]                               next
[18:01:26.486]                             if (!grepl(pattern, name)) 
[18:01:26.486]                               next
[18:01:26.486]                             invokeRestart(restart)
[18:01:26.486]                             muffled <- TRUE
[18:01:26.486]                             break
[18:01:26.486]                           }
[18:01:26.486]                         }
[18:01:26.486]                       }
[18:01:26.486]                       invisible(muffled)
[18:01:26.486]                     }
[18:01:26.486]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.486]                   }
[18:01:26.486]                 }
[18:01:26.486]             }
[18:01:26.486]         }))
[18:01:26.486]     }, error = function(ex) {
[18:01:26.486]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:26.486]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.486]                 ...future.rng), started = ...future.startTime, 
[18:01:26.486]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:26.486]             version = "1.8"), class = "FutureResult")
[18:01:26.486]     }, finally = {
[18:01:26.486]         if (!identical(...future.workdir, getwd())) 
[18:01:26.486]             setwd(...future.workdir)
[18:01:26.486]         {
[18:01:26.486]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:26.486]                 ...future.oldOptions$nwarnings <- NULL
[18:01:26.486]             }
[18:01:26.486]             base::options(...future.oldOptions)
[18:01:26.486]             if (.Platform$OS.type == "windows") {
[18:01:26.486]                 old_names <- names(...future.oldEnvVars)
[18:01:26.486]                 envs <- base::Sys.getenv()
[18:01:26.486]                 names <- names(envs)
[18:01:26.486]                 common <- intersect(names, old_names)
[18:01:26.486]                 added <- setdiff(names, old_names)
[18:01:26.486]                 removed <- setdiff(old_names, names)
[18:01:26.486]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:26.486]                   envs[common]]
[18:01:26.486]                 NAMES <- toupper(changed)
[18:01:26.486]                 args <- list()
[18:01:26.486]                 for (kk in seq_along(NAMES)) {
[18:01:26.486]                   name <- changed[[kk]]
[18:01:26.486]                   NAME <- NAMES[[kk]]
[18:01:26.486]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.486]                     next
[18:01:26.486]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.486]                 }
[18:01:26.486]                 NAMES <- toupper(added)
[18:01:26.486]                 for (kk in seq_along(NAMES)) {
[18:01:26.486]                   name <- added[[kk]]
[18:01:26.486]                   NAME <- NAMES[[kk]]
[18:01:26.486]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.486]                     next
[18:01:26.486]                   args[[name]] <- ""
[18:01:26.486]                 }
[18:01:26.486]                 NAMES <- toupper(removed)
[18:01:26.486]                 for (kk in seq_along(NAMES)) {
[18:01:26.486]                   name <- removed[[kk]]
[18:01:26.486]                   NAME <- NAMES[[kk]]
[18:01:26.486]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.486]                     next
[18:01:26.486]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.486]                 }
[18:01:26.486]                 if (length(args) > 0) 
[18:01:26.486]                   base::do.call(base::Sys.setenv, args = args)
[18:01:26.486]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:26.486]             }
[18:01:26.486]             else {
[18:01:26.486]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:26.486]             }
[18:01:26.486]             {
[18:01:26.486]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:26.486]                   0L) {
[18:01:26.486]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:26.486]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:26.486]                   base::options(opts)
[18:01:26.486]                 }
[18:01:26.486]                 {
[18:01:26.486]                   {
[18:01:26.486]                     base::options(mc.cores = ...future.mc.cores.old)
[18:01:26.486]                     NULL
[18:01:26.486]                   }
[18:01:26.486]                   options(future.plan = NULL)
[18:01:26.486]                   if (is.na(NA_character_)) 
[18:01:26.486]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.486]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:26.486]                   future::plan(list(function (..., workers = availableCores(), 
[18:01:26.486]                     lazy = FALSE, rscript_libs = .libPaths(), 
[18:01:26.486]                     envir = parent.frame()) 
[18:01:26.486]                   {
[18:01:26.486]                     if (is.function(workers)) 
[18:01:26.486]                       workers <- workers()
[18:01:26.486]                     workers <- structure(as.integer(workers), 
[18:01:26.486]                       class = class(workers))
[18:01:26.486]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[18:01:26.486]                       workers >= 1)
[18:01:26.486]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[18:01:26.486]                       return(sequential(..., lazy = TRUE, envir = envir))
[18:01:26.486]                     }
[18:01:26.486]                     future <- MultisessionFuture(..., workers = workers, 
[18:01:26.486]                       lazy = lazy, rscript_libs = rscript_libs, 
[18:01:26.486]                       envir = envir)
[18:01:26.486]                     if (!future$lazy) 
[18:01:26.486]                       future <- run(future)
[18:01:26.486]                     invisible(future)
[18:01:26.486]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:26.486]                 }
[18:01:26.486]             }
[18:01:26.486]         }
[18:01:26.486]     })
[18:01:26.486]     if (TRUE) {
[18:01:26.486]         base::sink(type = "output", split = FALSE)
[18:01:26.486]         if (TRUE) {
[18:01:26.486]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:26.486]         }
[18:01:26.486]         else {
[18:01:26.486]             ...future.result["stdout"] <- base::list(NULL)
[18:01:26.486]         }
[18:01:26.486]         base::close(...future.stdout)
[18:01:26.486]         ...future.stdout <- NULL
[18:01:26.486]     }
[18:01:26.486]     ...future.result$conditions <- ...future.conditions
[18:01:26.486]     ...future.result$finished <- base::Sys.time()
[18:01:26.486]     ...future.result
[18:01:26.486] }
[18:01:26.571] MultisessionFuture started
[18:01:26.572] result() for ClusterFuture ...
[18:01:26.572] receiveMessageFromWorker() for ClusterFuture ...
[18:01:26.573] - Validating connection of MultisessionFuture
[18:01:26.630] - received message: FutureResult
[18:01:26.630] - Received FutureResult
[18:01:26.634] - Erased future from FutureRegistry
[18:01:26.634] result() for ClusterFuture ...
[18:01:26.634] - result already collected: FutureResult
[18:01:26.634] result() for ClusterFuture ... done
[18:01:26.634] receiveMessageFromWorker() for ClusterFuture ... done
[18:01:26.635] result() for ClusterFuture ... done
[18:01:26.635] result() for ClusterFuture ...
[18:01:26.635] - result already collected: FutureResult
[18:01:26.635] result() for ClusterFuture ... done
[18:01:26.635] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[18:01:26.638] plan(): nbrOfWorkers() = 2
[18:01:26.640] getGlobalsAndPackages() ...
[18:01:26.641] 
[18:01:26.641] - globals: [0] <none>
[18:01:26.641] getGlobalsAndPackages() ... DONE
[18:01:26.653] Packages needed by the future expression (n = 0): <none>
[18:01:26.653] Packages needed by future strategies (n = 0): <none>
[18:01:26.654] {
[18:01:26.654]     {
[18:01:26.654]         {
[18:01:26.654]             ...future.startTime <- base::Sys.time()
[18:01:26.654]             {
[18:01:26.654]                 {
[18:01:26.654]                   {
[18:01:26.654]                     {
[18:01:26.654]                       base::local({
[18:01:26.654]                         has_future <- base::requireNamespace("future", 
[18:01:26.654]                           quietly = TRUE)
[18:01:26.654]                         if (has_future) {
[18:01:26.654]                           ns <- base::getNamespace("future")
[18:01:26.654]                           version <- ns[[".package"]][["version"]]
[18:01:26.654]                           if (is.null(version)) 
[18:01:26.654]                             version <- utils::packageVersion("future")
[18:01:26.654]                         }
[18:01:26.654]                         else {
[18:01:26.654]                           version <- NULL
[18:01:26.654]                         }
[18:01:26.654]                         if (!has_future || version < "1.8.0") {
[18:01:26.654]                           info <- base::c(r_version = base::gsub("R version ", 
[18:01:26.654]                             "", base::R.version$version.string), 
[18:01:26.654]                             platform = base::sprintf("%s (%s-bit)", 
[18:01:26.654]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:26.654]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:26.654]                               "release", "version")], collapse = " "), 
[18:01:26.654]                             hostname = base::Sys.info()[["nodename"]])
[18:01:26.654]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:01:26.654]                             info)
[18:01:26.654]                           info <- base::paste(info, collapse = "; ")
[18:01:26.654]                           if (!has_future) {
[18:01:26.654]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:26.654]                               info)
[18:01:26.654]                           }
[18:01:26.654]                           else {
[18:01:26.654]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:26.654]                               info, version)
[18:01:26.654]                           }
[18:01:26.654]                           base::stop(msg)
[18:01:26.654]                         }
[18:01:26.654]                       })
[18:01:26.654]                     }
[18:01:26.654]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:01:26.654]                     base::options(mc.cores = 1L)
[18:01:26.654]                   }
[18:01:26.654]                   options(future.plan = NULL)
[18:01:26.654]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.654]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:26.654]                 }
[18:01:26.654]                 ...future.workdir <- getwd()
[18:01:26.654]             }
[18:01:26.654]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:26.654]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:26.654]         }
[18:01:26.654]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:26.654]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:26.654]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:26.654]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:26.654]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:26.654]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:26.654]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:26.654]             base::names(...future.oldOptions))
[18:01:26.654]     }
[18:01:26.654]     if (FALSE) {
[18:01:26.654]     }
[18:01:26.654]     else {
[18:01:26.654]         if (TRUE) {
[18:01:26.654]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:26.654]                 open = "w")
[18:01:26.654]         }
[18:01:26.654]         else {
[18:01:26.654]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:26.654]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:26.654]         }
[18:01:26.654]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:26.654]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:26.654]             base::sink(type = "output", split = FALSE)
[18:01:26.654]             base::close(...future.stdout)
[18:01:26.654]         }, add = TRUE)
[18:01:26.654]     }
[18:01:26.654]     ...future.frame <- base::sys.nframe()
[18:01:26.654]     ...future.conditions <- base::list()
[18:01:26.654]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:26.654]     if (FALSE) {
[18:01:26.654]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:26.654]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:26.654]     }
[18:01:26.654]     ...future.result <- base::tryCatch({
[18:01:26.654]         base::withCallingHandlers({
[18:01:26.654]             ...future.value <- base::withVisible(base::local({
[18:01:26.654]                 ...future.makeSendCondition <- local({
[18:01:26.654]                   sendCondition <- NULL
[18:01:26.654]                   function(frame = 1L) {
[18:01:26.654]                     if (is.function(sendCondition)) 
[18:01:26.654]                       return(sendCondition)
[18:01:26.654]                     ns <- getNamespace("parallel")
[18:01:26.654]                     if (exists("sendData", mode = "function", 
[18:01:26.654]                       envir = ns)) {
[18:01:26.654]                       parallel_sendData <- get("sendData", mode = "function", 
[18:01:26.654]                         envir = ns)
[18:01:26.654]                       envir <- sys.frame(frame)
[18:01:26.654]                       master <- NULL
[18:01:26.654]                       while (!identical(envir, .GlobalEnv) && 
[18:01:26.654]                         !identical(envir, emptyenv())) {
[18:01:26.654]                         if (exists("master", mode = "list", envir = envir, 
[18:01:26.654]                           inherits = FALSE)) {
[18:01:26.654]                           master <- get("master", mode = "list", 
[18:01:26.654]                             envir = envir, inherits = FALSE)
[18:01:26.654]                           if (inherits(master, c("SOCKnode", 
[18:01:26.654]                             "SOCK0node"))) {
[18:01:26.654]                             sendCondition <<- function(cond) {
[18:01:26.654]                               data <- list(type = "VALUE", value = cond, 
[18:01:26.654]                                 success = TRUE)
[18:01:26.654]                               parallel_sendData(master, data)
[18:01:26.654]                             }
[18:01:26.654]                             return(sendCondition)
[18:01:26.654]                           }
[18:01:26.654]                         }
[18:01:26.654]                         frame <- frame + 1L
[18:01:26.654]                         envir <- sys.frame(frame)
[18:01:26.654]                       }
[18:01:26.654]                     }
[18:01:26.654]                     sendCondition <<- function(cond) NULL
[18:01:26.654]                   }
[18:01:26.654]                 })
[18:01:26.654]                 withCallingHandlers({
[18:01:26.654]                   42
[18:01:26.654]                 }, immediateCondition = function(cond) {
[18:01:26.654]                   sendCondition <- ...future.makeSendCondition()
[18:01:26.654]                   sendCondition(cond)
[18:01:26.654]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.654]                   {
[18:01:26.654]                     inherits <- base::inherits
[18:01:26.654]                     invokeRestart <- base::invokeRestart
[18:01:26.654]                     is.null <- base::is.null
[18:01:26.654]                     muffled <- FALSE
[18:01:26.654]                     if (inherits(cond, "message")) {
[18:01:26.654]                       muffled <- grepl(pattern, "muffleMessage")
[18:01:26.654]                       if (muffled) 
[18:01:26.654]                         invokeRestart("muffleMessage")
[18:01:26.654]                     }
[18:01:26.654]                     else if (inherits(cond, "warning")) {
[18:01:26.654]                       muffled <- grepl(pattern, "muffleWarning")
[18:01:26.654]                       if (muffled) 
[18:01:26.654]                         invokeRestart("muffleWarning")
[18:01:26.654]                     }
[18:01:26.654]                     else if (inherits(cond, "condition")) {
[18:01:26.654]                       if (!is.null(pattern)) {
[18:01:26.654]                         computeRestarts <- base::computeRestarts
[18:01:26.654]                         grepl <- base::grepl
[18:01:26.654]                         restarts <- computeRestarts(cond)
[18:01:26.654]                         for (restart in restarts) {
[18:01:26.654]                           name <- restart$name
[18:01:26.654]                           if (is.null(name)) 
[18:01:26.654]                             next
[18:01:26.654]                           if (!grepl(pattern, name)) 
[18:01:26.654]                             next
[18:01:26.654]                           invokeRestart(restart)
[18:01:26.654]                           muffled <- TRUE
[18:01:26.654]                           break
[18:01:26.654]                         }
[18:01:26.654]                       }
[18:01:26.654]                     }
[18:01:26.654]                     invisible(muffled)
[18:01:26.654]                   }
[18:01:26.654]                   muffleCondition(cond)
[18:01:26.654]                 })
[18:01:26.654]             }))
[18:01:26.654]             future::FutureResult(value = ...future.value$value, 
[18:01:26.654]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.654]                   ...future.rng), globalenv = if (FALSE) 
[18:01:26.654]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:26.654]                     ...future.globalenv.names))
[18:01:26.654]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:26.654]         }, condition = base::local({
[18:01:26.654]             c <- base::c
[18:01:26.654]             inherits <- base::inherits
[18:01:26.654]             invokeRestart <- base::invokeRestart
[18:01:26.654]             length <- base::length
[18:01:26.654]             list <- base::list
[18:01:26.654]             seq.int <- base::seq.int
[18:01:26.654]             signalCondition <- base::signalCondition
[18:01:26.654]             sys.calls <- base::sys.calls
[18:01:26.654]             `[[` <- base::`[[`
[18:01:26.654]             `+` <- base::`+`
[18:01:26.654]             `<<-` <- base::`<<-`
[18:01:26.654]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:26.654]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:26.654]                   3L)]
[18:01:26.654]             }
[18:01:26.654]             function(cond) {
[18:01:26.654]                 is_error <- inherits(cond, "error")
[18:01:26.654]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:26.654]                   NULL)
[18:01:26.654]                 if (is_error) {
[18:01:26.654]                   sessionInformation <- function() {
[18:01:26.654]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:26.654]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:26.654]                       search = base::search(), system = base::Sys.info())
[18:01:26.654]                   }
[18:01:26.654]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.654]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:26.654]                     cond$call), session = sessionInformation(), 
[18:01:26.654]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:26.654]                   signalCondition(cond)
[18:01:26.654]                 }
[18:01:26.654]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:26.654]                 "immediateCondition"))) {
[18:01:26.654]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:26.654]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.654]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:26.654]                   if (TRUE && !signal) {
[18:01:26.654]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.654]                     {
[18:01:26.654]                       inherits <- base::inherits
[18:01:26.654]                       invokeRestart <- base::invokeRestart
[18:01:26.654]                       is.null <- base::is.null
[18:01:26.654]                       muffled <- FALSE
[18:01:26.654]                       if (inherits(cond, "message")) {
[18:01:26.654]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.654]                         if (muffled) 
[18:01:26.654]                           invokeRestart("muffleMessage")
[18:01:26.654]                       }
[18:01:26.654]                       else if (inherits(cond, "warning")) {
[18:01:26.654]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.654]                         if (muffled) 
[18:01:26.654]                           invokeRestart("muffleWarning")
[18:01:26.654]                       }
[18:01:26.654]                       else if (inherits(cond, "condition")) {
[18:01:26.654]                         if (!is.null(pattern)) {
[18:01:26.654]                           computeRestarts <- base::computeRestarts
[18:01:26.654]                           grepl <- base::grepl
[18:01:26.654]                           restarts <- computeRestarts(cond)
[18:01:26.654]                           for (restart in restarts) {
[18:01:26.654]                             name <- restart$name
[18:01:26.654]                             if (is.null(name)) 
[18:01:26.654]                               next
[18:01:26.654]                             if (!grepl(pattern, name)) 
[18:01:26.654]                               next
[18:01:26.654]                             invokeRestart(restart)
[18:01:26.654]                             muffled <- TRUE
[18:01:26.654]                             break
[18:01:26.654]                           }
[18:01:26.654]                         }
[18:01:26.654]                       }
[18:01:26.654]                       invisible(muffled)
[18:01:26.654]                     }
[18:01:26.654]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.654]                   }
[18:01:26.654]                 }
[18:01:26.654]                 else {
[18:01:26.654]                   if (TRUE) {
[18:01:26.654]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.654]                     {
[18:01:26.654]                       inherits <- base::inherits
[18:01:26.654]                       invokeRestart <- base::invokeRestart
[18:01:26.654]                       is.null <- base::is.null
[18:01:26.654]                       muffled <- FALSE
[18:01:26.654]                       if (inherits(cond, "message")) {
[18:01:26.654]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.654]                         if (muffled) 
[18:01:26.654]                           invokeRestart("muffleMessage")
[18:01:26.654]                       }
[18:01:26.654]                       else if (inherits(cond, "warning")) {
[18:01:26.654]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.654]                         if (muffled) 
[18:01:26.654]                           invokeRestart("muffleWarning")
[18:01:26.654]                       }
[18:01:26.654]                       else if (inherits(cond, "condition")) {
[18:01:26.654]                         if (!is.null(pattern)) {
[18:01:26.654]                           computeRestarts <- base::computeRestarts
[18:01:26.654]                           grepl <- base::grepl
[18:01:26.654]                           restarts <- computeRestarts(cond)
[18:01:26.654]                           for (restart in restarts) {
[18:01:26.654]                             name <- restart$name
[18:01:26.654]                             if (is.null(name)) 
[18:01:26.654]                               next
[18:01:26.654]                             if (!grepl(pattern, name)) 
[18:01:26.654]                               next
[18:01:26.654]                             invokeRestart(restart)
[18:01:26.654]                             muffled <- TRUE
[18:01:26.654]                             break
[18:01:26.654]                           }
[18:01:26.654]                         }
[18:01:26.654]                       }
[18:01:26.654]                       invisible(muffled)
[18:01:26.654]                     }
[18:01:26.654]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.654]                   }
[18:01:26.654]                 }
[18:01:26.654]             }
[18:01:26.654]         }))
[18:01:26.654]     }, error = function(ex) {
[18:01:26.654]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:26.654]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.654]                 ...future.rng), started = ...future.startTime, 
[18:01:26.654]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:26.654]             version = "1.8"), class = "FutureResult")
[18:01:26.654]     }, finally = {
[18:01:26.654]         if (!identical(...future.workdir, getwd())) 
[18:01:26.654]             setwd(...future.workdir)
[18:01:26.654]         {
[18:01:26.654]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:26.654]                 ...future.oldOptions$nwarnings <- NULL
[18:01:26.654]             }
[18:01:26.654]             base::options(...future.oldOptions)
[18:01:26.654]             if (.Platform$OS.type == "windows") {
[18:01:26.654]                 old_names <- names(...future.oldEnvVars)
[18:01:26.654]                 envs <- base::Sys.getenv()
[18:01:26.654]                 names <- names(envs)
[18:01:26.654]                 common <- intersect(names, old_names)
[18:01:26.654]                 added <- setdiff(names, old_names)
[18:01:26.654]                 removed <- setdiff(old_names, names)
[18:01:26.654]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:26.654]                   envs[common]]
[18:01:26.654]                 NAMES <- toupper(changed)
[18:01:26.654]                 args <- list()
[18:01:26.654]                 for (kk in seq_along(NAMES)) {
[18:01:26.654]                   name <- changed[[kk]]
[18:01:26.654]                   NAME <- NAMES[[kk]]
[18:01:26.654]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.654]                     next
[18:01:26.654]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.654]                 }
[18:01:26.654]                 NAMES <- toupper(added)
[18:01:26.654]                 for (kk in seq_along(NAMES)) {
[18:01:26.654]                   name <- added[[kk]]
[18:01:26.654]                   NAME <- NAMES[[kk]]
[18:01:26.654]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.654]                     next
[18:01:26.654]                   args[[name]] <- ""
[18:01:26.654]                 }
[18:01:26.654]                 NAMES <- toupper(removed)
[18:01:26.654]                 for (kk in seq_along(NAMES)) {
[18:01:26.654]                   name <- removed[[kk]]
[18:01:26.654]                   NAME <- NAMES[[kk]]
[18:01:26.654]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.654]                     next
[18:01:26.654]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.654]                 }
[18:01:26.654]                 if (length(args) > 0) 
[18:01:26.654]                   base::do.call(base::Sys.setenv, args = args)
[18:01:26.654]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:26.654]             }
[18:01:26.654]             else {
[18:01:26.654]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:26.654]             }
[18:01:26.654]             {
[18:01:26.654]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:26.654]                   0L) {
[18:01:26.654]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:26.654]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:26.654]                   base::options(opts)
[18:01:26.654]                 }
[18:01:26.654]                 {
[18:01:26.654]                   {
[18:01:26.654]                     base::options(mc.cores = ...future.mc.cores.old)
[18:01:26.654]                     NULL
[18:01:26.654]                   }
[18:01:26.654]                   options(future.plan = NULL)
[18:01:26.654]                   if (is.na(NA_character_)) 
[18:01:26.654]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.654]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:26.654]                   future::plan(list(function (..., workers = availableCores(), 
[18:01:26.654]                     lazy = FALSE, rscript_libs = .libPaths(), 
[18:01:26.654]                     envir = parent.frame()) 
[18:01:26.654]                   {
[18:01:26.654]                     if (is.function(workers)) 
[18:01:26.654]                       workers <- workers()
[18:01:26.654]                     workers <- structure(as.integer(workers), 
[18:01:26.654]                       class = class(workers))
[18:01:26.654]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[18:01:26.654]                       workers >= 1)
[18:01:26.654]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[18:01:26.654]                       return(sequential(..., lazy = TRUE, envir = envir))
[18:01:26.654]                     }
[18:01:26.654]                     future <- MultisessionFuture(..., workers = workers, 
[18:01:26.654]                       lazy = lazy, rscript_libs = rscript_libs, 
[18:01:26.654]                       envir = envir)
[18:01:26.654]                     if (!future$lazy) 
[18:01:26.654]                       future <- run(future)
[18:01:26.654]                     invisible(future)
[18:01:26.654]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:26.654]                 }
[18:01:26.654]             }
[18:01:26.654]         }
[18:01:26.654]     })
[18:01:26.654]     if (TRUE) {
[18:01:26.654]         base::sink(type = "output", split = FALSE)
[18:01:26.654]         if (TRUE) {
[18:01:26.654]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:26.654]         }
[18:01:26.654]         else {
[18:01:26.654]             ...future.result["stdout"] <- base::list(NULL)
[18:01:26.654]         }
[18:01:26.654]         base::close(...future.stdout)
[18:01:26.654]         ...future.stdout <- NULL
[18:01:26.654]     }
[18:01:26.654]     ...future.result$conditions <- ...future.conditions
[18:01:26.654]     ...future.result$finished <- base::Sys.time()
[18:01:26.654]     ...future.result
[18:01:26.654] }
[18:01:26.660] MultisessionFuture started
MultisessionFuture:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:01:26.677] receiveMessageFromWorker() for ClusterFuture ...
[18:01:26.677] - Validating connection of MultisessionFuture
[18:01:26.678] - received message: FutureResult
[18:01:26.678] - Received FutureResult
[18:01:26.678] - Erased future from FutureRegistry
[18:01:26.678] result() for ClusterFuture ...
[18:01:26.679] - result already collected: FutureResult
[18:01:26.679] result() for ClusterFuture ... done
[18:01:26.679] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: fd4a23fd-3f1e-941b-f00a-64835db9cc52
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:01:26.679] result() for ClusterFuture ...
[18:01:26.679] - result already collected: FutureResult
[18:01:26.680] result() for ClusterFuture ... done
[18:01:26.680] result() for ClusterFuture ...
[18:01:26.680] - result already collected: FutureResult
[18:01:26.680] result() for ClusterFuture ... done
[18:01:26.680] getGlobalsAndPackages() ...
[18:01:26.681] Searching for globals...
[18:01:26.681] 
[18:01:26.681] Searching for globals ... DONE
[18:01:26.681] - globals: [0] <none>
[18:01:26.682] getGlobalsAndPackages() ... DONE
[18:01:26.682] run() for 'Future' ...
[18:01:26.682] - state: 'created'
[18:01:26.682] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:01:26.696] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:01:26.697] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:01:26.697]   - Field: 'node'
[18:01:26.697]   - Field: 'label'
[18:01:26.697]   - Field: 'local'
[18:01:26.697]   - Field: 'owner'
[18:01:26.698]   - Field: 'envir'
[18:01:26.698]   - Field: 'workers'
[18:01:26.698]   - Field: 'packages'
[18:01:26.698]   - Field: 'gc'
[18:01:26.698]   - Field: 'conditions'
[18:01:26.699]   - Field: 'persistent'
[18:01:26.699]   - Field: 'expr'
[18:01:26.699]   - Field: 'uuid'
[18:01:26.699]   - Field: 'seed'
[18:01:26.699]   - Field: 'version'
[18:01:26.700]   - Field: 'result'
[18:01:26.700]   - Field: 'asynchronous'
[18:01:26.700]   - Field: 'calls'
[18:01:26.700]   - Field: 'globals'
[18:01:26.700]   - Field: 'stdout'
[18:01:26.701]   - Field: 'earlySignal'
[18:01:26.701]   - Field: 'lazy'
[18:01:26.701]   - Field: 'state'
[18:01:26.701] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:01:26.701] - Launch lazy future ...
[18:01:26.702] Packages needed by the future expression (n = 0): <none>
[18:01:26.702] Packages needed by future strategies (n = 0): <none>
[18:01:26.703] {
[18:01:26.703]     {
[18:01:26.703]         {
[18:01:26.703]             ...future.startTime <- base::Sys.time()
[18:01:26.703]             {
[18:01:26.703]                 {
[18:01:26.703]                   {
[18:01:26.703]                     {
[18:01:26.703]                       base::local({
[18:01:26.703]                         has_future <- base::requireNamespace("future", 
[18:01:26.703]                           quietly = TRUE)
[18:01:26.703]                         if (has_future) {
[18:01:26.703]                           ns <- base::getNamespace("future")
[18:01:26.703]                           version <- ns[[".package"]][["version"]]
[18:01:26.703]                           if (is.null(version)) 
[18:01:26.703]                             version <- utils::packageVersion("future")
[18:01:26.703]                         }
[18:01:26.703]                         else {
[18:01:26.703]                           version <- NULL
[18:01:26.703]                         }
[18:01:26.703]                         if (!has_future || version < "1.8.0") {
[18:01:26.703]                           info <- base::c(r_version = base::gsub("R version ", 
[18:01:26.703]                             "", base::R.version$version.string), 
[18:01:26.703]                             platform = base::sprintf("%s (%s-bit)", 
[18:01:26.703]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:26.703]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:26.703]                               "release", "version")], collapse = " "), 
[18:01:26.703]                             hostname = base::Sys.info()[["nodename"]])
[18:01:26.703]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:01:26.703]                             info)
[18:01:26.703]                           info <- base::paste(info, collapse = "; ")
[18:01:26.703]                           if (!has_future) {
[18:01:26.703]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:26.703]                               info)
[18:01:26.703]                           }
[18:01:26.703]                           else {
[18:01:26.703]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:26.703]                               info, version)
[18:01:26.703]                           }
[18:01:26.703]                           base::stop(msg)
[18:01:26.703]                         }
[18:01:26.703]                       })
[18:01:26.703]                     }
[18:01:26.703]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:01:26.703]                     base::options(mc.cores = 1L)
[18:01:26.703]                   }
[18:01:26.703]                   options(future.plan = NULL)
[18:01:26.703]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.703]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:26.703]                 }
[18:01:26.703]                 ...future.workdir <- getwd()
[18:01:26.703]             }
[18:01:26.703]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:26.703]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:26.703]         }
[18:01:26.703]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:26.703]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:26.703]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:26.703]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:26.703]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:26.703]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:26.703]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:26.703]             base::names(...future.oldOptions))
[18:01:26.703]     }
[18:01:26.703]     if (FALSE) {
[18:01:26.703]     }
[18:01:26.703]     else {
[18:01:26.703]         if (TRUE) {
[18:01:26.703]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:26.703]                 open = "w")
[18:01:26.703]         }
[18:01:26.703]         else {
[18:01:26.703]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:26.703]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:26.703]         }
[18:01:26.703]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:26.703]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:26.703]             base::sink(type = "output", split = FALSE)
[18:01:26.703]             base::close(...future.stdout)
[18:01:26.703]         }, add = TRUE)
[18:01:26.703]     }
[18:01:26.703]     ...future.frame <- base::sys.nframe()
[18:01:26.703]     ...future.conditions <- base::list()
[18:01:26.703]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:26.703]     if (FALSE) {
[18:01:26.703]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:26.703]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:26.703]     }
[18:01:26.703]     ...future.result <- base::tryCatch({
[18:01:26.703]         base::withCallingHandlers({
[18:01:26.703]             ...future.value <- base::withVisible(base::local({
[18:01:26.703]                 ...future.makeSendCondition <- local({
[18:01:26.703]                   sendCondition <- NULL
[18:01:26.703]                   function(frame = 1L) {
[18:01:26.703]                     if (is.function(sendCondition)) 
[18:01:26.703]                       return(sendCondition)
[18:01:26.703]                     ns <- getNamespace("parallel")
[18:01:26.703]                     if (exists("sendData", mode = "function", 
[18:01:26.703]                       envir = ns)) {
[18:01:26.703]                       parallel_sendData <- get("sendData", mode = "function", 
[18:01:26.703]                         envir = ns)
[18:01:26.703]                       envir <- sys.frame(frame)
[18:01:26.703]                       master <- NULL
[18:01:26.703]                       while (!identical(envir, .GlobalEnv) && 
[18:01:26.703]                         !identical(envir, emptyenv())) {
[18:01:26.703]                         if (exists("master", mode = "list", envir = envir, 
[18:01:26.703]                           inherits = FALSE)) {
[18:01:26.703]                           master <- get("master", mode = "list", 
[18:01:26.703]                             envir = envir, inherits = FALSE)
[18:01:26.703]                           if (inherits(master, c("SOCKnode", 
[18:01:26.703]                             "SOCK0node"))) {
[18:01:26.703]                             sendCondition <<- function(cond) {
[18:01:26.703]                               data <- list(type = "VALUE", value = cond, 
[18:01:26.703]                                 success = TRUE)
[18:01:26.703]                               parallel_sendData(master, data)
[18:01:26.703]                             }
[18:01:26.703]                             return(sendCondition)
[18:01:26.703]                           }
[18:01:26.703]                         }
[18:01:26.703]                         frame <- frame + 1L
[18:01:26.703]                         envir <- sys.frame(frame)
[18:01:26.703]                       }
[18:01:26.703]                     }
[18:01:26.703]                     sendCondition <<- function(cond) NULL
[18:01:26.703]                   }
[18:01:26.703]                 })
[18:01:26.703]                 withCallingHandlers({
[18:01:26.703]                   42
[18:01:26.703]                 }, immediateCondition = function(cond) {
[18:01:26.703]                   sendCondition <- ...future.makeSendCondition()
[18:01:26.703]                   sendCondition(cond)
[18:01:26.703]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.703]                   {
[18:01:26.703]                     inherits <- base::inherits
[18:01:26.703]                     invokeRestart <- base::invokeRestart
[18:01:26.703]                     is.null <- base::is.null
[18:01:26.703]                     muffled <- FALSE
[18:01:26.703]                     if (inherits(cond, "message")) {
[18:01:26.703]                       muffled <- grepl(pattern, "muffleMessage")
[18:01:26.703]                       if (muffled) 
[18:01:26.703]                         invokeRestart("muffleMessage")
[18:01:26.703]                     }
[18:01:26.703]                     else if (inherits(cond, "warning")) {
[18:01:26.703]                       muffled <- grepl(pattern, "muffleWarning")
[18:01:26.703]                       if (muffled) 
[18:01:26.703]                         invokeRestart("muffleWarning")
[18:01:26.703]                     }
[18:01:26.703]                     else if (inherits(cond, "condition")) {
[18:01:26.703]                       if (!is.null(pattern)) {
[18:01:26.703]                         computeRestarts <- base::computeRestarts
[18:01:26.703]                         grepl <- base::grepl
[18:01:26.703]                         restarts <- computeRestarts(cond)
[18:01:26.703]                         for (restart in restarts) {
[18:01:26.703]                           name <- restart$name
[18:01:26.703]                           if (is.null(name)) 
[18:01:26.703]                             next
[18:01:26.703]                           if (!grepl(pattern, name)) 
[18:01:26.703]                             next
[18:01:26.703]                           invokeRestart(restart)
[18:01:26.703]                           muffled <- TRUE
[18:01:26.703]                           break
[18:01:26.703]                         }
[18:01:26.703]                       }
[18:01:26.703]                     }
[18:01:26.703]                     invisible(muffled)
[18:01:26.703]                   }
[18:01:26.703]                   muffleCondition(cond)
[18:01:26.703]                 })
[18:01:26.703]             }))
[18:01:26.703]             future::FutureResult(value = ...future.value$value, 
[18:01:26.703]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.703]                   ...future.rng), globalenv = if (FALSE) 
[18:01:26.703]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:26.703]                     ...future.globalenv.names))
[18:01:26.703]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:26.703]         }, condition = base::local({
[18:01:26.703]             c <- base::c
[18:01:26.703]             inherits <- base::inherits
[18:01:26.703]             invokeRestart <- base::invokeRestart
[18:01:26.703]             length <- base::length
[18:01:26.703]             list <- base::list
[18:01:26.703]             seq.int <- base::seq.int
[18:01:26.703]             signalCondition <- base::signalCondition
[18:01:26.703]             sys.calls <- base::sys.calls
[18:01:26.703]             `[[` <- base::`[[`
[18:01:26.703]             `+` <- base::`+`
[18:01:26.703]             `<<-` <- base::`<<-`
[18:01:26.703]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:26.703]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:26.703]                   3L)]
[18:01:26.703]             }
[18:01:26.703]             function(cond) {
[18:01:26.703]                 is_error <- inherits(cond, "error")
[18:01:26.703]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:26.703]                   NULL)
[18:01:26.703]                 if (is_error) {
[18:01:26.703]                   sessionInformation <- function() {
[18:01:26.703]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:26.703]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:26.703]                       search = base::search(), system = base::Sys.info())
[18:01:26.703]                   }
[18:01:26.703]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.703]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:26.703]                     cond$call), session = sessionInformation(), 
[18:01:26.703]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:26.703]                   signalCondition(cond)
[18:01:26.703]                 }
[18:01:26.703]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:26.703]                 "immediateCondition"))) {
[18:01:26.703]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:26.703]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.703]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:26.703]                   if (TRUE && !signal) {
[18:01:26.703]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.703]                     {
[18:01:26.703]                       inherits <- base::inherits
[18:01:26.703]                       invokeRestart <- base::invokeRestart
[18:01:26.703]                       is.null <- base::is.null
[18:01:26.703]                       muffled <- FALSE
[18:01:26.703]                       if (inherits(cond, "message")) {
[18:01:26.703]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.703]                         if (muffled) 
[18:01:26.703]                           invokeRestart("muffleMessage")
[18:01:26.703]                       }
[18:01:26.703]                       else if (inherits(cond, "warning")) {
[18:01:26.703]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.703]                         if (muffled) 
[18:01:26.703]                           invokeRestart("muffleWarning")
[18:01:26.703]                       }
[18:01:26.703]                       else if (inherits(cond, "condition")) {
[18:01:26.703]                         if (!is.null(pattern)) {
[18:01:26.703]                           computeRestarts <- base::computeRestarts
[18:01:26.703]                           grepl <- base::grepl
[18:01:26.703]                           restarts <- computeRestarts(cond)
[18:01:26.703]                           for (restart in restarts) {
[18:01:26.703]                             name <- restart$name
[18:01:26.703]                             if (is.null(name)) 
[18:01:26.703]                               next
[18:01:26.703]                             if (!grepl(pattern, name)) 
[18:01:26.703]                               next
[18:01:26.703]                             invokeRestart(restart)
[18:01:26.703]                             muffled <- TRUE
[18:01:26.703]                             break
[18:01:26.703]                           }
[18:01:26.703]                         }
[18:01:26.703]                       }
[18:01:26.703]                       invisible(muffled)
[18:01:26.703]                     }
[18:01:26.703]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.703]                   }
[18:01:26.703]                 }
[18:01:26.703]                 else {
[18:01:26.703]                   if (TRUE) {
[18:01:26.703]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.703]                     {
[18:01:26.703]                       inherits <- base::inherits
[18:01:26.703]                       invokeRestart <- base::invokeRestart
[18:01:26.703]                       is.null <- base::is.null
[18:01:26.703]                       muffled <- FALSE
[18:01:26.703]                       if (inherits(cond, "message")) {
[18:01:26.703]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.703]                         if (muffled) 
[18:01:26.703]                           invokeRestart("muffleMessage")
[18:01:26.703]                       }
[18:01:26.703]                       else if (inherits(cond, "warning")) {
[18:01:26.703]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.703]                         if (muffled) 
[18:01:26.703]                           invokeRestart("muffleWarning")
[18:01:26.703]                       }
[18:01:26.703]                       else if (inherits(cond, "condition")) {
[18:01:26.703]                         if (!is.null(pattern)) {
[18:01:26.703]                           computeRestarts <- base::computeRestarts
[18:01:26.703]                           grepl <- base::grepl
[18:01:26.703]                           restarts <- computeRestarts(cond)
[18:01:26.703]                           for (restart in restarts) {
[18:01:26.703]                             name <- restart$name
[18:01:26.703]                             if (is.null(name)) 
[18:01:26.703]                               next
[18:01:26.703]                             if (!grepl(pattern, name)) 
[18:01:26.703]                               next
[18:01:26.703]                             invokeRestart(restart)
[18:01:26.703]                             muffled <- TRUE
[18:01:26.703]                             break
[18:01:26.703]                           }
[18:01:26.703]                         }
[18:01:26.703]                       }
[18:01:26.703]                       invisible(muffled)
[18:01:26.703]                     }
[18:01:26.703]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.703]                   }
[18:01:26.703]                 }
[18:01:26.703]             }
[18:01:26.703]         }))
[18:01:26.703]     }, error = function(ex) {
[18:01:26.703]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:26.703]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.703]                 ...future.rng), started = ...future.startTime, 
[18:01:26.703]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:26.703]             version = "1.8"), class = "FutureResult")
[18:01:26.703]     }, finally = {
[18:01:26.703]         if (!identical(...future.workdir, getwd())) 
[18:01:26.703]             setwd(...future.workdir)
[18:01:26.703]         {
[18:01:26.703]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:26.703]                 ...future.oldOptions$nwarnings <- NULL
[18:01:26.703]             }
[18:01:26.703]             base::options(...future.oldOptions)
[18:01:26.703]             if (.Platform$OS.type == "windows") {
[18:01:26.703]                 old_names <- names(...future.oldEnvVars)
[18:01:26.703]                 envs <- base::Sys.getenv()
[18:01:26.703]                 names <- names(envs)
[18:01:26.703]                 common <- intersect(names, old_names)
[18:01:26.703]                 added <- setdiff(names, old_names)
[18:01:26.703]                 removed <- setdiff(old_names, names)
[18:01:26.703]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:26.703]                   envs[common]]
[18:01:26.703]                 NAMES <- toupper(changed)
[18:01:26.703]                 args <- list()
[18:01:26.703]                 for (kk in seq_along(NAMES)) {
[18:01:26.703]                   name <- changed[[kk]]
[18:01:26.703]                   NAME <- NAMES[[kk]]
[18:01:26.703]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.703]                     next
[18:01:26.703]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.703]                 }
[18:01:26.703]                 NAMES <- toupper(added)
[18:01:26.703]                 for (kk in seq_along(NAMES)) {
[18:01:26.703]                   name <- added[[kk]]
[18:01:26.703]                   NAME <- NAMES[[kk]]
[18:01:26.703]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.703]                     next
[18:01:26.703]                   args[[name]] <- ""
[18:01:26.703]                 }
[18:01:26.703]                 NAMES <- toupper(removed)
[18:01:26.703]                 for (kk in seq_along(NAMES)) {
[18:01:26.703]                   name <- removed[[kk]]
[18:01:26.703]                   NAME <- NAMES[[kk]]
[18:01:26.703]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.703]                     next
[18:01:26.703]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.703]                 }
[18:01:26.703]                 if (length(args) > 0) 
[18:01:26.703]                   base::do.call(base::Sys.setenv, args = args)
[18:01:26.703]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:26.703]             }
[18:01:26.703]             else {
[18:01:26.703]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:26.703]             }
[18:01:26.703]             {
[18:01:26.703]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:26.703]                   0L) {
[18:01:26.703]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:26.703]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:26.703]                   base::options(opts)
[18:01:26.703]                 }
[18:01:26.703]                 {
[18:01:26.703]                   {
[18:01:26.703]                     base::options(mc.cores = ...future.mc.cores.old)
[18:01:26.703]                     NULL
[18:01:26.703]                   }
[18:01:26.703]                   options(future.plan = NULL)
[18:01:26.703]                   if (is.na(NA_character_)) 
[18:01:26.703]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.703]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:26.703]                   future::plan(list(function (..., workers = availableCores(), 
[18:01:26.703]                     lazy = FALSE, rscript_libs = .libPaths(), 
[18:01:26.703]                     envir = parent.frame()) 
[18:01:26.703]                   {
[18:01:26.703]                     if (is.function(workers)) 
[18:01:26.703]                       workers <- workers()
[18:01:26.703]                     workers <- structure(as.integer(workers), 
[18:01:26.703]                       class = class(workers))
[18:01:26.703]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[18:01:26.703]                       workers >= 1)
[18:01:26.703]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[18:01:26.703]                       return(sequential(..., lazy = TRUE, envir = envir))
[18:01:26.703]                     }
[18:01:26.703]                     future <- MultisessionFuture(..., workers = workers, 
[18:01:26.703]                       lazy = lazy, rscript_libs = rscript_libs, 
[18:01:26.703]                       envir = envir)
[18:01:26.703]                     if (!future$lazy) 
[18:01:26.703]                       future <- run(future)
[18:01:26.703]                     invisible(future)
[18:01:26.703]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:26.703]                 }
[18:01:26.703]             }
[18:01:26.703]         }
[18:01:26.703]     })
[18:01:26.703]     if (TRUE) {
[18:01:26.703]         base::sink(type = "output", split = FALSE)
[18:01:26.703]         if (TRUE) {
[18:01:26.703]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:26.703]         }
[18:01:26.703]         else {
[18:01:26.703]             ...future.result["stdout"] <- base::list(NULL)
[18:01:26.703]         }
[18:01:26.703]         base::close(...future.stdout)
[18:01:26.703]         ...future.stdout <- NULL
[18:01:26.703]     }
[18:01:26.703]     ...future.result$conditions <- ...future.conditions
[18:01:26.703]     ...future.result$finished <- base::Sys.time()
[18:01:26.703]     ...future.result
[18:01:26.703] }
[18:01:26.709] MultisessionFuture started
[18:01:26.709] - Launch lazy future ... done
[18:01:26.709] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:01:26.725] receiveMessageFromWorker() for ClusterFuture ...
[18:01:26.725] - Validating connection of MultisessionFuture
[18:01:26.725] - received message: FutureResult
[18:01:26.725] - Received FutureResult
[18:01:26.726] - Erased future from FutureRegistry
[18:01:26.726] result() for ClusterFuture ...
[18:01:26.726] - result already collected: FutureResult
[18:01:26.726] result() for ClusterFuture ... done
[18:01:26.726] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: fd4a23fd-3f1e-941b-f00a-64835db9cc52
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:01:26.727] result() for ClusterFuture ...
[18:01:26.727] - result already collected: FutureResult
[18:01:26.727] result() for ClusterFuture ... done
[18:01:26.727] result() for ClusterFuture ...
[18:01:26.727] - result already collected: FutureResult
[18:01:26.728] result() for ClusterFuture ... done
[18:01:26.728] getGlobalsAndPackages() ...
[18:01:26.728] Searching for globals...
[18:01:26.729] - globals found: [1] '{'
[18:01:26.729] Searching for globals ... DONE
[18:01:26.730] Resolving globals: FALSE
[18:01:26.730] 
[18:01:26.730] 
[18:01:26.730] getGlobalsAndPackages() ... DONE
[18:01:26.731] run() for 'Future' ...
[18:01:26.731] - state: 'created'
[18:01:26.731] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:01:26.746] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:01:26.746] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:01:26.746]   - Field: 'node'
[18:01:26.746]   - Field: 'label'
[18:01:26.746]   - Field: 'local'
[18:01:26.747]   - Field: 'owner'
[18:01:26.747]   - Field: 'envir'
[18:01:26.747]   - Field: 'workers'
[18:01:26.747]   - Field: 'packages'
[18:01:26.747]   - Field: 'gc'
[18:01:26.748]   - Field: 'conditions'
[18:01:26.748]   - Field: 'persistent'
[18:01:26.748]   - Field: 'expr'
[18:01:26.748]   - Field: 'uuid'
[18:01:26.748]   - Field: 'seed'
[18:01:26.749]   - Field: 'version'
[18:01:26.749]   - Field: 'result'
[18:01:26.749]   - Field: 'asynchronous'
[18:01:26.749]   - Field: 'calls'
[18:01:26.749]   - Field: 'globals'
[18:01:26.749]   - Field: 'stdout'
[18:01:26.750]   - Field: 'earlySignal'
[18:01:26.750]   - Field: 'lazy'
[18:01:26.750]   - Field: 'state'
[18:01:26.750] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:01:26.750] - Launch lazy future ...
[18:01:26.751] Packages needed by the future expression (n = 0): <none>
[18:01:26.751] Packages needed by future strategies (n = 0): <none>
[18:01:26.752] {
[18:01:26.752]     {
[18:01:26.752]         {
[18:01:26.752]             ...future.startTime <- base::Sys.time()
[18:01:26.752]             {
[18:01:26.752]                 {
[18:01:26.752]                   {
[18:01:26.752]                     {
[18:01:26.752]                       base::local({
[18:01:26.752]                         has_future <- base::requireNamespace("future", 
[18:01:26.752]                           quietly = TRUE)
[18:01:26.752]                         if (has_future) {
[18:01:26.752]                           ns <- base::getNamespace("future")
[18:01:26.752]                           version <- ns[[".package"]][["version"]]
[18:01:26.752]                           if (is.null(version)) 
[18:01:26.752]                             version <- utils::packageVersion("future")
[18:01:26.752]                         }
[18:01:26.752]                         else {
[18:01:26.752]                           version <- NULL
[18:01:26.752]                         }
[18:01:26.752]                         if (!has_future || version < "1.8.0") {
[18:01:26.752]                           info <- base::c(r_version = base::gsub("R version ", 
[18:01:26.752]                             "", base::R.version$version.string), 
[18:01:26.752]                             platform = base::sprintf("%s (%s-bit)", 
[18:01:26.752]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:26.752]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:26.752]                               "release", "version")], collapse = " "), 
[18:01:26.752]                             hostname = base::Sys.info()[["nodename"]])
[18:01:26.752]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:01:26.752]                             info)
[18:01:26.752]                           info <- base::paste(info, collapse = "; ")
[18:01:26.752]                           if (!has_future) {
[18:01:26.752]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:26.752]                               info)
[18:01:26.752]                           }
[18:01:26.752]                           else {
[18:01:26.752]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:26.752]                               info, version)
[18:01:26.752]                           }
[18:01:26.752]                           base::stop(msg)
[18:01:26.752]                         }
[18:01:26.752]                       })
[18:01:26.752]                     }
[18:01:26.752]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:01:26.752]                     base::options(mc.cores = 1L)
[18:01:26.752]                   }
[18:01:26.752]                   options(future.plan = NULL)
[18:01:26.752]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.752]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:26.752]                 }
[18:01:26.752]                 ...future.workdir <- getwd()
[18:01:26.752]             }
[18:01:26.752]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:26.752]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:26.752]         }
[18:01:26.752]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:26.752]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:26.752]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:26.752]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:26.752]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:26.752]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:26.752]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:26.752]             base::names(...future.oldOptions))
[18:01:26.752]     }
[18:01:26.752]     if (FALSE) {
[18:01:26.752]     }
[18:01:26.752]     else {
[18:01:26.752]         if (TRUE) {
[18:01:26.752]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:26.752]                 open = "w")
[18:01:26.752]         }
[18:01:26.752]         else {
[18:01:26.752]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:26.752]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:26.752]         }
[18:01:26.752]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:26.752]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:26.752]             base::sink(type = "output", split = FALSE)
[18:01:26.752]             base::close(...future.stdout)
[18:01:26.752]         }, add = TRUE)
[18:01:26.752]     }
[18:01:26.752]     ...future.frame <- base::sys.nframe()
[18:01:26.752]     ...future.conditions <- base::list()
[18:01:26.752]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:26.752]     if (FALSE) {
[18:01:26.752]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:26.752]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:26.752]     }
[18:01:26.752]     ...future.result <- base::tryCatch({
[18:01:26.752]         base::withCallingHandlers({
[18:01:26.752]             ...future.value <- base::withVisible(base::local({
[18:01:26.752]                 ...future.makeSendCondition <- local({
[18:01:26.752]                   sendCondition <- NULL
[18:01:26.752]                   function(frame = 1L) {
[18:01:26.752]                     if (is.function(sendCondition)) 
[18:01:26.752]                       return(sendCondition)
[18:01:26.752]                     ns <- getNamespace("parallel")
[18:01:26.752]                     if (exists("sendData", mode = "function", 
[18:01:26.752]                       envir = ns)) {
[18:01:26.752]                       parallel_sendData <- get("sendData", mode = "function", 
[18:01:26.752]                         envir = ns)
[18:01:26.752]                       envir <- sys.frame(frame)
[18:01:26.752]                       master <- NULL
[18:01:26.752]                       while (!identical(envir, .GlobalEnv) && 
[18:01:26.752]                         !identical(envir, emptyenv())) {
[18:01:26.752]                         if (exists("master", mode = "list", envir = envir, 
[18:01:26.752]                           inherits = FALSE)) {
[18:01:26.752]                           master <- get("master", mode = "list", 
[18:01:26.752]                             envir = envir, inherits = FALSE)
[18:01:26.752]                           if (inherits(master, c("SOCKnode", 
[18:01:26.752]                             "SOCK0node"))) {
[18:01:26.752]                             sendCondition <<- function(cond) {
[18:01:26.752]                               data <- list(type = "VALUE", value = cond, 
[18:01:26.752]                                 success = TRUE)
[18:01:26.752]                               parallel_sendData(master, data)
[18:01:26.752]                             }
[18:01:26.752]                             return(sendCondition)
[18:01:26.752]                           }
[18:01:26.752]                         }
[18:01:26.752]                         frame <- frame + 1L
[18:01:26.752]                         envir <- sys.frame(frame)
[18:01:26.752]                       }
[18:01:26.752]                     }
[18:01:26.752]                     sendCondition <<- function(cond) NULL
[18:01:26.752]                   }
[18:01:26.752]                 })
[18:01:26.752]                 withCallingHandlers({
[18:01:26.752]                   {
[18:01:26.752]                     42
[18:01:26.752]                   }
[18:01:26.752]                 }, immediateCondition = function(cond) {
[18:01:26.752]                   sendCondition <- ...future.makeSendCondition()
[18:01:26.752]                   sendCondition(cond)
[18:01:26.752]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.752]                   {
[18:01:26.752]                     inherits <- base::inherits
[18:01:26.752]                     invokeRestart <- base::invokeRestart
[18:01:26.752]                     is.null <- base::is.null
[18:01:26.752]                     muffled <- FALSE
[18:01:26.752]                     if (inherits(cond, "message")) {
[18:01:26.752]                       muffled <- grepl(pattern, "muffleMessage")
[18:01:26.752]                       if (muffled) 
[18:01:26.752]                         invokeRestart("muffleMessage")
[18:01:26.752]                     }
[18:01:26.752]                     else if (inherits(cond, "warning")) {
[18:01:26.752]                       muffled <- grepl(pattern, "muffleWarning")
[18:01:26.752]                       if (muffled) 
[18:01:26.752]                         invokeRestart("muffleWarning")
[18:01:26.752]                     }
[18:01:26.752]                     else if (inherits(cond, "condition")) {
[18:01:26.752]                       if (!is.null(pattern)) {
[18:01:26.752]                         computeRestarts <- base::computeRestarts
[18:01:26.752]                         grepl <- base::grepl
[18:01:26.752]                         restarts <- computeRestarts(cond)
[18:01:26.752]                         for (restart in restarts) {
[18:01:26.752]                           name <- restart$name
[18:01:26.752]                           if (is.null(name)) 
[18:01:26.752]                             next
[18:01:26.752]                           if (!grepl(pattern, name)) 
[18:01:26.752]                             next
[18:01:26.752]                           invokeRestart(restart)
[18:01:26.752]                           muffled <- TRUE
[18:01:26.752]                           break
[18:01:26.752]                         }
[18:01:26.752]                       }
[18:01:26.752]                     }
[18:01:26.752]                     invisible(muffled)
[18:01:26.752]                   }
[18:01:26.752]                   muffleCondition(cond)
[18:01:26.752]                 })
[18:01:26.752]             }))
[18:01:26.752]             future::FutureResult(value = ...future.value$value, 
[18:01:26.752]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.752]                   ...future.rng), globalenv = if (FALSE) 
[18:01:26.752]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:26.752]                     ...future.globalenv.names))
[18:01:26.752]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:26.752]         }, condition = base::local({
[18:01:26.752]             c <- base::c
[18:01:26.752]             inherits <- base::inherits
[18:01:26.752]             invokeRestart <- base::invokeRestart
[18:01:26.752]             length <- base::length
[18:01:26.752]             list <- base::list
[18:01:26.752]             seq.int <- base::seq.int
[18:01:26.752]             signalCondition <- base::signalCondition
[18:01:26.752]             sys.calls <- base::sys.calls
[18:01:26.752]             `[[` <- base::`[[`
[18:01:26.752]             `+` <- base::`+`
[18:01:26.752]             `<<-` <- base::`<<-`
[18:01:26.752]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:26.752]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:26.752]                   3L)]
[18:01:26.752]             }
[18:01:26.752]             function(cond) {
[18:01:26.752]                 is_error <- inherits(cond, "error")
[18:01:26.752]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:26.752]                   NULL)
[18:01:26.752]                 if (is_error) {
[18:01:26.752]                   sessionInformation <- function() {
[18:01:26.752]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:26.752]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:26.752]                       search = base::search(), system = base::Sys.info())
[18:01:26.752]                   }
[18:01:26.752]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.752]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:26.752]                     cond$call), session = sessionInformation(), 
[18:01:26.752]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:26.752]                   signalCondition(cond)
[18:01:26.752]                 }
[18:01:26.752]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:26.752]                 "immediateCondition"))) {
[18:01:26.752]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:26.752]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.752]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:26.752]                   if (TRUE && !signal) {
[18:01:26.752]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.752]                     {
[18:01:26.752]                       inherits <- base::inherits
[18:01:26.752]                       invokeRestart <- base::invokeRestart
[18:01:26.752]                       is.null <- base::is.null
[18:01:26.752]                       muffled <- FALSE
[18:01:26.752]                       if (inherits(cond, "message")) {
[18:01:26.752]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.752]                         if (muffled) 
[18:01:26.752]                           invokeRestart("muffleMessage")
[18:01:26.752]                       }
[18:01:26.752]                       else if (inherits(cond, "warning")) {
[18:01:26.752]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.752]                         if (muffled) 
[18:01:26.752]                           invokeRestart("muffleWarning")
[18:01:26.752]                       }
[18:01:26.752]                       else if (inherits(cond, "condition")) {
[18:01:26.752]                         if (!is.null(pattern)) {
[18:01:26.752]                           computeRestarts <- base::computeRestarts
[18:01:26.752]                           grepl <- base::grepl
[18:01:26.752]                           restarts <- computeRestarts(cond)
[18:01:26.752]                           for (restart in restarts) {
[18:01:26.752]                             name <- restart$name
[18:01:26.752]                             if (is.null(name)) 
[18:01:26.752]                               next
[18:01:26.752]                             if (!grepl(pattern, name)) 
[18:01:26.752]                               next
[18:01:26.752]                             invokeRestart(restart)
[18:01:26.752]                             muffled <- TRUE
[18:01:26.752]                             break
[18:01:26.752]                           }
[18:01:26.752]                         }
[18:01:26.752]                       }
[18:01:26.752]                       invisible(muffled)
[18:01:26.752]                     }
[18:01:26.752]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.752]                   }
[18:01:26.752]                 }
[18:01:26.752]                 else {
[18:01:26.752]                   if (TRUE) {
[18:01:26.752]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.752]                     {
[18:01:26.752]                       inherits <- base::inherits
[18:01:26.752]                       invokeRestart <- base::invokeRestart
[18:01:26.752]                       is.null <- base::is.null
[18:01:26.752]                       muffled <- FALSE
[18:01:26.752]                       if (inherits(cond, "message")) {
[18:01:26.752]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.752]                         if (muffled) 
[18:01:26.752]                           invokeRestart("muffleMessage")
[18:01:26.752]                       }
[18:01:26.752]                       else if (inherits(cond, "warning")) {
[18:01:26.752]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.752]                         if (muffled) 
[18:01:26.752]                           invokeRestart("muffleWarning")
[18:01:26.752]                       }
[18:01:26.752]                       else if (inherits(cond, "condition")) {
[18:01:26.752]                         if (!is.null(pattern)) {
[18:01:26.752]                           computeRestarts <- base::computeRestarts
[18:01:26.752]                           grepl <- base::grepl
[18:01:26.752]                           restarts <- computeRestarts(cond)
[18:01:26.752]                           for (restart in restarts) {
[18:01:26.752]                             name <- restart$name
[18:01:26.752]                             if (is.null(name)) 
[18:01:26.752]                               next
[18:01:26.752]                             if (!grepl(pattern, name)) 
[18:01:26.752]                               next
[18:01:26.752]                             invokeRestart(restart)
[18:01:26.752]                             muffled <- TRUE
[18:01:26.752]                             break
[18:01:26.752]                           }
[18:01:26.752]                         }
[18:01:26.752]                       }
[18:01:26.752]                       invisible(muffled)
[18:01:26.752]                     }
[18:01:26.752]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.752]                   }
[18:01:26.752]                 }
[18:01:26.752]             }
[18:01:26.752]         }))
[18:01:26.752]     }, error = function(ex) {
[18:01:26.752]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:26.752]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.752]                 ...future.rng), started = ...future.startTime, 
[18:01:26.752]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:26.752]             version = "1.8"), class = "FutureResult")
[18:01:26.752]     }, finally = {
[18:01:26.752]         if (!identical(...future.workdir, getwd())) 
[18:01:26.752]             setwd(...future.workdir)
[18:01:26.752]         {
[18:01:26.752]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:26.752]                 ...future.oldOptions$nwarnings <- NULL
[18:01:26.752]             }
[18:01:26.752]             base::options(...future.oldOptions)
[18:01:26.752]             if (.Platform$OS.type == "windows") {
[18:01:26.752]                 old_names <- names(...future.oldEnvVars)
[18:01:26.752]                 envs <- base::Sys.getenv()
[18:01:26.752]                 names <- names(envs)
[18:01:26.752]                 common <- intersect(names, old_names)
[18:01:26.752]                 added <- setdiff(names, old_names)
[18:01:26.752]                 removed <- setdiff(old_names, names)
[18:01:26.752]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:26.752]                   envs[common]]
[18:01:26.752]                 NAMES <- toupper(changed)
[18:01:26.752]                 args <- list()
[18:01:26.752]                 for (kk in seq_along(NAMES)) {
[18:01:26.752]                   name <- changed[[kk]]
[18:01:26.752]                   NAME <- NAMES[[kk]]
[18:01:26.752]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.752]                     next
[18:01:26.752]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.752]                 }
[18:01:26.752]                 NAMES <- toupper(added)
[18:01:26.752]                 for (kk in seq_along(NAMES)) {
[18:01:26.752]                   name <- added[[kk]]
[18:01:26.752]                   NAME <- NAMES[[kk]]
[18:01:26.752]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.752]                     next
[18:01:26.752]                   args[[name]] <- ""
[18:01:26.752]                 }
[18:01:26.752]                 NAMES <- toupper(removed)
[18:01:26.752]                 for (kk in seq_along(NAMES)) {
[18:01:26.752]                   name <- removed[[kk]]
[18:01:26.752]                   NAME <- NAMES[[kk]]
[18:01:26.752]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.752]                     next
[18:01:26.752]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.752]                 }
[18:01:26.752]                 if (length(args) > 0) 
[18:01:26.752]                   base::do.call(base::Sys.setenv, args = args)
[18:01:26.752]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:26.752]             }
[18:01:26.752]             else {
[18:01:26.752]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:26.752]             }
[18:01:26.752]             {
[18:01:26.752]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:26.752]                   0L) {
[18:01:26.752]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:26.752]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:26.752]                   base::options(opts)
[18:01:26.752]                 }
[18:01:26.752]                 {
[18:01:26.752]                   {
[18:01:26.752]                     base::options(mc.cores = ...future.mc.cores.old)
[18:01:26.752]                     NULL
[18:01:26.752]                   }
[18:01:26.752]                   options(future.plan = NULL)
[18:01:26.752]                   if (is.na(NA_character_)) 
[18:01:26.752]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.752]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:26.752]                   future::plan(list(function (..., workers = availableCores(), 
[18:01:26.752]                     lazy = FALSE, rscript_libs = .libPaths(), 
[18:01:26.752]                     envir = parent.frame()) 
[18:01:26.752]                   {
[18:01:26.752]                     if (is.function(workers)) 
[18:01:26.752]                       workers <- workers()
[18:01:26.752]                     workers <- structure(as.integer(workers), 
[18:01:26.752]                       class = class(workers))
[18:01:26.752]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[18:01:26.752]                       workers >= 1)
[18:01:26.752]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[18:01:26.752]                       return(sequential(..., lazy = TRUE, envir = envir))
[18:01:26.752]                     }
[18:01:26.752]                     future <- MultisessionFuture(..., workers = workers, 
[18:01:26.752]                       lazy = lazy, rscript_libs = rscript_libs, 
[18:01:26.752]                       envir = envir)
[18:01:26.752]                     if (!future$lazy) 
[18:01:26.752]                       future <- run(future)
[18:01:26.752]                     invisible(future)
[18:01:26.752]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:26.752]                 }
[18:01:26.752]             }
[18:01:26.752]         }
[18:01:26.752]     })
[18:01:26.752]     if (TRUE) {
[18:01:26.752]         base::sink(type = "output", split = FALSE)
[18:01:26.752]         if (TRUE) {
[18:01:26.752]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:26.752]         }
[18:01:26.752]         else {
[18:01:26.752]             ...future.result["stdout"] <- base::list(NULL)
[18:01:26.752]         }
[18:01:26.752]         base::close(...future.stdout)
[18:01:26.752]         ...future.stdout <- NULL
[18:01:26.752]     }
[18:01:26.752]     ...future.result$conditions <- ...future.conditions
[18:01:26.752]     ...future.result$finished <- base::Sys.time()
[18:01:26.752]     ...future.result
[18:01:26.752] }
[18:01:26.758] MultisessionFuture started
[18:01:26.758] - Launch lazy future ... done
[18:01:26.758] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: '<none>'
Expression:
{
    42
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:01:26.774] receiveMessageFromWorker() for ClusterFuture ...
[18:01:26.775] - Validating connection of MultisessionFuture
[18:01:26.775] - received message: FutureResult
[18:01:26.775] - Received FutureResult
[18:01:26.775] - Erased future from FutureRegistry
[18:01:26.776] result() for ClusterFuture ...
[18:01:26.776] - result already collected: FutureResult
[18:01:26.776] result() for ClusterFuture ... done
[18:01:26.776] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: fd4a23fd-3f1e-941b-f00a-64835db9cc52
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:01:26.779] result() for ClusterFuture ...
[18:01:26.779] - result already collected: FutureResult
[18:01:26.779] result() for ClusterFuture ... done
[18:01:26.780] result() for ClusterFuture ...
[18:01:26.780] - result already collected: FutureResult
[18:01:26.780] result() for ClusterFuture ... done
[18:01:26.782] getGlobalsAndPackages() ...
[18:01:26.782] 
[18:01:26.782] - globals: [0] <none>
[18:01:26.783] getGlobalsAndPackages() ... DONE
[18:01:26.795] Packages needed by the future expression (n = 0): <none>
[18:01:26.795] Packages needed by future strategies (n = 0): <none>
[18:01:26.795] {
[18:01:26.795]     {
[18:01:26.795]         {
[18:01:26.795]             ...future.startTime <- base::Sys.time()
[18:01:26.795]             {
[18:01:26.795]                 {
[18:01:26.795]                   {
[18:01:26.795]                     {
[18:01:26.795]                       base::local({
[18:01:26.795]                         has_future <- base::requireNamespace("future", 
[18:01:26.795]                           quietly = TRUE)
[18:01:26.795]                         if (has_future) {
[18:01:26.795]                           ns <- base::getNamespace("future")
[18:01:26.795]                           version <- ns[[".package"]][["version"]]
[18:01:26.795]                           if (is.null(version)) 
[18:01:26.795]                             version <- utils::packageVersion("future")
[18:01:26.795]                         }
[18:01:26.795]                         else {
[18:01:26.795]                           version <- NULL
[18:01:26.795]                         }
[18:01:26.795]                         if (!has_future || version < "1.8.0") {
[18:01:26.795]                           info <- base::c(r_version = base::gsub("R version ", 
[18:01:26.795]                             "", base::R.version$version.string), 
[18:01:26.795]                             platform = base::sprintf("%s (%s-bit)", 
[18:01:26.795]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:26.795]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:26.795]                               "release", "version")], collapse = " "), 
[18:01:26.795]                             hostname = base::Sys.info()[["nodename"]])
[18:01:26.795]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:01:26.795]                             info)
[18:01:26.795]                           info <- base::paste(info, collapse = "; ")
[18:01:26.795]                           if (!has_future) {
[18:01:26.795]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:26.795]                               info)
[18:01:26.795]                           }
[18:01:26.795]                           else {
[18:01:26.795]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:26.795]                               info, version)
[18:01:26.795]                           }
[18:01:26.795]                           base::stop(msg)
[18:01:26.795]                         }
[18:01:26.795]                       })
[18:01:26.795]                     }
[18:01:26.795]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:01:26.795]                     base::options(mc.cores = 1L)
[18:01:26.795]                   }
[18:01:26.795]                   options(future.plan = NULL)
[18:01:26.795]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.795]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:26.795]                 }
[18:01:26.795]                 ...future.workdir <- getwd()
[18:01:26.795]             }
[18:01:26.795]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:26.795]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:26.795]         }
[18:01:26.795]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:26.795]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:26.795]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:26.795]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:26.795]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:26.795]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:26.795]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:26.795]             base::names(...future.oldOptions))
[18:01:26.795]     }
[18:01:26.795]     if (FALSE) {
[18:01:26.795]     }
[18:01:26.795]     else {
[18:01:26.795]         if (TRUE) {
[18:01:26.795]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:26.795]                 open = "w")
[18:01:26.795]         }
[18:01:26.795]         else {
[18:01:26.795]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:26.795]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:26.795]         }
[18:01:26.795]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:26.795]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:26.795]             base::sink(type = "output", split = FALSE)
[18:01:26.795]             base::close(...future.stdout)
[18:01:26.795]         }, add = TRUE)
[18:01:26.795]     }
[18:01:26.795]     ...future.frame <- base::sys.nframe()
[18:01:26.795]     ...future.conditions <- base::list()
[18:01:26.795]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:26.795]     if (FALSE) {
[18:01:26.795]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:26.795]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:26.795]     }
[18:01:26.795]     ...future.result <- base::tryCatch({
[18:01:26.795]         base::withCallingHandlers({
[18:01:26.795]             ...future.value <- base::withVisible(base::local({
[18:01:26.795]                 ...future.makeSendCondition <- local({
[18:01:26.795]                   sendCondition <- NULL
[18:01:26.795]                   function(frame = 1L) {
[18:01:26.795]                     if (is.function(sendCondition)) 
[18:01:26.795]                       return(sendCondition)
[18:01:26.795]                     ns <- getNamespace("parallel")
[18:01:26.795]                     if (exists("sendData", mode = "function", 
[18:01:26.795]                       envir = ns)) {
[18:01:26.795]                       parallel_sendData <- get("sendData", mode = "function", 
[18:01:26.795]                         envir = ns)
[18:01:26.795]                       envir <- sys.frame(frame)
[18:01:26.795]                       master <- NULL
[18:01:26.795]                       while (!identical(envir, .GlobalEnv) && 
[18:01:26.795]                         !identical(envir, emptyenv())) {
[18:01:26.795]                         if (exists("master", mode = "list", envir = envir, 
[18:01:26.795]                           inherits = FALSE)) {
[18:01:26.795]                           master <- get("master", mode = "list", 
[18:01:26.795]                             envir = envir, inherits = FALSE)
[18:01:26.795]                           if (inherits(master, c("SOCKnode", 
[18:01:26.795]                             "SOCK0node"))) {
[18:01:26.795]                             sendCondition <<- function(cond) {
[18:01:26.795]                               data <- list(type = "VALUE", value = cond, 
[18:01:26.795]                                 success = TRUE)
[18:01:26.795]                               parallel_sendData(master, data)
[18:01:26.795]                             }
[18:01:26.795]                             return(sendCondition)
[18:01:26.795]                           }
[18:01:26.795]                         }
[18:01:26.795]                         frame <- frame + 1L
[18:01:26.795]                         envir <- sys.frame(frame)
[18:01:26.795]                       }
[18:01:26.795]                     }
[18:01:26.795]                     sendCondition <<- function(cond) NULL
[18:01:26.795]                   }
[18:01:26.795]                 })
[18:01:26.795]                 withCallingHandlers({
[18:01:26.795]                   42
[18:01:26.795]                 }, immediateCondition = function(cond) {
[18:01:26.795]                   sendCondition <- ...future.makeSendCondition()
[18:01:26.795]                   sendCondition(cond)
[18:01:26.795]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.795]                   {
[18:01:26.795]                     inherits <- base::inherits
[18:01:26.795]                     invokeRestart <- base::invokeRestart
[18:01:26.795]                     is.null <- base::is.null
[18:01:26.795]                     muffled <- FALSE
[18:01:26.795]                     if (inherits(cond, "message")) {
[18:01:26.795]                       muffled <- grepl(pattern, "muffleMessage")
[18:01:26.795]                       if (muffled) 
[18:01:26.795]                         invokeRestart("muffleMessage")
[18:01:26.795]                     }
[18:01:26.795]                     else if (inherits(cond, "warning")) {
[18:01:26.795]                       muffled <- grepl(pattern, "muffleWarning")
[18:01:26.795]                       if (muffled) 
[18:01:26.795]                         invokeRestart("muffleWarning")
[18:01:26.795]                     }
[18:01:26.795]                     else if (inherits(cond, "condition")) {
[18:01:26.795]                       if (!is.null(pattern)) {
[18:01:26.795]                         computeRestarts <- base::computeRestarts
[18:01:26.795]                         grepl <- base::grepl
[18:01:26.795]                         restarts <- computeRestarts(cond)
[18:01:26.795]                         for (restart in restarts) {
[18:01:26.795]                           name <- restart$name
[18:01:26.795]                           if (is.null(name)) 
[18:01:26.795]                             next
[18:01:26.795]                           if (!grepl(pattern, name)) 
[18:01:26.795]                             next
[18:01:26.795]                           invokeRestart(restart)
[18:01:26.795]                           muffled <- TRUE
[18:01:26.795]                           break
[18:01:26.795]                         }
[18:01:26.795]                       }
[18:01:26.795]                     }
[18:01:26.795]                     invisible(muffled)
[18:01:26.795]                   }
[18:01:26.795]                   muffleCondition(cond)
[18:01:26.795]                 })
[18:01:26.795]             }))
[18:01:26.795]             future::FutureResult(value = ...future.value$value, 
[18:01:26.795]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.795]                   ...future.rng), globalenv = if (FALSE) 
[18:01:26.795]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:26.795]                     ...future.globalenv.names))
[18:01:26.795]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:26.795]         }, condition = base::local({
[18:01:26.795]             c <- base::c
[18:01:26.795]             inherits <- base::inherits
[18:01:26.795]             invokeRestart <- base::invokeRestart
[18:01:26.795]             length <- base::length
[18:01:26.795]             list <- base::list
[18:01:26.795]             seq.int <- base::seq.int
[18:01:26.795]             signalCondition <- base::signalCondition
[18:01:26.795]             sys.calls <- base::sys.calls
[18:01:26.795]             `[[` <- base::`[[`
[18:01:26.795]             `+` <- base::`+`
[18:01:26.795]             `<<-` <- base::`<<-`
[18:01:26.795]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:26.795]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:26.795]                   3L)]
[18:01:26.795]             }
[18:01:26.795]             function(cond) {
[18:01:26.795]                 is_error <- inherits(cond, "error")
[18:01:26.795]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:26.795]                   NULL)
[18:01:26.795]                 if (is_error) {
[18:01:26.795]                   sessionInformation <- function() {
[18:01:26.795]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:26.795]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:26.795]                       search = base::search(), system = base::Sys.info())
[18:01:26.795]                   }
[18:01:26.795]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.795]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:26.795]                     cond$call), session = sessionInformation(), 
[18:01:26.795]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:26.795]                   signalCondition(cond)
[18:01:26.795]                 }
[18:01:26.795]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:26.795]                 "immediateCondition"))) {
[18:01:26.795]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:26.795]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.795]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:26.795]                   if (TRUE && !signal) {
[18:01:26.795]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.795]                     {
[18:01:26.795]                       inherits <- base::inherits
[18:01:26.795]                       invokeRestart <- base::invokeRestart
[18:01:26.795]                       is.null <- base::is.null
[18:01:26.795]                       muffled <- FALSE
[18:01:26.795]                       if (inherits(cond, "message")) {
[18:01:26.795]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.795]                         if (muffled) 
[18:01:26.795]                           invokeRestart("muffleMessage")
[18:01:26.795]                       }
[18:01:26.795]                       else if (inherits(cond, "warning")) {
[18:01:26.795]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.795]                         if (muffled) 
[18:01:26.795]                           invokeRestart("muffleWarning")
[18:01:26.795]                       }
[18:01:26.795]                       else if (inherits(cond, "condition")) {
[18:01:26.795]                         if (!is.null(pattern)) {
[18:01:26.795]                           computeRestarts <- base::computeRestarts
[18:01:26.795]                           grepl <- base::grepl
[18:01:26.795]                           restarts <- computeRestarts(cond)
[18:01:26.795]                           for (restart in restarts) {
[18:01:26.795]                             name <- restart$name
[18:01:26.795]                             if (is.null(name)) 
[18:01:26.795]                               next
[18:01:26.795]                             if (!grepl(pattern, name)) 
[18:01:26.795]                               next
[18:01:26.795]                             invokeRestart(restart)
[18:01:26.795]                             muffled <- TRUE
[18:01:26.795]                             break
[18:01:26.795]                           }
[18:01:26.795]                         }
[18:01:26.795]                       }
[18:01:26.795]                       invisible(muffled)
[18:01:26.795]                     }
[18:01:26.795]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.795]                   }
[18:01:26.795]                 }
[18:01:26.795]                 else {
[18:01:26.795]                   if (TRUE) {
[18:01:26.795]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.795]                     {
[18:01:26.795]                       inherits <- base::inherits
[18:01:26.795]                       invokeRestart <- base::invokeRestart
[18:01:26.795]                       is.null <- base::is.null
[18:01:26.795]                       muffled <- FALSE
[18:01:26.795]                       if (inherits(cond, "message")) {
[18:01:26.795]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.795]                         if (muffled) 
[18:01:26.795]                           invokeRestart("muffleMessage")
[18:01:26.795]                       }
[18:01:26.795]                       else if (inherits(cond, "warning")) {
[18:01:26.795]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.795]                         if (muffled) 
[18:01:26.795]                           invokeRestart("muffleWarning")
[18:01:26.795]                       }
[18:01:26.795]                       else if (inherits(cond, "condition")) {
[18:01:26.795]                         if (!is.null(pattern)) {
[18:01:26.795]                           computeRestarts <- base::computeRestarts
[18:01:26.795]                           grepl <- base::grepl
[18:01:26.795]                           restarts <- computeRestarts(cond)
[18:01:26.795]                           for (restart in restarts) {
[18:01:26.795]                             name <- restart$name
[18:01:26.795]                             if (is.null(name)) 
[18:01:26.795]                               next
[18:01:26.795]                             if (!grepl(pattern, name)) 
[18:01:26.795]                               next
[18:01:26.795]                             invokeRestart(restart)
[18:01:26.795]                             muffled <- TRUE
[18:01:26.795]                             break
[18:01:26.795]                           }
[18:01:26.795]                         }
[18:01:26.795]                       }
[18:01:26.795]                       invisible(muffled)
[18:01:26.795]                     }
[18:01:26.795]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.795]                   }
[18:01:26.795]                 }
[18:01:26.795]             }
[18:01:26.795]         }))
[18:01:26.795]     }, error = function(ex) {
[18:01:26.795]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:26.795]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.795]                 ...future.rng), started = ...future.startTime, 
[18:01:26.795]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:26.795]             version = "1.8"), class = "FutureResult")
[18:01:26.795]     }, finally = {
[18:01:26.795]         if (!identical(...future.workdir, getwd())) 
[18:01:26.795]             setwd(...future.workdir)
[18:01:26.795]         {
[18:01:26.795]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:26.795]                 ...future.oldOptions$nwarnings <- NULL
[18:01:26.795]             }
[18:01:26.795]             base::options(...future.oldOptions)
[18:01:26.795]             if (.Platform$OS.type == "windows") {
[18:01:26.795]                 old_names <- names(...future.oldEnvVars)
[18:01:26.795]                 envs <- base::Sys.getenv()
[18:01:26.795]                 names <- names(envs)
[18:01:26.795]                 common <- intersect(names, old_names)
[18:01:26.795]                 added <- setdiff(names, old_names)
[18:01:26.795]                 removed <- setdiff(old_names, names)
[18:01:26.795]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:26.795]                   envs[common]]
[18:01:26.795]                 NAMES <- toupper(changed)
[18:01:26.795]                 args <- list()
[18:01:26.795]                 for (kk in seq_along(NAMES)) {
[18:01:26.795]                   name <- changed[[kk]]
[18:01:26.795]                   NAME <- NAMES[[kk]]
[18:01:26.795]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.795]                     next
[18:01:26.795]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.795]                 }
[18:01:26.795]                 NAMES <- toupper(added)
[18:01:26.795]                 for (kk in seq_along(NAMES)) {
[18:01:26.795]                   name <- added[[kk]]
[18:01:26.795]                   NAME <- NAMES[[kk]]
[18:01:26.795]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.795]                     next
[18:01:26.795]                   args[[name]] <- ""
[18:01:26.795]                 }
[18:01:26.795]                 NAMES <- toupper(removed)
[18:01:26.795]                 for (kk in seq_along(NAMES)) {
[18:01:26.795]                   name <- removed[[kk]]
[18:01:26.795]                   NAME <- NAMES[[kk]]
[18:01:26.795]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.795]                     next
[18:01:26.795]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.795]                 }
[18:01:26.795]                 if (length(args) > 0) 
[18:01:26.795]                   base::do.call(base::Sys.setenv, args = args)
[18:01:26.795]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:26.795]             }
[18:01:26.795]             else {
[18:01:26.795]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:26.795]             }
[18:01:26.795]             {
[18:01:26.795]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:26.795]                   0L) {
[18:01:26.795]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:26.795]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:26.795]                   base::options(opts)
[18:01:26.795]                 }
[18:01:26.795]                 {
[18:01:26.795]                   {
[18:01:26.795]                     base::options(mc.cores = ...future.mc.cores.old)
[18:01:26.795]                     NULL
[18:01:26.795]                   }
[18:01:26.795]                   options(future.plan = NULL)
[18:01:26.795]                   if (is.na(NA_character_)) 
[18:01:26.795]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.795]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:26.795]                   future::plan(list(function (..., workers = availableCores(), 
[18:01:26.795]                     lazy = FALSE, rscript_libs = .libPaths(), 
[18:01:26.795]                     envir = parent.frame()) 
[18:01:26.795]                   {
[18:01:26.795]                     if (is.function(workers)) 
[18:01:26.795]                       workers <- workers()
[18:01:26.795]                     workers <- structure(as.integer(workers), 
[18:01:26.795]                       class = class(workers))
[18:01:26.795]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[18:01:26.795]                       workers >= 1)
[18:01:26.795]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[18:01:26.795]                       return(sequential(..., lazy = TRUE, envir = envir))
[18:01:26.795]                     }
[18:01:26.795]                     future <- MultisessionFuture(..., workers = workers, 
[18:01:26.795]                       lazy = lazy, rscript_libs = rscript_libs, 
[18:01:26.795]                       envir = envir)
[18:01:26.795]                     if (!future$lazy) 
[18:01:26.795]                       future <- run(future)
[18:01:26.795]                     invisible(future)
[18:01:26.795]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:26.795]                 }
[18:01:26.795]             }
[18:01:26.795]         }
[18:01:26.795]     })
[18:01:26.795]     if (TRUE) {
[18:01:26.795]         base::sink(type = "output", split = FALSE)
[18:01:26.795]         if (TRUE) {
[18:01:26.795]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:26.795]         }
[18:01:26.795]         else {
[18:01:26.795]             ...future.result["stdout"] <- base::list(NULL)
[18:01:26.795]         }
[18:01:26.795]         base::close(...future.stdout)
[18:01:26.795]         ...future.stdout <- NULL
[18:01:26.795]     }
[18:01:26.795]     ...future.result$conditions <- ...future.conditions
[18:01:26.795]     ...future.result$finished <- base::Sys.time()
[18:01:26.795]     ...future.result
[18:01:26.795] }
[18:01:26.801] MultisessionFuture started
MultisessionFuture:
Label: 'strategy = multisession'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:01:26.817] receiveMessageFromWorker() for ClusterFuture ...
[18:01:26.817] - Validating connection of MultisessionFuture
[18:01:26.817] - received message: FutureResult
[18:01:26.818] - Received FutureResult
[18:01:26.818] - Erased future from FutureRegistry
[18:01:26.818] result() for ClusterFuture ...
[18:01:26.818] - result already collected: FutureResult
[18:01:26.818] result() for ClusterFuture ... done
[18:01:26.818] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: fd4a23fd-3f1e-941b-f00a-64835db9cc52
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:01:26.819] result() for ClusterFuture ...
[18:01:26.819] - result already collected: FutureResult
[18:01:26.819] result() for ClusterFuture ... done
[18:01:26.819] result() for ClusterFuture ...
[18:01:26.819] - result already collected: FutureResult
[18:01:26.820] result() for ClusterFuture ... done
[18:01:26.820] getGlobalsAndPackages() ...
[18:01:26.820] Searching for globals...
[18:01:26.820] 
[18:01:26.821] Searching for globals ... DONE
[18:01:26.821] - globals: [0] <none>
[18:01:26.821] getGlobalsAndPackages() ... DONE
[18:01:26.821] run() for 'Future' ...
[18:01:26.821] - state: 'created'
[18:01:26.822] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:01:26.835] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:01:26.835] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:01:26.836]   - Field: 'node'
[18:01:26.836]   - Field: 'label'
[18:01:26.836]   - Field: 'local'
[18:01:26.836]   - Field: 'owner'
[18:01:26.836]   - Field: 'envir'
[18:01:26.837]   - Field: 'workers'
[18:01:26.837]   - Field: 'packages'
[18:01:26.837]   - Field: 'gc'
[18:01:26.837]   - Field: 'conditions'
[18:01:26.837]   - Field: 'persistent'
[18:01:26.837]   - Field: 'expr'
[18:01:26.838]   - Field: 'uuid'
[18:01:26.838]   - Field: 'seed'
[18:01:26.838]   - Field: 'version'
[18:01:26.838]   - Field: 'result'
[18:01:26.838]   - Field: 'asynchronous'
[18:01:26.839]   - Field: 'calls'
[18:01:26.839]   - Field: 'globals'
[18:01:26.839]   - Field: 'stdout'
[18:01:26.839]   - Field: 'earlySignal'
[18:01:26.839]   - Field: 'lazy'
[18:01:26.839]   - Field: 'state'
[18:01:26.840] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:01:26.840] - Launch lazy future ...
[18:01:26.840] Packages needed by the future expression (n = 0): <none>
[18:01:26.840] Packages needed by future strategies (n = 0): <none>
[18:01:26.841] {
[18:01:26.841]     {
[18:01:26.841]         {
[18:01:26.841]             ...future.startTime <- base::Sys.time()
[18:01:26.841]             {
[18:01:26.841]                 {
[18:01:26.841]                   {
[18:01:26.841]                     {
[18:01:26.841]                       base::local({
[18:01:26.841]                         has_future <- base::requireNamespace("future", 
[18:01:26.841]                           quietly = TRUE)
[18:01:26.841]                         if (has_future) {
[18:01:26.841]                           ns <- base::getNamespace("future")
[18:01:26.841]                           version <- ns[[".package"]][["version"]]
[18:01:26.841]                           if (is.null(version)) 
[18:01:26.841]                             version <- utils::packageVersion("future")
[18:01:26.841]                         }
[18:01:26.841]                         else {
[18:01:26.841]                           version <- NULL
[18:01:26.841]                         }
[18:01:26.841]                         if (!has_future || version < "1.8.0") {
[18:01:26.841]                           info <- base::c(r_version = base::gsub("R version ", 
[18:01:26.841]                             "", base::R.version$version.string), 
[18:01:26.841]                             platform = base::sprintf("%s (%s-bit)", 
[18:01:26.841]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:26.841]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:26.841]                               "release", "version")], collapse = " "), 
[18:01:26.841]                             hostname = base::Sys.info()[["nodename"]])
[18:01:26.841]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:01:26.841]                             info)
[18:01:26.841]                           info <- base::paste(info, collapse = "; ")
[18:01:26.841]                           if (!has_future) {
[18:01:26.841]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:26.841]                               info)
[18:01:26.841]                           }
[18:01:26.841]                           else {
[18:01:26.841]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:26.841]                               info, version)
[18:01:26.841]                           }
[18:01:26.841]                           base::stop(msg)
[18:01:26.841]                         }
[18:01:26.841]                       })
[18:01:26.841]                     }
[18:01:26.841]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:01:26.841]                     base::options(mc.cores = 1L)
[18:01:26.841]                   }
[18:01:26.841]                   options(future.plan = NULL)
[18:01:26.841]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.841]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:26.841]                 }
[18:01:26.841]                 ...future.workdir <- getwd()
[18:01:26.841]             }
[18:01:26.841]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:26.841]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:26.841]         }
[18:01:26.841]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:26.841]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:26.841]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:26.841]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:26.841]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:26.841]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:26.841]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:26.841]             base::names(...future.oldOptions))
[18:01:26.841]     }
[18:01:26.841]     if (FALSE) {
[18:01:26.841]     }
[18:01:26.841]     else {
[18:01:26.841]         if (TRUE) {
[18:01:26.841]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:26.841]                 open = "w")
[18:01:26.841]         }
[18:01:26.841]         else {
[18:01:26.841]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:26.841]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:26.841]         }
[18:01:26.841]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:26.841]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:26.841]             base::sink(type = "output", split = FALSE)
[18:01:26.841]             base::close(...future.stdout)
[18:01:26.841]         }, add = TRUE)
[18:01:26.841]     }
[18:01:26.841]     ...future.frame <- base::sys.nframe()
[18:01:26.841]     ...future.conditions <- base::list()
[18:01:26.841]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:26.841]     if (FALSE) {
[18:01:26.841]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:26.841]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:26.841]     }
[18:01:26.841]     ...future.result <- base::tryCatch({
[18:01:26.841]         base::withCallingHandlers({
[18:01:26.841]             ...future.value <- base::withVisible(base::local({
[18:01:26.841]                 ...future.makeSendCondition <- local({
[18:01:26.841]                   sendCondition <- NULL
[18:01:26.841]                   function(frame = 1L) {
[18:01:26.841]                     if (is.function(sendCondition)) 
[18:01:26.841]                       return(sendCondition)
[18:01:26.841]                     ns <- getNamespace("parallel")
[18:01:26.841]                     if (exists("sendData", mode = "function", 
[18:01:26.841]                       envir = ns)) {
[18:01:26.841]                       parallel_sendData <- get("sendData", mode = "function", 
[18:01:26.841]                         envir = ns)
[18:01:26.841]                       envir <- sys.frame(frame)
[18:01:26.841]                       master <- NULL
[18:01:26.841]                       while (!identical(envir, .GlobalEnv) && 
[18:01:26.841]                         !identical(envir, emptyenv())) {
[18:01:26.841]                         if (exists("master", mode = "list", envir = envir, 
[18:01:26.841]                           inherits = FALSE)) {
[18:01:26.841]                           master <- get("master", mode = "list", 
[18:01:26.841]                             envir = envir, inherits = FALSE)
[18:01:26.841]                           if (inherits(master, c("SOCKnode", 
[18:01:26.841]                             "SOCK0node"))) {
[18:01:26.841]                             sendCondition <<- function(cond) {
[18:01:26.841]                               data <- list(type = "VALUE", value = cond, 
[18:01:26.841]                                 success = TRUE)
[18:01:26.841]                               parallel_sendData(master, data)
[18:01:26.841]                             }
[18:01:26.841]                             return(sendCondition)
[18:01:26.841]                           }
[18:01:26.841]                         }
[18:01:26.841]                         frame <- frame + 1L
[18:01:26.841]                         envir <- sys.frame(frame)
[18:01:26.841]                       }
[18:01:26.841]                     }
[18:01:26.841]                     sendCondition <<- function(cond) NULL
[18:01:26.841]                   }
[18:01:26.841]                 })
[18:01:26.841]                 withCallingHandlers({
[18:01:26.841]                   42
[18:01:26.841]                 }, immediateCondition = function(cond) {
[18:01:26.841]                   sendCondition <- ...future.makeSendCondition()
[18:01:26.841]                   sendCondition(cond)
[18:01:26.841]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.841]                   {
[18:01:26.841]                     inherits <- base::inherits
[18:01:26.841]                     invokeRestart <- base::invokeRestart
[18:01:26.841]                     is.null <- base::is.null
[18:01:26.841]                     muffled <- FALSE
[18:01:26.841]                     if (inherits(cond, "message")) {
[18:01:26.841]                       muffled <- grepl(pattern, "muffleMessage")
[18:01:26.841]                       if (muffled) 
[18:01:26.841]                         invokeRestart("muffleMessage")
[18:01:26.841]                     }
[18:01:26.841]                     else if (inherits(cond, "warning")) {
[18:01:26.841]                       muffled <- grepl(pattern, "muffleWarning")
[18:01:26.841]                       if (muffled) 
[18:01:26.841]                         invokeRestart("muffleWarning")
[18:01:26.841]                     }
[18:01:26.841]                     else if (inherits(cond, "condition")) {
[18:01:26.841]                       if (!is.null(pattern)) {
[18:01:26.841]                         computeRestarts <- base::computeRestarts
[18:01:26.841]                         grepl <- base::grepl
[18:01:26.841]                         restarts <- computeRestarts(cond)
[18:01:26.841]                         for (restart in restarts) {
[18:01:26.841]                           name <- restart$name
[18:01:26.841]                           if (is.null(name)) 
[18:01:26.841]                             next
[18:01:26.841]                           if (!grepl(pattern, name)) 
[18:01:26.841]                             next
[18:01:26.841]                           invokeRestart(restart)
[18:01:26.841]                           muffled <- TRUE
[18:01:26.841]                           break
[18:01:26.841]                         }
[18:01:26.841]                       }
[18:01:26.841]                     }
[18:01:26.841]                     invisible(muffled)
[18:01:26.841]                   }
[18:01:26.841]                   muffleCondition(cond)
[18:01:26.841]                 })
[18:01:26.841]             }))
[18:01:26.841]             future::FutureResult(value = ...future.value$value, 
[18:01:26.841]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.841]                   ...future.rng), globalenv = if (FALSE) 
[18:01:26.841]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:26.841]                     ...future.globalenv.names))
[18:01:26.841]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:26.841]         }, condition = base::local({
[18:01:26.841]             c <- base::c
[18:01:26.841]             inherits <- base::inherits
[18:01:26.841]             invokeRestart <- base::invokeRestart
[18:01:26.841]             length <- base::length
[18:01:26.841]             list <- base::list
[18:01:26.841]             seq.int <- base::seq.int
[18:01:26.841]             signalCondition <- base::signalCondition
[18:01:26.841]             sys.calls <- base::sys.calls
[18:01:26.841]             `[[` <- base::`[[`
[18:01:26.841]             `+` <- base::`+`
[18:01:26.841]             `<<-` <- base::`<<-`
[18:01:26.841]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:26.841]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:26.841]                   3L)]
[18:01:26.841]             }
[18:01:26.841]             function(cond) {
[18:01:26.841]                 is_error <- inherits(cond, "error")
[18:01:26.841]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:26.841]                   NULL)
[18:01:26.841]                 if (is_error) {
[18:01:26.841]                   sessionInformation <- function() {
[18:01:26.841]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:26.841]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:26.841]                       search = base::search(), system = base::Sys.info())
[18:01:26.841]                   }
[18:01:26.841]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.841]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:26.841]                     cond$call), session = sessionInformation(), 
[18:01:26.841]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:26.841]                   signalCondition(cond)
[18:01:26.841]                 }
[18:01:26.841]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:26.841]                 "immediateCondition"))) {
[18:01:26.841]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:26.841]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.841]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:26.841]                   if (TRUE && !signal) {
[18:01:26.841]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.841]                     {
[18:01:26.841]                       inherits <- base::inherits
[18:01:26.841]                       invokeRestart <- base::invokeRestart
[18:01:26.841]                       is.null <- base::is.null
[18:01:26.841]                       muffled <- FALSE
[18:01:26.841]                       if (inherits(cond, "message")) {
[18:01:26.841]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.841]                         if (muffled) 
[18:01:26.841]                           invokeRestart("muffleMessage")
[18:01:26.841]                       }
[18:01:26.841]                       else if (inherits(cond, "warning")) {
[18:01:26.841]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.841]                         if (muffled) 
[18:01:26.841]                           invokeRestart("muffleWarning")
[18:01:26.841]                       }
[18:01:26.841]                       else if (inherits(cond, "condition")) {
[18:01:26.841]                         if (!is.null(pattern)) {
[18:01:26.841]                           computeRestarts <- base::computeRestarts
[18:01:26.841]                           grepl <- base::grepl
[18:01:26.841]                           restarts <- computeRestarts(cond)
[18:01:26.841]                           for (restart in restarts) {
[18:01:26.841]                             name <- restart$name
[18:01:26.841]                             if (is.null(name)) 
[18:01:26.841]                               next
[18:01:26.841]                             if (!grepl(pattern, name)) 
[18:01:26.841]                               next
[18:01:26.841]                             invokeRestart(restart)
[18:01:26.841]                             muffled <- TRUE
[18:01:26.841]                             break
[18:01:26.841]                           }
[18:01:26.841]                         }
[18:01:26.841]                       }
[18:01:26.841]                       invisible(muffled)
[18:01:26.841]                     }
[18:01:26.841]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.841]                   }
[18:01:26.841]                 }
[18:01:26.841]                 else {
[18:01:26.841]                   if (TRUE) {
[18:01:26.841]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.841]                     {
[18:01:26.841]                       inherits <- base::inherits
[18:01:26.841]                       invokeRestart <- base::invokeRestart
[18:01:26.841]                       is.null <- base::is.null
[18:01:26.841]                       muffled <- FALSE
[18:01:26.841]                       if (inherits(cond, "message")) {
[18:01:26.841]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.841]                         if (muffled) 
[18:01:26.841]                           invokeRestart("muffleMessage")
[18:01:26.841]                       }
[18:01:26.841]                       else if (inherits(cond, "warning")) {
[18:01:26.841]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.841]                         if (muffled) 
[18:01:26.841]                           invokeRestart("muffleWarning")
[18:01:26.841]                       }
[18:01:26.841]                       else if (inherits(cond, "condition")) {
[18:01:26.841]                         if (!is.null(pattern)) {
[18:01:26.841]                           computeRestarts <- base::computeRestarts
[18:01:26.841]                           grepl <- base::grepl
[18:01:26.841]                           restarts <- computeRestarts(cond)
[18:01:26.841]                           for (restart in restarts) {
[18:01:26.841]                             name <- restart$name
[18:01:26.841]                             if (is.null(name)) 
[18:01:26.841]                               next
[18:01:26.841]                             if (!grepl(pattern, name)) 
[18:01:26.841]                               next
[18:01:26.841]                             invokeRestart(restart)
[18:01:26.841]                             muffled <- TRUE
[18:01:26.841]                             break
[18:01:26.841]                           }
[18:01:26.841]                         }
[18:01:26.841]                       }
[18:01:26.841]                       invisible(muffled)
[18:01:26.841]                     }
[18:01:26.841]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.841]                   }
[18:01:26.841]                 }
[18:01:26.841]             }
[18:01:26.841]         }))
[18:01:26.841]     }, error = function(ex) {
[18:01:26.841]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:26.841]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.841]                 ...future.rng), started = ...future.startTime, 
[18:01:26.841]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:26.841]             version = "1.8"), class = "FutureResult")
[18:01:26.841]     }, finally = {
[18:01:26.841]         if (!identical(...future.workdir, getwd())) 
[18:01:26.841]             setwd(...future.workdir)
[18:01:26.841]         {
[18:01:26.841]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:26.841]                 ...future.oldOptions$nwarnings <- NULL
[18:01:26.841]             }
[18:01:26.841]             base::options(...future.oldOptions)
[18:01:26.841]             if (.Platform$OS.type == "windows") {
[18:01:26.841]                 old_names <- names(...future.oldEnvVars)
[18:01:26.841]                 envs <- base::Sys.getenv()
[18:01:26.841]                 names <- names(envs)
[18:01:26.841]                 common <- intersect(names, old_names)
[18:01:26.841]                 added <- setdiff(names, old_names)
[18:01:26.841]                 removed <- setdiff(old_names, names)
[18:01:26.841]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:26.841]                   envs[common]]
[18:01:26.841]                 NAMES <- toupper(changed)
[18:01:26.841]                 args <- list()
[18:01:26.841]                 for (kk in seq_along(NAMES)) {
[18:01:26.841]                   name <- changed[[kk]]
[18:01:26.841]                   NAME <- NAMES[[kk]]
[18:01:26.841]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.841]                     next
[18:01:26.841]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.841]                 }
[18:01:26.841]                 NAMES <- toupper(added)
[18:01:26.841]                 for (kk in seq_along(NAMES)) {
[18:01:26.841]                   name <- added[[kk]]
[18:01:26.841]                   NAME <- NAMES[[kk]]
[18:01:26.841]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.841]                     next
[18:01:26.841]                   args[[name]] <- ""
[18:01:26.841]                 }
[18:01:26.841]                 NAMES <- toupper(removed)
[18:01:26.841]                 for (kk in seq_along(NAMES)) {
[18:01:26.841]                   name <- removed[[kk]]
[18:01:26.841]                   NAME <- NAMES[[kk]]
[18:01:26.841]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.841]                     next
[18:01:26.841]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.841]                 }
[18:01:26.841]                 if (length(args) > 0) 
[18:01:26.841]                   base::do.call(base::Sys.setenv, args = args)
[18:01:26.841]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:26.841]             }
[18:01:26.841]             else {
[18:01:26.841]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:26.841]             }
[18:01:26.841]             {
[18:01:26.841]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:26.841]                   0L) {
[18:01:26.841]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:26.841]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:26.841]                   base::options(opts)
[18:01:26.841]                 }
[18:01:26.841]                 {
[18:01:26.841]                   {
[18:01:26.841]                     base::options(mc.cores = ...future.mc.cores.old)
[18:01:26.841]                     NULL
[18:01:26.841]                   }
[18:01:26.841]                   options(future.plan = NULL)
[18:01:26.841]                   if (is.na(NA_character_)) 
[18:01:26.841]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.841]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:26.841]                   future::plan(list(function (..., workers = availableCores(), 
[18:01:26.841]                     lazy = FALSE, rscript_libs = .libPaths(), 
[18:01:26.841]                     envir = parent.frame()) 
[18:01:26.841]                   {
[18:01:26.841]                     if (is.function(workers)) 
[18:01:26.841]                       workers <- workers()
[18:01:26.841]                     workers <- structure(as.integer(workers), 
[18:01:26.841]                       class = class(workers))
[18:01:26.841]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[18:01:26.841]                       workers >= 1)
[18:01:26.841]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[18:01:26.841]                       return(sequential(..., lazy = TRUE, envir = envir))
[18:01:26.841]                     }
[18:01:26.841]                     future <- MultisessionFuture(..., workers = workers, 
[18:01:26.841]                       lazy = lazy, rscript_libs = rscript_libs, 
[18:01:26.841]                       envir = envir)
[18:01:26.841]                     if (!future$lazy) 
[18:01:26.841]                       future <- run(future)
[18:01:26.841]                     invisible(future)
[18:01:26.841]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:26.841]                 }
[18:01:26.841]             }
[18:01:26.841]         }
[18:01:26.841]     })
[18:01:26.841]     if (TRUE) {
[18:01:26.841]         base::sink(type = "output", split = FALSE)
[18:01:26.841]         if (TRUE) {
[18:01:26.841]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:26.841]         }
[18:01:26.841]         else {
[18:01:26.841]             ...future.result["stdout"] <- base::list(NULL)
[18:01:26.841]         }
[18:01:26.841]         base::close(...future.stdout)
[18:01:26.841]         ...future.stdout <- NULL
[18:01:26.841]     }
[18:01:26.841]     ...future.result$conditions <- ...future.conditions
[18:01:26.841]     ...future.result$finished <- base::Sys.time()
[18:01:26.841]     ...future.result
[18:01:26.841] }
[18:01:26.847] MultisessionFuture started
[18:01:26.847] - Launch lazy future ... done
[18:01:26.847] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'strategy = multisession'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:01:26.863] receiveMessageFromWorker() for ClusterFuture ...
[18:01:26.863] - Validating connection of MultisessionFuture
[18:01:26.864] - received message: FutureResult
[18:01:26.864] - Received FutureResult
[18:01:26.864] - Erased future from FutureRegistry
[18:01:26.864] result() for ClusterFuture ...
[18:01:26.864] - result already collected: FutureResult
[18:01:26.865] result() for ClusterFuture ... done
[18:01:26.865] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: fd4a23fd-3f1e-941b-f00a-64835db9cc52
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:01:26.865] result() for ClusterFuture ...
[18:01:26.865] - result already collected: FutureResult
[18:01:26.865] result() for ClusterFuture ... done
[18:01:26.866] result() for ClusterFuture ...
[18:01:26.866] - result already collected: FutureResult
[18:01:26.866] result() for ClusterFuture ... done
[18:01:26.866] getGlobalsAndPackages() ...
[18:01:26.867] Searching for globals...
[18:01:26.867] - globals found: [1] '{'
[18:01:26.868] Searching for globals ... DONE
[18:01:26.868] Resolving globals: FALSE
[18:01:26.868] 
[18:01:26.868] 
[18:01:26.869] getGlobalsAndPackages() ... DONE
[18:01:26.869] run() for 'Future' ...
[18:01:26.870] - state: 'created'
[18:01:26.870] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:01:26.885] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:01:26.885] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:01:26.886]   - Field: 'node'
[18:01:26.886]   - Field: 'label'
[18:01:26.886]   - Field: 'local'
[18:01:26.886]   - Field: 'owner'
[18:01:26.886]   - Field: 'envir'
[18:01:26.887]   - Field: 'workers'
[18:01:26.887]   - Field: 'packages'
[18:01:26.887]   - Field: 'gc'
[18:01:26.887]   - Field: 'conditions'
[18:01:26.887]   - Field: 'persistent'
[18:01:26.888]   - Field: 'expr'
[18:01:26.888]   - Field: 'uuid'
[18:01:26.888]   - Field: 'seed'
[18:01:26.888]   - Field: 'version'
[18:01:26.888]   - Field: 'result'
[18:01:26.888]   - Field: 'asynchronous'
[18:01:26.889]   - Field: 'calls'
[18:01:26.889]   - Field: 'globals'
[18:01:26.889]   - Field: 'stdout'
[18:01:26.889]   - Field: 'earlySignal'
[18:01:26.889]   - Field: 'lazy'
[18:01:26.890]   - Field: 'state'
[18:01:26.890] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:01:26.890] - Launch lazy future ...
[18:01:26.890] Packages needed by the future expression (n = 0): <none>
[18:01:26.890] Packages needed by future strategies (n = 0): <none>
[18:01:26.891] {
[18:01:26.891]     {
[18:01:26.891]         {
[18:01:26.891]             ...future.startTime <- base::Sys.time()
[18:01:26.891]             {
[18:01:26.891]                 {
[18:01:26.891]                   {
[18:01:26.891]                     {
[18:01:26.891]                       base::local({
[18:01:26.891]                         has_future <- base::requireNamespace("future", 
[18:01:26.891]                           quietly = TRUE)
[18:01:26.891]                         if (has_future) {
[18:01:26.891]                           ns <- base::getNamespace("future")
[18:01:26.891]                           version <- ns[[".package"]][["version"]]
[18:01:26.891]                           if (is.null(version)) 
[18:01:26.891]                             version <- utils::packageVersion("future")
[18:01:26.891]                         }
[18:01:26.891]                         else {
[18:01:26.891]                           version <- NULL
[18:01:26.891]                         }
[18:01:26.891]                         if (!has_future || version < "1.8.0") {
[18:01:26.891]                           info <- base::c(r_version = base::gsub("R version ", 
[18:01:26.891]                             "", base::R.version$version.string), 
[18:01:26.891]                             platform = base::sprintf("%s (%s-bit)", 
[18:01:26.891]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:01:26.891]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:01:26.891]                               "release", "version")], collapse = " "), 
[18:01:26.891]                             hostname = base::Sys.info()[["nodename"]])
[18:01:26.891]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:01:26.891]                             info)
[18:01:26.891]                           info <- base::paste(info, collapse = "; ")
[18:01:26.891]                           if (!has_future) {
[18:01:26.891]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:01:26.891]                               info)
[18:01:26.891]                           }
[18:01:26.891]                           else {
[18:01:26.891]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:01:26.891]                               info, version)
[18:01:26.891]                           }
[18:01:26.891]                           base::stop(msg)
[18:01:26.891]                         }
[18:01:26.891]                       })
[18:01:26.891]                     }
[18:01:26.891]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:01:26.891]                     base::options(mc.cores = 1L)
[18:01:26.891]                   }
[18:01:26.891]                   options(future.plan = NULL)
[18:01:26.891]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.891]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:01:26.891]                 }
[18:01:26.891]                 ...future.workdir <- getwd()
[18:01:26.891]             }
[18:01:26.891]             ...future.oldOptions <- base::as.list(base::.Options)
[18:01:26.891]             ...future.oldEnvVars <- base::Sys.getenv()
[18:01:26.891]         }
[18:01:26.891]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:01:26.891]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:01:26.891]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:01:26.891]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:01:26.891]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:01:26.891]             future.stdout.windows.reencode = NULL, width = 80L)
[18:01:26.891]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:01:26.891]             base::names(...future.oldOptions))
[18:01:26.891]     }
[18:01:26.891]     if (FALSE) {
[18:01:26.891]     }
[18:01:26.891]     else {
[18:01:26.891]         if (TRUE) {
[18:01:26.891]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:01:26.891]                 open = "w")
[18:01:26.891]         }
[18:01:26.891]         else {
[18:01:26.891]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:01:26.891]                 windows = "NUL", "/dev/null"), open = "w")
[18:01:26.891]         }
[18:01:26.891]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:01:26.891]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:01:26.891]             base::sink(type = "output", split = FALSE)
[18:01:26.891]             base::close(...future.stdout)
[18:01:26.891]         }, add = TRUE)
[18:01:26.891]     }
[18:01:26.891]     ...future.frame <- base::sys.nframe()
[18:01:26.891]     ...future.conditions <- base::list()
[18:01:26.891]     ...future.rng <- base::globalenv()$.Random.seed
[18:01:26.891]     if (FALSE) {
[18:01:26.891]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:01:26.891]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:01:26.891]     }
[18:01:26.891]     ...future.result <- base::tryCatch({
[18:01:26.891]         base::withCallingHandlers({
[18:01:26.891]             ...future.value <- base::withVisible(base::local({
[18:01:26.891]                 ...future.makeSendCondition <- local({
[18:01:26.891]                   sendCondition <- NULL
[18:01:26.891]                   function(frame = 1L) {
[18:01:26.891]                     if (is.function(sendCondition)) 
[18:01:26.891]                       return(sendCondition)
[18:01:26.891]                     ns <- getNamespace("parallel")
[18:01:26.891]                     if (exists("sendData", mode = "function", 
[18:01:26.891]                       envir = ns)) {
[18:01:26.891]                       parallel_sendData <- get("sendData", mode = "function", 
[18:01:26.891]                         envir = ns)
[18:01:26.891]                       envir <- sys.frame(frame)
[18:01:26.891]                       master <- NULL
[18:01:26.891]                       while (!identical(envir, .GlobalEnv) && 
[18:01:26.891]                         !identical(envir, emptyenv())) {
[18:01:26.891]                         if (exists("master", mode = "list", envir = envir, 
[18:01:26.891]                           inherits = FALSE)) {
[18:01:26.891]                           master <- get("master", mode = "list", 
[18:01:26.891]                             envir = envir, inherits = FALSE)
[18:01:26.891]                           if (inherits(master, c("SOCKnode", 
[18:01:26.891]                             "SOCK0node"))) {
[18:01:26.891]                             sendCondition <<- function(cond) {
[18:01:26.891]                               data <- list(type = "VALUE", value = cond, 
[18:01:26.891]                                 success = TRUE)
[18:01:26.891]                               parallel_sendData(master, data)
[18:01:26.891]                             }
[18:01:26.891]                             return(sendCondition)
[18:01:26.891]                           }
[18:01:26.891]                         }
[18:01:26.891]                         frame <- frame + 1L
[18:01:26.891]                         envir <- sys.frame(frame)
[18:01:26.891]                       }
[18:01:26.891]                     }
[18:01:26.891]                     sendCondition <<- function(cond) NULL
[18:01:26.891]                   }
[18:01:26.891]                 })
[18:01:26.891]                 withCallingHandlers({
[18:01:26.891]                   {
[18:01:26.891]                     42
[18:01:26.891]                   }
[18:01:26.891]                 }, immediateCondition = function(cond) {
[18:01:26.891]                   sendCondition <- ...future.makeSendCondition()
[18:01:26.891]                   sendCondition(cond)
[18:01:26.891]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.891]                   {
[18:01:26.891]                     inherits <- base::inherits
[18:01:26.891]                     invokeRestart <- base::invokeRestart
[18:01:26.891]                     is.null <- base::is.null
[18:01:26.891]                     muffled <- FALSE
[18:01:26.891]                     if (inherits(cond, "message")) {
[18:01:26.891]                       muffled <- grepl(pattern, "muffleMessage")
[18:01:26.891]                       if (muffled) 
[18:01:26.891]                         invokeRestart("muffleMessage")
[18:01:26.891]                     }
[18:01:26.891]                     else if (inherits(cond, "warning")) {
[18:01:26.891]                       muffled <- grepl(pattern, "muffleWarning")
[18:01:26.891]                       if (muffled) 
[18:01:26.891]                         invokeRestart("muffleWarning")
[18:01:26.891]                     }
[18:01:26.891]                     else if (inherits(cond, "condition")) {
[18:01:26.891]                       if (!is.null(pattern)) {
[18:01:26.891]                         computeRestarts <- base::computeRestarts
[18:01:26.891]                         grepl <- base::grepl
[18:01:26.891]                         restarts <- computeRestarts(cond)
[18:01:26.891]                         for (restart in restarts) {
[18:01:26.891]                           name <- restart$name
[18:01:26.891]                           if (is.null(name)) 
[18:01:26.891]                             next
[18:01:26.891]                           if (!grepl(pattern, name)) 
[18:01:26.891]                             next
[18:01:26.891]                           invokeRestart(restart)
[18:01:26.891]                           muffled <- TRUE
[18:01:26.891]                           break
[18:01:26.891]                         }
[18:01:26.891]                       }
[18:01:26.891]                     }
[18:01:26.891]                     invisible(muffled)
[18:01:26.891]                   }
[18:01:26.891]                   muffleCondition(cond)
[18:01:26.891]                 })
[18:01:26.891]             }))
[18:01:26.891]             future::FutureResult(value = ...future.value$value, 
[18:01:26.891]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.891]                   ...future.rng), globalenv = if (FALSE) 
[18:01:26.891]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:01:26.891]                     ...future.globalenv.names))
[18:01:26.891]                 else NULL, started = ...future.startTime, version = "1.8")
[18:01:26.891]         }, condition = base::local({
[18:01:26.891]             c <- base::c
[18:01:26.891]             inherits <- base::inherits
[18:01:26.891]             invokeRestart <- base::invokeRestart
[18:01:26.891]             length <- base::length
[18:01:26.891]             list <- base::list
[18:01:26.891]             seq.int <- base::seq.int
[18:01:26.891]             signalCondition <- base::signalCondition
[18:01:26.891]             sys.calls <- base::sys.calls
[18:01:26.891]             `[[` <- base::`[[`
[18:01:26.891]             `+` <- base::`+`
[18:01:26.891]             `<<-` <- base::`<<-`
[18:01:26.891]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:01:26.891]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:01:26.891]                   3L)]
[18:01:26.891]             }
[18:01:26.891]             function(cond) {
[18:01:26.891]                 is_error <- inherits(cond, "error")
[18:01:26.891]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:01:26.891]                   NULL)
[18:01:26.891]                 if (is_error) {
[18:01:26.891]                   sessionInformation <- function() {
[18:01:26.891]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:01:26.891]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:01:26.891]                       search = base::search(), system = base::Sys.info())
[18:01:26.891]                   }
[18:01:26.891]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.891]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:01:26.891]                     cond$call), session = sessionInformation(), 
[18:01:26.891]                     timestamp = base::Sys.time(), signaled = 0L)
[18:01:26.891]                   signalCondition(cond)
[18:01:26.891]                 }
[18:01:26.891]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:01:26.891]                 "immediateCondition"))) {
[18:01:26.891]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:01:26.891]                   ...future.conditions[[length(...future.conditions) + 
[18:01:26.891]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:01:26.891]                   if (TRUE && !signal) {
[18:01:26.891]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.891]                     {
[18:01:26.891]                       inherits <- base::inherits
[18:01:26.891]                       invokeRestart <- base::invokeRestart
[18:01:26.891]                       is.null <- base::is.null
[18:01:26.891]                       muffled <- FALSE
[18:01:26.891]                       if (inherits(cond, "message")) {
[18:01:26.891]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.891]                         if (muffled) 
[18:01:26.891]                           invokeRestart("muffleMessage")
[18:01:26.891]                       }
[18:01:26.891]                       else if (inherits(cond, "warning")) {
[18:01:26.891]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.891]                         if (muffled) 
[18:01:26.891]                           invokeRestart("muffleWarning")
[18:01:26.891]                       }
[18:01:26.891]                       else if (inherits(cond, "condition")) {
[18:01:26.891]                         if (!is.null(pattern)) {
[18:01:26.891]                           computeRestarts <- base::computeRestarts
[18:01:26.891]                           grepl <- base::grepl
[18:01:26.891]                           restarts <- computeRestarts(cond)
[18:01:26.891]                           for (restart in restarts) {
[18:01:26.891]                             name <- restart$name
[18:01:26.891]                             if (is.null(name)) 
[18:01:26.891]                               next
[18:01:26.891]                             if (!grepl(pattern, name)) 
[18:01:26.891]                               next
[18:01:26.891]                             invokeRestart(restart)
[18:01:26.891]                             muffled <- TRUE
[18:01:26.891]                             break
[18:01:26.891]                           }
[18:01:26.891]                         }
[18:01:26.891]                       }
[18:01:26.891]                       invisible(muffled)
[18:01:26.891]                     }
[18:01:26.891]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.891]                   }
[18:01:26.891]                 }
[18:01:26.891]                 else {
[18:01:26.891]                   if (TRUE) {
[18:01:26.891]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:01:26.891]                     {
[18:01:26.891]                       inherits <- base::inherits
[18:01:26.891]                       invokeRestart <- base::invokeRestart
[18:01:26.891]                       is.null <- base::is.null
[18:01:26.891]                       muffled <- FALSE
[18:01:26.891]                       if (inherits(cond, "message")) {
[18:01:26.891]                         muffled <- grepl(pattern, "muffleMessage")
[18:01:26.891]                         if (muffled) 
[18:01:26.891]                           invokeRestart("muffleMessage")
[18:01:26.891]                       }
[18:01:26.891]                       else if (inherits(cond, "warning")) {
[18:01:26.891]                         muffled <- grepl(pattern, "muffleWarning")
[18:01:26.891]                         if (muffled) 
[18:01:26.891]                           invokeRestart("muffleWarning")
[18:01:26.891]                       }
[18:01:26.891]                       else if (inherits(cond, "condition")) {
[18:01:26.891]                         if (!is.null(pattern)) {
[18:01:26.891]                           computeRestarts <- base::computeRestarts
[18:01:26.891]                           grepl <- base::grepl
[18:01:26.891]                           restarts <- computeRestarts(cond)
[18:01:26.891]                           for (restart in restarts) {
[18:01:26.891]                             name <- restart$name
[18:01:26.891]                             if (is.null(name)) 
[18:01:26.891]                               next
[18:01:26.891]                             if (!grepl(pattern, name)) 
[18:01:26.891]                               next
[18:01:26.891]                             invokeRestart(restart)
[18:01:26.891]                             muffled <- TRUE
[18:01:26.891]                             break
[18:01:26.891]                           }
[18:01:26.891]                         }
[18:01:26.891]                       }
[18:01:26.891]                       invisible(muffled)
[18:01:26.891]                     }
[18:01:26.891]                     muffleCondition(cond, pattern = "^muffle")
[18:01:26.891]                   }
[18:01:26.891]                 }
[18:01:26.891]             }
[18:01:26.891]         }))
[18:01:26.891]     }, error = function(ex) {
[18:01:26.891]         base::structure(base::list(value = NULL, visible = NULL, 
[18:01:26.891]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:01:26.891]                 ...future.rng), started = ...future.startTime, 
[18:01:26.891]             finished = Sys.time(), session_uuid = NA_character_, 
[18:01:26.891]             version = "1.8"), class = "FutureResult")
[18:01:26.891]     }, finally = {
[18:01:26.891]         if (!identical(...future.workdir, getwd())) 
[18:01:26.891]             setwd(...future.workdir)
[18:01:26.891]         {
[18:01:26.891]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:01:26.891]                 ...future.oldOptions$nwarnings <- NULL
[18:01:26.891]             }
[18:01:26.891]             base::options(...future.oldOptions)
[18:01:26.891]             if (.Platform$OS.type == "windows") {
[18:01:26.891]                 old_names <- names(...future.oldEnvVars)
[18:01:26.891]                 envs <- base::Sys.getenv()
[18:01:26.891]                 names <- names(envs)
[18:01:26.891]                 common <- intersect(names, old_names)
[18:01:26.891]                 added <- setdiff(names, old_names)
[18:01:26.891]                 removed <- setdiff(old_names, names)
[18:01:26.891]                 changed <- common[...future.oldEnvVars[common] != 
[18:01:26.891]                   envs[common]]
[18:01:26.891]                 NAMES <- toupper(changed)
[18:01:26.891]                 args <- list()
[18:01:26.891]                 for (kk in seq_along(NAMES)) {
[18:01:26.891]                   name <- changed[[kk]]
[18:01:26.891]                   NAME <- NAMES[[kk]]
[18:01:26.891]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.891]                     next
[18:01:26.891]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.891]                 }
[18:01:26.891]                 NAMES <- toupper(added)
[18:01:26.891]                 for (kk in seq_along(NAMES)) {
[18:01:26.891]                   name <- added[[kk]]
[18:01:26.891]                   NAME <- NAMES[[kk]]
[18:01:26.891]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.891]                     next
[18:01:26.891]                   args[[name]] <- ""
[18:01:26.891]                 }
[18:01:26.891]                 NAMES <- toupper(removed)
[18:01:26.891]                 for (kk in seq_along(NAMES)) {
[18:01:26.891]                   name <- removed[[kk]]
[18:01:26.891]                   NAME <- NAMES[[kk]]
[18:01:26.891]                   if (name != NAME && is.element(NAME, old_names)) 
[18:01:26.891]                     next
[18:01:26.891]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:01:26.891]                 }
[18:01:26.891]                 if (length(args) > 0) 
[18:01:26.891]                   base::do.call(base::Sys.setenv, args = args)
[18:01:26.891]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:01:26.891]             }
[18:01:26.891]             else {
[18:01:26.891]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:01:26.891]             }
[18:01:26.891]             {
[18:01:26.891]                 if (base::length(...future.futureOptionsAdded) > 
[18:01:26.891]                   0L) {
[18:01:26.891]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:01:26.891]                   base::names(opts) <- ...future.futureOptionsAdded
[18:01:26.891]                   base::options(opts)
[18:01:26.891]                 }
[18:01:26.891]                 {
[18:01:26.891]                   {
[18:01:26.891]                     base::options(mc.cores = ...future.mc.cores.old)
[18:01:26.891]                     NULL
[18:01:26.891]                   }
[18:01:26.891]                   options(future.plan = NULL)
[18:01:26.891]                   if (is.na(NA_character_)) 
[18:01:26.891]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:01:26.891]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:01:26.891]                   future::plan(list(function (..., workers = availableCores(), 
[18:01:26.891]                     lazy = FALSE, rscript_libs = .libPaths(), 
[18:01:26.891]                     envir = parent.frame()) 
[18:01:26.891]                   {
[18:01:26.891]                     if (is.function(workers)) 
[18:01:26.891]                       workers <- workers()
[18:01:26.891]                     workers <- structure(as.integer(workers), 
[18:01:26.891]                       class = class(workers))
[18:01:26.891]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[18:01:26.891]                       workers >= 1)
[18:01:26.891]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[18:01:26.891]                       return(sequential(..., lazy = TRUE, envir = envir))
[18:01:26.891]                     }
[18:01:26.891]                     future <- MultisessionFuture(..., workers = workers, 
[18:01:26.891]                       lazy = lazy, rscript_libs = rscript_libs, 
[18:01:26.891]                       envir = envir)
[18:01:26.891]                     if (!future$lazy) 
[18:01:26.891]                       future <- run(future)
[18:01:26.891]                     invisible(future)
[18:01:26.891]                   }), .cleanup = FALSE, .init = FALSE)
[18:01:26.891]                 }
[18:01:26.891]             }
[18:01:26.891]         }
[18:01:26.891]     })
[18:01:26.891]     if (TRUE) {
[18:01:26.891]         base::sink(type = "output", split = FALSE)
[18:01:26.891]         if (TRUE) {
[18:01:26.891]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:01:26.891]         }
[18:01:26.891]         else {
[18:01:26.891]             ...future.result["stdout"] <- base::list(NULL)
[18:01:26.891]         }
[18:01:26.891]         base::close(...future.stdout)
[18:01:26.891]         ...future.stdout <- NULL
[18:01:26.891]     }
[18:01:26.891]     ...future.result$conditions <- ...future.conditions
[18:01:26.891]     ...future.result$finished <- base::Sys.time()
[18:01:26.891]     ...future.result
[18:01:26.891] }
[18:01:26.897] MultisessionFuture started
[18:01:26.897] - Launch lazy future ... done
[18:01:26.897] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'strategy = multisession'
Expression:
{
    42
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:01:26.913] receiveMessageFromWorker() for ClusterFuture ...
[18:01:26.914] - Validating connection of MultisessionFuture
[18:01:26.914] - received message: FutureResult
[18:01:26.914] - Received FutureResult
[18:01:26.914] - Erased future from FutureRegistry
[18:01:26.914] result() for ClusterFuture ...
[18:01:26.915] - result already collected: FutureResult
[18:01:26.915] result() for ClusterFuture ... done
[18:01:26.915] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: fd4a23fd-3f1e-941b-f00a-64835db9cc52
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:01:26.915] result() for ClusterFuture ...
[18:01:26.915] - result already collected: FutureResult
[18:01:26.916] result() for ClusterFuture ... done
[18:01:26.916] result() for ClusterFuture ...
[18:01:26.916] - result already collected: FutureResult
[18:01:26.916] result() for ClusterFuture ... done
- plan('multisession') ... DONE
> 
> message("*** Futures - labels ... DONE")
*** Futures - labels ... DONE
> 
> source("incl/end.R")
[18:01:26.917] plan(): Setting new future strategy stack:
[18:01:26.917] List of future strategies:
[18:01:26.917] 1. FutureStrategy:
[18:01:26.917]    - args: function (..., envir = parent.frame())
[18:01:26.917]    - tweaked: FALSE
[18:01:26.917]    - call: future::plan(oplan)
[18:01:26.918] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=201] '!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', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RETICULATE_AUTOCONFIGURE', 'RTOOLS43_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_RTOOLS43_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_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_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_SUBDIRS_STRICT_', '_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_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_INSTALL_TIME_PATCHES_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '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 
   0.70    0.10    1.57