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

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

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

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

> source("incl/start.R")
Loading required package: future
[10:56:20.569] plan(): Setting new future strategy stack:
[10:56:20.570] List of future strategies:
[10:56:20.570] 1. mirai_multisession:
[10:56:20.570]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
[10:56:20.570]    - tweaked: FALSE
[10:56:20.570]    - call: future::plan(future.mirai::mirai_multisession)
[10:56:20.583] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
[10:56:20.583] < mirai | $data >
[10:56:20.588] getGlobalsAndPackages() ...
[10:56:20.589] Not searching for globals
[10:56:20.589] - globals: [0] <none>
[10:56:20.589] getGlobalsAndPackages() ... DONE
[10:56:20.590] getGlobalsAndPackages() ...
[10:56:20.590] 
[10:56:20.590] - globals: [0] <none>
[10:56:20.590] getGlobalsAndPackages() ... DONE
[10:56:20.882] Packages needed by the future expression (n = 0): <none>
[10:56:20.883] Packages needed by future strategies (n = 0): <none>
[10:56:20.884] {
[10:56:20.884]     {
[10:56:20.884]         {
[10:56:20.884]             ...future.startTime <- base::Sys.time()
[10:56:20.884]             {
[10:56:20.884]                 {
[10:56:20.884]                   {
[10:56:20.884]                     base::local({
[10:56:20.884]                       has_future <- base::requireNamespace("future", 
[10:56:20.884]                         quietly = TRUE)
[10:56:20.884]                       if (has_future) {
[10:56:20.884]                         ns <- base::getNamespace("future")
[10:56:20.884]                         version <- ns[[".package"]][["version"]]
[10:56:20.884]                         if (is.null(version)) 
[10:56:20.884]                           version <- utils::packageVersion("future")
[10:56:20.884]                       }
[10:56:20.884]                       else {
[10:56:20.884]                         version <- NULL
[10:56:20.884]                       }
[10:56:20.884]                       if (!has_future || version < "1.8.0") {
[10:56:20.884]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:20.884]                           "", base::R.version$version.string), 
[10:56:20.884]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:20.884]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:20.884]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:20.884]                             "release", "version")], collapse = " "), 
[10:56:20.884]                           hostname = base::Sys.info()[["nodename"]])
[10:56:20.884]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:20.884]                           info)
[10:56:20.884]                         info <- base::paste(info, collapse = "; ")
[10:56:20.884]                         if (!has_future) {
[10:56:20.884]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:20.884]                             info)
[10:56:20.884]                         }
[10:56:20.884]                         else {
[10:56:20.884]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:20.884]                             info, version)
[10:56:20.884]                         }
[10:56:20.884]                         base::stop(msg)
[10:56:20.884]                       }
[10:56:20.884]                     })
[10:56:20.884]                   }
[10:56:20.884]                   ...future.strategy.old <- future::plan("list")
[10:56:20.884]                   options(future.plan = NULL)
[10:56:20.884]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:20.884]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:20.884]                 }
[10:56:20.884]                 ...future.workdir <- getwd()
[10:56:20.884]             }
[10:56:20.884]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:20.884]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:20.884]         }
[10:56:20.884]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:20.884]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:20.884]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:20.884]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:20.884]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:20.884]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:20.884]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:20.884]             base::names(...future.oldOptions))
[10:56:20.884]     }
[10:56:20.884]     if (FALSE) {
[10:56:20.884]     }
[10:56:20.884]     else {
[10:56:20.884]         if (TRUE) {
[10:56:20.884]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:20.884]                 open = "w")
[10:56:20.884]         }
[10:56:20.884]         else {
[10:56:20.884]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:20.884]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:20.884]         }
[10:56:20.884]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:20.884]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:20.884]             base::sink(type = "output", split = FALSE)
[10:56:20.884]             base::close(...future.stdout)
[10:56:20.884]         }, add = TRUE)
[10:56:20.884]     }
[10:56:20.884]     ...future.frame <- base::sys.nframe()
[10:56:20.884]     ...future.conditions <- base::list()
[10:56:20.884]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:20.884]     if (FALSE) {
[10:56:20.884]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:20.884]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:20.884]     }
[10:56:20.884]     ...future.result <- base::tryCatch({
[10:56:20.884]         base::withCallingHandlers({
[10:56:20.884]             ...future.value <- base::withVisible(base::local(NA))
[10:56:20.884]             future::FutureResult(value = ...future.value$value, 
[10:56:20.884]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:20.884]                   ...future.rng), globalenv = if (FALSE) 
[10:56:20.884]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:20.884]                     ...future.globalenv.names))
[10:56:20.884]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:20.884]         }, condition = base::local({
[10:56:20.884]             c <- base::c
[10:56:20.884]             inherits <- base::inherits
[10:56:20.884]             invokeRestart <- base::invokeRestart
[10:56:20.884]             length <- base::length
[10:56:20.884]             list <- base::list
[10:56:20.884]             seq.int <- base::seq.int
[10:56:20.884]             signalCondition <- base::signalCondition
[10:56:20.884]             sys.calls <- base::sys.calls
[10:56:20.884]             `[[` <- base::`[[`
[10:56:20.884]             `+` <- base::`+`
[10:56:20.884]             `<<-` <- base::`<<-`
[10:56:20.884]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:20.884]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:20.884]                   3L)]
[10:56:20.884]             }
[10:56:20.884]             function(cond) {
[10:56:20.884]                 is_error <- inherits(cond, "error")
[10:56:20.884]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:20.884]                   NULL)
[10:56:20.884]                 if (is_error) {
[10:56:20.884]                   sessionInformation <- function() {
[10:56:20.884]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:20.884]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:20.884]                       search = base::search(), system = base::Sys.info())
[10:56:20.884]                   }
[10:56:20.884]                   ...future.conditions[[length(...future.conditions) + 
[10:56:20.884]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:20.884]                     cond$call), session = sessionInformation(), 
[10:56:20.884]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:20.884]                   signalCondition(cond)
[10:56:20.884]                 }
[10:56:20.884]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:20.884]                   signal <- FALSE && inherits(cond, character(0))
[10:56:20.884]                   ...future.conditions[[length(...future.conditions) + 
[10:56:20.884]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:20.884]                   if (FALSE && !signal) {
[10:56:20.884]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:20.884]                     {
[10:56:20.884]                       inherits <- base::inherits
[10:56:20.884]                       invokeRestart <- base::invokeRestart
[10:56:20.884]                       is.null <- base::is.null
[10:56:20.884]                       muffled <- FALSE
[10:56:20.884]                       if (inherits(cond, "message")) {
[10:56:20.884]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:20.884]                         if (muffled) 
[10:56:20.884]                           invokeRestart("muffleMessage")
[10:56:20.884]                       }
[10:56:20.884]                       else if (inherits(cond, "warning")) {
[10:56:20.884]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:20.884]                         if (muffled) 
[10:56:20.884]                           invokeRestart("muffleWarning")
[10:56:20.884]                       }
[10:56:20.884]                       else if (inherits(cond, "condition")) {
[10:56:20.884]                         if (!is.null(pattern)) {
[10:56:20.884]                           computeRestarts <- base::computeRestarts
[10:56:20.884]                           grepl <- base::grepl
[10:56:20.884]                           restarts <- computeRestarts(cond)
[10:56:20.884]                           for (restart in restarts) {
[10:56:20.884]                             name <- restart$name
[10:56:20.884]                             if (is.null(name)) 
[10:56:20.884]                               next
[10:56:20.884]                             if (!grepl(pattern, name)) 
[10:56:20.884]                               next
[10:56:20.884]                             invokeRestart(restart)
[10:56:20.884]                             muffled <- TRUE
[10:56:20.884]                             break
[10:56:20.884]                           }
[10:56:20.884]                         }
[10:56:20.884]                       }
[10:56:20.884]                       invisible(muffled)
[10:56:20.884]                     }
[10:56:20.884]                     muffleCondition(cond, pattern = "^muffle")
[10:56:20.884]                   }
[10:56:20.884]                 }
[10:56:20.884]                 else {
[10:56:20.884]                   if (TRUE) {
[10:56:20.884]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:20.884]                     {
[10:56:20.884]                       inherits <- base::inherits
[10:56:20.884]                       invokeRestart <- base::invokeRestart
[10:56:20.884]                       is.null <- base::is.null
[10:56:20.884]                       muffled <- FALSE
[10:56:20.884]                       if (inherits(cond, "message")) {
[10:56:20.884]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:20.884]                         if (muffled) 
[10:56:20.884]                           invokeRestart("muffleMessage")
[10:56:20.884]                       }
[10:56:20.884]                       else if (inherits(cond, "warning")) {
[10:56:20.884]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:20.884]                         if (muffled) 
[10:56:20.884]                           invokeRestart("muffleWarning")
[10:56:20.884]                       }
[10:56:20.884]                       else if (inherits(cond, "condition")) {
[10:56:20.884]                         if (!is.null(pattern)) {
[10:56:20.884]                           computeRestarts <- base::computeRestarts
[10:56:20.884]                           grepl <- base::grepl
[10:56:20.884]                           restarts <- computeRestarts(cond)
[10:56:20.884]                           for (restart in restarts) {
[10:56:20.884]                             name <- restart$name
[10:56:20.884]                             if (is.null(name)) 
[10:56:20.884]                               next
[10:56:20.884]                             if (!grepl(pattern, name)) 
[10:56:20.884]                               next
[10:56:20.884]                             invokeRestart(restart)
[10:56:20.884]                             muffled <- TRUE
[10:56:20.884]                             break
[10:56:20.884]                           }
[10:56:20.884]                         }
[10:56:20.884]                       }
[10:56:20.884]                       invisible(muffled)
[10:56:20.884]                     }
[10:56:20.884]                     muffleCondition(cond, pattern = "^muffle")
[10:56:20.884]                   }
[10:56:20.884]                 }
[10:56:20.884]             }
[10:56:20.884]         }))
[10:56:20.884]     }, error = function(ex) {
[10:56:20.884]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:20.884]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:20.884]                 ...future.rng), started = ...future.startTime, 
[10:56:20.884]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:20.884]             version = "1.8"), class = "FutureResult")
[10:56:20.884]     }, finally = {
[10:56:20.884]         if (!identical(...future.workdir, getwd())) 
[10:56:20.884]             setwd(...future.workdir)
[10:56:20.884]         {
[10:56:20.884]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:20.884]                 ...future.oldOptions$nwarnings <- NULL
[10:56:20.884]             }
[10:56:20.884]             base::options(...future.oldOptions)
[10:56:20.884]             if (.Platform$OS.type == "windows") {
[10:56:20.884]                 old_names <- names(...future.oldEnvVars)
[10:56:20.884]                 envs <- base::Sys.getenv()
[10:56:20.884]                 names <- names(envs)
[10:56:20.884]                 common <- intersect(names, old_names)
[10:56:20.884]                 added <- setdiff(names, old_names)
[10:56:20.884]                 removed <- setdiff(old_names, names)
[10:56:20.884]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:20.884]                   envs[common]]
[10:56:20.884]                 NAMES <- toupper(changed)
[10:56:20.884]                 args <- list()
[10:56:20.884]                 for (kk in seq_along(NAMES)) {
[10:56:20.884]                   name <- changed[[kk]]
[10:56:20.884]                   NAME <- NAMES[[kk]]
[10:56:20.884]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:20.884]                     next
[10:56:20.884]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:20.884]                 }
[10:56:20.884]                 NAMES <- toupper(added)
[10:56:20.884]                 for (kk in seq_along(NAMES)) {
[10:56:20.884]                   name <- added[[kk]]
[10:56:20.884]                   NAME <- NAMES[[kk]]
[10:56:20.884]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:20.884]                     next
[10:56:20.884]                   args[[name]] <- ""
[10:56:20.884]                 }
[10:56:20.884]                 NAMES <- toupper(removed)
[10:56:20.884]                 for (kk in seq_along(NAMES)) {
[10:56:20.884]                   name <- removed[[kk]]
[10:56:20.884]                   NAME <- NAMES[[kk]]
[10:56:20.884]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:20.884]                     next
[10:56:20.884]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:20.884]                 }
[10:56:20.884]                 if (length(args) > 0) 
[10:56:20.884]                   base::do.call(base::Sys.setenv, args = args)
[10:56:20.884]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:20.884]             }
[10:56:20.884]             else {
[10:56:20.884]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:20.884]             }
[10:56:20.884]             {
[10:56:20.884]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:20.884]                   0L) {
[10:56:20.884]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:20.884]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:20.884]                   base::options(opts)
[10:56:20.884]                 }
[10:56:20.884]                 {
[10:56:20.884]                   NULL
[10:56:20.884]                   options(future.plan = NULL)
[10:56:20.884]                   if (is.na(NA_character_)) 
[10:56:20.884]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:20.884]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:20.884]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:20.884]                     .init = FALSE)
[10:56:20.884]                 }
[10:56:20.884]             }
[10:56:20.884]         }
[10:56:20.884]     })
[10:56:20.884]     if (TRUE) {
[10:56:20.884]         base::sink(type = "output", split = FALSE)
[10:56:20.884]         if (TRUE) {
[10:56:20.884]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:20.884]         }
[10:56:20.884]         else {
[10:56:20.884]             ...future.result["stdout"] <- base::list(NULL)
[10:56:20.884]         }
[10:56:20.884]         base::close(...future.stdout)
[10:56:20.884]         ...future.stdout <- NULL
[10:56:20.884]     }
[10:56:20.884]     ...future.result$conditions <- ...future.conditions
[10:56:20.884]     ...future.result$finished <- base::Sys.time()
[10:56:20.884]     ...future.result
[10:56:20.884] }
[10:56:20.997] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ... DONE
[10:56:20.998] plan(): nbrOfWorkers() = 2
> library("listenv")
> 
> message("*** mirai_multisession() ...")
*** mirai_multisession() ...
> 
> for (cores in 1:min(2L, availableCores())) {
+   ## FIXME:
+   if (!fullTest && cores > 1) next
+ 
+   mprintf("Testing with %d cores ...", cores)
+   options(mc.cores = cores - 1L)
+ 
+   for (globals in c(FALSE, TRUE)) {
+     mprintf("*** mirai_multisession(..., globals = %s) without globals",
+             globals)
+ 
+     f <- mirai_multisession({
+       42L
+     }, globals = globals)
+     stopifnot(inherits(f, "MiraiFuture"))
+ 
+     print(resolved(f))
+     y <- value(f)
+     print(y)
+     stopifnot(y == 42L)
+ 
+     mprintf("*** mirai_multisession(..., globals = %s) with globals", globals)
+     ## A global variable
+     a <- 0
+     f <- mirai_multisession({
+       b <- 3
+       c <- 2
+       a * b * c
+     }, globals = globals)
+     print(f)
+ 
+ 
+     ## A mirai_multisession future is evaluated in a separated
+     ## process.  Changing the value of a global
+     ## variable should not affect the result of the
+     ## future.
+     a <- 7  ## Make sure globals are frozen
+     if (globals) {
+       v <- value(f)
+       print(v)
+       stopifnot(v == 0)
+     } else {
+       res <- tryCatch({ value(f) }, error = identity)
+       print(res)
+       stopifnot(inherits(res, "error"))
+     }
+ 
+ 
+     mprintf("*** mirai_multisession(..., globals = %s) with globals and blocking", globals) #nolint
+     x <- listenv()
+     for (ii in 1:3) {
+       mprintf(" - Creating mirai_multisession future #%d ...", ii)
+       x[[ii]] <- mirai_multisession({ ii }, globals = globals)
+     }
+     mprintf(" - Resolving %d mirai_multisession futures", length(x))
+     if (globals) {
+       v <- sapply(x, FUN = value)
+       stopifnot(all(v == 1:3))
+     } else {
+       v <- lapply(x, FUN = function(f) tryCatch(value(f), error = identity))
+       stopifnot(all(sapply(v, FUN = inherits, "error")))
+     }
+ 
+     mprintf("*** mirai_multisession(..., globals = %s) and errors", globals)
+     f <- mirai_multisession({
+       stop("Whoops!")
+       1
+     }, globals = globals)
+     print(f)
+     v <- value(f, signal = FALSE)
+     print(v)
+     stopifnot(inherits(v, "error"))
+ 
+     res <- tryCatch({
+       v <- value(f)
+     }, error = identity)
+     print(res)
+     stopifnot(inherits(res, "error"))
+ 
+     ## Error is repeated
+     res <- tryCatch({
+       v <- value(f)
+     }, error = identity)
+     print(res)
+     stopifnot(inherits(res, "error"))
+ 
+   } # for (globals ...)
+ 
+ 
+   message("*** mirai_multisession(..., workers = 1L) ...")
+ 
+   a <- 2
+   b <- 3
+   y_truth <- a * b
+ 
+   f <- mirai_multisession({ a * b }, workers = 1L)
+   rm(list = c("a", "b"))
+ 
+   v <- value(f)
+   print(v)
+   stopifnot(v == y_truth)
+ 
+   message("*** mirai_multisession(..., workers = 1L) ... DONE")
+ 
+   mprintf("Testing with %d cores ... DONE", cores)
+ } ## for (cores ...)
[10:56:21.106] Testing with 1 cores ...[10:56:21.106] *** mirai_multisession(..., globals = FALSE) without globals[10:56:21.109] getGlobalsAndPackages() ...
[10:56:21.109] Not searching for globals
[10:56:21.109] - globals: [0] <none>
[10:56:21.110] getGlobalsAndPackages() ... DONE
[10:56:21.110] getGlobalsAndPackages() ...
[10:56:21.110] 
[10:56:21.110] - globals: [0] <none>
[10:56:21.110] getGlobalsAndPackages() ... DONE
[10:56:21.257] Packages needed by the future expression (n = 0): <none>
[10:56:21.258] Packages needed by future strategies (n = 0): <none>
[10:56:21.258] {
[10:56:21.258]     {
[10:56:21.258]         {
[10:56:21.258]             ...future.startTime <- base::Sys.time()
[10:56:21.258]             {
[10:56:21.258]                 {
[10:56:21.258]                   {
[10:56:21.258]                     base::local({
[10:56:21.258]                       has_future <- base::requireNamespace("future", 
[10:56:21.258]                         quietly = TRUE)
[10:56:21.258]                       if (has_future) {
[10:56:21.258]                         ns <- base::getNamespace("future")
[10:56:21.258]                         version <- ns[[".package"]][["version"]]
[10:56:21.258]                         if (is.null(version)) 
[10:56:21.258]                           version <- utils::packageVersion("future")
[10:56:21.258]                       }
[10:56:21.258]                       else {
[10:56:21.258]                         version <- NULL
[10:56:21.258]                       }
[10:56:21.258]                       if (!has_future || version < "1.8.0") {
[10:56:21.258]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.258]                           "", base::R.version$version.string), 
[10:56:21.258]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.258]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.258]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.258]                             "release", "version")], collapse = " "), 
[10:56:21.258]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.258]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.258]                           info)
[10:56:21.258]                         info <- base::paste(info, collapse = "; ")
[10:56:21.258]                         if (!has_future) {
[10:56:21.258]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.258]                             info)
[10:56:21.258]                         }
[10:56:21.258]                         else {
[10:56:21.258]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.258]                             info, version)
[10:56:21.258]                         }
[10:56:21.258]                         base::stop(msg)
[10:56:21.258]                       }
[10:56:21.258]                     })
[10:56:21.258]                   }
[10:56:21.258]                   ...future.strategy.old <- future::plan("list")
[10:56:21.258]                   options(future.plan = NULL)
[10:56:21.258]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.258]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.258]                 }
[10:56:21.258]                 ...future.workdir <- getwd()
[10:56:21.258]             }
[10:56:21.258]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.258]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.258]         }
[10:56:21.258]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.258]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.258]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.258]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.258]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.258]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.258]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.258]             base::names(...future.oldOptions))
[10:56:21.258]     }
[10:56:21.258]     if (FALSE) {
[10:56:21.258]     }
[10:56:21.258]     else {
[10:56:21.258]         if (TRUE) {
[10:56:21.258]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.258]                 open = "w")
[10:56:21.258]         }
[10:56:21.258]         else {
[10:56:21.258]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.258]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.258]         }
[10:56:21.258]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.258]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.258]             base::sink(type = "output", split = FALSE)
[10:56:21.258]             base::close(...future.stdout)
[10:56:21.258]         }, add = TRUE)
[10:56:21.258]     }
[10:56:21.258]     ...future.frame <- base::sys.nframe()
[10:56:21.258]     ...future.conditions <- base::list()
[10:56:21.258]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.258]     if (FALSE) {
[10:56:21.258]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.258]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.258]     }
[10:56:21.258]     ...future.result <- base::tryCatch({
[10:56:21.258]         base::withCallingHandlers({
[10:56:21.258]             ...future.value <- base::withVisible(base::local({
[10:56:21.258]                 42L
[10:56:21.258]             }))
[10:56:21.258]             future::FutureResult(value = ...future.value$value, 
[10:56:21.258]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.258]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.258]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.258]                     ...future.globalenv.names))
[10:56:21.258]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.258]         }, condition = base::local({
[10:56:21.258]             c <- base::c
[10:56:21.258]             inherits <- base::inherits
[10:56:21.258]             invokeRestart <- base::invokeRestart
[10:56:21.258]             length <- base::length
[10:56:21.258]             list <- base::list
[10:56:21.258]             seq.int <- base::seq.int
[10:56:21.258]             signalCondition <- base::signalCondition
[10:56:21.258]             sys.calls <- base::sys.calls
[10:56:21.258]             `[[` <- base::`[[`
[10:56:21.258]             `+` <- base::`+`
[10:56:21.258]             `<<-` <- base::`<<-`
[10:56:21.258]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.258]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.258]                   3L)]
[10:56:21.258]             }
[10:56:21.258]             function(cond) {
[10:56:21.258]                 is_error <- inherits(cond, "error")
[10:56:21.258]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.258]                   NULL)
[10:56:21.258]                 if (is_error) {
[10:56:21.258]                   sessionInformation <- function() {
[10:56:21.258]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.258]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.258]                       search = base::search(), system = base::Sys.info())
[10:56:21.258]                   }
[10:56:21.258]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.258]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.258]                     cond$call), session = sessionInformation(), 
[10:56:21.258]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.258]                   signalCondition(cond)
[10:56:21.258]                 }
[10:56:21.258]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.258]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.258]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.258]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.258]                   if (FALSE && !signal) {
[10:56:21.258]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.258]                     {
[10:56:21.258]                       inherits <- base::inherits
[10:56:21.258]                       invokeRestart <- base::invokeRestart
[10:56:21.258]                       is.null <- base::is.null
[10:56:21.258]                       muffled <- FALSE
[10:56:21.258]                       if (inherits(cond, "message")) {
[10:56:21.258]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.258]                         if (muffled) 
[10:56:21.258]                           invokeRestart("muffleMessage")
[10:56:21.258]                       }
[10:56:21.258]                       else if (inherits(cond, "warning")) {
[10:56:21.258]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.258]                         if (muffled) 
[10:56:21.258]                           invokeRestart("muffleWarning")
[10:56:21.258]                       }
[10:56:21.258]                       else if (inherits(cond, "condition")) {
[10:56:21.258]                         if (!is.null(pattern)) {
[10:56:21.258]                           computeRestarts <- base::computeRestarts
[10:56:21.258]                           grepl <- base::grepl
[10:56:21.258]                           restarts <- computeRestarts(cond)
[10:56:21.258]                           for (restart in restarts) {
[10:56:21.258]                             name <- restart$name
[10:56:21.258]                             if (is.null(name)) 
[10:56:21.258]                               next
[10:56:21.258]                             if (!grepl(pattern, name)) 
[10:56:21.258]                               next
[10:56:21.258]                             invokeRestart(restart)
[10:56:21.258]                             muffled <- TRUE
[10:56:21.258]                             break
[10:56:21.258]                           }
[10:56:21.258]                         }
[10:56:21.258]                       }
[10:56:21.258]                       invisible(muffled)
[10:56:21.258]                     }
[10:56:21.258]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.258]                   }
[10:56:21.258]                 }
[10:56:21.258]                 else {
[10:56:21.258]                   if (TRUE) {
[10:56:21.258]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.258]                     {
[10:56:21.258]                       inherits <- base::inherits
[10:56:21.258]                       invokeRestart <- base::invokeRestart
[10:56:21.258]                       is.null <- base::is.null
[10:56:21.258]                       muffled <- FALSE
[10:56:21.258]                       if (inherits(cond, "message")) {
[10:56:21.258]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.258]                         if (muffled) 
[10:56:21.258]                           invokeRestart("muffleMessage")
[10:56:21.258]                       }
[10:56:21.258]                       else if (inherits(cond, "warning")) {
[10:56:21.258]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.258]                         if (muffled) 
[10:56:21.258]                           invokeRestart("muffleWarning")
[10:56:21.258]                       }
[10:56:21.258]                       else if (inherits(cond, "condition")) {
[10:56:21.258]                         if (!is.null(pattern)) {
[10:56:21.258]                           computeRestarts <- base::computeRestarts
[10:56:21.258]                           grepl <- base::grepl
[10:56:21.258]                           restarts <- computeRestarts(cond)
[10:56:21.258]                           for (restart in restarts) {
[10:56:21.258]                             name <- restart$name
[10:56:21.258]                             if (is.null(name)) 
[10:56:21.258]                               next
[10:56:21.258]                             if (!grepl(pattern, name)) 
[10:56:21.258]                               next
[10:56:21.258]                             invokeRestart(restart)
[10:56:21.258]                             muffled <- TRUE
[10:56:21.258]                             break
[10:56:21.258]                           }
[10:56:21.258]                         }
[10:56:21.258]                       }
[10:56:21.258]                       invisible(muffled)
[10:56:21.258]                     }
[10:56:21.258]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.258]                   }
[10:56:21.258]                 }
[10:56:21.258]             }
[10:56:21.258]         }))
[10:56:21.258]     }, error = function(ex) {
[10:56:21.258]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.258]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.258]                 ...future.rng), started = ...future.startTime, 
[10:56:21.258]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.258]             version = "1.8"), class = "FutureResult")
[10:56:21.258]     }, finally = {
[10:56:21.258]         if (!identical(...future.workdir, getwd())) 
[10:56:21.258]             setwd(...future.workdir)
[10:56:21.258]         {
[10:56:21.258]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.258]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.258]             }
[10:56:21.258]             base::options(...future.oldOptions)
[10:56:21.258]             if (.Platform$OS.type == "windows") {
[10:56:21.258]                 old_names <- names(...future.oldEnvVars)
[10:56:21.258]                 envs <- base::Sys.getenv()
[10:56:21.258]                 names <- names(envs)
[10:56:21.258]                 common <- intersect(names, old_names)
[10:56:21.258]                 added <- setdiff(names, old_names)
[10:56:21.258]                 removed <- setdiff(old_names, names)
[10:56:21.258]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.258]                   envs[common]]
[10:56:21.258]                 NAMES <- toupper(changed)
[10:56:21.258]                 args <- list()
[10:56:21.258]                 for (kk in seq_along(NAMES)) {
[10:56:21.258]                   name <- changed[[kk]]
[10:56:21.258]                   NAME <- NAMES[[kk]]
[10:56:21.258]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.258]                     next
[10:56:21.258]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.258]                 }
[10:56:21.258]                 NAMES <- toupper(added)
[10:56:21.258]                 for (kk in seq_along(NAMES)) {
[10:56:21.258]                   name <- added[[kk]]
[10:56:21.258]                   NAME <- NAMES[[kk]]
[10:56:21.258]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.258]                     next
[10:56:21.258]                   args[[name]] <- ""
[10:56:21.258]                 }
[10:56:21.258]                 NAMES <- toupper(removed)
[10:56:21.258]                 for (kk in seq_along(NAMES)) {
[10:56:21.258]                   name <- removed[[kk]]
[10:56:21.258]                   NAME <- NAMES[[kk]]
[10:56:21.258]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.258]                     next
[10:56:21.258]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.258]                 }
[10:56:21.258]                 if (length(args) > 0) 
[10:56:21.258]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.258]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.258]             }
[10:56:21.258]             else {
[10:56:21.258]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.258]             }
[10:56:21.258]             {
[10:56:21.258]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.258]                   0L) {
[10:56:21.258]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.258]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.258]                   base::options(opts)
[10:56:21.258]                 }
[10:56:21.258]                 {
[10:56:21.258]                   NULL
[10:56:21.258]                   options(future.plan = NULL)
[10:56:21.258]                   if (is.na(NA_character_)) 
[10:56:21.258]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.258]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.258]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.258]                     .init = FALSE)
[10:56:21.258]                 }
[10:56:21.258]             }
[10:56:21.258]         }
[10:56:21.258]     })
[10:56:21.258]     if (TRUE) {
[10:56:21.258]         base::sink(type = "output", split = FALSE)
[10:56:21.258]         if (TRUE) {
[10:56:21.258]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.258]         }
[10:56:21.258]         else {
[10:56:21.258]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.258]         }
[10:56:21.258]         base::close(...future.stdout)
[10:56:21.258]         ...future.stdout <- NULL
[10:56:21.258]     }
[10:56:21.258]     ...future.result$conditions <- ...future.conditions
[10:56:21.258]     ...future.result$finished <- base::Sys.time()
[10:56:21.258]     ...future.result
[10:56:21.258] }
[10:56:21.263] resolved() for 'MiraiFuture' ...
[10:56:21.263] - state: 'running'
[10:56:21.263] - run: TRUE
[10:56:21.263] - result: 'NULL'
[10:56:21.264] - resolved: FALSE
[10:56:21.264] resolved() for 'MiraiFuture' ... done
[1] FALSE
[1] 42
[10:56:21.383] *** mirai_multisession(..., globals = FALSE) with globals[10:56:21.385] getGlobalsAndPackages() ...
[10:56:21.385] Not searching for globals
[10:56:21.385] - globals: [0] <none>
[10:56:21.386] getGlobalsAndPackages() ... DONE
[10:56:21.386] getGlobalsAndPackages() ...
[10:56:21.386] 
[10:56:21.386] - globals: [0] <none>
[10:56:21.386] getGlobalsAndPackages() ... DONE
[10:56:21.387] Packages needed by the future expression (n = 0): <none>
[10:56:21.387] Packages needed by future strategies (n = 0): <none>
[10:56:21.388] {
[10:56:21.388]     {
[10:56:21.388]         {
[10:56:21.388]             ...future.startTime <- base::Sys.time()
[10:56:21.388]             {
[10:56:21.388]                 {
[10:56:21.388]                   {
[10:56:21.388]                     base::local({
[10:56:21.388]                       has_future <- base::requireNamespace("future", 
[10:56:21.388]                         quietly = TRUE)
[10:56:21.388]                       if (has_future) {
[10:56:21.388]                         ns <- base::getNamespace("future")
[10:56:21.388]                         version <- ns[[".package"]][["version"]]
[10:56:21.388]                         if (is.null(version)) 
[10:56:21.388]                           version <- utils::packageVersion("future")
[10:56:21.388]                       }
[10:56:21.388]                       else {
[10:56:21.388]                         version <- NULL
[10:56:21.388]                       }
[10:56:21.388]                       if (!has_future || version < "1.8.0") {
[10:56:21.388]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.388]                           "", base::R.version$version.string), 
[10:56:21.388]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.388]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.388]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.388]                             "release", "version")], collapse = " "), 
[10:56:21.388]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.388]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.388]                           info)
[10:56:21.388]                         info <- base::paste(info, collapse = "; ")
[10:56:21.388]                         if (!has_future) {
[10:56:21.388]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.388]                             info)
[10:56:21.388]                         }
[10:56:21.388]                         else {
[10:56:21.388]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.388]                             info, version)
[10:56:21.388]                         }
[10:56:21.388]                         base::stop(msg)
[10:56:21.388]                       }
[10:56:21.388]                     })
[10:56:21.388]                   }
[10:56:21.388]                   ...future.strategy.old <- future::plan("list")
[10:56:21.388]                   options(future.plan = NULL)
[10:56:21.388]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.388]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.388]                 }
[10:56:21.388]                 ...future.workdir <- getwd()
[10:56:21.388]             }
[10:56:21.388]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.388]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.388]         }
[10:56:21.388]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.388]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.388]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.388]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.388]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.388]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.388]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.388]             base::names(...future.oldOptions))
[10:56:21.388]     }
[10:56:21.388]     if (FALSE) {
[10:56:21.388]     }
[10:56:21.388]     else {
[10:56:21.388]         if (TRUE) {
[10:56:21.388]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.388]                 open = "w")
[10:56:21.388]         }
[10:56:21.388]         else {
[10:56:21.388]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.388]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.388]         }
[10:56:21.388]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.388]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.388]             base::sink(type = "output", split = FALSE)
[10:56:21.388]             base::close(...future.stdout)
[10:56:21.388]         }, add = TRUE)
[10:56:21.388]     }
[10:56:21.388]     ...future.frame <- base::sys.nframe()
[10:56:21.388]     ...future.conditions <- base::list()
[10:56:21.388]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.388]     if (FALSE) {
[10:56:21.388]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.388]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.388]     }
[10:56:21.388]     ...future.result <- base::tryCatch({
[10:56:21.388]         base::withCallingHandlers({
[10:56:21.388]             ...future.value <- base::withVisible(base::local({
[10:56:21.388]                 b <- 3
[10:56:21.388]                 c <- 2
[10:56:21.388]                 a * b * c
[10:56:21.388]             }))
[10:56:21.388]             future::FutureResult(value = ...future.value$value, 
[10:56:21.388]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.388]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.388]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.388]                     ...future.globalenv.names))
[10:56:21.388]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.388]         }, condition = base::local({
[10:56:21.388]             c <- base::c
[10:56:21.388]             inherits <- base::inherits
[10:56:21.388]             invokeRestart <- base::invokeRestart
[10:56:21.388]             length <- base::length
[10:56:21.388]             list <- base::list
[10:56:21.388]             seq.int <- base::seq.int
[10:56:21.388]             signalCondition <- base::signalCondition
[10:56:21.388]             sys.calls <- base::sys.calls
[10:56:21.388]             `[[` <- base::`[[`
[10:56:21.388]             `+` <- base::`+`
[10:56:21.388]             `<<-` <- base::`<<-`
[10:56:21.388]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.388]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.388]                   3L)]
[10:56:21.388]             }
[10:56:21.388]             function(cond) {
[10:56:21.388]                 is_error <- inherits(cond, "error")
[10:56:21.388]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.388]                   NULL)
[10:56:21.388]                 if (is_error) {
[10:56:21.388]                   sessionInformation <- function() {
[10:56:21.388]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.388]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.388]                       search = base::search(), system = base::Sys.info())
[10:56:21.388]                   }
[10:56:21.388]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.388]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.388]                     cond$call), session = sessionInformation(), 
[10:56:21.388]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.388]                   signalCondition(cond)
[10:56:21.388]                 }
[10:56:21.388]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.388]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.388]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.388]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.388]                   if (FALSE && !signal) {
[10:56:21.388]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.388]                     {
[10:56:21.388]                       inherits <- base::inherits
[10:56:21.388]                       invokeRestart <- base::invokeRestart
[10:56:21.388]                       is.null <- base::is.null
[10:56:21.388]                       muffled <- FALSE
[10:56:21.388]                       if (inherits(cond, "message")) {
[10:56:21.388]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.388]                         if (muffled) 
[10:56:21.388]                           invokeRestart("muffleMessage")
[10:56:21.388]                       }
[10:56:21.388]                       else if (inherits(cond, "warning")) {
[10:56:21.388]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.388]                         if (muffled) 
[10:56:21.388]                           invokeRestart("muffleWarning")
[10:56:21.388]                       }
[10:56:21.388]                       else if (inherits(cond, "condition")) {
[10:56:21.388]                         if (!is.null(pattern)) {
[10:56:21.388]                           computeRestarts <- base::computeRestarts
[10:56:21.388]                           grepl <- base::grepl
[10:56:21.388]                           restarts <- computeRestarts(cond)
[10:56:21.388]                           for (restart in restarts) {
[10:56:21.388]                             name <- restart$name
[10:56:21.388]                             if (is.null(name)) 
[10:56:21.388]                               next
[10:56:21.388]                             if (!grepl(pattern, name)) 
[10:56:21.388]                               next
[10:56:21.388]                             invokeRestart(restart)
[10:56:21.388]                             muffled <- TRUE
[10:56:21.388]                             break
[10:56:21.388]                           }
[10:56:21.388]                         }
[10:56:21.388]                       }
[10:56:21.388]                       invisible(muffled)
[10:56:21.388]                     }
[10:56:21.388]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.388]                   }
[10:56:21.388]                 }
[10:56:21.388]                 else {
[10:56:21.388]                   if (TRUE) {
[10:56:21.388]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.388]                     {
[10:56:21.388]                       inherits <- base::inherits
[10:56:21.388]                       invokeRestart <- base::invokeRestart
[10:56:21.388]                       is.null <- base::is.null
[10:56:21.388]                       muffled <- FALSE
[10:56:21.388]                       if (inherits(cond, "message")) {
[10:56:21.388]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.388]                         if (muffled) 
[10:56:21.388]                           invokeRestart("muffleMessage")
[10:56:21.388]                       }
[10:56:21.388]                       else if (inherits(cond, "warning")) {
[10:56:21.388]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.388]                         if (muffled) 
[10:56:21.388]                           invokeRestart("muffleWarning")
[10:56:21.388]                       }
[10:56:21.388]                       else if (inherits(cond, "condition")) {
[10:56:21.388]                         if (!is.null(pattern)) {
[10:56:21.388]                           computeRestarts <- base::computeRestarts
[10:56:21.388]                           grepl <- base::grepl
[10:56:21.388]                           restarts <- computeRestarts(cond)
[10:56:21.388]                           for (restart in restarts) {
[10:56:21.388]                             name <- restart$name
[10:56:21.388]                             if (is.null(name)) 
[10:56:21.388]                               next
[10:56:21.388]                             if (!grepl(pattern, name)) 
[10:56:21.388]                               next
[10:56:21.388]                             invokeRestart(restart)
[10:56:21.388]                             muffled <- TRUE
[10:56:21.388]                             break
[10:56:21.388]                           }
[10:56:21.388]                         }
[10:56:21.388]                       }
[10:56:21.388]                       invisible(muffled)
[10:56:21.388]                     }
[10:56:21.388]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.388]                   }
[10:56:21.388]                 }
[10:56:21.388]             }
[10:56:21.388]         }))
[10:56:21.388]     }, error = function(ex) {
[10:56:21.388]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.388]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.388]                 ...future.rng), started = ...future.startTime, 
[10:56:21.388]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.388]             version = "1.8"), class = "FutureResult")
[10:56:21.388]     }, finally = {
[10:56:21.388]         if (!identical(...future.workdir, getwd())) 
[10:56:21.388]             setwd(...future.workdir)
[10:56:21.388]         {
[10:56:21.388]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.388]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.388]             }
[10:56:21.388]             base::options(...future.oldOptions)
[10:56:21.388]             if (.Platform$OS.type == "windows") {
[10:56:21.388]                 old_names <- names(...future.oldEnvVars)
[10:56:21.388]                 envs <- base::Sys.getenv()
[10:56:21.388]                 names <- names(envs)
[10:56:21.388]                 common <- intersect(names, old_names)
[10:56:21.388]                 added <- setdiff(names, old_names)
[10:56:21.388]                 removed <- setdiff(old_names, names)
[10:56:21.388]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.388]                   envs[common]]
[10:56:21.388]                 NAMES <- toupper(changed)
[10:56:21.388]                 args <- list()
[10:56:21.388]                 for (kk in seq_along(NAMES)) {
[10:56:21.388]                   name <- changed[[kk]]
[10:56:21.388]                   NAME <- NAMES[[kk]]
[10:56:21.388]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.388]                     next
[10:56:21.388]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.388]                 }
[10:56:21.388]                 NAMES <- toupper(added)
[10:56:21.388]                 for (kk in seq_along(NAMES)) {
[10:56:21.388]                   name <- added[[kk]]
[10:56:21.388]                   NAME <- NAMES[[kk]]
[10:56:21.388]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.388]                     next
[10:56:21.388]                   args[[name]] <- ""
[10:56:21.388]                 }
[10:56:21.388]                 NAMES <- toupper(removed)
[10:56:21.388]                 for (kk in seq_along(NAMES)) {
[10:56:21.388]                   name <- removed[[kk]]
[10:56:21.388]                   NAME <- NAMES[[kk]]
[10:56:21.388]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.388]                     next
[10:56:21.388]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.388]                 }
[10:56:21.388]                 if (length(args) > 0) 
[10:56:21.388]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.388]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.388]             }
[10:56:21.388]             else {
[10:56:21.388]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.388]             }
[10:56:21.388]             {
[10:56:21.388]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.388]                   0L) {
[10:56:21.388]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.388]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.388]                   base::options(opts)
[10:56:21.388]                 }
[10:56:21.388]                 {
[10:56:21.388]                   NULL
[10:56:21.388]                   options(future.plan = NULL)
[10:56:21.388]                   if (is.na(NA_character_)) 
[10:56:21.388]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.388]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.388]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.388]                     .init = FALSE)
[10:56:21.388]                 }
[10:56:21.388]             }
[10:56:21.388]         }
[10:56:21.388]     })
[10:56:21.388]     if (TRUE) {
[10:56:21.388]         base::sink(type = "output", split = FALSE)
[10:56:21.388]         if (TRUE) {
[10:56:21.388]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.388]         }
[10:56:21.388]         else {
[10:56:21.388]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.388]         }
[10:56:21.388]         base::close(...future.stdout)
[10:56:21.388]         ...future.stdout <- NULL
[10:56:21.388]     }
[10:56:21.388]     ...future.result$conditions <- ...future.conditions
[10:56:21.388]     ...future.result$finished <- base::Sys.time()
[10:56:21.388]     ...future.result
[10:56:21.388] }
MiraiFuture:
Label: '<none>'
Expression:
{
    b <- 3
    c <- 2
    a * b * c
}
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)
[10:56:21.393] resolved() for 'MiraiFuture' ...
[10:56:21.393] - state: 'running'
[10:56:21.393] - run: TRUE
[10:56:21.393] - result: 'NULL'
[10:56:21.393] - resolved: FALSE
[10:56:21.394] resolved() for 'MiraiFuture' ... done
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 73cff85d-f0c3-d79d-6a2d-a22fd2dfb2cd
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:56:21.394] signalConditions() ...
[10:56:21.395]  - include = 'immediateCondition'
[10:56:21.395]  - exclude = 
[10:56:21.395]  - resignal = FALSE
[10:56:21.395]  - Number of conditions: 1
[10:56:21.395] signalConditions() ... done
[10:56:21.395] Future state: 'finished'
[10:56:21.396] signalConditions() ...
[10:56:21.396]  - include = 'condition'
[10:56:21.396]  - exclude = 'immediateCondition'
[10:56:21.396]  - resignal = TRUE
[10:56:21.396]  - Number of conditions: 1
[10:56:21.396]  - Condition #1: 'simpleError', 'error', 'condition'
[10:56:21.397] signalConditions() ... done
<simpleError in eval(quote({    b <- 3    c <- 2    a * b * c}), new.env()): object 'a' not found>
[10:56:21.397] *** mirai_multisession(..., globals = FALSE) with globals and blocking[10:56:21.397]  - Creating mirai_multisession future #1 ...[10:56:21.399] getGlobalsAndPackages() ...
[10:56:21.400] Not searching for globals
[10:56:21.400] - globals: [0] <none>
[10:56:21.400] getGlobalsAndPackages() ... DONE
[10:56:21.400] getGlobalsAndPackages() ...
[10:56:21.400] 
[10:56:21.401] - globals: [0] <none>
[10:56:21.401] getGlobalsAndPackages() ... DONE
[10:56:21.401] Packages needed by the future expression (n = 0): <none>
[10:56:21.401] Packages needed by future strategies (n = 0): <none>
[10:56:21.402] {
[10:56:21.402]     {
[10:56:21.402]         {
[10:56:21.402]             ...future.startTime <- base::Sys.time()
[10:56:21.402]             {
[10:56:21.402]                 {
[10:56:21.402]                   {
[10:56:21.402]                     base::local({
[10:56:21.402]                       has_future <- base::requireNamespace("future", 
[10:56:21.402]                         quietly = TRUE)
[10:56:21.402]                       if (has_future) {
[10:56:21.402]                         ns <- base::getNamespace("future")
[10:56:21.402]                         version <- ns[[".package"]][["version"]]
[10:56:21.402]                         if (is.null(version)) 
[10:56:21.402]                           version <- utils::packageVersion("future")
[10:56:21.402]                       }
[10:56:21.402]                       else {
[10:56:21.402]                         version <- NULL
[10:56:21.402]                       }
[10:56:21.402]                       if (!has_future || version < "1.8.0") {
[10:56:21.402]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.402]                           "", base::R.version$version.string), 
[10:56:21.402]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.402]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.402]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.402]                             "release", "version")], collapse = " "), 
[10:56:21.402]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.402]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.402]                           info)
[10:56:21.402]                         info <- base::paste(info, collapse = "; ")
[10:56:21.402]                         if (!has_future) {
[10:56:21.402]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.402]                             info)
[10:56:21.402]                         }
[10:56:21.402]                         else {
[10:56:21.402]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.402]                             info, version)
[10:56:21.402]                         }
[10:56:21.402]                         base::stop(msg)
[10:56:21.402]                       }
[10:56:21.402]                     })
[10:56:21.402]                   }
[10:56:21.402]                   ...future.strategy.old <- future::plan("list")
[10:56:21.402]                   options(future.plan = NULL)
[10:56:21.402]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.402]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.402]                 }
[10:56:21.402]                 ...future.workdir <- getwd()
[10:56:21.402]             }
[10:56:21.402]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.402]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.402]         }
[10:56:21.402]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.402]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.402]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.402]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.402]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.402]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.402]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.402]             base::names(...future.oldOptions))
[10:56:21.402]     }
[10:56:21.402]     if (FALSE) {
[10:56:21.402]     }
[10:56:21.402]     else {
[10:56:21.402]         if (TRUE) {
[10:56:21.402]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.402]                 open = "w")
[10:56:21.402]         }
[10:56:21.402]         else {
[10:56:21.402]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.402]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.402]         }
[10:56:21.402]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.402]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.402]             base::sink(type = "output", split = FALSE)
[10:56:21.402]             base::close(...future.stdout)
[10:56:21.402]         }, add = TRUE)
[10:56:21.402]     }
[10:56:21.402]     ...future.frame <- base::sys.nframe()
[10:56:21.402]     ...future.conditions <- base::list()
[10:56:21.402]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.402]     if (FALSE) {
[10:56:21.402]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.402]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.402]     }
[10:56:21.402]     ...future.result <- base::tryCatch({
[10:56:21.402]         base::withCallingHandlers({
[10:56:21.402]             ...future.value <- base::withVisible(base::local({
[10:56:21.402]                 ii
[10:56:21.402]             }))
[10:56:21.402]             future::FutureResult(value = ...future.value$value, 
[10:56:21.402]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.402]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.402]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.402]                     ...future.globalenv.names))
[10:56:21.402]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.402]         }, condition = base::local({
[10:56:21.402]             c <- base::c
[10:56:21.402]             inherits <- base::inherits
[10:56:21.402]             invokeRestart <- base::invokeRestart
[10:56:21.402]             length <- base::length
[10:56:21.402]             list <- base::list
[10:56:21.402]             seq.int <- base::seq.int
[10:56:21.402]             signalCondition <- base::signalCondition
[10:56:21.402]             sys.calls <- base::sys.calls
[10:56:21.402]             `[[` <- base::`[[`
[10:56:21.402]             `+` <- base::`+`
[10:56:21.402]             `<<-` <- base::`<<-`
[10:56:21.402]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.402]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.402]                   3L)]
[10:56:21.402]             }
[10:56:21.402]             function(cond) {
[10:56:21.402]                 is_error <- inherits(cond, "error")
[10:56:21.402]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.402]                   NULL)
[10:56:21.402]                 if (is_error) {
[10:56:21.402]                   sessionInformation <- function() {
[10:56:21.402]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.402]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.402]                       search = base::search(), system = base::Sys.info())
[10:56:21.402]                   }
[10:56:21.402]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.402]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.402]                     cond$call), session = sessionInformation(), 
[10:56:21.402]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.402]                   signalCondition(cond)
[10:56:21.402]                 }
[10:56:21.402]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.402]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.402]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.402]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.402]                   if (FALSE && !signal) {
[10:56:21.402]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.402]                     {
[10:56:21.402]                       inherits <- base::inherits
[10:56:21.402]                       invokeRestart <- base::invokeRestart
[10:56:21.402]                       is.null <- base::is.null
[10:56:21.402]                       muffled <- FALSE
[10:56:21.402]                       if (inherits(cond, "message")) {
[10:56:21.402]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.402]                         if (muffled) 
[10:56:21.402]                           invokeRestart("muffleMessage")
[10:56:21.402]                       }
[10:56:21.402]                       else if (inherits(cond, "warning")) {
[10:56:21.402]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.402]                         if (muffled) 
[10:56:21.402]                           invokeRestart("muffleWarning")
[10:56:21.402]                       }
[10:56:21.402]                       else if (inherits(cond, "condition")) {
[10:56:21.402]                         if (!is.null(pattern)) {
[10:56:21.402]                           computeRestarts <- base::computeRestarts
[10:56:21.402]                           grepl <- base::grepl
[10:56:21.402]                           restarts <- computeRestarts(cond)
[10:56:21.402]                           for (restart in restarts) {
[10:56:21.402]                             name <- restart$name
[10:56:21.402]                             if (is.null(name)) 
[10:56:21.402]                               next
[10:56:21.402]                             if (!grepl(pattern, name)) 
[10:56:21.402]                               next
[10:56:21.402]                             invokeRestart(restart)
[10:56:21.402]                             muffled <- TRUE
[10:56:21.402]                             break
[10:56:21.402]                           }
[10:56:21.402]                         }
[10:56:21.402]                       }
[10:56:21.402]                       invisible(muffled)
[10:56:21.402]                     }
[10:56:21.402]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.402]                   }
[10:56:21.402]                 }
[10:56:21.402]                 else {
[10:56:21.402]                   if (TRUE) {
[10:56:21.402]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.402]                     {
[10:56:21.402]                       inherits <- base::inherits
[10:56:21.402]                       invokeRestart <- base::invokeRestart
[10:56:21.402]                       is.null <- base::is.null
[10:56:21.402]                       muffled <- FALSE
[10:56:21.402]                       if (inherits(cond, "message")) {
[10:56:21.402]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.402]                         if (muffled) 
[10:56:21.402]                           invokeRestart("muffleMessage")
[10:56:21.402]                       }
[10:56:21.402]                       else if (inherits(cond, "warning")) {
[10:56:21.402]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.402]                         if (muffled) 
[10:56:21.402]                           invokeRestart("muffleWarning")
[10:56:21.402]                       }
[10:56:21.402]                       else if (inherits(cond, "condition")) {
[10:56:21.402]                         if (!is.null(pattern)) {
[10:56:21.402]                           computeRestarts <- base::computeRestarts
[10:56:21.402]                           grepl <- base::grepl
[10:56:21.402]                           restarts <- computeRestarts(cond)
[10:56:21.402]                           for (restart in restarts) {
[10:56:21.402]                             name <- restart$name
[10:56:21.402]                             if (is.null(name)) 
[10:56:21.402]                               next
[10:56:21.402]                             if (!grepl(pattern, name)) 
[10:56:21.402]                               next
[10:56:21.402]                             invokeRestart(restart)
[10:56:21.402]                             muffled <- TRUE
[10:56:21.402]                             break
[10:56:21.402]                           }
[10:56:21.402]                         }
[10:56:21.402]                       }
[10:56:21.402]                       invisible(muffled)
[10:56:21.402]                     }
[10:56:21.402]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.402]                   }
[10:56:21.402]                 }
[10:56:21.402]             }
[10:56:21.402]         }))
[10:56:21.402]     }, error = function(ex) {
[10:56:21.402]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.402]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.402]                 ...future.rng), started = ...future.startTime, 
[10:56:21.402]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.402]             version = "1.8"), class = "FutureResult")
[10:56:21.402]     }, finally = {
[10:56:21.402]         if (!identical(...future.workdir, getwd())) 
[10:56:21.402]             setwd(...future.workdir)
[10:56:21.402]         {
[10:56:21.402]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.402]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.402]             }
[10:56:21.402]             base::options(...future.oldOptions)
[10:56:21.402]             if (.Platform$OS.type == "windows") {
[10:56:21.402]                 old_names <- names(...future.oldEnvVars)
[10:56:21.402]                 envs <- base::Sys.getenv()
[10:56:21.402]                 names <- names(envs)
[10:56:21.402]                 common <- intersect(names, old_names)
[10:56:21.402]                 added <- setdiff(names, old_names)
[10:56:21.402]                 removed <- setdiff(old_names, names)
[10:56:21.402]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.402]                   envs[common]]
[10:56:21.402]                 NAMES <- toupper(changed)
[10:56:21.402]                 args <- list()
[10:56:21.402]                 for (kk in seq_along(NAMES)) {
[10:56:21.402]                   name <- changed[[kk]]
[10:56:21.402]                   NAME <- NAMES[[kk]]
[10:56:21.402]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.402]                     next
[10:56:21.402]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.402]                 }
[10:56:21.402]                 NAMES <- toupper(added)
[10:56:21.402]                 for (kk in seq_along(NAMES)) {
[10:56:21.402]                   name <- added[[kk]]
[10:56:21.402]                   NAME <- NAMES[[kk]]
[10:56:21.402]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.402]                     next
[10:56:21.402]                   args[[name]] <- ""
[10:56:21.402]                 }
[10:56:21.402]                 NAMES <- toupper(removed)
[10:56:21.402]                 for (kk in seq_along(NAMES)) {
[10:56:21.402]                   name <- removed[[kk]]
[10:56:21.402]                   NAME <- NAMES[[kk]]
[10:56:21.402]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.402]                     next
[10:56:21.402]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.402]                 }
[10:56:21.402]                 if (length(args) > 0) 
[10:56:21.402]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.402]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.402]             }
[10:56:21.402]             else {
[10:56:21.402]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.402]             }
[10:56:21.402]             {
[10:56:21.402]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.402]                   0L) {
[10:56:21.402]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.402]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.402]                   base::options(opts)
[10:56:21.402]                 }
[10:56:21.402]                 {
[10:56:21.402]                   NULL
[10:56:21.402]                   options(future.plan = NULL)
[10:56:21.402]                   if (is.na(NA_character_)) 
[10:56:21.402]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.402]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.402]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.402]                     .init = FALSE)
[10:56:21.402]                 }
[10:56:21.402]             }
[10:56:21.402]         }
[10:56:21.402]     })
[10:56:21.402]     if (TRUE) {
[10:56:21.402]         base::sink(type = "output", split = FALSE)
[10:56:21.402]         if (TRUE) {
[10:56:21.402]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.402]         }
[10:56:21.402]         else {
[10:56:21.402]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.402]         }
[10:56:21.402]         base::close(...future.stdout)
[10:56:21.402]         ...future.stdout <- NULL
[10:56:21.402]     }
[10:56:21.402]     ...future.result$conditions <- ...future.conditions
[10:56:21.402]     ...future.result$finished <- base::Sys.time()
[10:56:21.402]     ...future.result
[10:56:21.402] }
[10:56:21.406]  - Creating mirai_multisession future #2 ...[10:56:21.409] getGlobalsAndPackages() ...
[10:56:21.409] Not searching for globals
[10:56:21.409] - globals: [0] <none>
[10:56:21.409] getGlobalsAndPackages() ... DONE
[10:56:21.410] getGlobalsAndPackages() ...
[10:56:21.410] 
[10:56:21.410] - globals: [0] <none>
[10:56:21.410] getGlobalsAndPackages() ... DONE
[10:56:21.411] Packages needed by the future expression (n = 0): <none>
[10:56:21.411] Packages needed by future strategies (n = 0): <none>
[10:56:21.411] {
[10:56:21.411]     {
[10:56:21.411]         {
[10:56:21.411]             ...future.startTime <- base::Sys.time()
[10:56:21.411]             {
[10:56:21.411]                 {
[10:56:21.411]                   {
[10:56:21.411]                     base::local({
[10:56:21.411]                       has_future <- base::requireNamespace("future", 
[10:56:21.411]                         quietly = TRUE)
[10:56:21.411]                       if (has_future) {
[10:56:21.411]                         ns <- base::getNamespace("future")
[10:56:21.411]                         version <- ns[[".package"]][["version"]]
[10:56:21.411]                         if (is.null(version)) 
[10:56:21.411]                           version <- utils::packageVersion("future")
[10:56:21.411]                       }
[10:56:21.411]                       else {
[10:56:21.411]                         version <- NULL
[10:56:21.411]                       }
[10:56:21.411]                       if (!has_future || version < "1.8.0") {
[10:56:21.411]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.411]                           "", base::R.version$version.string), 
[10:56:21.411]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.411]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.411]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.411]                             "release", "version")], collapse = " "), 
[10:56:21.411]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.411]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.411]                           info)
[10:56:21.411]                         info <- base::paste(info, collapse = "; ")
[10:56:21.411]                         if (!has_future) {
[10:56:21.411]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.411]                             info)
[10:56:21.411]                         }
[10:56:21.411]                         else {
[10:56:21.411]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.411]                             info, version)
[10:56:21.411]                         }
[10:56:21.411]                         base::stop(msg)
[10:56:21.411]                       }
[10:56:21.411]                     })
[10:56:21.411]                   }
[10:56:21.411]                   ...future.strategy.old <- future::plan("list")
[10:56:21.411]                   options(future.plan = NULL)
[10:56:21.411]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.411]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.411]                 }
[10:56:21.411]                 ...future.workdir <- getwd()
[10:56:21.411]             }
[10:56:21.411]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.411]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.411]         }
[10:56:21.411]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.411]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.411]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.411]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.411]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.411]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.411]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.411]             base::names(...future.oldOptions))
[10:56:21.411]     }
[10:56:21.411]     if (FALSE) {
[10:56:21.411]     }
[10:56:21.411]     else {
[10:56:21.411]         if (TRUE) {
[10:56:21.411]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.411]                 open = "w")
[10:56:21.411]         }
[10:56:21.411]         else {
[10:56:21.411]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.411]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.411]         }
[10:56:21.411]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.411]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.411]             base::sink(type = "output", split = FALSE)
[10:56:21.411]             base::close(...future.stdout)
[10:56:21.411]         }, add = TRUE)
[10:56:21.411]     }
[10:56:21.411]     ...future.frame <- base::sys.nframe()
[10:56:21.411]     ...future.conditions <- base::list()
[10:56:21.411]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.411]     if (FALSE) {
[10:56:21.411]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.411]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.411]     }
[10:56:21.411]     ...future.result <- base::tryCatch({
[10:56:21.411]         base::withCallingHandlers({
[10:56:21.411]             ...future.value <- base::withVisible(base::local({
[10:56:21.411]                 ii
[10:56:21.411]             }))
[10:56:21.411]             future::FutureResult(value = ...future.value$value, 
[10:56:21.411]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.411]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.411]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.411]                     ...future.globalenv.names))
[10:56:21.411]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.411]         }, condition = base::local({
[10:56:21.411]             c <- base::c
[10:56:21.411]             inherits <- base::inherits
[10:56:21.411]             invokeRestart <- base::invokeRestart
[10:56:21.411]             length <- base::length
[10:56:21.411]             list <- base::list
[10:56:21.411]             seq.int <- base::seq.int
[10:56:21.411]             signalCondition <- base::signalCondition
[10:56:21.411]             sys.calls <- base::sys.calls
[10:56:21.411]             `[[` <- base::`[[`
[10:56:21.411]             `+` <- base::`+`
[10:56:21.411]             `<<-` <- base::`<<-`
[10:56:21.411]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.411]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.411]                   3L)]
[10:56:21.411]             }
[10:56:21.411]             function(cond) {
[10:56:21.411]                 is_error <- inherits(cond, "error")
[10:56:21.411]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.411]                   NULL)
[10:56:21.411]                 if (is_error) {
[10:56:21.411]                   sessionInformation <- function() {
[10:56:21.411]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.411]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.411]                       search = base::search(), system = base::Sys.info())
[10:56:21.411]                   }
[10:56:21.411]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.411]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.411]                     cond$call), session = sessionInformation(), 
[10:56:21.411]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.411]                   signalCondition(cond)
[10:56:21.411]                 }
[10:56:21.411]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.411]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.411]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.411]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.411]                   if (FALSE && !signal) {
[10:56:21.411]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.411]                     {
[10:56:21.411]                       inherits <- base::inherits
[10:56:21.411]                       invokeRestart <- base::invokeRestart
[10:56:21.411]                       is.null <- base::is.null
[10:56:21.411]                       muffled <- FALSE
[10:56:21.411]                       if (inherits(cond, "message")) {
[10:56:21.411]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.411]                         if (muffled) 
[10:56:21.411]                           invokeRestart("muffleMessage")
[10:56:21.411]                       }
[10:56:21.411]                       else if (inherits(cond, "warning")) {
[10:56:21.411]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.411]                         if (muffled) 
[10:56:21.411]                           invokeRestart("muffleWarning")
[10:56:21.411]                       }
[10:56:21.411]                       else if (inherits(cond, "condition")) {
[10:56:21.411]                         if (!is.null(pattern)) {
[10:56:21.411]                           computeRestarts <- base::computeRestarts
[10:56:21.411]                           grepl <- base::grepl
[10:56:21.411]                           restarts <- computeRestarts(cond)
[10:56:21.411]                           for (restart in restarts) {
[10:56:21.411]                             name <- restart$name
[10:56:21.411]                             if (is.null(name)) 
[10:56:21.411]                               next
[10:56:21.411]                             if (!grepl(pattern, name)) 
[10:56:21.411]                               next
[10:56:21.411]                             invokeRestart(restart)
[10:56:21.411]                             muffled <- TRUE
[10:56:21.411]                             break
[10:56:21.411]                           }
[10:56:21.411]                         }
[10:56:21.411]                       }
[10:56:21.411]                       invisible(muffled)
[10:56:21.411]                     }
[10:56:21.411]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.411]                   }
[10:56:21.411]                 }
[10:56:21.411]                 else {
[10:56:21.411]                   if (TRUE) {
[10:56:21.411]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.411]                     {
[10:56:21.411]                       inherits <- base::inherits
[10:56:21.411]                       invokeRestart <- base::invokeRestart
[10:56:21.411]                       is.null <- base::is.null
[10:56:21.411]                       muffled <- FALSE
[10:56:21.411]                       if (inherits(cond, "message")) {
[10:56:21.411]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.411]                         if (muffled) 
[10:56:21.411]                           invokeRestart("muffleMessage")
[10:56:21.411]                       }
[10:56:21.411]                       else if (inherits(cond, "warning")) {
[10:56:21.411]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.411]                         if (muffled) 
[10:56:21.411]                           invokeRestart("muffleWarning")
[10:56:21.411]                       }
[10:56:21.411]                       else if (inherits(cond, "condition")) {
[10:56:21.411]                         if (!is.null(pattern)) {
[10:56:21.411]                           computeRestarts <- base::computeRestarts
[10:56:21.411]                           grepl <- base::grepl
[10:56:21.411]                           restarts <- computeRestarts(cond)
[10:56:21.411]                           for (restart in restarts) {
[10:56:21.411]                             name <- restart$name
[10:56:21.411]                             if (is.null(name)) 
[10:56:21.411]                               next
[10:56:21.411]                             if (!grepl(pattern, name)) 
[10:56:21.411]                               next
[10:56:21.411]                             invokeRestart(restart)
[10:56:21.411]                             muffled <- TRUE
[10:56:21.411]                             break
[10:56:21.411]                           }
[10:56:21.411]                         }
[10:56:21.411]                       }
[10:56:21.411]                       invisible(muffled)
[10:56:21.411]                     }
[10:56:21.411]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.411]                   }
[10:56:21.411]                 }
[10:56:21.411]             }
[10:56:21.411]         }))
[10:56:21.411]     }, error = function(ex) {
[10:56:21.411]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.411]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.411]                 ...future.rng), started = ...future.startTime, 
[10:56:21.411]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.411]             version = "1.8"), class = "FutureResult")
[10:56:21.411]     }, finally = {
[10:56:21.411]         if (!identical(...future.workdir, getwd())) 
[10:56:21.411]             setwd(...future.workdir)
[10:56:21.411]         {
[10:56:21.411]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.411]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.411]             }
[10:56:21.411]             base::options(...future.oldOptions)
[10:56:21.411]             if (.Platform$OS.type == "windows") {
[10:56:21.411]                 old_names <- names(...future.oldEnvVars)
[10:56:21.411]                 envs <- base::Sys.getenv()
[10:56:21.411]                 names <- names(envs)
[10:56:21.411]                 common <- intersect(names, old_names)
[10:56:21.411]                 added <- setdiff(names, old_names)
[10:56:21.411]                 removed <- setdiff(old_names, names)
[10:56:21.411]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.411]                   envs[common]]
[10:56:21.411]                 NAMES <- toupper(changed)
[10:56:21.411]                 args <- list()
[10:56:21.411]                 for (kk in seq_along(NAMES)) {
[10:56:21.411]                   name <- changed[[kk]]
[10:56:21.411]                   NAME <- NAMES[[kk]]
[10:56:21.411]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.411]                     next
[10:56:21.411]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.411]                 }
[10:56:21.411]                 NAMES <- toupper(added)
[10:56:21.411]                 for (kk in seq_along(NAMES)) {
[10:56:21.411]                   name <- added[[kk]]
[10:56:21.411]                   NAME <- NAMES[[kk]]
[10:56:21.411]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.411]                     next
[10:56:21.411]                   args[[name]] <- ""
[10:56:21.411]                 }
[10:56:21.411]                 NAMES <- toupper(removed)
[10:56:21.411]                 for (kk in seq_along(NAMES)) {
[10:56:21.411]                   name <- removed[[kk]]
[10:56:21.411]                   NAME <- NAMES[[kk]]
[10:56:21.411]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.411]                     next
[10:56:21.411]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.411]                 }
[10:56:21.411]                 if (length(args) > 0) 
[10:56:21.411]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.411]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.411]             }
[10:56:21.411]             else {
[10:56:21.411]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.411]             }
[10:56:21.411]             {
[10:56:21.411]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.411]                   0L) {
[10:56:21.411]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.411]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.411]                   base::options(opts)
[10:56:21.411]                 }
[10:56:21.411]                 {
[10:56:21.411]                   NULL
[10:56:21.411]                   options(future.plan = NULL)
[10:56:21.411]                   if (is.na(NA_character_)) 
[10:56:21.411]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.411]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.411]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.411]                     .init = FALSE)
[10:56:21.411]                 }
[10:56:21.411]             }
[10:56:21.411]         }
[10:56:21.411]     })
[10:56:21.411]     if (TRUE) {
[10:56:21.411]         base::sink(type = "output", split = FALSE)
[10:56:21.411]         if (TRUE) {
[10:56:21.411]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.411]         }
[10:56:21.411]         else {
[10:56:21.411]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.411]         }
[10:56:21.411]         base::close(...future.stdout)
[10:56:21.411]         ...future.stdout <- NULL
[10:56:21.411]     }
[10:56:21.411]     ...future.result$conditions <- ...future.conditions
[10:56:21.411]     ...future.result$finished <- base::Sys.time()
[10:56:21.411]     ...future.result
[10:56:21.411] }
[10:56:21.416]  - Creating mirai_multisession future #3 ...[10:56:21.418] getGlobalsAndPackages() ...
[10:56:21.418] Not searching for globals
[10:56:21.418] - globals: [0] <none>
[10:56:21.419] getGlobalsAndPackages() ... DONE
[10:56:21.419] getGlobalsAndPackages() ...
[10:56:21.419] 
[10:56:21.419] - globals: [0] <none>
[10:56:21.419] getGlobalsAndPackages() ... DONE
[10:56:21.420] Packages needed by the future expression (n = 0): <none>
[10:56:21.420] Packages needed by future strategies (n = 0): <none>
[10:56:21.421] {
[10:56:21.421]     {
[10:56:21.421]         {
[10:56:21.421]             ...future.startTime <- base::Sys.time()
[10:56:21.421]             {
[10:56:21.421]                 {
[10:56:21.421]                   {
[10:56:21.421]                     base::local({
[10:56:21.421]                       has_future <- base::requireNamespace("future", 
[10:56:21.421]                         quietly = TRUE)
[10:56:21.421]                       if (has_future) {
[10:56:21.421]                         ns <- base::getNamespace("future")
[10:56:21.421]                         version <- ns[[".package"]][["version"]]
[10:56:21.421]                         if (is.null(version)) 
[10:56:21.421]                           version <- utils::packageVersion("future")
[10:56:21.421]                       }
[10:56:21.421]                       else {
[10:56:21.421]                         version <- NULL
[10:56:21.421]                       }
[10:56:21.421]                       if (!has_future || version < "1.8.0") {
[10:56:21.421]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.421]                           "", base::R.version$version.string), 
[10:56:21.421]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.421]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.421]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.421]                             "release", "version")], collapse = " "), 
[10:56:21.421]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.421]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.421]                           info)
[10:56:21.421]                         info <- base::paste(info, collapse = "; ")
[10:56:21.421]                         if (!has_future) {
[10:56:21.421]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.421]                             info)
[10:56:21.421]                         }
[10:56:21.421]                         else {
[10:56:21.421]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.421]                             info, version)
[10:56:21.421]                         }
[10:56:21.421]                         base::stop(msg)
[10:56:21.421]                       }
[10:56:21.421]                     })
[10:56:21.421]                   }
[10:56:21.421]                   ...future.strategy.old <- future::plan("list")
[10:56:21.421]                   options(future.plan = NULL)
[10:56:21.421]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.421]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.421]                 }
[10:56:21.421]                 ...future.workdir <- getwd()
[10:56:21.421]             }
[10:56:21.421]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.421]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.421]         }
[10:56:21.421]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.421]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.421]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.421]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.421]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.421]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.421]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.421]             base::names(...future.oldOptions))
[10:56:21.421]     }
[10:56:21.421]     if (FALSE) {
[10:56:21.421]     }
[10:56:21.421]     else {
[10:56:21.421]         if (TRUE) {
[10:56:21.421]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.421]                 open = "w")
[10:56:21.421]         }
[10:56:21.421]         else {
[10:56:21.421]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.421]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.421]         }
[10:56:21.421]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.421]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.421]             base::sink(type = "output", split = FALSE)
[10:56:21.421]             base::close(...future.stdout)
[10:56:21.421]         }, add = TRUE)
[10:56:21.421]     }
[10:56:21.421]     ...future.frame <- base::sys.nframe()
[10:56:21.421]     ...future.conditions <- base::list()
[10:56:21.421]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.421]     if (FALSE) {
[10:56:21.421]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.421]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.421]     }
[10:56:21.421]     ...future.result <- base::tryCatch({
[10:56:21.421]         base::withCallingHandlers({
[10:56:21.421]             ...future.value <- base::withVisible(base::local({
[10:56:21.421]                 ii
[10:56:21.421]             }))
[10:56:21.421]             future::FutureResult(value = ...future.value$value, 
[10:56:21.421]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.421]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.421]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.421]                     ...future.globalenv.names))
[10:56:21.421]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.421]         }, condition = base::local({
[10:56:21.421]             c <- base::c
[10:56:21.421]             inherits <- base::inherits
[10:56:21.421]             invokeRestart <- base::invokeRestart
[10:56:21.421]             length <- base::length
[10:56:21.421]             list <- base::list
[10:56:21.421]             seq.int <- base::seq.int
[10:56:21.421]             signalCondition <- base::signalCondition
[10:56:21.421]             sys.calls <- base::sys.calls
[10:56:21.421]             `[[` <- base::`[[`
[10:56:21.421]             `+` <- base::`+`
[10:56:21.421]             `<<-` <- base::`<<-`
[10:56:21.421]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.421]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.421]                   3L)]
[10:56:21.421]             }
[10:56:21.421]             function(cond) {
[10:56:21.421]                 is_error <- inherits(cond, "error")
[10:56:21.421]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.421]                   NULL)
[10:56:21.421]                 if (is_error) {
[10:56:21.421]                   sessionInformation <- function() {
[10:56:21.421]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.421]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.421]                       search = base::search(), system = base::Sys.info())
[10:56:21.421]                   }
[10:56:21.421]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.421]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.421]                     cond$call), session = sessionInformation(), 
[10:56:21.421]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.421]                   signalCondition(cond)
[10:56:21.421]                 }
[10:56:21.421]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.421]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.421]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.421]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.421]                   if (FALSE && !signal) {
[10:56:21.421]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.421]                     {
[10:56:21.421]                       inherits <- base::inherits
[10:56:21.421]                       invokeRestart <- base::invokeRestart
[10:56:21.421]                       is.null <- base::is.null
[10:56:21.421]                       muffled <- FALSE
[10:56:21.421]                       if (inherits(cond, "message")) {
[10:56:21.421]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.421]                         if (muffled) 
[10:56:21.421]                           invokeRestart("muffleMessage")
[10:56:21.421]                       }
[10:56:21.421]                       else if (inherits(cond, "warning")) {
[10:56:21.421]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.421]                         if (muffled) 
[10:56:21.421]                           invokeRestart("muffleWarning")
[10:56:21.421]                       }
[10:56:21.421]                       else if (inherits(cond, "condition")) {
[10:56:21.421]                         if (!is.null(pattern)) {
[10:56:21.421]                           computeRestarts <- base::computeRestarts
[10:56:21.421]                           grepl <- base::grepl
[10:56:21.421]                           restarts <- computeRestarts(cond)
[10:56:21.421]                           for (restart in restarts) {
[10:56:21.421]                             name <- restart$name
[10:56:21.421]                             if (is.null(name)) 
[10:56:21.421]                               next
[10:56:21.421]                             if (!grepl(pattern, name)) 
[10:56:21.421]                               next
[10:56:21.421]                             invokeRestart(restart)
[10:56:21.421]                             muffled <- TRUE
[10:56:21.421]                             break
[10:56:21.421]                           }
[10:56:21.421]                         }
[10:56:21.421]                       }
[10:56:21.421]                       invisible(muffled)
[10:56:21.421]                     }
[10:56:21.421]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.421]                   }
[10:56:21.421]                 }
[10:56:21.421]                 else {
[10:56:21.421]                   if (TRUE) {
[10:56:21.421]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.421]                     {
[10:56:21.421]                       inherits <- base::inherits
[10:56:21.421]                       invokeRestart <- base::invokeRestart
[10:56:21.421]                       is.null <- base::is.null
[10:56:21.421]                       muffled <- FALSE
[10:56:21.421]                       if (inherits(cond, "message")) {
[10:56:21.421]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.421]                         if (muffled) 
[10:56:21.421]                           invokeRestart("muffleMessage")
[10:56:21.421]                       }
[10:56:21.421]                       else if (inherits(cond, "warning")) {
[10:56:21.421]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.421]                         if (muffled) 
[10:56:21.421]                           invokeRestart("muffleWarning")
[10:56:21.421]                       }
[10:56:21.421]                       else if (inherits(cond, "condition")) {
[10:56:21.421]                         if (!is.null(pattern)) {
[10:56:21.421]                           computeRestarts <- base::computeRestarts
[10:56:21.421]                           grepl <- base::grepl
[10:56:21.421]                           restarts <- computeRestarts(cond)
[10:56:21.421]                           for (restart in restarts) {
[10:56:21.421]                             name <- restart$name
[10:56:21.421]                             if (is.null(name)) 
[10:56:21.421]                               next
[10:56:21.421]                             if (!grepl(pattern, name)) 
[10:56:21.421]                               next
[10:56:21.421]                             invokeRestart(restart)
[10:56:21.421]                             muffled <- TRUE
[10:56:21.421]                             break
[10:56:21.421]                           }
[10:56:21.421]                         }
[10:56:21.421]                       }
[10:56:21.421]                       invisible(muffled)
[10:56:21.421]                     }
[10:56:21.421]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.421]                   }
[10:56:21.421]                 }
[10:56:21.421]             }
[10:56:21.421]         }))
[10:56:21.421]     }, error = function(ex) {
[10:56:21.421]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.421]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.421]                 ...future.rng), started = ...future.startTime, 
[10:56:21.421]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.421]             version = "1.8"), class = "FutureResult")
[10:56:21.421]     }, finally = {
[10:56:21.421]         if (!identical(...future.workdir, getwd())) 
[10:56:21.421]             setwd(...future.workdir)
[10:56:21.421]         {
[10:56:21.421]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.421]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.421]             }
[10:56:21.421]             base::options(...future.oldOptions)
[10:56:21.421]             if (.Platform$OS.type == "windows") {
[10:56:21.421]                 old_names <- names(...future.oldEnvVars)
[10:56:21.421]                 envs <- base::Sys.getenv()
[10:56:21.421]                 names <- names(envs)
[10:56:21.421]                 common <- intersect(names, old_names)
[10:56:21.421]                 added <- setdiff(names, old_names)
[10:56:21.421]                 removed <- setdiff(old_names, names)
[10:56:21.421]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.421]                   envs[common]]
[10:56:21.421]                 NAMES <- toupper(changed)
[10:56:21.421]                 args <- list()
[10:56:21.421]                 for (kk in seq_along(NAMES)) {
[10:56:21.421]                   name <- changed[[kk]]
[10:56:21.421]                   NAME <- NAMES[[kk]]
[10:56:21.421]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.421]                     next
[10:56:21.421]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.421]                 }
[10:56:21.421]                 NAMES <- toupper(added)
[10:56:21.421]                 for (kk in seq_along(NAMES)) {
[10:56:21.421]                   name <- added[[kk]]
[10:56:21.421]                   NAME <- NAMES[[kk]]
[10:56:21.421]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.421]                     next
[10:56:21.421]                   args[[name]] <- ""
[10:56:21.421]                 }
[10:56:21.421]                 NAMES <- toupper(removed)
[10:56:21.421]                 for (kk in seq_along(NAMES)) {
[10:56:21.421]                   name <- removed[[kk]]
[10:56:21.421]                   NAME <- NAMES[[kk]]
[10:56:21.421]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.421]                     next
[10:56:21.421]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.421]                 }
[10:56:21.421]                 if (length(args) > 0) 
[10:56:21.421]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.421]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.421]             }
[10:56:21.421]             else {
[10:56:21.421]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.421]             }
[10:56:21.421]             {
[10:56:21.421]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.421]                   0L) {
[10:56:21.421]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.421]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.421]                   base::options(opts)
[10:56:21.421]                 }
[10:56:21.421]                 {
[10:56:21.421]                   NULL
[10:56:21.421]                   options(future.plan = NULL)
[10:56:21.421]                   if (is.na(NA_character_)) 
[10:56:21.421]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.421]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.421]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.421]                     .init = FALSE)
[10:56:21.421]                 }
[10:56:21.421]             }
[10:56:21.421]         }
[10:56:21.421]     })
[10:56:21.421]     if (TRUE) {
[10:56:21.421]         base::sink(type = "output", split = FALSE)
[10:56:21.421]         if (TRUE) {
[10:56:21.421]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.421]         }
[10:56:21.421]         else {
[10:56:21.421]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.421]         }
[10:56:21.421]         base::close(...future.stdout)
[10:56:21.421]         ...future.stdout <- NULL
[10:56:21.421]     }
[10:56:21.421]     ...future.result$conditions <- ...future.conditions
[10:56:21.421]     ...future.result$finished <- base::Sys.time()
[10:56:21.421]     ...future.result
[10:56:21.421] }
[10:56:21.425]  - Resolving 3 mirai_multisession futures[10:56:21.425] signalConditions() ...
[10:56:21.426]  - include = 'immediateCondition'
[10:56:21.426]  - exclude = 
[10:56:21.426]  - resignal = FALSE
[10:56:21.426]  - Number of conditions: 1
[10:56:21.426] signalConditions() ... done
[10:56:21.426] Future state: 'finished'
[10:56:21.427] signalConditions() ...
[10:56:21.427]  - include = 'condition'
[10:56:21.427]  - exclude = 'immediateCondition'
[10:56:21.429]  - resignal = TRUE
[10:56:21.430]  - Number of conditions: 1
[10:56:21.430]  - Condition #1: 'simpleError', 'error', 'condition'
[10:56:21.430] signalConditions() ... done
[10:56:21.431] signalConditions() ...
[10:56:21.431]  - include = 'immediateCondition'
[10:56:21.431]  - exclude = 
[10:56:21.431]  - resignal = FALSE
[10:56:21.431]  - Number of conditions: 1
[10:56:21.431] signalConditions() ... done
[10:56:21.432] Future state: 'finished'
[10:56:21.432] signalConditions() ...
[10:56:21.432]  - include = 'condition'
[10:56:21.432]  - exclude = 'immediateCondition'
[10:56:21.432]  - resignal = TRUE
[10:56:21.432]  - Number of conditions: 1
[10:56:21.433]  - Condition #1: 'simpleError', 'error', 'condition'
[10:56:21.433] signalConditions() ... done
[10:56:21.433] signalConditions() ...
[10:56:21.433]  - include = 'immediateCondition'
[10:56:21.434]  - exclude = 
[10:56:21.434]  - resignal = FALSE
[10:56:21.434]  - Number of conditions: 1
[10:56:21.434] signalConditions() ... done
[10:56:21.434] Future state: 'finished'
[10:56:21.434] signalConditions() ...
[10:56:21.435]  - include = 'condition'
[10:56:21.435]  - exclude = 'immediateCondition'
[10:56:21.435]  - resignal = TRUE
[10:56:21.435]  - Number of conditions: 1
[10:56:21.435]  - Condition #1: 'simpleError', 'error', 'condition'
[10:56:21.435] signalConditions() ... done
[10:56:21.436] *** mirai_multisession(..., globals = FALSE) and errors[10:56:21.438] getGlobalsAndPackages() ...
[10:56:21.438] Not searching for globals
[10:56:21.438] - globals: [0] <none>
[10:56:21.438] getGlobalsAndPackages() ... DONE
[10:56:21.439] getGlobalsAndPackages() ...
[10:56:21.439] 
[10:56:21.439] - globals: [0] <none>
[10:56:21.439] getGlobalsAndPackages() ... DONE
[10:56:21.439] Packages needed by the future expression (n = 0): <none>
[10:56:21.440] Packages needed by future strategies (n = 0): <none>
[10:56:21.440] {
[10:56:21.440]     {
[10:56:21.440]         {
[10:56:21.440]             ...future.startTime <- base::Sys.time()
[10:56:21.440]             {
[10:56:21.440]                 {
[10:56:21.440]                   {
[10:56:21.440]                     base::local({
[10:56:21.440]                       has_future <- base::requireNamespace("future", 
[10:56:21.440]                         quietly = TRUE)
[10:56:21.440]                       if (has_future) {
[10:56:21.440]                         ns <- base::getNamespace("future")
[10:56:21.440]                         version <- ns[[".package"]][["version"]]
[10:56:21.440]                         if (is.null(version)) 
[10:56:21.440]                           version <- utils::packageVersion("future")
[10:56:21.440]                       }
[10:56:21.440]                       else {
[10:56:21.440]                         version <- NULL
[10:56:21.440]                       }
[10:56:21.440]                       if (!has_future || version < "1.8.0") {
[10:56:21.440]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.440]                           "", base::R.version$version.string), 
[10:56:21.440]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.440]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.440]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.440]                             "release", "version")], collapse = " "), 
[10:56:21.440]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.440]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.440]                           info)
[10:56:21.440]                         info <- base::paste(info, collapse = "; ")
[10:56:21.440]                         if (!has_future) {
[10:56:21.440]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.440]                             info)
[10:56:21.440]                         }
[10:56:21.440]                         else {
[10:56:21.440]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.440]                             info, version)
[10:56:21.440]                         }
[10:56:21.440]                         base::stop(msg)
[10:56:21.440]                       }
[10:56:21.440]                     })
[10:56:21.440]                   }
[10:56:21.440]                   ...future.strategy.old <- future::plan("list")
[10:56:21.440]                   options(future.plan = NULL)
[10:56:21.440]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.440]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.440]                 }
[10:56:21.440]                 ...future.workdir <- getwd()
[10:56:21.440]             }
[10:56:21.440]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.440]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.440]         }
[10:56:21.440]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.440]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.440]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.440]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.440]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.440]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.440]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.440]             base::names(...future.oldOptions))
[10:56:21.440]     }
[10:56:21.440]     if (FALSE) {
[10:56:21.440]     }
[10:56:21.440]     else {
[10:56:21.440]         if (TRUE) {
[10:56:21.440]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.440]                 open = "w")
[10:56:21.440]         }
[10:56:21.440]         else {
[10:56:21.440]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.440]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.440]         }
[10:56:21.440]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.440]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.440]             base::sink(type = "output", split = FALSE)
[10:56:21.440]             base::close(...future.stdout)
[10:56:21.440]         }, add = TRUE)
[10:56:21.440]     }
[10:56:21.440]     ...future.frame <- base::sys.nframe()
[10:56:21.440]     ...future.conditions <- base::list()
[10:56:21.440]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.440]     if (FALSE) {
[10:56:21.440]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.440]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.440]     }
[10:56:21.440]     ...future.result <- base::tryCatch({
[10:56:21.440]         base::withCallingHandlers({
[10:56:21.440]             ...future.value <- base::withVisible(base::local({
[10:56:21.440]                 stop("Whoops!")
[10:56:21.440]                 1
[10:56:21.440]             }))
[10:56:21.440]             future::FutureResult(value = ...future.value$value, 
[10:56:21.440]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.440]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.440]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.440]                     ...future.globalenv.names))
[10:56:21.440]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.440]         }, condition = base::local({
[10:56:21.440]             c <- base::c
[10:56:21.440]             inherits <- base::inherits
[10:56:21.440]             invokeRestart <- base::invokeRestart
[10:56:21.440]             length <- base::length
[10:56:21.440]             list <- base::list
[10:56:21.440]             seq.int <- base::seq.int
[10:56:21.440]             signalCondition <- base::signalCondition
[10:56:21.440]             sys.calls <- base::sys.calls
[10:56:21.440]             `[[` <- base::`[[`
[10:56:21.440]             `+` <- base::`+`
[10:56:21.440]             `<<-` <- base::`<<-`
[10:56:21.440]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.440]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.440]                   3L)]
[10:56:21.440]             }
[10:56:21.440]             function(cond) {
[10:56:21.440]                 is_error <- inherits(cond, "error")
[10:56:21.440]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.440]                   NULL)
[10:56:21.440]                 if (is_error) {
[10:56:21.440]                   sessionInformation <- function() {
[10:56:21.440]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.440]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.440]                       search = base::search(), system = base::Sys.info())
[10:56:21.440]                   }
[10:56:21.440]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.440]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.440]                     cond$call), session = sessionInformation(), 
[10:56:21.440]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.440]                   signalCondition(cond)
[10:56:21.440]                 }
[10:56:21.440]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.440]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.440]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.440]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.440]                   if (FALSE && !signal) {
[10:56:21.440]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.440]                     {
[10:56:21.440]                       inherits <- base::inherits
[10:56:21.440]                       invokeRestart <- base::invokeRestart
[10:56:21.440]                       is.null <- base::is.null
[10:56:21.440]                       muffled <- FALSE
[10:56:21.440]                       if (inherits(cond, "message")) {
[10:56:21.440]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.440]                         if (muffled) 
[10:56:21.440]                           invokeRestart("muffleMessage")
[10:56:21.440]                       }
[10:56:21.440]                       else if (inherits(cond, "warning")) {
[10:56:21.440]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.440]                         if (muffled) 
[10:56:21.440]                           invokeRestart("muffleWarning")
[10:56:21.440]                       }
[10:56:21.440]                       else if (inherits(cond, "condition")) {
[10:56:21.440]                         if (!is.null(pattern)) {
[10:56:21.440]                           computeRestarts <- base::computeRestarts
[10:56:21.440]                           grepl <- base::grepl
[10:56:21.440]                           restarts <- computeRestarts(cond)
[10:56:21.440]                           for (restart in restarts) {
[10:56:21.440]                             name <- restart$name
[10:56:21.440]                             if (is.null(name)) 
[10:56:21.440]                               next
[10:56:21.440]                             if (!grepl(pattern, name)) 
[10:56:21.440]                               next
[10:56:21.440]                             invokeRestart(restart)
[10:56:21.440]                             muffled <- TRUE
[10:56:21.440]                             break
[10:56:21.440]                           }
[10:56:21.440]                         }
[10:56:21.440]                       }
[10:56:21.440]                       invisible(muffled)
[10:56:21.440]                     }
[10:56:21.440]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.440]                   }
[10:56:21.440]                 }
[10:56:21.440]                 else {
[10:56:21.440]                   if (TRUE) {
[10:56:21.440]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.440]                     {
[10:56:21.440]                       inherits <- base::inherits
[10:56:21.440]                       invokeRestart <- base::invokeRestart
[10:56:21.440]                       is.null <- base::is.null
[10:56:21.440]                       muffled <- FALSE
[10:56:21.440]                       if (inherits(cond, "message")) {
[10:56:21.440]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.440]                         if (muffled) 
[10:56:21.440]                           invokeRestart("muffleMessage")
[10:56:21.440]                       }
[10:56:21.440]                       else if (inherits(cond, "warning")) {
[10:56:21.440]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.440]                         if (muffled) 
[10:56:21.440]                           invokeRestart("muffleWarning")
[10:56:21.440]                       }
[10:56:21.440]                       else if (inherits(cond, "condition")) {
[10:56:21.440]                         if (!is.null(pattern)) {
[10:56:21.440]                           computeRestarts <- base::computeRestarts
[10:56:21.440]                           grepl <- base::grepl
[10:56:21.440]                           restarts <- computeRestarts(cond)
[10:56:21.440]                           for (restart in restarts) {
[10:56:21.440]                             name <- restart$name
[10:56:21.440]                             if (is.null(name)) 
[10:56:21.440]                               next
[10:56:21.440]                             if (!grepl(pattern, name)) 
[10:56:21.440]                               next
[10:56:21.440]                             invokeRestart(restart)
[10:56:21.440]                             muffled <- TRUE
[10:56:21.440]                             break
[10:56:21.440]                           }
[10:56:21.440]                         }
[10:56:21.440]                       }
[10:56:21.440]                       invisible(muffled)
[10:56:21.440]                     }
[10:56:21.440]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.440]                   }
[10:56:21.440]                 }
[10:56:21.440]             }
[10:56:21.440]         }))
[10:56:21.440]     }, error = function(ex) {
[10:56:21.440]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.440]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.440]                 ...future.rng), started = ...future.startTime, 
[10:56:21.440]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.440]             version = "1.8"), class = "FutureResult")
[10:56:21.440]     }, finally = {
[10:56:21.440]         if (!identical(...future.workdir, getwd())) 
[10:56:21.440]             setwd(...future.workdir)
[10:56:21.440]         {
[10:56:21.440]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.440]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.440]             }
[10:56:21.440]             base::options(...future.oldOptions)
[10:56:21.440]             if (.Platform$OS.type == "windows") {
[10:56:21.440]                 old_names <- names(...future.oldEnvVars)
[10:56:21.440]                 envs <- base::Sys.getenv()
[10:56:21.440]                 names <- names(envs)
[10:56:21.440]                 common <- intersect(names, old_names)
[10:56:21.440]                 added <- setdiff(names, old_names)
[10:56:21.440]                 removed <- setdiff(old_names, names)
[10:56:21.440]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.440]                   envs[common]]
[10:56:21.440]                 NAMES <- toupper(changed)
[10:56:21.440]                 args <- list()
[10:56:21.440]                 for (kk in seq_along(NAMES)) {
[10:56:21.440]                   name <- changed[[kk]]
[10:56:21.440]                   NAME <- NAMES[[kk]]
[10:56:21.440]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.440]                     next
[10:56:21.440]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.440]                 }
[10:56:21.440]                 NAMES <- toupper(added)
[10:56:21.440]                 for (kk in seq_along(NAMES)) {
[10:56:21.440]                   name <- added[[kk]]
[10:56:21.440]                   NAME <- NAMES[[kk]]
[10:56:21.440]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.440]                     next
[10:56:21.440]                   args[[name]] <- ""
[10:56:21.440]                 }
[10:56:21.440]                 NAMES <- toupper(removed)
[10:56:21.440]                 for (kk in seq_along(NAMES)) {
[10:56:21.440]                   name <- removed[[kk]]
[10:56:21.440]                   NAME <- NAMES[[kk]]
[10:56:21.440]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.440]                     next
[10:56:21.440]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.440]                 }
[10:56:21.440]                 if (length(args) > 0) 
[10:56:21.440]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.440]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.440]             }
[10:56:21.440]             else {
[10:56:21.440]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.440]             }
[10:56:21.440]             {
[10:56:21.440]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.440]                   0L) {
[10:56:21.440]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.440]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.440]                   base::options(opts)
[10:56:21.440]                 }
[10:56:21.440]                 {
[10:56:21.440]                   NULL
[10:56:21.440]                   options(future.plan = NULL)
[10:56:21.440]                   if (is.na(NA_character_)) 
[10:56:21.440]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.440]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.440]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.440]                     .init = FALSE)
[10:56:21.440]                 }
[10:56:21.440]             }
[10:56:21.440]         }
[10:56:21.440]     })
[10:56:21.440]     if (TRUE) {
[10:56:21.440]         base::sink(type = "output", split = FALSE)
[10:56:21.440]         if (TRUE) {
[10:56:21.440]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.440]         }
[10:56:21.440]         else {
[10:56:21.440]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.440]         }
[10:56:21.440]         base::close(...future.stdout)
[10:56:21.440]         ...future.stdout <- NULL
[10:56:21.440]     }
[10:56:21.440]     ...future.result$conditions <- ...future.conditions
[10:56:21.440]     ...future.result$finished <- base::Sys.time()
[10:56:21.440]     ...future.result
[10:56:21.440] }
MiraiFuture:
Label: '<none>'
Expression:
{
    stop("Whoops!")
    1
}
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)
[10:56:21.444] resolved() for 'MiraiFuture' ...
[10:56:21.445] - state: 'running'
[10:56:21.445] - run: TRUE
[10:56:21.445] - result: 'NULL'
[10:56:21.445] - resolved: FALSE
[10:56:21.445] resolved() for 'MiraiFuture' ... done
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 73cff85d-f0c3-d79d-6a2d-a22fd2dfb2cd
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:56:21.446] signalConditions() ...
[10:56:21.446]  - include = 'immediateCondition'
[10:56:21.447]  - exclude = 
[10:56:21.447]  - resignal = FALSE
[10:56:21.447]  - Number of conditions: 1
[10:56:21.447] signalConditions() ... done
<simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
[10:56:21.448] signalConditions() ...
[10:56:21.448]  - include = 'immediateCondition'
[10:56:21.448]  - exclude = 
[10:56:21.448]  - resignal = FALSE
[10:56:21.448]  - Number of conditions: 1
[10:56:21.448] signalConditions() ... done
[10:56:21.449] Future state: 'finished'
[10:56:21.449] signalConditions() ...
[10:56:21.449]  - include = 'condition'
[10:56:21.449]  - exclude = 'immediateCondition'
[10:56:21.449]  - resignal = TRUE
[10:56:21.449]  - Number of conditions: 1
[10:56:21.450]  - Condition #1: 'simpleError', 'error', 'condition'
[10:56:21.450] signalConditions() ... done
<simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
[10:56:21.450] signalConditions() ...
[10:56:21.450]  - include = 'immediateCondition'
[10:56:21.451]  - exclude = 
[10:56:21.451]  - resignal = FALSE
[10:56:21.451]  - Number of conditions: 1
[10:56:21.451] signalConditions() ... done
[10:56:21.451] Future state: 'finished'
[10:56:21.451] signalConditions() ...
[10:56:21.452]  - include = 'condition'
[10:56:21.452]  - exclude = 'immediateCondition'
[10:56:21.452]  - resignal = TRUE
[10:56:21.452]  - Number of conditions: 1
[10:56:21.452]  - Condition #1: 'simpleError', 'error', 'condition'
[10:56:21.452] signalConditions() ... done
<simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
[10:56:21.453] *** mirai_multisession(..., globals = TRUE) without globals[10:56:21.455] getGlobalsAndPackages() ...
[10:56:21.455] Searching for globals...
[10:56:21.458] - globals found: [1] '{'
[10:56:21.459] Searching for globals ... DONE
[10:56:21.459] Resolving globals: FALSE
[10:56:21.460] 
[10:56:21.460] 
[10:56:21.460] getGlobalsAndPackages() ... DONE
[10:56:21.460] getGlobalsAndPackages() ...
[10:56:21.460] 
[10:56:21.460] - globals: [0] <none>
[10:56:21.460] getGlobalsAndPackages() ... DONE
[10:56:21.461] Packages needed by the future expression (n = 0): <none>
[10:56:21.461] Packages needed by future strategies (n = 0): <none>
[10:56:21.462] {
[10:56:21.462]     {
[10:56:21.462]         {
[10:56:21.462]             ...future.startTime <- base::Sys.time()
[10:56:21.462]             {
[10:56:21.462]                 {
[10:56:21.462]                   {
[10:56:21.462]                     base::local({
[10:56:21.462]                       has_future <- base::requireNamespace("future", 
[10:56:21.462]                         quietly = TRUE)
[10:56:21.462]                       if (has_future) {
[10:56:21.462]                         ns <- base::getNamespace("future")
[10:56:21.462]                         version <- ns[[".package"]][["version"]]
[10:56:21.462]                         if (is.null(version)) 
[10:56:21.462]                           version <- utils::packageVersion("future")
[10:56:21.462]                       }
[10:56:21.462]                       else {
[10:56:21.462]                         version <- NULL
[10:56:21.462]                       }
[10:56:21.462]                       if (!has_future || version < "1.8.0") {
[10:56:21.462]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.462]                           "", base::R.version$version.string), 
[10:56:21.462]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.462]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.462]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.462]                             "release", "version")], collapse = " "), 
[10:56:21.462]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.462]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.462]                           info)
[10:56:21.462]                         info <- base::paste(info, collapse = "; ")
[10:56:21.462]                         if (!has_future) {
[10:56:21.462]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.462]                             info)
[10:56:21.462]                         }
[10:56:21.462]                         else {
[10:56:21.462]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.462]                             info, version)
[10:56:21.462]                         }
[10:56:21.462]                         base::stop(msg)
[10:56:21.462]                       }
[10:56:21.462]                     })
[10:56:21.462]                   }
[10:56:21.462]                   ...future.strategy.old <- future::plan("list")
[10:56:21.462]                   options(future.plan = NULL)
[10:56:21.462]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.462]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.462]                 }
[10:56:21.462]                 ...future.workdir <- getwd()
[10:56:21.462]             }
[10:56:21.462]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.462]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.462]         }
[10:56:21.462]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.462]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.462]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.462]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.462]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.462]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.462]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.462]             base::names(...future.oldOptions))
[10:56:21.462]     }
[10:56:21.462]     if (FALSE) {
[10:56:21.462]     }
[10:56:21.462]     else {
[10:56:21.462]         if (TRUE) {
[10:56:21.462]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.462]                 open = "w")
[10:56:21.462]         }
[10:56:21.462]         else {
[10:56:21.462]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.462]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.462]         }
[10:56:21.462]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.462]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.462]             base::sink(type = "output", split = FALSE)
[10:56:21.462]             base::close(...future.stdout)
[10:56:21.462]         }, add = TRUE)
[10:56:21.462]     }
[10:56:21.462]     ...future.frame <- base::sys.nframe()
[10:56:21.462]     ...future.conditions <- base::list()
[10:56:21.462]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.462]     if (FALSE) {
[10:56:21.462]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.462]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.462]     }
[10:56:21.462]     ...future.result <- base::tryCatch({
[10:56:21.462]         base::withCallingHandlers({
[10:56:21.462]             ...future.value <- base::withVisible(base::local({
[10:56:21.462]                 42L
[10:56:21.462]             }))
[10:56:21.462]             future::FutureResult(value = ...future.value$value, 
[10:56:21.462]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.462]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.462]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.462]                     ...future.globalenv.names))
[10:56:21.462]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.462]         }, condition = base::local({
[10:56:21.462]             c <- base::c
[10:56:21.462]             inherits <- base::inherits
[10:56:21.462]             invokeRestart <- base::invokeRestart
[10:56:21.462]             length <- base::length
[10:56:21.462]             list <- base::list
[10:56:21.462]             seq.int <- base::seq.int
[10:56:21.462]             signalCondition <- base::signalCondition
[10:56:21.462]             sys.calls <- base::sys.calls
[10:56:21.462]             `[[` <- base::`[[`
[10:56:21.462]             `+` <- base::`+`
[10:56:21.462]             `<<-` <- base::`<<-`
[10:56:21.462]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.462]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.462]                   3L)]
[10:56:21.462]             }
[10:56:21.462]             function(cond) {
[10:56:21.462]                 is_error <- inherits(cond, "error")
[10:56:21.462]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.462]                   NULL)
[10:56:21.462]                 if (is_error) {
[10:56:21.462]                   sessionInformation <- function() {
[10:56:21.462]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.462]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.462]                       search = base::search(), system = base::Sys.info())
[10:56:21.462]                   }
[10:56:21.462]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.462]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.462]                     cond$call), session = sessionInformation(), 
[10:56:21.462]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.462]                   signalCondition(cond)
[10:56:21.462]                 }
[10:56:21.462]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.462]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.462]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.462]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.462]                   if (FALSE && !signal) {
[10:56:21.462]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.462]                     {
[10:56:21.462]                       inherits <- base::inherits
[10:56:21.462]                       invokeRestart <- base::invokeRestart
[10:56:21.462]                       is.null <- base::is.null
[10:56:21.462]                       muffled <- FALSE
[10:56:21.462]                       if (inherits(cond, "message")) {
[10:56:21.462]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.462]                         if (muffled) 
[10:56:21.462]                           invokeRestart("muffleMessage")
[10:56:21.462]                       }
[10:56:21.462]                       else if (inherits(cond, "warning")) {
[10:56:21.462]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.462]                         if (muffled) 
[10:56:21.462]                           invokeRestart("muffleWarning")
[10:56:21.462]                       }
[10:56:21.462]                       else if (inherits(cond, "condition")) {
[10:56:21.462]                         if (!is.null(pattern)) {
[10:56:21.462]                           computeRestarts <- base::computeRestarts
[10:56:21.462]                           grepl <- base::grepl
[10:56:21.462]                           restarts <- computeRestarts(cond)
[10:56:21.462]                           for (restart in restarts) {
[10:56:21.462]                             name <- restart$name
[10:56:21.462]                             if (is.null(name)) 
[10:56:21.462]                               next
[10:56:21.462]                             if (!grepl(pattern, name)) 
[10:56:21.462]                               next
[10:56:21.462]                             invokeRestart(restart)
[10:56:21.462]                             muffled <- TRUE
[10:56:21.462]                             break
[10:56:21.462]                           }
[10:56:21.462]                         }
[10:56:21.462]                       }
[10:56:21.462]                       invisible(muffled)
[10:56:21.462]                     }
[10:56:21.462]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.462]                   }
[10:56:21.462]                 }
[10:56:21.462]                 else {
[10:56:21.462]                   if (TRUE) {
[10:56:21.462]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.462]                     {
[10:56:21.462]                       inherits <- base::inherits
[10:56:21.462]                       invokeRestart <- base::invokeRestart
[10:56:21.462]                       is.null <- base::is.null
[10:56:21.462]                       muffled <- FALSE
[10:56:21.462]                       if (inherits(cond, "message")) {
[10:56:21.462]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.462]                         if (muffled) 
[10:56:21.462]                           invokeRestart("muffleMessage")
[10:56:21.462]                       }
[10:56:21.462]                       else if (inherits(cond, "warning")) {
[10:56:21.462]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.462]                         if (muffled) 
[10:56:21.462]                           invokeRestart("muffleWarning")
[10:56:21.462]                       }
[10:56:21.462]                       else if (inherits(cond, "condition")) {
[10:56:21.462]                         if (!is.null(pattern)) {
[10:56:21.462]                           computeRestarts <- base::computeRestarts
[10:56:21.462]                           grepl <- base::grepl
[10:56:21.462]                           restarts <- computeRestarts(cond)
[10:56:21.462]                           for (restart in restarts) {
[10:56:21.462]                             name <- restart$name
[10:56:21.462]                             if (is.null(name)) 
[10:56:21.462]                               next
[10:56:21.462]                             if (!grepl(pattern, name)) 
[10:56:21.462]                               next
[10:56:21.462]                             invokeRestart(restart)
[10:56:21.462]                             muffled <- TRUE
[10:56:21.462]                             break
[10:56:21.462]                           }
[10:56:21.462]                         }
[10:56:21.462]                       }
[10:56:21.462]                       invisible(muffled)
[10:56:21.462]                     }
[10:56:21.462]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.462]                   }
[10:56:21.462]                 }
[10:56:21.462]             }
[10:56:21.462]         }))
[10:56:21.462]     }, error = function(ex) {
[10:56:21.462]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.462]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.462]                 ...future.rng), started = ...future.startTime, 
[10:56:21.462]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.462]             version = "1.8"), class = "FutureResult")
[10:56:21.462]     }, finally = {
[10:56:21.462]         if (!identical(...future.workdir, getwd())) 
[10:56:21.462]             setwd(...future.workdir)
[10:56:21.462]         {
[10:56:21.462]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.462]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.462]             }
[10:56:21.462]             base::options(...future.oldOptions)
[10:56:21.462]             if (.Platform$OS.type == "windows") {
[10:56:21.462]                 old_names <- names(...future.oldEnvVars)
[10:56:21.462]                 envs <- base::Sys.getenv()
[10:56:21.462]                 names <- names(envs)
[10:56:21.462]                 common <- intersect(names, old_names)
[10:56:21.462]                 added <- setdiff(names, old_names)
[10:56:21.462]                 removed <- setdiff(old_names, names)
[10:56:21.462]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.462]                   envs[common]]
[10:56:21.462]                 NAMES <- toupper(changed)
[10:56:21.462]                 args <- list()
[10:56:21.462]                 for (kk in seq_along(NAMES)) {
[10:56:21.462]                   name <- changed[[kk]]
[10:56:21.462]                   NAME <- NAMES[[kk]]
[10:56:21.462]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.462]                     next
[10:56:21.462]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.462]                 }
[10:56:21.462]                 NAMES <- toupper(added)
[10:56:21.462]                 for (kk in seq_along(NAMES)) {
[10:56:21.462]                   name <- added[[kk]]
[10:56:21.462]                   NAME <- NAMES[[kk]]
[10:56:21.462]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.462]                     next
[10:56:21.462]                   args[[name]] <- ""
[10:56:21.462]                 }
[10:56:21.462]                 NAMES <- toupper(removed)
[10:56:21.462]                 for (kk in seq_along(NAMES)) {
[10:56:21.462]                   name <- removed[[kk]]
[10:56:21.462]                   NAME <- NAMES[[kk]]
[10:56:21.462]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.462]                     next
[10:56:21.462]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.462]                 }
[10:56:21.462]                 if (length(args) > 0) 
[10:56:21.462]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.462]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.462]             }
[10:56:21.462]             else {
[10:56:21.462]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.462]             }
[10:56:21.462]             {
[10:56:21.462]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.462]                   0L) {
[10:56:21.462]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.462]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.462]                   base::options(opts)
[10:56:21.462]                 }
[10:56:21.462]                 {
[10:56:21.462]                   NULL
[10:56:21.462]                   options(future.plan = NULL)
[10:56:21.462]                   if (is.na(NA_character_)) 
[10:56:21.462]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.462]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.462]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.462]                     .init = FALSE)
[10:56:21.462]                 }
[10:56:21.462]             }
[10:56:21.462]         }
[10:56:21.462]     })
[10:56:21.462]     if (TRUE) {
[10:56:21.462]         base::sink(type = "output", split = FALSE)
[10:56:21.462]         if (TRUE) {
[10:56:21.462]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.462]         }
[10:56:21.462]         else {
[10:56:21.462]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.462]         }
[10:56:21.462]         base::close(...future.stdout)
[10:56:21.462]         ...future.stdout <- NULL
[10:56:21.462]     }
[10:56:21.462]     ...future.result$conditions <- ...future.conditions
[10:56:21.462]     ...future.result$finished <- base::Sys.time()
[10:56:21.462]     ...future.result
[10:56:21.462] }
[10:56:21.466] resolved() for 'MiraiFuture' ...
[10:56:21.466] - state: 'running'
[10:56:21.466] - run: TRUE
[10:56:21.466] - result: 'NULL'
[10:56:21.466] - resolved: FALSE
[10:56:21.466] resolved() for 'MiraiFuture' ... done
[1] FALSE
[1] 42
[10:56:21.467] *** mirai_multisession(..., globals = TRUE) with globals[10:56:21.470] getGlobalsAndPackages() ...
[10:56:21.470] Searching for globals...
[10:56:21.478] - globals found: [4] '{', '<-', '*', 'a'
[10:56:21.478] Searching for globals ... DONE
[10:56:21.478] Resolving globals: FALSE
[10:56:21.479] The total size of the 1 globals is 56 bytes (56 bytes)
[10:56:21.480] The total size of the 1 globals exported for future expression ('{; b <- 3; c <- 2; a * b * c; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (56 bytes of class 'numeric')
[10:56:21.480] - globals: [1] 'a'
[10:56:21.480] 
[10:56:21.480] getGlobalsAndPackages() ... DONE
[10:56:21.480] getGlobalsAndPackages() ...
[10:56:21.481] - globals passed as-is: [1] 'a'
[10:56:21.481] Resolving globals: FALSE
[10:56:21.481] - globals: [1] 'a'
[10:56:21.481] 
[10:56:21.481] getGlobalsAndPackages() ... DONE
[10:56:21.482] Packages needed by the future expression (n = 0): <none>
[10:56:21.482] Packages needed by future strategies (n = 0): <none>
[10:56:21.483] {
[10:56:21.483]     {
[10:56:21.483]         {
[10:56:21.483]             ...future.startTime <- base::Sys.time()
[10:56:21.483]             {
[10:56:21.483]                 {
[10:56:21.483]                   {
[10:56:21.483]                     base::local({
[10:56:21.483]                       has_future <- base::requireNamespace("future", 
[10:56:21.483]                         quietly = TRUE)
[10:56:21.483]                       if (has_future) {
[10:56:21.483]                         ns <- base::getNamespace("future")
[10:56:21.483]                         version <- ns[[".package"]][["version"]]
[10:56:21.483]                         if (is.null(version)) 
[10:56:21.483]                           version <- utils::packageVersion("future")
[10:56:21.483]                       }
[10:56:21.483]                       else {
[10:56:21.483]                         version <- NULL
[10:56:21.483]                       }
[10:56:21.483]                       if (!has_future || version < "1.8.0") {
[10:56:21.483]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.483]                           "", base::R.version$version.string), 
[10:56:21.483]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.483]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.483]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.483]                             "release", "version")], collapse = " "), 
[10:56:21.483]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.483]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.483]                           info)
[10:56:21.483]                         info <- base::paste(info, collapse = "; ")
[10:56:21.483]                         if (!has_future) {
[10:56:21.483]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.483]                             info)
[10:56:21.483]                         }
[10:56:21.483]                         else {
[10:56:21.483]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.483]                             info, version)
[10:56:21.483]                         }
[10:56:21.483]                         base::stop(msg)
[10:56:21.483]                       }
[10:56:21.483]                     })
[10:56:21.483]                   }
[10:56:21.483]                   ...future.strategy.old <- future::plan("list")
[10:56:21.483]                   options(future.plan = NULL)
[10:56:21.483]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.483]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.483]                 }
[10:56:21.483]                 ...future.workdir <- getwd()
[10:56:21.483]             }
[10:56:21.483]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.483]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.483]         }
[10:56:21.483]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.483]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.483]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.483]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.483]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.483]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.483]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.483]             base::names(...future.oldOptions))
[10:56:21.483]     }
[10:56:21.483]     if (FALSE) {
[10:56:21.483]     }
[10:56:21.483]     else {
[10:56:21.483]         if (TRUE) {
[10:56:21.483]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.483]                 open = "w")
[10:56:21.483]         }
[10:56:21.483]         else {
[10:56:21.483]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.483]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.483]         }
[10:56:21.483]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.483]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.483]             base::sink(type = "output", split = FALSE)
[10:56:21.483]             base::close(...future.stdout)
[10:56:21.483]         }, add = TRUE)
[10:56:21.483]     }
[10:56:21.483]     ...future.frame <- base::sys.nframe()
[10:56:21.483]     ...future.conditions <- base::list()
[10:56:21.483]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.483]     if (FALSE) {
[10:56:21.483]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.483]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.483]     }
[10:56:21.483]     ...future.result <- base::tryCatch({
[10:56:21.483]         base::withCallingHandlers({
[10:56:21.483]             ...future.value <- base::withVisible(base::local({
[10:56:21.483]                 b <- 3
[10:56:21.483]                 c <- 2
[10:56:21.483]                 a * b * c
[10:56:21.483]             }))
[10:56:21.483]             future::FutureResult(value = ...future.value$value, 
[10:56:21.483]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.483]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.483]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.483]                     ...future.globalenv.names))
[10:56:21.483]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.483]         }, condition = base::local({
[10:56:21.483]             c <- base::c
[10:56:21.483]             inherits <- base::inherits
[10:56:21.483]             invokeRestart <- base::invokeRestart
[10:56:21.483]             length <- base::length
[10:56:21.483]             list <- base::list
[10:56:21.483]             seq.int <- base::seq.int
[10:56:21.483]             signalCondition <- base::signalCondition
[10:56:21.483]             sys.calls <- base::sys.calls
[10:56:21.483]             `[[` <- base::`[[`
[10:56:21.483]             `+` <- base::`+`
[10:56:21.483]             `<<-` <- base::`<<-`
[10:56:21.483]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.483]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.483]                   3L)]
[10:56:21.483]             }
[10:56:21.483]             function(cond) {
[10:56:21.483]                 is_error <- inherits(cond, "error")
[10:56:21.483]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.483]                   NULL)
[10:56:21.483]                 if (is_error) {
[10:56:21.483]                   sessionInformation <- function() {
[10:56:21.483]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.483]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.483]                       search = base::search(), system = base::Sys.info())
[10:56:21.483]                   }
[10:56:21.483]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.483]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.483]                     cond$call), session = sessionInformation(), 
[10:56:21.483]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.483]                   signalCondition(cond)
[10:56:21.483]                 }
[10:56:21.483]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.483]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.483]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.483]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.483]                   if (FALSE && !signal) {
[10:56:21.483]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.483]                     {
[10:56:21.483]                       inherits <- base::inherits
[10:56:21.483]                       invokeRestart <- base::invokeRestart
[10:56:21.483]                       is.null <- base::is.null
[10:56:21.483]                       muffled <- FALSE
[10:56:21.483]                       if (inherits(cond, "message")) {
[10:56:21.483]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.483]                         if (muffled) 
[10:56:21.483]                           invokeRestart("muffleMessage")
[10:56:21.483]                       }
[10:56:21.483]                       else if (inherits(cond, "warning")) {
[10:56:21.483]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.483]                         if (muffled) 
[10:56:21.483]                           invokeRestart("muffleWarning")
[10:56:21.483]                       }
[10:56:21.483]                       else if (inherits(cond, "condition")) {
[10:56:21.483]                         if (!is.null(pattern)) {
[10:56:21.483]                           computeRestarts <- base::computeRestarts
[10:56:21.483]                           grepl <- base::grepl
[10:56:21.483]                           restarts <- computeRestarts(cond)
[10:56:21.483]                           for (restart in restarts) {
[10:56:21.483]                             name <- restart$name
[10:56:21.483]                             if (is.null(name)) 
[10:56:21.483]                               next
[10:56:21.483]                             if (!grepl(pattern, name)) 
[10:56:21.483]                               next
[10:56:21.483]                             invokeRestart(restart)
[10:56:21.483]                             muffled <- TRUE
[10:56:21.483]                             break
[10:56:21.483]                           }
[10:56:21.483]                         }
[10:56:21.483]                       }
[10:56:21.483]                       invisible(muffled)
[10:56:21.483]                     }
[10:56:21.483]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.483]                   }
[10:56:21.483]                 }
[10:56:21.483]                 else {
[10:56:21.483]                   if (TRUE) {
[10:56:21.483]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.483]                     {
[10:56:21.483]                       inherits <- base::inherits
[10:56:21.483]                       invokeRestart <- base::invokeRestart
[10:56:21.483]                       is.null <- base::is.null
[10:56:21.483]                       muffled <- FALSE
[10:56:21.483]                       if (inherits(cond, "message")) {
[10:56:21.483]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.483]                         if (muffled) 
[10:56:21.483]                           invokeRestart("muffleMessage")
[10:56:21.483]                       }
[10:56:21.483]                       else if (inherits(cond, "warning")) {
[10:56:21.483]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.483]                         if (muffled) 
[10:56:21.483]                           invokeRestart("muffleWarning")
[10:56:21.483]                       }
[10:56:21.483]                       else if (inherits(cond, "condition")) {
[10:56:21.483]                         if (!is.null(pattern)) {
[10:56:21.483]                           computeRestarts <- base::computeRestarts
[10:56:21.483]                           grepl <- base::grepl
[10:56:21.483]                           restarts <- computeRestarts(cond)
[10:56:21.483]                           for (restart in restarts) {
[10:56:21.483]                             name <- restart$name
[10:56:21.483]                             if (is.null(name)) 
[10:56:21.483]                               next
[10:56:21.483]                             if (!grepl(pattern, name)) 
[10:56:21.483]                               next
[10:56:21.483]                             invokeRestart(restart)
[10:56:21.483]                             muffled <- TRUE
[10:56:21.483]                             break
[10:56:21.483]                           }
[10:56:21.483]                         }
[10:56:21.483]                       }
[10:56:21.483]                       invisible(muffled)
[10:56:21.483]                     }
[10:56:21.483]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.483]                   }
[10:56:21.483]                 }
[10:56:21.483]             }
[10:56:21.483]         }))
[10:56:21.483]     }, error = function(ex) {
[10:56:21.483]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.483]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.483]                 ...future.rng), started = ...future.startTime, 
[10:56:21.483]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.483]             version = "1.8"), class = "FutureResult")
[10:56:21.483]     }, finally = {
[10:56:21.483]         if (!identical(...future.workdir, getwd())) 
[10:56:21.483]             setwd(...future.workdir)
[10:56:21.483]         {
[10:56:21.483]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.483]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.483]             }
[10:56:21.483]             base::options(...future.oldOptions)
[10:56:21.483]             if (.Platform$OS.type == "windows") {
[10:56:21.483]                 old_names <- names(...future.oldEnvVars)
[10:56:21.483]                 envs <- base::Sys.getenv()
[10:56:21.483]                 names <- names(envs)
[10:56:21.483]                 common <- intersect(names, old_names)
[10:56:21.483]                 added <- setdiff(names, old_names)
[10:56:21.483]                 removed <- setdiff(old_names, names)
[10:56:21.483]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.483]                   envs[common]]
[10:56:21.483]                 NAMES <- toupper(changed)
[10:56:21.483]                 args <- list()
[10:56:21.483]                 for (kk in seq_along(NAMES)) {
[10:56:21.483]                   name <- changed[[kk]]
[10:56:21.483]                   NAME <- NAMES[[kk]]
[10:56:21.483]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.483]                     next
[10:56:21.483]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.483]                 }
[10:56:21.483]                 NAMES <- toupper(added)
[10:56:21.483]                 for (kk in seq_along(NAMES)) {
[10:56:21.483]                   name <- added[[kk]]
[10:56:21.483]                   NAME <- NAMES[[kk]]
[10:56:21.483]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.483]                     next
[10:56:21.483]                   args[[name]] <- ""
[10:56:21.483]                 }
[10:56:21.483]                 NAMES <- toupper(removed)
[10:56:21.483]                 for (kk in seq_along(NAMES)) {
[10:56:21.483]                   name <- removed[[kk]]
[10:56:21.483]                   NAME <- NAMES[[kk]]
[10:56:21.483]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.483]                     next
[10:56:21.483]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.483]                 }
[10:56:21.483]                 if (length(args) > 0) 
[10:56:21.483]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.483]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.483]             }
[10:56:21.483]             else {
[10:56:21.483]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.483]             }
[10:56:21.483]             {
[10:56:21.483]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.483]                   0L) {
[10:56:21.483]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.483]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.483]                   base::options(opts)
[10:56:21.483]                 }
[10:56:21.483]                 {
[10:56:21.483]                   NULL
[10:56:21.483]                   options(future.plan = NULL)
[10:56:21.483]                   if (is.na(NA_character_)) 
[10:56:21.483]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.483]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.483]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.483]                     .init = FALSE)
[10:56:21.483]                 }
[10:56:21.483]             }
[10:56:21.483]         }
[10:56:21.483]     })
[10:56:21.483]     if (TRUE) {
[10:56:21.483]         base::sink(type = "output", split = FALSE)
[10:56:21.483]         if (TRUE) {
[10:56:21.483]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.483]         }
[10:56:21.483]         else {
[10:56:21.483]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.483]         }
[10:56:21.483]         base::close(...future.stdout)
[10:56:21.483]         ...future.stdout <- NULL
[10:56:21.483]     }
[10:56:21.483]     ...future.result$conditions <- ...future.conditions
[10:56:21.483]     ...future.result$finished <- base::Sys.time()
[10:56:21.483]     ...future.result
[10:56:21.483] }
MiraiFuture:
Label: '<none>'
Expression:
{
    b <- 3
    c <- 2
    a * b * c
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 56 bytes (numeric 'a' of 56 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:56:21.487] resolved() for 'MiraiFuture' ...
[10:56:21.487] - state: 'running'
[10:56:21.488] - run: TRUE
[10:56:21.488] - result: 'NULL'
[10:56:21.488] - resolved: FALSE
[10:56:21.488] resolved() for 'MiraiFuture' ... done
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 73cff85d-f0c3-d79d-6a2d-a22fd2dfb2cd
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[1] 0
[10:56:21.489] *** mirai_multisession(..., globals = TRUE) with globals and blocking[10:56:21.489]  - Creating mirai_multisession future #1 ...[10:56:21.491] getGlobalsAndPackages() ...
[10:56:21.491] Searching for globals...
[10:56:21.492] - globals found: [2] '{', 'ii'
[10:56:21.492] Searching for globals ... DONE
[10:56:21.492] Resolving globals: FALSE
[10:56:21.493] The total size of the 1 globals is 56 bytes (56 bytes)
[10:56:21.493] The total size of the 1 globals exported for future expression ('{; ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[10:56:21.494] - globals: [1] 'ii'
[10:56:21.494] 
[10:56:21.494] getGlobalsAndPackages() ... DONE
[10:56:21.494] getGlobalsAndPackages() ...
[10:56:21.494] - globals passed as-is: [1] 'ii'
[10:56:21.494] Resolving globals: FALSE
[10:56:21.495] - globals: [1] 'ii'
[10:56:21.495] 
[10:56:21.495] getGlobalsAndPackages() ... DONE
[10:56:21.495] Packages needed by the future expression (n = 0): <none>
[10:56:21.496] Packages needed by future strategies (n = 0): <none>
[10:56:21.496] {
[10:56:21.496]     {
[10:56:21.496]         {
[10:56:21.496]             ...future.startTime <- base::Sys.time()
[10:56:21.496]             {
[10:56:21.496]                 {
[10:56:21.496]                   {
[10:56:21.496]                     base::local({
[10:56:21.496]                       has_future <- base::requireNamespace("future", 
[10:56:21.496]                         quietly = TRUE)
[10:56:21.496]                       if (has_future) {
[10:56:21.496]                         ns <- base::getNamespace("future")
[10:56:21.496]                         version <- ns[[".package"]][["version"]]
[10:56:21.496]                         if (is.null(version)) 
[10:56:21.496]                           version <- utils::packageVersion("future")
[10:56:21.496]                       }
[10:56:21.496]                       else {
[10:56:21.496]                         version <- NULL
[10:56:21.496]                       }
[10:56:21.496]                       if (!has_future || version < "1.8.0") {
[10:56:21.496]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.496]                           "", base::R.version$version.string), 
[10:56:21.496]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.496]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.496]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.496]                             "release", "version")], collapse = " "), 
[10:56:21.496]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.496]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.496]                           info)
[10:56:21.496]                         info <- base::paste(info, collapse = "; ")
[10:56:21.496]                         if (!has_future) {
[10:56:21.496]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.496]                             info)
[10:56:21.496]                         }
[10:56:21.496]                         else {
[10:56:21.496]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.496]                             info, version)
[10:56:21.496]                         }
[10:56:21.496]                         base::stop(msg)
[10:56:21.496]                       }
[10:56:21.496]                     })
[10:56:21.496]                   }
[10:56:21.496]                   ...future.strategy.old <- future::plan("list")
[10:56:21.496]                   options(future.plan = NULL)
[10:56:21.496]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.496]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.496]                 }
[10:56:21.496]                 ...future.workdir <- getwd()
[10:56:21.496]             }
[10:56:21.496]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.496]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.496]         }
[10:56:21.496]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.496]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.496]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.496]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.496]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.496]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.496]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.496]             base::names(...future.oldOptions))
[10:56:21.496]     }
[10:56:21.496]     if (FALSE) {
[10:56:21.496]     }
[10:56:21.496]     else {
[10:56:21.496]         if (TRUE) {
[10:56:21.496]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.496]                 open = "w")
[10:56:21.496]         }
[10:56:21.496]         else {
[10:56:21.496]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.496]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.496]         }
[10:56:21.496]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.496]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.496]             base::sink(type = "output", split = FALSE)
[10:56:21.496]             base::close(...future.stdout)
[10:56:21.496]         }, add = TRUE)
[10:56:21.496]     }
[10:56:21.496]     ...future.frame <- base::sys.nframe()
[10:56:21.496]     ...future.conditions <- base::list()
[10:56:21.496]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.496]     if (FALSE) {
[10:56:21.496]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.496]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.496]     }
[10:56:21.496]     ...future.result <- base::tryCatch({
[10:56:21.496]         base::withCallingHandlers({
[10:56:21.496]             ...future.value <- base::withVisible(base::local({
[10:56:21.496]                 ii
[10:56:21.496]             }))
[10:56:21.496]             future::FutureResult(value = ...future.value$value, 
[10:56:21.496]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.496]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.496]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.496]                     ...future.globalenv.names))
[10:56:21.496]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.496]         }, condition = base::local({
[10:56:21.496]             c <- base::c
[10:56:21.496]             inherits <- base::inherits
[10:56:21.496]             invokeRestart <- base::invokeRestart
[10:56:21.496]             length <- base::length
[10:56:21.496]             list <- base::list
[10:56:21.496]             seq.int <- base::seq.int
[10:56:21.496]             signalCondition <- base::signalCondition
[10:56:21.496]             sys.calls <- base::sys.calls
[10:56:21.496]             `[[` <- base::`[[`
[10:56:21.496]             `+` <- base::`+`
[10:56:21.496]             `<<-` <- base::`<<-`
[10:56:21.496]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.496]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.496]                   3L)]
[10:56:21.496]             }
[10:56:21.496]             function(cond) {
[10:56:21.496]                 is_error <- inherits(cond, "error")
[10:56:21.496]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.496]                   NULL)
[10:56:21.496]                 if (is_error) {
[10:56:21.496]                   sessionInformation <- function() {
[10:56:21.496]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.496]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.496]                       search = base::search(), system = base::Sys.info())
[10:56:21.496]                   }
[10:56:21.496]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.496]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.496]                     cond$call), session = sessionInformation(), 
[10:56:21.496]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.496]                   signalCondition(cond)
[10:56:21.496]                 }
[10:56:21.496]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.496]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.496]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.496]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.496]                   if (FALSE && !signal) {
[10:56:21.496]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.496]                     {
[10:56:21.496]                       inherits <- base::inherits
[10:56:21.496]                       invokeRestart <- base::invokeRestart
[10:56:21.496]                       is.null <- base::is.null
[10:56:21.496]                       muffled <- FALSE
[10:56:21.496]                       if (inherits(cond, "message")) {
[10:56:21.496]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.496]                         if (muffled) 
[10:56:21.496]                           invokeRestart("muffleMessage")
[10:56:21.496]                       }
[10:56:21.496]                       else if (inherits(cond, "warning")) {
[10:56:21.496]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.496]                         if (muffled) 
[10:56:21.496]                           invokeRestart("muffleWarning")
[10:56:21.496]                       }
[10:56:21.496]                       else if (inherits(cond, "condition")) {
[10:56:21.496]                         if (!is.null(pattern)) {
[10:56:21.496]                           computeRestarts <- base::computeRestarts
[10:56:21.496]                           grepl <- base::grepl
[10:56:21.496]                           restarts <- computeRestarts(cond)
[10:56:21.496]                           for (restart in restarts) {
[10:56:21.496]                             name <- restart$name
[10:56:21.496]                             if (is.null(name)) 
[10:56:21.496]                               next
[10:56:21.496]                             if (!grepl(pattern, name)) 
[10:56:21.496]                               next
[10:56:21.496]                             invokeRestart(restart)
[10:56:21.496]                             muffled <- TRUE
[10:56:21.496]                             break
[10:56:21.496]                           }
[10:56:21.496]                         }
[10:56:21.496]                       }
[10:56:21.496]                       invisible(muffled)
[10:56:21.496]                     }
[10:56:21.496]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.496]                   }
[10:56:21.496]                 }
[10:56:21.496]                 else {
[10:56:21.496]                   if (TRUE) {
[10:56:21.496]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.496]                     {
[10:56:21.496]                       inherits <- base::inherits
[10:56:21.496]                       invokeRestart <- base::invokeRestart
[10:56:21.496]                       is.null <- base::is.null
[10:56:21.496]                       muffled <- FALSE
[10:56:21.496]                       if (inherits(cond, "message")) {
[10:56:21.496]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.496]                         if (muffled) 
[10:56:21.496]                           invokeRestart("muffleMessage")
[10:56:21.496]                       }
[10:56:21.496]                       else if (inherits(cond, "warning")) {
[10:56:21.496]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.496]                         if (muffled) 
[10:56:21.496]                           invokeRestart("muffleWarning")
[10:56:21.496]                       }
[10:56:21.496]                       else if (inherits(cond, "condition")) {
[10:56:21.496]                         if (!is.null(pattern)) {
[10:56:21.496]                           computeRestarts <- base::computeRestarts
[10:56:21.496]                           grepl <- base::grepl
[10:56:21.496]                           restarts <- computeRestarts(cond)
[10:56:21.496]                           for (restart in restarts) {
[10:56:21.496]                             name <- restart$name
[10:56:21.496]                             if (is.null(name)) 
[10:56:21.496]                               next
[10:56:21.496]                             if (!grepl(pattern, name)) 
[10:56:21.496]                               next
[10:56:21.496]                             invokeRestart(restart)
[10:56:21.496]                             muffled <- TRUE
[10:56:21.496]                             break
[10:56:21.496]                           }
[10:56:21.496]                         }
[10:56:21.496]                       }
[10:56:21.496]                       invisible(muffled)
[10:56:21.496]                     }
[10:56:21.496]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.496]                   }
[10:56:21.496]                 }
[10:56:21.496]             }
[10:56:21.496]         }))
[10:56:21.496]     }, error = function(ex) {
[10:56:21.496]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.496]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.496]                 ...future.rng), started = ...future.startTime, 
[10:56:21.496]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.496]             version = "1.8"), class = "FutureResult")
[10:56:21.496]     }, finally = {
[10:56:21.496]         if (!identical(...future.workdir, getwd())) 
[10:56:21.496]             setwd(...future.workdir)
[10:56:21.496]         {
[10:56:21.496]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.496]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.496]             }
[10:56:21.496]             base::options(...future.oldOptions)
[10:56:21.496]             if (.Platform$OS.type == "windows") {
[10:56:21.496]                 old_names <- names(...future.oldEnvVars)
[10:56:21.496]                 envs <- base::Sys.getenv()
[10:56:21.496]                 names <- names(envs)
[10:56:21.496]                 common <- intersect(names, old_names)
[10:56:21.496]                 added <- setdiff(names, old_names)
[10:56:21.496]                 removed <- setdiff(old_names, names)
[10:56:21.496]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.496]                   envs[common]]
[10:56:21.496]                 NAMES <- toupper(changed)
[10:56:21.496]                 args <- list()
[10:56:21.496]                 for (kk in seq_along(NAMES)) {
[10:56:21.496]                   name <- changed[[kk]]
[10:56:21.496]                   NAME <- NAMES[[kk]]
[10:56:21.496]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.496]                     next
[10:56:21.496]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.496]                 }
[10:56:21.496]                 NAMES <- toupper(added)
[10:56:21.496]                 for (kk in seq_along(NAMES)) {
[10:56:21.496]                   name <- added[[kk]]
[10:56:21.496]                   NAME <- NAMES[[kk]]
[10:56:21.496]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.496]                     next
[10:56:21.496]                   args[[name]] <- ""
[10:56:21.496]                 }
[10:56:21.496]                 NAMES <- toupper(removed)
[10:56:21.496]                 for (kk in seq_along(NAMES)) {
[10:56:21.496]                   name <- removed[[kk]]
[10:56:21.496]                   NAME <- NAMES[[kk]]
[10:56:21.496]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.496]                     next
[10:56:21.496]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.496]                 }
[10:56:21.496]                 if (length(args) > 0) 
[10:56:21.496]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.496]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.496]             }
[10:56:21.496]             else {
[10:56:21.496]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.496]             }
[10:56:21.496]             {
[10:56:21.496]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.496]                   0L) {
[10:56:21.496]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.496]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.496]                   base::options(opts)
[10:56:21.496]                 }
[10:56:21.496]                 {
[10:56:21.496]                   NULL
[10:56:21.496]                   options(future.plan = NULL)
[10:56:21.496]                   if (is.na(NA_character_)) 
[10:56:21.496]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.496]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.496]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.496]                     .init = FALSE)
[10:56:21.496]                 }
[10:56:21.496]             }
[10:56:21.496]         }
[10:56:21.496]     })
[10:56:21.496]     if (TRUE) {
[10:56:21.496]         base::sink(type = "output", split = FALSE)
[10:56:21.496]         if (TRUE) {
[10:56:21.496]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.496]         }
[10:56:21.496]         else {
[10:56:21.496]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.496]         }
[10:56:21.496]         base::close(...future.stdout)
[10:56:21.496]         ...future.stdout <- NULL
[10:56:21.496]     }
[10:56:21.496]     ...future.result$conditions <- ...future.conditions
[10:56:21.496]     ...future.result$finished <- base::Sys.time()
[10:56:21.496]     ...future.result
[10:56:21.496] }
[10:56:21.500]  - Creating mirai_multisession future #2 ...[10:56:21.502] getGlobalsAndPackages() ...
[10:56:21.502] Searching for globals...
[10:56:21.503] - globals found: [2] '{', 'ii'
[10:56:21.503] Searching for globals ... DONE
[10:56:21.504] Resolving globals: FALSE
[10:56:21.504] The total size of the 1 globals is 56 bytes (56 bytes)
[10:56:21.505] The total size of the 1 globals exported for future expression ('{; ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[10:56:21.505] - globals: [1] 'ii'
[10:56:21.505] 
[10:56:21.505] getGlobalsAndPackages() ... DONE
[10:56:21.505] getGlobalsAndPackages() ...
[10:56:21.505] - globals passed as-is: [1] 'ii'
[10:56:21.506] Resolving globals: FALSE
[10:56:21.506] - globals: [1] 'ii'
[10:56:21.506] 
[10:56:21.506] getGlobalsAndPackages() ... DONE
[10:56:21.507] Packages needed by the future expression (n = 0): <none>
[10:56:21.507] Packages needed by future strategies (n = 0): <none>
[10:56:21.507] {
[10:56:21.507]     {
[10:56:21.507]         {
[10:56:21.507]             ...future.startTime <- base::Sys.time()
[10:56:21.507]             {
[10:56:21.507]                 {
[10:56:21.507]                   {
[10:56:21.507]                     base::local({
[10:56:21.507]                       has_future <- base::requireNamespace("future", 
[10:56:21.507]                         quietly = TRUE)
[10:56:21.507]                       if (has_future) {
[10:56:21.507]                         ns <- base::getNamespace("future")
[10:56:21.507]                         version <- ns[[".package"]][["version"]]
[10:56:21.507]                         if (is.null(version)) 
[10:56:21.507]                           version <- utils::packageVersion("future")
[10:56:21.507]                       }
[10:56:21.507]                       else {
[10:56:21.507]                         version <- NULL
[10:56:21.507]                       }
[10:56:21.507]                       if (!has_future || version < "1.8.0") {
[10:56:21.507]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.507]                           "", base::R.version$version.string), 
[10:56:21.507]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.507]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.507]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.507]                             "release", "version")], collapse = " "), 
[10:56:21.507]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.507]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.507]                           info)
[10:56:21.507]                         info <- base::paste(info, collapse = "; ")
[10:56:21.507]                         if (!has_future) {
[10:56:21.507]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.507]                             info)
[10:56:21.507]                         }
[10:56:21.507]                         else {
[10:56:21.507]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.507]                             info, version)
[10:56:21.507]                         }
[10:56:21.507]                         base::stop(msg)
[10:56:21.507]                       }
[10:56:21.507]                     })
[10:56:21.507]                   }
[10:56:21.507]                   ...future.strategy.old <- future::plan("list")
[10:56:21.507]                   options(future.plan = NULL)
[10:56:21.507]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.507]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.507]                 }
[10:56:21.507]                 ...future.workdir <- getwd()
[10:56:21.507]             }
[10:56:21.507]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.507]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.507]         }
[10:56:21.507]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.507]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.507]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.507]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.507]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.507]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.507]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.507]             base::names(...future.oldOptions))
[10:56:21.507]     }
[10:56:21.507]     if (FALSE) {
[10:56:21.507]     }
[10:56:21.507]     else {
[10:56:21.507]         if (TRUE) {
[10:56:21.507]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.507]                 open = "w")
[10:56:21.507]         }
[10:56:21.507]         else {
[10:56:21.507]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.507]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.507]         }
[10:56:21.507]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.507]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.507]             base::sink(type = "output", split = FALSE)
[10:56:21.507]             base::close(...future.stdout)
[10:56:21.507]         }, add = TRUE)
[10:56:21.507]     }
[10:56:21.507]     ...future.frame <- base::sys.nframe()
[10:56:21.507]     ...future.conditions <- base::list()
[10:56:21.507]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.507]     if (FALSE) {
[10:56:21.507]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.507]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.507]     }
[10:56:21.507]     ...future.result <- base::tryCatch({
[10:56:21.507]         base::withCallingHandlers({
[10:56:21.507]             ...future.value <- base::withVisible(base::local({
[10:56:21.507]                 ii
[10:56:21.507]             }))
[10:56:21.507]             future::FutureResult(value = ...future.value$value, 
[10:56:21.507]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.507]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.507]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.507]                     ...future.globalenv.names))
[10:56:21.507]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.507]         }, condition = base::local({
[10:56:21.507]             c <- base::c
[10:56:21.507]             inherits <- base::inherits
[10:56:21.507]             invokeRestart <- base::invokeRestart
[10:56:21.507]             length <- base::length
[10:56:21.507]             list <- base::list
[10:56:21.507]             seq.int <- base::seq.int
[10:56:21.507]             signalCondition <- base::signalCondition
[10:56:21.507]             sys.calls <- base::sys.calls
[10:56:21.507]             `[[` <- base::`[[`
[10:56:21.507]             `+` <- base::`+`
[10:56:21.507]             `<<-` <- base::`<<-`
[10:56:21.507]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.507]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.507]                   3L)]
[10:56:21.507]             }
[10:56:21.507]             function(cond) {
[10:56:21.507]                 is_error <- inherits(cond, "error")
[10:56:21.507]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.507]                   NULL)
[10:56:21.507]                 if (is_error) {
[10:56:21.507]                   sessionInformation <- function() {
[10:56:21.507]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.507]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.507]                       search = base::search(), system = base::Sys.info())
[10:56:21.507]                   }
[10:56:21.507]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.507]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.507]                     cond$call), session = sessionInformation(), 
[10:56:21.507]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.507]                   signalCondition(cond)
[10:56:21.507]                 }
[10:56:21.507]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.507]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.507]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.507]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.507]                   if (FALSE && !signal) {
[10:56:21.507]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.507]                     {
[10:56:21.507]                       inherits <- base::inherits
[10:56:21.507]                       invokeRestart <- base::invokeRestart
[10:56:21.507]                       is.null <- base::is.null
[10:56:21.507]                       muffled <- FALSE
[10:56:21.507]                       if (inherits(cond, "message")) {
[10:56:21.507]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.507]                         if (muffled) 
[10:56:21.507]                           invokeRestart("muffleMessage")
[10:56:21.507]                       }
[10:56:21.507]                       else if (inherits(cond, "warning")) {
[10:56:21.507]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.507]                         if (muffled) 
[10:56:21.507]                           invokeRestart("muffleWarning")
[10:56:21.507]                       }
[10:56:21.507]                       else if (inherits(cond, "condition")) {
[10:56:21.507]                         if (!is.null(pattern)) {
[10:56:21.507]                           computeRestarts <- base::computeRestarts
[10:56:21.507]                           grepl <- base::grepl
[10:56:21.507]                           restarts <- computeRestarts(cond)
[10:56:21.507]                           for (restart in restarts) {
[10:56:21.507]                             name <- restart$name
[10:56:21.507]                             if (is.null(name)) 
[10:56:21.507]                               next
[10:56:21.507]                             if (!grepl(pattern, name)) 
[10:56:21.507]                               next
[10:56:21.507]                             invokeRestart(restart)
[10:56:21.507]                             muffled <- TRUE
[10:56:21.507]                             break
[10:56:21.507]                           }
[10:56:21.507]                         }
[10:56:21.507]                       }
[10:56:21.507]                       invisible(muffled)
[10:56:21.507]                     }
[10:56:21.507]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.507]                   }
[10:56:21.507]                 }
[10:56:21.507]                 else {
[10:56:21.507]                   if (TRUE) {
[10:56:21.507]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.507]                     {
[10:56:21.507]                       inherits <- base::inherits
[10:56:21.507]                       invokeRestart <- base::invokeRestart
[10:56:21.507]                       is.null <- base::is.null
[10:56:21.507]                       muffled <- FALSE
[10:56:21.507]                       if (inherits(cond, "message")) {
[10:56:21.507]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.507]                         if (muffled) 
[10:56:21.507]                           invokeRestart("muffleMessage")
[10:56:21.507]                       }
[10:56:21.507]                       else if (inherits(cond, "warning")) {
[10:56:21.507]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.507]                         if (muffled) 
[10:56:21.507]                           invokeRestart("muffleWarning")
[10:56:21.507]                       }
[10:56:21.507]                       else if (inherits(cond, "condition")) {
[10:56:21.507]                         if (!is.null(pattern)) {
[10:56:21.507]                           computeRestarts <- base::computeRestarts
[10:56:21.507]                           grepl <- base::grepl
[10:56:21.507]                           restarts <- computeRestarts(cond)
[10:56:21.507]                           for (restart in restarts) {
[10:56:21.507]                             name <- restart$name
[10:56:21.507]                             if (is.null(name)) 
[10:56:21.507]                               next
[10:56:21.507]                             if (!grepl(pattern, name)) 
[10:56:21.507]                               next
[10:56:21.507]                             invokeRestart(restart)
[10:56:21.507]                             muffled <- TRUE
[10:56:21.507]                             break
[10:56:21.507]                           }
[10:56:21.507]                         }
[10:56:21.507]                       }
[10:56:21.507]                       invisible(muffled)
[10:56:21.507]                     }
[10:56:21.507]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.507]                   }
[10:56:21.507]                 }
[10:56:21.507]             }
[10:56:21.507]         }))
[10:56:21.507]     }, error = function(ex) {
[10:56:21.507]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.507]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.507]                 ...future.rng), started = ...future.startTime, 
[10:56:21.507]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.507]             version = "1.8"), class = "FutureResult")
[10:56:21.507]     }, finally = {
[10:56:21.507]         if (!identical(...future.workdir, getwd())) 
[10:56:21.507]             setwd(...future.workdir)
[10:56:21.507]         {
[10:56:21.507]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.507]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.507]             }
[10:56:21.507]             base::options(...future.oldOptions)
[10:56:21.507]             if (.Platform$OS.type == "windows") {
[10:56:21.507]                 old_names <- names(...future.oldEnvVars)
[10:56:21.507]                 envs <- base::Sys.getenv()
[10:56:21.507]                 names <- names(envs)
[10:56:21.507]                 common <- intersect(names, old_names)
[10:56:21.507]                 added <- setdiff(names, old_names)
[10:56:21.507]                 removed <- setdiff(old_names, names)
[10:56:21.507]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.507]                   envs[common]]
[10:56:21.507]                 NAMES <- toupper(changed)
[10:56:21.507]                 args <- list()
[10:56:21.507]                 for (kk in seq_along(NAMES)) {
[10:56:21.507]                   name <- changed[[kk]]
[10:56:21.507]                   NAME <- NAMES[[kk]]
[10:56:21.507]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.507]                     next
[10:56:21.507]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.507]                 }
[10:56:21.507]                 NAMES <- toupper(added)
[10:56:21.507]                 for (kk in seq_along(NAMES)) {
[10:56:21.507]                   name <- added[[kk]]
[10:56:21.507]                   NAME <- NAMES[[kk]]
[10:56:21.507]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.507]                     next
[10:56:21.507]                   args[[name]] <- ""
[10:56:21.507]                 }
[10:56:21.507]                 NAMES <- toupper(removed)
[10:56:21.507]                 for (kk in seq_along(NAMES)) {
[10:56:21.507]                   name <- removed[[kk]]
[10:56:21.507]                   NAME <- NAMES[[kk]]
[10:56:21.507]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.507]                     next
[10:56:21.507]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.507]                 }
[10:56:21.507]                 if (length(args) > 0) 
[10:56:21.507]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.507]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.507]             }
[10:56:21.507]             else {
[10:56:21.507]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.507]             }
[10:56:21.507]             {
[10:56:21.507]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.507]                   0L) {
[10:56:21.507]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.507]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.507]                   base::options(opts)
[10:56:21.507]                 }
[10:56:21.507]                 {
[10:56:21.507]                   NULL
[10:56:21.507]                   options(future.plan = NULL)
[10:56:21.507]                   if (is.na(NA_character_)) 
[10:56:21.507]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.507]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.507]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.507]                     .init = FALSE)
[10:56:21.507]                 }
[10:56:21.507]             }
[10:56:21.507]         }
[10:56:21.507]     })
[10:56:21.507]     if (TRUE) {
[10:56:21.507]         base::sink(type = "output", split = FALSE)
[10:56:21.507]         if (TRUE) {
[10:56:21.507]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.507]         }
[10:56:21.507]         else {
[10:56:21.507]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.507]         }
[10:56:21.507]         base::close(...future.stdout)
[10:56:21.507]         ...future.stdout <- NULL
[10:56:21.507]     }
[10:56:21.507]     ...future.result$conditions <- ...future.conditions
[10:56:21.507]     ...future.result$finished <- base::Sys.time()
[10:56:21.507]     ...future.result
[10:56:21.507] }
[10:56:21.511]  - Creating mirai_multisession future #3 ...[10:56:21.513] getGlobalsAndPackages() ...
[10:56:21.514] Searching for globals...
[10:56:21.515] - globals found: [2] '{', 'ii'
[10:56:21.515] Searching for globals ... DONE
[10:56:21.515] Resolving globals: FALSE
[10:56:21.515] The total size of the 1 globals is 56 bytes (56 bytes)
[10:56:21.516] The total size of the 1 globals exported for future expression ('{; ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[10:56:21.516] - globals: [1] 'ii'
[10:56:21.516] 
[10:56:21.516] getGlobalsAndPackages() ... DONE
[10:56:21.517] getGlobalsAndPackages() ...
[10:56:21.517] - globals passed as-is: [1] 'ii'
[10:56:21.517] Resolving globals: FALSE
[10:56:21.517] - globals: [1] 'ii'
[10:56:21.519] 
[10:56:21.520] getGlobalsAndPackages() ... DONE
[10:56:21.520] Packages needed by the future expression (n = 0): <none>
[10:56:21.520] Packages needed by future strategies (n = 0): <none>
[10:56:21.521] {
[10:56:21.521]     {
[10:56:21.521]         {
[10:56:21.521]             ...future.startTime <- base::Sys.time()
[10:56:21.521]             {
[10:56:21.521]                 {
[10:56:21.521]                   {
[10:56:21.521]                     base::local({
[10:56:21.521]                       has_future <- base::requireNamespace("future", 
[10:56:21.521]                         quietly = TRUE)
[10:56:21.521]                       if (has_future) {
[10:56:21.521]                         ns <- base::getNamespace("future")
[10:56:21.521]                         version <- ns[[".package"]][["version"]]
[10:56:21.521]                         if (is.null(version)) 
[10:56:21.521]                           version <- utils::packageVersion("future")
[10:56:21.521]                       }
[10:56:21.521]                       else {
[10:56:21.521]                         version <- NULL
[10:56:21.521]                       }
[10:56:21.521]                       if (!has_future || version < "1.8.0") {
[10:56:21.521]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.521]                           "", base::R.version$version.string), 
[10:56:21.521]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.521]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.521]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.521]                             "release", "version")], collapse = " "), 
[10:56:21.521]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.521]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.521]                           info)
[10:56:21.521]                         info <- base::paste(info, collapse = "; ")
[10:56:21.521]                         if (!has_future) {
[10:56:21.521]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.521]                             info)
[10:56:21.521]                         }
[10:56:21.521]                         else {
[10:56:21.521]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.521]                             info, version)
[10:56:21.521]                         }
[10:56:21.521]                         base::stop(msg)
[10:56:21.521]                       }
[10:56:21.521]                     })
[10:56:21.521]                   }
[10:56:21.521]                   ...future.strategy.old <- future::plan("list")
[10:56:21.521]                   options(future.plan = NULL)
[10:56:21.521]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.521]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.521]                 }
[10:56:21.521]                 ...future.workdir <- getwd()
[10:56:21.521]             }
[10:56:21.521]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.521]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.521]         }
[10:56:21.521]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.521]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.521]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.521]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.521]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.521]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.521]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.521]             base::names(...future.oldOptions))
[10:56:21.521]     }
[10:56:21.521]     if (FALSE) {
[10:56:21.521]     }
[10:56:21.521]     else {
[10:56:21.521]         if (TRUE) {
[10:56:21.521]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.521]                 open = "w")
[10:56:21.521]         }
[10:56:21.521]         else {
[10:56:21.521]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.521]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.521]         }
[10:56:21.521]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.521]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.521]             base::sink(type = "output", split = FALSE)
[10:56:21.521]             base::close(...future.stdout)
[10:56:21.521]         }, add = TRUE)
[10:56:21.521]     }
[10:56:21.521]     ...future.frame <- base::sys.nframe()
[10:56:21.521]     ...future.conditions <- base::list()
[10:56:21.521]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.521]     if (FALSE) {
[10:56:21.521]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.521]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.521]     }
[10:56:21.521]     ...future.result <- base::tryCatch({
[10:56:21.521]         base::withCallingHandlers({
[10:56:21.521]             ...future.value <- base::withVisible(base::local({
[10:56:21.521]                 ii
[10:56:21.521]             }))
[10:56:21.521]             future::FutureResult(value = ...future.value$value, 
[10:56:21.521]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.521]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.521]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.521]                     ...future.globalenv.names))
[10:56:21.521]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.521]         }, condition = base::local({
[10:56:21.521]             c <- base::c
[10:56:21.521]             inherits <- base::inherits
[10:56:21.521]             invokeRestart <- base::invokeRestart
[10:56:21.521]             length <- base::length
[10:56:21.521]             list <- base::list
[10:56:21.521]             seq.int <- base::seq.int
[10:56:21.521]             signalCondition <- base::signalCondition
[10:56:21.521]             sys.calls <- base::sys.calls
[10:56:21.521]             `[[` <- base::`[[`
[10:56:21.521]             `+` <- base::`+`
[10:56:21.521]             `<<-` <- base::`<<-`
[10:56:21.521]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.521]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.521]                   3L)]
[10:56:21.521]             }
[10:56:21.521]             function(cond) {
[10:56:21.521]                 is_error <- inherits(cond, "error")
[10:56:21.521]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.521]                   NULL)
[10:56:21.521]                 if (is_error) {
[10:56:21.521]                   sessionInformation <- function() {
[10:56:21.521]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.521]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.521]                       search = base::search(), system = base::Sys.info())
[10:56:21.521]                   }
[10:56:21.521]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.521]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.521]                     cond$call), session = sessionInformation(), 
[10:56:21.521]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.521]                   signalCondition(cond)
[10:56:21.521]                 }
[10:56:21.521]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.521]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.521]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.521]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.521]                   if (FALSE && !signal) {
[10:56:21.521]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.521]                     {
[10:56:21.521]                       inherits <- base::inherits
[10:56:21.521]                       invokeRestart <- base::invokeRestart
[10:56:21.521]                       is.null <- base::is.null
[10:56:21.521]                       muffled <- FALSE
[10:56:21.521]                       if (inherits(cond, "message")) {
[10:56:21.521]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.521]                         if (muffled) 
[10:56:21.521]                           invokeRestart("muffleMessage")
[10:56:21.521]                       }
[10:56:21.521]                       else if (inherits(cond, "warning")) {
[10:56:21.521]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.521]                         if (muffled) 
[10:56:21.521]                           invokeRestart("muffleWarning")
[10:56:21.521]                       }
[10:56:21.521]                       else if (inherits(cond, "condition")) {
[10:56:21.521]                         if (!is.null(pattern)) {
[10:56:21.521]                           computeRestarts <- base::computeRestarts
[10:56:21.521]                           grepl <- base::grepl
[10:56:21.521]                           restarts <- computeRestarts(cond)
[10:56:21.521]                           for (restart in restarts) {
[10:56:21.521]                             name <- restart$name
[10:56:21.521]                             if (is.null(name)) 
[10:56:21.521]                               next
[10:56:21.521]                             if (!grepl(pattern, name)) 
[10:56:21.521]                               next
[10:56:21.521]                             invokeRestart(restart)
[10:56:21.521]                             muffled <- TRUE
[10:56:21.521]                             break
[10:56:21.521]                           }
[10:56:21.521]                         }
[10:56:21.521]                       }
[10:56:21.521]                       invisible(muffled)
[10:56:21.521]                     }
[10:56:21.521]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.521]                   }
[10:56:21.521]                 }
[10:56:21.521]                 else {
[10:56:21.521]                   if (TRUE) {
[10:56:21.521]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.521]                     {
[10:56:21.521]                       inherits <- base::inherits
[10:56:21.521]                       invokeRestart <- base::invokeRestart
[10:56:21.521]                       is.null <- base::is.null
[10:56:21.521]                       muffled <- FALSE
[10:56:21.521]                       if (inherits(cond, "message")) {
[10:56:21.521]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.521]                         if (muffled) 
[10:56:21.521]                           invokeRestart("muffleMessage")
[10:56:21.521]                       }
[10:56:21.521]                       else if (inherits(cond, "warning")) {
[10:56:21.521]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.521]                         if (muffled) 
[10:56:21.521]                           invokeRestart("muffleWarning")
[10:56:21.521]                       }
[10:56:21.521]                       else if (inherits(cond, "condition")) {
[10:56:21.521]                         if (!is.null(pattern)) {
[10:56:21.521]                           computeRestarts <- base::computeRestarts
[10:56:21.521]                           grepl <- base::grepl
[10:56:21.521]                           restarts <- computeRestarts(cond)
[10:56:21.521]                           for (restart in restarts) {
[10:56:21.521]                             name <- restart$name
[10:56:21.521]                             if (is.null(name)) 
[10:56:21.521]                               next
[10:56:21.521]                             if (!grepl(pattern, name)) 
[10:56:21.521]                               next
[10:56:21.521]                             invokeRestart(restart)
[10:56:21.521]                             muffled <- TRUE
[10:56:21.521]                             break
[10:56:21.521]                           }
[10:56:21.521]                         }
[10:56:21.521]                       }
[10:56:21.521]                       invisible(muffled)
[10:56:21.521]                     }
[10:56:21.521]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.521]                   }
[10:56:21.521]                 }
[10:56:21.521]             }
[10:56:21.521]         }))
[10:56:21.521]     }, error = function(ex) {
[10:56:21.521]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.521]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.521]                 ...future.rng), started = ...future.startTime, 
[10:56:21.521]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.521]             version = "1.8"), class = "FutureResult")
[10:56:21.521]     }, finally = {
[10:56:21.521]         if (!identical(...future.workdir, getwd())) 
[10:56:21.521]             setwd(...future.workdir)
[10:56:21.521]         {
[10:56:21.521]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.521]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.521]             }
[10:56:21.521]             base::options(...future.oldOptions)
[10:56:21.521]             if (.Platform$OS.type == "windows") {
[10:56:21.521]                 old_names <- names(...future.oldEnvVars)
[10:56:21.521]                 envs <- base::Sys.getenv()
[10:56:21.521]                 names <- names(envs)
[10:56:21.521]                 common <- intersect(names, old_names)
[10:56:21.521]                 added <- setdiff(names, old_names)
[10:56:21.521]                 removed <- setdiff(old_names, names)
[10:56:21.521]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.521]                   envs[common]]
[10:56:21.521]                 NAMES <- toupper(changed)
[10:56:21.521]                 args <- list()
[10:56:21.521]                 for (kk in seq_along(NAMES)) {
[10:56:21.521]                   name <- changed[[kk]]
[10:56:21.521]                   NAME <- NAMES[[kk]]
[10:56:21.521]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.521]                     next
[10:56:21.521]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.521]                 }
[10:56:21.521]                 NAMES <- toupper(added)
[10:56:21.521]                 for (kk in seq_along(NAMES)) {
[10:56:21.521]                   name <- added[[kk]]
[10:56:21.521]                   NAME <- NAMES[[kk]]
[10:56:21.521]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.521]                     next
[10:56:21.521]                   args[[name]] <- ""
[10:56:21.521]                 }
[10:56:21.521]                 NAMES <- toupper(removed)
[10:56:21.521]                 for (kk in seq_along(NAMES)) {
[10:56:21.521]                   name <- removed[[kk]]
[10:56:21.521]                   NAME <- NAMES[[kk]]
[10:56:21.521]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.521]                     next
[10:56:21.521]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.521]                 }
[10:56:21.521]                 if (length(args) > 0) 
[10:56:21.521]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.521]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.521]             }
[10:56:21.521]             else {
[10:56:21.521]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.521]             }
[10:56:21.521]             {
[10:56:21.521]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.521]                   0L) {
[10:56:21.521]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.521]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.521]                   base::options(opts)
[10:56:21.521]                 }
[10:56:21.521]                 {
[10:56:21.521]                   NULL
[10:56:21.521]                   options(future.plan = NULL)
[10:56:21.521]                   if (is.na(NA_character_)) 
[10:56:21.521]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.521]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.521]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.521]                     .init = FALSE)
[10:56:21.521]                 }
[10:56:21.521]             }
[10:56:21.521]         }
[10:56:21.521]     })
[10:56:21.521]     if (TRUE) {
[10:56:21.521]         base::sink(type = "output", split = FALSE)
[10:56:21.521]         if (TRUE) {
[10:56:21.521]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.521]         }
[10:56:21.521]         else {
[10:56:21.521]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.521]         }
[10:56:21.521]         base::close(...future.stdout)
[10:56:21.521]         ...future.stdout <- NULL
[10:56:21.521]     }
[10:56:21.521]     ...future.result$conditions <- ...future.conditions
[10:56:21.521]     ...future.result$finished <- base::Sys.time()
[10:56:21.521]     ...future.result
[10:56:21.521] }
[10:56:21.525]  - Resolving 3 mirai_multisession futures[10:56:21.527] *** mirai_multisession(..., globals = TRUE) and errors[10:56:21.529] getGlobalsAndPackages() ...
[10:56:21.529] Searching for globals...
[10:56:21.530] - globals found: [2] '{', 'stop'
[10:56:21.530] Searching for globals ... DONE
[10:56:21.531] Resolving globals: FALSE
[10:56:21.531] 
[10:56:21.531] 
[10:56:21.531] getGlobalsAndPackages() ... DONE
[10:56:21.531] getGlobalsAndPackages() ...
[10:56:21.532] 
[10:56:21.532] - globals: [0] <none>
[10:56:21.532] getGlobalsAndPackages() ... DONE
[10:56:21.532] Packages needed by the future expression (n = 0): <none>
[10:56:21.532] Packages needed by future strategies (n = 0): <none>
[10:56:21.533] {
[10:56:21.533]     {
[10:56:21.533]         {
[10:56:21.533]             ...future.startTime <- base::Sys.time()
[10:56:21.533]             {
[10:56:21.533]                 {
[10:56:21.533]                   {
[10:56:21.533]                     base::local({
[10:56:21.533]                       has_future <- base::requireNamespace("future", 
[10:56:21.533]                         quietly = TRUE)
[10:56:21.533]                       if (has_future) {
[10:56:21.533]                         ns <- base::getNamespace("future")
[10:56:21.533]                         version <- ns[[".package"]][["version"]]
[10:56:21.533]                         if (is.null(version)) 
[10:56:21.533]                           version <- utils::packageVersion("future")
[10:56:21.533]                       }
[10:56:21.533]                       else {
[10:56:21.533]                         version <- NULL
[10:56:21.533]                       }
[10:56:21.533]                       if (!has_future || version < "1.8.0") {
[10:56:21.533]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.533]                           "", base::R.version$version.string), 
[10:56:21.533]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.533]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.533]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.533]                             "release", "version")], collapse = " "), 
[10:56:21.533]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.533]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.533]                           info)
[10:56:21.533]                         info <- base::paste(info, collapse = "; ")
[10:56:21.533]                         if (!has_future) {
[10:56:21.533]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.533]                             info)
[10:56:21.533]                         }
[10:56:21.533]                         else {
[10:56:21.533]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.533]                             info, version)
[10:56:21.533]                         }
[10:56:21.533]                         base::stop(msg)
[10:56:21.533]                       }
[10:56:21.533]                     })
[10:56:21.533]                   }
[10:56:21.533]                   ...future.strategy.old <- future::plan("list")
[10:56:21.533]                   options(future.plan = NULL)
[10:56:21.533]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.533]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.533]                 }
[10:56:21.533]                 ...future.workdir <- getwd()
[10:56:21.533]             }
[10:56:21.533]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.533]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.533]         }
[10:56:21.533]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.533]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.533]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.533]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.533]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.533]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.533]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.533]             base::names(...future.oldOptions))
[10:56:21.533]     }
[10:56:21.533]     if (FALSE) {
[10:56:21.533]     }
[10:56:21.533]     else {
[10:56:21.533]         if (TRUE) {
[10:56:21.533]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.533]                 open = "w")
[10:56:21.533]         }
[10:56:21.533]         else {
[10:56:21.533]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.533]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.533]         }
[10:56:21.533]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.533]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.533]             base::sink(type = "output", split = FALSE)
[10:56:21.533]             base::close(...future.stdout)
[10:56:21.533]         }, add = TRUE)
[10:56:21.533]     }
[10:56:21.533]     ...future.frame <- base::sys.nframe()
[10:56:21.533]     ...future.conditions <- base::list()
[10:56:21.533]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.533]     if (FALSE) {
[10:56:21.533]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.533]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.533]     }
[10:56:21.533]     ...future.result <- base::tryCatch({
[10:56:21.533]         base::withCallingHandlers({
[10:56:21.533]             ...future.value <- base::withVisible(base::local({
[10:56:21.533]                 stop("Whoops!")
[10:56:21.533]                 1
[10:56:21.533]             }))
[10:56:21.533]             future::FutureResult(value = ...future.value$value, 
[10:56:21.533]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.533]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.533]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.533]                     ...future.globalenv.names))
[10:56:21.533]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.533]         }, condition = base::local({
[10:56:21.533]             c <- base::c
[10:56:21.533]             inherits <- base::inherits
[10:56:21.533]             invokeRestart <- base::invokeRestart
[10:56:21.533]             length <- base::length
[10:56:21.533]             list <- base::list
[10:56:21.533]             seq.int <- base::seq.int
[10:56:21.533]             signalCondition <- base::signalCondition
[10:56:21.533]             sys.calls <- base::sys.calls
[10:56:21.533]             `[[` <- base::`[[`
[10:56:21.533]             `+` <- base::`+`
[10:56:21.533]             `<<-` <- base::`<<-`
[10:56:21.533]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.533]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.533]                   3L)]
[10:56:21.533]             }
[10:56:21.533]             function(cond) {
[10:56:21.533]                 is_error <- inherits(cond, "error")
[10:56:21.533]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.533]                   NULL)
[10:56:21.533]                 if (is_error) {
[10:56:21.533]                   sessionInformation <- function() {
[10:56:21.533]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.533]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.533]                       search = base::search(), system = base::Sys.info())
[10:56:21.533]                   }
[10:56:21.533]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.533]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.533]                     cond$call), session = sessionInformation(), 
[10:56:21.533]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.533]                   signalCondition(cond)
[10:56:21.533]                 }
[10:56:21.533]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.533]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.533]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.533]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.533]                   if (FALSE && !signal) {
[10:56:21.533]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.533]                     {
[10:56:21.533]                       inherits <- base::inherits
[10:56:21.533]                       invokeRestart <- base::invokeRestart
[10:56:21.533]                       is.null <- base::is.null
[10:56:21.533]                       muffled <- FALSE
[10:56:21.533]                       if (inherits(cond, "message")) {
[10:56:21.533]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.533]                         if (muffled) 
[10:56:21.533]                           invokeRestart("muffleMessage")
[10:56:21.533]                       }
[10:56:21.533]                       else if (inherits(cond, "warning")) {
[10:56:21.533]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.533]                         if (muffled) 
[10:56:21.533]                           invokeRestart("muffleWarning")
[10:56:21.533]                       }
[10:56:21.533]                       else if (inherits(cond, "condition")) {
[10:56:21.533]                         if (!is.null(pattern)) {
[10:56:21.533]                           computeRestarts <- base::computeRestarts
[10:56:21.533]                           grepl <- base::grepl
[10:56:21.533]                           restarts <- computeRestarts(cond)
[10:56:21.533]                           for (restart in restarts) {
[10:56:21.533]                             name <- restart$name
[10:56:21.533]                             if (is.null(name)) 
[10:56:21.533]                               next
[10:56:21.533]                             if (!grepl(pattern, name)) 
[10:56:21.533]                               next
[10:56:21.533]                             invokeRestart(restart)
[10:56:21.533]                             muffled <- TRUE
[10:56:21.533]                             break
[10:56:21.533]                           }
[10:56:21.533]                         }
[10:56:21.533]                       }
[10:56:21.533]                       invisible(muffled)
[10:56:21.533]                     }
[10:56:21.533]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.533]                   }
[10:56:21.533]                 }
[10:56:21.533]                 else {
[10:56:21.533]                   if (TRUE) {
[10:56:21.533]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.533]                     {
[10:56:21.533]                       inherits <- base::inherits
[10:56:21.533]                       invokeRestart <- base::invokeRestart
[10:56:21.533]                       is.null <- base::is.null
[10:56:21.533]                       muffled <- FALSE
[10:56:21.533]                       if (inherits(cond, "message")) {
[10:56:21.533]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.533]                         if (muffled) 
[10:56:21.533]                           invokeRestart("muffleMessage")
[10:56:21.533]                       }
[10:56:21.533]                       else if (inherits(cond, "warning")) {
[10:56:21.533]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.533]                         if (muffled) 
[10:56:21.533]                           invokeRestart("muffleWarning")
[10:56:21.533]                       }
[10:56:21.533]                       else if (inherits(cond, "condition")) {
[10:56:21.533]                         if (!is.null(pattern)) {
[10:56:21.533]                           computeRestarts <- base::computeRestarts
[10:56:21.533]                           grepl <- base::grepl
[10:56:21.533]                           restarts <- computeRestarts(cond)
[10:56:21.533]                           for (restart in restarts) {
[10:56:21.533]                             name <- restart$name
[10:56:21.533]                             if (is.null(name)) 
[10:56:21.533]                               next
[10:56:21.533]                             if (!grepl(pattern, name)) 
[10:56:21.533]                               next
[10:56:21.533]                             invokeRestart(restart)
[10:56:21.533]                             muffled <- TRUE
[10:56:21.533]                             break
[10:56:21.533]                           }
[10:56:21.533]                         }
[10:56:21.533]                       }
[10:56:21.533]                       invisible(muffled)
[10:56:21.533]                     }
[10:56:21.533]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.533]                   }
[10:56:21.533]                 }
[10:56:21.533]             }
[10:56:21.533]         }))
[10:56:21.533]     }, error = function(ex) {
[10:56:21.533]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.533]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.533]                 ...future.rng), started = ...future.startTime, 
[10:56:21.533]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.533]             version = "1.8"), class = "FutureResult")
[10:56:21.533]     }, finally = {
[10:56:21.533]         if (!identical(...future.workdir, getwd())) 
[10:56:21.533]             setwd(...future.workdir)
[10:56:21.533]         {
[10:56:21.533]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.533]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.533]             }
[10:56:21.533]             base::options(...future.oldOptions)
[10:56:21.533]             if (.Platform$OS.type == "windows") {
[10:56:21.533]                 old_names <- names(...future.oldEnvVars)
[10:56:21.533]                 envs <- base::Sys.getenv()
[10:56:21.533]                 names <- names(envs)
[10:56:21.533]                 common <- intersect(names, old_names)
[10:56:21.533]                 added <- setdiff(names, old_names)
[10:56:21.533]                 removed <- setdiff(old_names, names)
[10:56:21.533]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.533]                   envs[common]]
[10:56:21.533]                 NAMES <- toupper(changed)
[10:56:21.533]                 args <- list()
[10:56:21.533]                 for (kk in seq_along(NAMES)) {
[10:56:21.533]                   name <- changed[[kk]]
[10:56:21.533]                   NAME <- NAMES[[kk]]
[10:56:21.533]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.533]                     next
[10:56:21.533]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.533]                 }
[10:56:21.533]                 NAMES <- toupper(added)
[10:56:21.533]                 for (kk in seq_along(NAMES)) {
[10:56:21.533]                   name <- added[[kk]]
[10:56:21.533]                   NAME <- NAMES[[kk]]
[10:56:21.533]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.533]                     next
[10:56:21.533]                   args[[name]] <- ""
[10:56:21.533]                 }
[10:56:21.533]                 NAMES <- toupper(removed)
[10:56:21.533]                 for (kk in seq_along(NAMES)) {
[10:56:21.533]                   name <- removed[[kk]]
[10:56:21.533]                   NAME <- NAMES[[kk]]
[10:56:21.533]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.533]                     next
[10:56:21.533]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.533]                 }
[10:56:21.533]                 if (length(args) > 0) 
[10:56:21.533]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.533]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.533]             }
[10:56:21.533]             else {
[10:56:21.533]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.533]             }
[10:56:21.533]             {
[10:56:21.533]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.533]                   0L) {
[10:56:21.533]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.533]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.533]                   base::options(opts)
[10:56:21.533]                 }
[10:56:21.533]                 {
[10:56:21.533]                   NULL
[10:56:21.533]                   options(future.plan = NULL)
[10:56:21.533]                   if (is.na(NA_character_)) 
[10:56:21.533]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.533]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.533]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.533]                     .init = FALSE)
[10:56:21.533]                 }
[10:56:21.533]             }
[10:56:21.533]         }
[10:56:21.533]     })
[10:56:21.533]     if (TRUE) {
[10:56:21.533]         base::sink(type = "output", split = FALSE)
[10:56:21.533]         if (TRUE) {
[10:56:21.533]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.533]         }
[10:56:21.533]         else {
[10:56:21.533]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.533]         }
[10:56:21.533]         base::close(...future.stdout)
[10:56:21.533]         ...future.stdout <- NULL
[10:56:21.533]     }
[10:56:21.533]     ...future.result$conditions <- ...future.conditions
[10:56:21.533]     ...future.result$finished <- base::Sys.time()
[10:56:21.533]     ...future.result
[10:56:21.533] }
MiraiFuture:
Label: '<none>'
Expression:
{
    stop("Whoops!")
    1
}
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)
[10:56:21.537] resolved() for 'MiraiFuture' ...
[10:56:21.537] - state: 'running'
[10:56:21.538] - run: TRUE
[10:56:21.538] - result: 'NULL'
[10:56:21.538] - resolved: FALSE
[10:56:21.538] resolved() for 'MiraiFuture' ... done
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 73cff85d-f0c3-d79d-6a2d-a22fd2dfb2cd
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:56:21.539] signalConditions() ...
[10:56:21.539]  - include = 'immediateCondition'
[10:56:21.540]  - exclude = 
[10:56:21.540]  - resignal = FALSE
[10:56:21.540]  - Number of conditions: 1
[10:56:21.540] signalConditions() ... done
<simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
[10:56:21.540] signalConditions() ...
[10:56:21.541]  - include = 'immediateCondition'
[10:56:21.541]  - exclude = 
[10:56:21.541]  - resignal = FALSE
[10:56:21.541]  - Number of conditions: 1
[10:56:21.541] signalConditions() ... done
[10:56:21.542] Future state: 'finished'
[10:56:21.542] signalConditions() ...
[10:56:21.542]  - include = 'condition'
[10:56:21.542]  - exclude = 'immediateCondition'
[10:56:21.542]  - resignal = TRUE
[10:56:21.542]  - Number of conditions: 1
[10:56:21.543]  - Condition #1: 'simpleError', 'error', 'condition'
[10:56:21.543] signalConditions() ... done
<simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
[10:56:21.543] signalConditions() ...
[10:56:21.543]  - include = 'immediateCondition'
[10:56:21.544]  - exclude = 
[10:56:21.544]  - resignal = FALSE
[10:56:21.544]  - Number of conditions: 1
[10:56:21.544] signalConditions() ... done
[10:56:21.544] Future state: 'finished'
[10:56:21.544] signalConditions() ...
[10:56:21.545]  - include = 'condition'
[10:56:21.545]  - exclude = 'immediateCondition'
[10:56:21.545]  - resignal = TRUE
[10:56:21.545]  - Number of conditions: 1
[10:56:21.545]  - Condition #1: 'simpleError', 'error', 'condition'
[10:56:21.546] signalConditions() ... done
<simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
*** mirai_multisession(..., workers = 1L) ...
[10:56:21.546] getGlobalsAndPackages() ...
[10:56:21.546] Searching for globals...
[10:56:21.547] - globals found: [4] '{', '*', 'a', 'b'
[10:56:21.547] Searching for globals ... DONE
[10:56:21.548] Resolving globals: FALSE
[10:56:21.548] The total size of the 2 globals is 112 bytes (112 bytes)
[10:56:21.549] The total size of the 2 globals exported for future expression ('{; a * b; }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'a' (56 bytes of class 'numeric') and 'b' (56 bytes of class 'numeric')
[10:56:21.549] - globals: [2] 'a', 'b'
[10:56:21.549] 
[10:56:21.549] getGlobalsAndPackages() ... DONE
[10:56:21.550] getGlobalsAndPackages() ...
[10:56:21.550] - globals passed as-is: [2] 'a', 'b'
[10:56:21.550] Resolving globals: FALSE
[10:56:21.550] - globals: [2] 'a', 'b'
[10:56:21.550] 
[10:56:21.551] getGlobalsAndPackages() ... DONE
[10:56:21.551] Packages needed by the future expression (n = 0): <none>
[10:56:21.551] Packages needed by future strategies (n = 0): <none>
[10:56:21.552] {
[10:56:21.552]     {
[10:56:21.552]         {
[10:56:21.552]             ...future.startTime <- base::Sys.time()
[10:56:21.552]             {
[10:56:21.552]                 {
[10:56:21.552]                   {
[10:56:21.552]                     base::local({
[10:56:21.552]                       has_future <- base::requireNamespace("future", 
[10:56:21.552]                         quietly = TRUE)
[10:56:21.552]                       if (has_future) {
[10:56:21.552]                         ns <- base::getNamespace("future")
[10:56:21.552]                         version <- ns[[".package"]][["version"]]
[10:56:21.552]                         if (is.null(version)) 
[10:56:21.552]                           version <- utils::packageVersion("future")
[10:56:21.552]                       }
[10:56:21.552]                       else {
[10:56:21.552]                         version <- NULL
[10:56:21.552]                       }
[10:56:21.552]                       if (!has_future || version < "1.8.0") {
[10:56:21.552]                         info <- base::c(r_version = base::gsub("R version ", 
[10:56:21.552]                           "", base::R.version$version.string), 
[10:56:21.552]                           platform = base::sprintf("%s (%s-bit)", 
[10:56:21.552]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:56:21.552]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:56:21.552]                             "release", "version")], collapse = " "), 
[10:56:21.552]                           hostname = base::Sys.info()[["nodename"]])
[10:56:21.552]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:56:21.552]                           info)
[10:56:21.552]                         info <- base::paste(info, collapse = "; ")
[10:56:21.552]                         if (!has_future) {
[10:56:21.552]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:56:21.552]                             info)
[10:56:21.552]                         }
[10:56:21.552]                         else {
[10:56:21.552]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:56:21.552]                             info, version)
[10:56:21.552]                         }
[10:56:21.552]                         base::stop(msg)
[10:56:21.552]                       }
[10:56:21.552]                     })
[10:56:21.552]                   }
[10:56:21.552]                   ...future.strategy.old <- future::plan("list")
[10:56:21.552]                   options(future.plan = NULL)
[10:56:21.552]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.552]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:56:21.552]                 }
[10:56:21.552]                 ...future.workdir <- getwd()
[10:56:21.552]             }
[10:56:21.552]             ...future.oldOptions <- base::as.list(base::.Options)
[10:56:21.552]             ...future.oldEnvVars <- base::Sys.getenv()
[10:56:21.552]         }
[10:56:21.552]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:56:21.552]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:56:21.552]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:56:21.552]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:56:21.552]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:56:21.552]             future.stdout.windows.reencode = NULL, width = 80L)
[10:56:21.552]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:56:21.552]             base::names(...future.oldOptions))
[10:56:21.552]     }
[10:56:21.552]     if (FALSE) {
[10:56:21.552]     }
[10:56:21.552]     else {
[10:56:21.552]         if (TRUE) {
[10:56:21.552]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:56:21.552]                 open = "w")
[10:56:21.552]         }
[10:56:21.552]         else {
[10:56:21.552]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:56:21.552]                 windows = "NUL", "/dev/null"), open = "w")
[10:56:21.552]         }
[10:56:21.552]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:56:21.552]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:56:21.552]             base::sink(type = "output", split = FALSE)
[10:56:21.552]             base::close(...future.stdout)
[10:56:21.552]         }, add = TRUE)
[10:56:21.552]     }
[10:56:21.552]     ...future.frame <- base::sys.nframe()
[10:56:21.552]     ...future.conditions <- base::list()
[10:56:21.552]     ...future.rng <- base::globalenv()$.Random.seed
[10:56:21.552]     if (FALSE) {
[10:56:21.552]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:56:21.552]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:56:21.552]     }
[10:56:21.552]     ...future.result <- base::tryCatch({
[10:56:21.552]         base::withCallingHandlers({
[10:56:21.552]             ...future.value <- base::withVisible(base::local({
[10:56:21.552]                 a * b
[10:56:21.552]             }))
[10:56:21.552]             future::FutureResult(value = ...future.value$value, 
[10:56:21.552]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.552]                   ...future.rng), globalenv = if (FALSE) 
[10:56:21.552]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:56:21.552]                     ...future.globalenv.names))
[10:56:21.552]                 else NULL, started = ...future.startTime, version = "1.8")
[10:56:21.552]         }, condition = base::local({
[10:56:21.552]             c <- base::c
[10:56:21.552]             inherits <- base::inherits
[10:56:21.552]             invokeRestart <- base::invokeRestart
[10:56:21.552]             length <- base::length
[10:56:21.552]             list <- base::list
[10:56:21.552]             seq.int <- base::seq.int
[10:56:21.552]             signalCondition <- base::signalCondition
[10:56:21.552]             sys.calls <- base::sys.calls
[10:56:21.552]             `[[` <- base::`[[`
[10:56:21.552]             `+` <- base::`+`
[10:56:21.552]             `<<-` <- base::`<<-`
[10:56:21.552]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:56:21.552]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:56:21.552]                   3L)]
[10:56:21.552]             }
[10:56:21.552]             function(cond) {
[10:56:21.552]                 is_error <- inherits(cond, "error")
[10:56:21.552]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:56:21.552]                   NULL)
[10:56:21.552]                 if (is_error) {
[10:56:21.552]                   sessionInformation <- function() {
[10:56:21.552]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:56:21.552]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:56:21.552]                       search = base::search(), system = base::Sys.info())
[10:56:21.552]                   }
[10:56:21.552]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.552]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:56:21.552]                     cond$call), session = sessionInformation(), 
[10:56:21.552]                     timestamp = base::Sys.time(), signaled = 0L)
[10:56:21.552]                   signalCondition(cond)
[10:56:21.552]                 }
[10:56:21.552]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:56:21.552]                   signal <- FALSE && inherits(cond, character(0))
[10:56:21.552]                   ...future.conditions[[length(...future.conditions) + 
[10:56:21.552]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:56:21.552]                   if (FALSE && !signal) {
[10:56:21.552]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.552]                     {
[10:56:21.552]                       inherits <- base::inherits
[10:56:21.552]                       invokeRestart <- base::invokeRestart
[10:56:21.552]                       is.null <- base::is.null
[10:56:21.552]                       muffled <- FALSE
[10:56:21.552]                       if (inherits(cond, "message")) {
[10:56:21.552]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.552]                         if (muffled) 
[10:56:21.552]                           invokeRestart("muffleMessage")
[10:56:21.552]                       }
[10:56:21.552]                       else if (inherits(cond, "warning")) {
[10:56:21.552]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.552]                         if (muffled) 
[10:56:21.552]                           invokeRestart("muffleWarning")
[10:56:21.552]                       }
[10:56:21.552]                       else if (inherits(cond, "condition")) {
[10:56:21.552]                         if (!is.null(pattern)) {
[10:56:21.552]                           computeRestarts <- base::computeRestarts
[10:56:21.552]                           grepl <- base::grepl
[10:56:21.552]                           restarts <- computeRestarts(cond)
[10:56:21.552]                           for (restart in restarts) {
[10:56:21.552]                             name <- restart$name
[10:56:21.552]                             if (is.null(name)) 
[10:56:21.552]                               next
[10:56:21.552]                             if (!grepl(pattern, name)) 
[10:56:21.552]                               next
[10:56:21.552]                             invokeRestart(restart)
[10:56:21.552]                             muffled <- TRUE
[10:56:21.552]                             break
[10:56:21.552]                           }
[10:56:21.552]                         }
[10:56:21.552]                       }
[10:56:21.552]                       invisible(muffled)
[10:56:21.552]                     }
[10:56:21.552]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.552]                   }
[10:56:21.552]                 }
[10:56:21.552]                 else {
[10:56:21.552]                   if (TRUE) {
[10:56:21.552]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:56:21.552]                     {
[10:56:21.552]                       inherits <- base::inherits
[10:56:21.552]                       invokeRestart <- base::invokeRestart
[10:56:21.552]                       is.null <- base::is.null
[10:56:21.552]                       muffled <- FALSE
[10:56:21.552]                       if (inherits(cond, "message")) {
[10:56:21.552]                         muffled <- grepl(pattern, "muffleMessage")
[10:56:21.552]                         if (muffled) 
[10:56:21.552]                           invokeRestart("muffleMessage")
[10:56:21.552]                       }
[10:56:21.552]                       else if (inherits(cond, "warning")) {
[10:56:21.552]                         muffled <- grepl(pattern, "muffleWarning")
[10:56:21.552]                         if (muffled) 
[10:56:21.552]                           invokeRestart("muffleWarning")
[10:56:21.552]                       }
[10:56:21.552]                       else if (inherits(cond, "condition")) {
[10:56:21.552]                         if (!is.null(pattern)) {
[10:56:21.552]                           computeRestarts <- base::computeRestarts
[10:56:21.552]                           grepl <- base::grepl
[10:56:21.552]                           restarts <- computeRestarts(cond)
[10:56:21.552]                           for (restart in restarts) {
[10:56:21.552]                             name <- restart$name
[10:56:21.552]                             if (is.null(name)) 
[10:56:21.552]                               next
[10:56:21.552]                             if (!grepl(pattern, name)) 
[10:56:21.552]                               next
[10:56:21.552]                             invokeRestart(restart)
[10:56:21.552]                             muffled <- TRUE
[10:56:21.552]                             break
[10:56:21.552]                           }
[10:56:21.552]                         }
[10:56:21.552]                       }
[10:56:21.552]                       invisible(muffled)
[10:56:21.552]                     }
[10:56:21.552]                     muffleCondition(cond, pattern = "^muffle")
[10:56:21.552]                   }
[10:56:21.552]                 }
[10:56:21.552]             }
[10:56:21.552]         }))
[10:56:21.552]     }, error = function(ex) {
[10:56:21.552]         base::structure(base::list(value = NULL, visible = NULL, 
[10:56:21.552]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:56:21.552]                 ...future.rng), started = ...future.startTime, 
[10:56:21.552]             finished = Sys.time(), session_uuid = NA_character_, 
[10:56:21.552]             version = "1.8"), class = "FutureResult")
[10:56:21.552]     }, finally = {
[10:56:21.552]         if (!identical(...future.workdir, getwd())) 
[10:56:21.552]             setwd(...future.workdir)
[10:56:21.552]         {
[10:56:21.552]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:56:21.552]                 ...future.oldOptions$nwarnings <- NULL
[10:56:21.552]             }
[10:56:21.552]             base::options(...future.oldOptions)
[10:56:21.552]             if (.Platform$OS.type == "windows") {
[10:56:21.552]                 old_names <- names(...future.oldEnvVars)
[10:56:21.552]                 envs <- base::Sys.getenv()
[10:56:21.552]                 names <- names(envs)
[10:56:21.552]                 common <- intersect(names, old_names)
[10:56:21.552]                 added <- setdiff(names, old_names)
[10:56:21.552]                 removed <- setdiff(old_names, names)
[10:56:21.552]                 changed <- common[...future.oldEnvVars[common] != 
[10:56:21.552]                   envs[common]]
[10:56:21.552]                 NAMES <- toupper(changed)
[10:56:21.552]                 args <- list()
[10:56:21.552]                 for (kk in seq_along(NAMES)) {
[10:56:21.552]                   name <- changed[[kk]]
[10:56:21.552]                   NAME <- NAMES[[kk]]
[10:56:21.552]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.552]                     next
[10:56:21.552]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.552]                 }
[10:56:21.552]                 NAMES <- toupper(added)
[10:56:21.552]                 for (kk in seq_along(NAMES)) {
[10:56:21.552]                   name <- added[[kk]]
[10:56:21.552]                   NAME <- NAMES[[kk]]
[10:56:21.552]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.552]                     next
[10:56:21.552]                   args[[name]] <- ""
[10:56:21.552]                 }
[10:56:21.552]                 NAMES <- toupper(removed)
[10:56:21.552]                 for (kk in seq_along(NAMES)) {
[10:56:21.552]                   name <- removed[[kk]]
[10:56:21.552]                   NAME <- NAMES[[kk]]
[10:56:21.552]                   if (name != NAME && is.element(NAME, old_names)) 
[10:56:21.552]                     next
[10:56:21.552]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:56:21.552]                 }
[10:56:21.552]                 if (length(args) > 0) 
[10:56:21.552]                   base::do.call(base::Sys.setenv, args = args)
[10:56:21.552]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:56:21.552]             }
[10:56:21.552]             else {
[10:56:21.552]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:56:21.552]             }
[10:56:21.552]             {
[10:56:21.552]                 if (base::length(...future.futureOptionsAdded) > 
[10:56:21.552]                   0L) {
[10:56:21.552]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:56:21.552]                   base::names(opts) <- ...future.futureOptionsAdded
[10:56:21.552]                   base::options(opts)
[10:56:21.552]                 }
[10:56:21.552]                 {
[10:56:21.552]                   NULL
[10:56:21.552]                   options(future.plan = NULL)
[10:56:21.552]                   if (is.na(NA_character_)) 
[10:56:21.552]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:56:21.552]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:56:21.552]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:56:21.552]                     .init = FALSE)
[10:56:21.552]                 }
[10:56:21.552]             }
[10:56:21.552]         }
[10:56:21.552]     })
[10:56:21.552]     if (TRUE) {
[10:56:21.552]         base::sink(type = "output", split = FALSE)
[10:56:21.552]         if (TRUE) {
[10:56:21.552]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:56:21.552]         }
[10:56:21.552]         else {
[10:56:21.552]             ...future.result["stdout"] <- base::list(NULL)
[10:56:21.552]         }
[10:56:21.552]         base::close(...future.stdout)
[10:56:21.552]         ...future.stdout <- NULL
[10:56:21.552]     }
[10:56:21.552]     ...future.result$conditions <- ...future.conditions
[10:56:21.552]     ...future.result$finished <- base::Sys.time()
[10:56:21.552]     ...future.result
[10:56:21.552] }
[1] 6
*** mirai_multisession(..., workers = 1L) ... DONE
[10:56:21.558] Testing with 1 cores ... DONE> 
> message("*** mirai_multisession() ... DONE")
*** mirai_multisession() ... DONE
> 
> source("incl/end.R")
> 
> proc.time()
   user  system elapsed 
   0.56    0.10    1.29