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:55:42.114] plan(): Setting new future strategy stack:
[10:55:42.115] List of future strategies:
[10:55:42.115] 1. mirai_multisession:
[10:55:42.115]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
[10:55:42.115]    - tweaked: FALSE
[10:55:42.115]    - call: future::plan(future.mirai::mirai_multisession)
[10:55:42.127] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
[10:55:42.128] < mirai | $data >
[10:55:42.133] getGlobalsAndPackages() ...
[10:55:42.133] Not searching for globals
[10:55:42.133] - globals: [0] <none>
[10:55:42.133] getGlobalsAndPackages() ... DONE
[10:55:42.134] getGlobalsAndPackages() ...
[10:55:42.134] 
[10:55:42.134] - globals: [0] <none>
[10:55:42.134] getGlobalsAndPackages() ... DONE
[10:55:42.407] Packages needed by the future expression (n = 0): <none>
[10:55:42.407] Packages needed by future strategies (n = 0): <none>
[10:55:42.408] {
[10:55:42.408]     {
[10:55:42.408]         {
[10:55:42.408]             ...future.startTime <- base::Sys.time()
[10:55:42.408]             {
[10:55:42.408]                 {
[10:55:42.408]                   {
[10:55:42.408]                     base::local({
[10:55:42.408]                       has_future <- base::requireNamespace("future", 
[10:55:42.408]                         quietly = TRUE)
[10:55:42.408]                       if (has_future) {
[10:55:42.408]                         ns <- base::getNamespace("future")
[10:55:42.408]                         version <- ns[[".package"]][["version"]]
[10:55:42.408]                         if (is.null(version)) 
[10:55:42.408]                           version <- utils::packageVersion("future")
[10:55:42.408]                       }
[10:55:42.408]                       else {
[10:55:42.408]                         version <- NULL
[10:55:42.408]                       }
[10:55:42.408]                       if (!has_future || version < "1.8.0") {
[10:55:42.408]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.408]                           "", base::R.version$version.string), 
[10:55:42.408]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.408]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.408]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.408]                             "release", "version")], collapse = " "), 
[10:55:42.408]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.408]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.408]                           info)
[10:55:42.408]                         info <- base::paste(info, collapse = "; ")
[10:55:42.408]                         if (!has_future) {
[10:55:42.408]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.408]                             info)
[10:55:42.408]                         }
[10:55:42.408]                         else {
[10:55:42.408]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.408]                             info, version)
[10:55:42.408]                         }
[10:55:42.408]                         base::stop(msg)
[10:55:42.408]                       }
[10:55:42.408]                     })
[10:55:42.408]                   }
[10:55:42.408]                   ...future.strategy.old <- future::plan("list")
[10:55:42.408]                   options(future.plan = NULL)
[10:55:42.408]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.408]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.408]                 }
[10:55:42.408]                 ...future.workdir <- getwd()
[10:55:42.408]             }
[10:55:42.408]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.408]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.408]         }
[10:55:42.408]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.408]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.408]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.408]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.408]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.408]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.408]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.408]             base::names(...future.oldOptions))
[10:55:42.408]     }
[10:55:42.408]     if (FALSE) {
[10:55:42.408]     }
[10:55:42.408]     else {
[10:55:42.408]         if (TRUE) {
[10:55:42.408]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.408]                 open = "w")
[10:55:42.408]         }
[10:55:42.408]         else {
[10:55:42.408]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.408]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.408]         }
[10:55:42.408]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.408]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.408]             base::sink(type = "output", split = FALSE)
[10:55:42.408]             base::close(...future.stdout)
[10:55:42.408]         }, add = TRUE)
[10:55:42.408]     }
[10:55:42.408]     ...future.frame <- base::sys.nframe()
[10:55:42.408]     ...future.conditions <- base::list()
[10:55:42.408]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.408]     if (FALSE) {
[10:55:42.408]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.408]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.408]     }
[10:55:42.408]     ...future.result <- base::tryCatch({
[10:55:42.408]         base::withCallingHandlers({
[10:55:42.408]             ...future.value <- base::withVisible(base::local(NA))
[10:55:42.408]             future::FutureResult(value = ...future.value$value, 
[10:55:42.408]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.408]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.408]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.408]                     ...future.globalenv.names))
[10:55:42.408]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.408]         }, condition = base::local({
[10:55:42.408]             c <- base::c
[10:55:42.408]             inherits <- base::inherits
[10:55:42.408]             invokeRestart <- base::invokeRestart
[10:55:42.408]             length <- base::length
[10:55:42.408]             list <- base::list
[10:55:42.408]             seq.int <- base::seq.int
[10:55:42.408]             signalCondition <- base::signalCondition
[10:55:42.408]             sys.calls <- base::sys.calls
[10:55:42.408]             `[[` <- base::`[[`
[10:55:42.408]             `+` <- base::`+`
[10:55:42.408]             `<<-` <- base::`<<-`
[10:55:42.408]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.408]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.408]                   3L)]
[10:55:42.408]             }
[10:55:42.408]             function(cond) {
[10:55:42.408]                 is_error <- inherits(cond, "error")
[10:55:42.408]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.408]                   NULL)
[10:55:42.408]                 if (is_error) {
[10:55:42.408]                   sessionInformation <- function() {
[10:55:42.408]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.408]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.408]                       search = base::search(), system = base::Sys.info())
[10:55:42.408]                   }
[10:55:42.408]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.408]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.408]                     cond$call), session = sessionInformation(), 
[10:55:42.408]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.408]                   signalCondition(cond)
[10:55:42.408]                 }
[10:55:42.408]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.408]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.408]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.408]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.408]                   if (FALSE && !signal) {
[10:55:42.408]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.408]                     {
[10:55:42.408]                       inherits <- base::inherits
[10:55:42.408]                       invokeRestart <- base::invokeRestart
[10:55:42.408]                       is.null <- base::is.null
[10:55:42.408]                       muffled <- FALSE
[10:55:42.408]                       if (inherits(cond, "message")) {
[10:55:42.408]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.408]                         if (muffled) 
[10:55:42.408]                           invokeRestart("muffleMessage")
[10:55:42.408]                       }
[10:55:42.408]                       else if (inherits(cond, "warning")) {
[10:55:42.408]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.408]                         if (muffled) 
[10:55:42.408]                           invokeRestart("muffleWarning")
[10:55:42.408]                       }
[10:55:42.408]                       else if (inherits(cond, "condition")) {
[10:55:42.408]                         if (!is.null(pattern)) {
[10:55:42.408]                           computeRestarts <- base::computeRestarts
[10:55:42.408]                           grepl <- base::grepl
[10:55:42.408]                           restarts <- computeRestarts(cond)
[10:55:42.408]                           for (restart in restarts) {
[10:55:42.408]                             name <- restart$name
[10:55:42.408]                             if (is.null(name)) 
[10:55:42.408]                               next
[10:55:42.408]                             if (!grepl(pattern, name)) 
[10:55:42.408]                               next
[10:55:42.408]                             invokeRestart(restart)
[10:55:42.408]                             muffled <- TRUE
[10:55:42.408]                             break
[10:55:42.408]                           }
[10:55:42.408]                         }
[10:55:42.408]                       }
[10:55:42.408]                       invisible(muffled)
[10:55:42.408]                     }
[10:55:42.408]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.408]                   }
[10:55:42.408]                 }
[10:55:42.408]                 else {
[10:55:42.408]                   if (TRUE) {
[10:55:42.408]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.408]                     {
[10:55:42.408]                       inherits <- base::inherits
[10:55:42.408]                       invokeRestart <- base::invokeRestart
[10:55:42.408]                       is.null <- base::is.null
[10:55:42.408]                       muffled <- FALSE
[10:55:42.408]                       if (inherits(cond, "message")) {
[10:55:42.408]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.408]                         if (muffled) 
[10:55:42.408]                           invokeRestart("muffleMessage")
[10:55:42.408]                       }
[10:55:42.408]                       else if (inherits(cond, "warning")) {
[10:55:42.408]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.408]                         if (muffled) 
[10:55:42.408]                           invokeRestart("muffleWarning")
[10:55:42.408]                       }
[10:55:42.408]                       else if (inherits(cond, "condition")) {
[10:55:42.408]                         if (!is.null(pattern)) {
[10:55:42.408]                           computeRestarts <- base::computeRestarts
[10:55:42.408]                           grepl <- base::grepl
[10:55:42.408]                           restarts <- computeRestarts(cond)
[10:55:42.408]                           for (restart in restarts) {
[10:55:42.408]                             name <- restart$name
[10:55:42.408]                             if (is.null(name)) 
[10:55:42.408]                               next
[10:55:42.408]                             if (!grepl(pattern, name)) 
[10:55:42.408]                               next
[10:55:42.408]                             invokeRestart(restart)
[10:55:42.408]                             muffled <- TRUE
[10:55:42.408]                             break
[10:55:42.408]                           }
[10:55:42.408]                         }
[10:55:42.408]                       }
[10:55:42.408]                       invisible(muffled)
[10:55:42.408]                     }
[10:55:42.408]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.408]                   }
[10:55:42.408]                 }
[10:55:42.408]             }
[10:55:42.408]         }))
[10:55:42.408]     }, error = function(ex) {
[10:55:42.408]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.408]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.408]                 ...future.rng), started = ...future.startTime, 
[10:55:42.408]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.408]             version = "1.8"), class = "FutureResult")
[10:55:42.408]     }, finally = {
[10:55:42.408]         if (!identical(...future.workdir, getwd())) 
[10:55:42.408]             setwd(...future.workdir)
[10:55:42.408]         {
[10:55:42.408]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.408]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.408]             }
[10:55:42.408]             base::options(...future.oldOptions)
[10:55:42.408]             if (.Platform$OS.type == "windows") {
[10:55:42.408]                 old_names <- names(...future.oldEnvVars)
[10:55:42.408]                 envs <- base::Sys.getenv()
[10:55:42.408]                 names <- names(envs)
[10:55:42.408]                 common <- intersect(names, old_names)
[10:55:42.408]                 added <- setdiff(names, old_names)
[10:55:42.408]                 removed <- setdiff(old_names, names)
[10:55:42.408]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.408]                   envs[common]]
[10:55:42.408]                 NAMES <- toupper(changed)
[10:55:42.408]                 args <- list()
[10:55:42.408]                 for (kk in seq_along(NAMES)) {
[10:55:42.408]                   name <- changed[[kk]]
[10:55:42.408]                   NAME <- NAMES[[kk]]
[10:55:42.408]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.408]                     next
[10:55:42.408]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.408]                 }
[10:55:42.408]                 NAMES <- toupper(added)
[10:55:42.408]                 for (kk in seq_along(NAMES)) {
[10:55:42.408]                   name <- added[[kk]]
[10:55:42.408]                   NAME <- NAMES[[kk]]
[10:55:42.408]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.408]                     next
[10:55:42.408]                   args[[name]] <- ""
[10:55:42.408]                 }
[10:55:42.408]                 NAMES <- toupper(removed)
[10:55:42.408]                 for (kk in seq_along(NAMES)) {
[10:55:42.408]                   name <- removed[[kk]]
[10:55:42.408]                   NAME <- NAMES[[kk]]
[10:55:42.408]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.408]                     next
[10:55:42.408]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.408]                 }
[10:55:42.408]                 if (length(args) > 0) 
[10:55:42.408]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.408]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.408]             }
[10:55:42.408]             else {
[10:55:42.408]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.408]             }
[10:55:42.408]             {
[10:55:42.408]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.408]                   0L) {
[10:55:42.408]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.408]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.408]                   base::options(opts)
[10:55:42.408]                 }
[10:55:42.408]                 {
[10:55:42.408]                   NULL
[10:55:42.408]                   options(future.plan = NULL)
[10:55:42.408]                   if (is.na(NA_character_)) 
[10:55:42.408]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.408]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.408]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.408]                     .init = FALSE)
[10:55:42.408]                 }
[10:55:42.408]             }
[10:55:42.408]         }
[10:55:42.408]     })
[10:55:42.408]     if (TRUE) {
[10:55:42.408]         base::sink(type = "output", split = FALSE)
[10:55:42.408]         if (TRUE) {
[10:55:42.408]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.408]         }
[10:55:42.408]         else {
[10:55:42.408]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.408]         }
[10:55:42.408]         base::close(...future.stdout)
[10:55:42.408]         ...future.stdout <- NULL
[10:55:42.408]     }
[10:55:42.408]     ...future.result$conditions <- ...future.conditions
[10:55:42.408]     ...future.result$finished <- base::Sys.time()
[10:55:42.408]     ...future.result
[10:55:42.408] }
[10:55:42.518] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ... DONE
[10:55:42.519] plan(): nbrOfWorkers() = 2
> 
> message("*** Futures - labels ...")
*** Futures - labels ...
> 
> strategies <- c("mirai_cluster", "mirai_multisession")
> 
> for (strategy in strategies) {
+   mprintf("- plan('%s') ...", strategy)
+   plan(strategy)
+ 
+   for (label in list(NULL, sprintf("strategy_%s", strategy))) {
+     fcn <- get(strategy, mode = "function")
+     stopifnot(inherits(fcn, strategy))
+     f <- fcn(42, label = label)
+     print(f)
+     stopifnot(identical(f$label, label))
+     v <- value(f)
+     stopifnot(v == 42)
+ 
+     f <- future(42, label = label)
+     print(f)
+     stopifnot(identical(f$label, label))
+     v <- value(f)
+     stopifnot(v == 42)
+ 
+     v %<-% { 42 } %label% label
+     f <- futureOf(v)
+     print(f)
+     stopifnot(identical(f$label, label))
+     stopifnot(v == 42)
+ 
+   } ## for (label ...)
+ 
+   mprintf("- plan('%s') ... DONE", strategy)
+ } ## for (strategy ...)
[10:55:42.554] - plan('mirai_cluster') ...[10:55:42.555] plan(): Setting new future strategy stack:
[10:55:42.556] List of future strategies:
[10:55:42.556] 1. mirai_cluster:
[10:55:42.556]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = "<NULL>")
[10:55:42.556]    - tweaked: FALSE
[10:55:42.556]    - call: plan(strategy)
[10:55:42.589] plan(): plan_init() of 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
[10:55:42.590] < mirai | $data >
[10:55:42.590] getGlobalsAndPackages() ...
[10:55:42.590] Not searching for globals
[10:55:42.591] - globals: [0] <none>
[10:55:42.591] getGlobalsAndPackages() ... DONE
[10:55:42.591] getGlobalsAndPackages() ...
[10:55:42.591] 
[10:55:42.592] - globals: [0] <none>
[10:55:42.592] getGlobalsAndPackages() ... DONE
[10:55:42.592] Packages needed by the future expression (n = 0): <none>
[10:55:42.593] Packages needed by future strategies (n = 0): <none>
[10:55:42.594] {
[10:55:42.594]     {
[10:55:42.594]         {
[10:55:42.594]             ...future.startTime <- base::Sys.time()
[10:55:42.594]             {
[10:55:42.594]                 {
[10:55:42.594]                   {
[10:55:42.594]                     base::local({
[10:55:42.594]                       has_future <- base::requireNamespace("future", 
[10:55:42.594]                         quietly = TRUE)
[10:55:42.594]                       if (has_future) {
[10:55:42.594]                         ns <- base::getNamespace("future")
[10:55:42.594]                         version <- ns[[".package"]][["version"]]
[10:55:42.594]                         if (is.null(version)) 
[10:55:42.594]                           version <- utils::packageVersion("future")
[10:55:42.594]                       }
[10:55:42.594]                       else {
[10:55:42.594]                         version <- NULL
[10:55:42.594]                       }
[10:55:42.594]                       if (!has_future || version < "1.8.0") {
[10:55:42.594]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.594]                           "", base::R.version$version.string), 
[10:55:42.594]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.594]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.594]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.594]                             "release", "version")], collapse = " "), 
[10:55:42.594]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.594]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.594]                           info)
[10:55:42.594]                         info <- base::paste(info, collapse = "; ")
[10:55:42.594]                         if (!has_future) {
[10:55:42.594]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.594]                             info)
[10:55:42.594]                         }
[10:55:42.594]                         else {
[10:55:42.594]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.594]                             info, version)
[10:55:42.594]                         }
[10:55:42.594]                         base::stop(msg)
[10:55:42.594]                       }
[10:55:42.594]                     })
[10:55:42.594]                   }
[10:55:42.594]                   ...future.strategy.old <- future::plan("list")
[10:55:42.594]                   options(future.plan = NULL)
[10:55:42.594]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.594]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.594]                 }
[10:55:42.594]                 ...future.workdir <- getwd()
[10:55:42.594]             }
[10:55:42.594]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.594]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.594]         }
[10:55:42.594]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.594]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.594]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.594]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.594]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.594]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.594]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.594]             base::names(...future.oldOptions))
[10:55:42.594]     }
[10:55:42.594]     if (FALSE) {
[10:55:42.594]     }
[10:55:42.594]     else {
[10:55:42.594]         if (TRUE) {
[10:55:42.594]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.594]                 open = "w")
[10:55:42.594]         }
[10:55:42.594]         else {
[10:55:42.594]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.594]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.594]         }
[10:55:42.594]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.594]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.594]             base::sink(type = "output", split = FALSE)
[10:55:42.594]             base::close(...future.stdout)
[10:55:42.594]         }, add = TRUE)
[10:55:42.594]     }
[10:55:42.594]     ...future.frame <- base::sys.nframe()
[10:55:42.594]     ...future.conditions <- base::list()
[10:55:42.594]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.594]     if (FALSE) {
[10:55:42.594]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.594]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.594]     }
[10:55:42.594]     ...future.result <- base::tryCatch({
[10:55:42.594]         base::withCallingHandlers({
[10:55:42.594]             ...future.value <- base::withVisible(base::local(NA))
[10:55:42.594]             future::FutureResult(value = ...future.value$value, 
[10:55:42.594]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.594]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.594]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.594]                     ...future.globalenv.names))
[10:55:42.594]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.594]         }, condition = base::local({
[10:55:42.594]             c <- base::c
[10:55:42.594]             inherits <- base::inherits
[10:55:42.594]             invokeRestart <- base::invokeRestart
[10:55:42.594]             length <- base::length
[10:55:42.594]             list <- base::list
[10:55:42.594]             seq.int <- base::seq.int
[10:55:42.594]             signalCondition <- base::signalCondition
[10:55:42.594]             sys.calls <- base::sys.calls
[10:55:42.594]             `[[` <- base::`[[`
[10:55:42.594]             `+` <- base::`+`
[10:55:42.594]             `<<-` <- base::`<<-`
[10:55:42.594]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.594]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.594]                   3L)]
[10:55:42.594]             }
[10:55:42.594]             function(cond) {
[10:55:42.594]                 is_error <- inherits(cond, "error")
[10:55:42.594]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.594]                   NULL)
[10:55:42.594]                 if (is_error) {
[10:55:42.594]                   sessionInformation <- function() {
[10:55:42.594]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.594]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.594]                       search = base::search(), system = base::Sys.info())
[10:55:42.594]                   }
[10:55:42.594]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.594]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.594]                     cond$call), session = sessionInformation(), 
[10:55:42.594]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.594]                   signalCondition(cond)
[10:55:42.594]                 }
[10:55:42.594]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.594]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.594]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.594]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.594]                   if (FALSE && !signal) {
[10:55:42.594]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.594]                     {
[10:55:42.594]                       inherits <- base::inherits
[10:55:42.594]                       invokeRestart <- base::invokeRestart
[10:55:42.594]                       is.null <- base::is.null
[10:55:42.594]                       muffled <- FALSE
[10:55:42.594]                       if (inherits(cond, "message")) {
[10:55:42.594]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.594]                         if (muffled) 
[10:55:42.594]                           invokeRestart("muffleMessage")
[10:55:42.594]                       }
[10:55:42.594]                       else if (inherits(cond, "warning")) {
[10:55:42.594]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.594]                         if (muffled) 
[10:55:42.594]                           invokeRestart("muffleWarning")
[10:55:42.594]                       }
[10:55:42.594]                       else if (inherits(cond, "condition")) {
[10:55:42.594]                         if (!is.null(pattern)) {
[10:55:42.594]                           computeRestarts <- base::computeRestarts
[10:55:42.594]                           grepl <- base::grepl
[10:55:42.594]                           restarts <- computeRestarts(cond)
[10:55:42.594]                           for (restart in restarts) {
[10:55:42.594]                             name <- restart$name
[10:55:42.594]                             if (is.null(name)) 
[10:55:42.594]                               next
[10:55:42.594]                             if (!grepl(pattern, name)) 
[10:55:42.594]                               next
[10:55:42.594]                             invokeRestart(restart)
[10:55:42.594]                             muffled <- TRUE
[10:55:42.594]                             break
[10:55:42.594]                           }
[10:55:42.594]                         }
[10:55:42.594]                       }
[10:55:42.594]                       invisible(muffled)
[10:55:42.594]                     }
[10:55:42.594]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.594]                   }
[10:55:42.594]                 }
[10:55:42.594]                 else {
[10:55:42.594]                   if (TRUE) {
[10:55:42.594]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.594]                     {
[10:55:42.594]                       inherits <- base::inherits
[10:55:42.594]                       invokeRestart <- base::invokeRestart
[10:55:42.594]                       is.null <- base::is.null
[10:55:42.594]                       muffled <- FALSE
[10:55:42.594]                       if (inherits(cond, "message")) {
[10:55:42.594]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.594]                         if (muffled) 
[10:55:42.594]                           invokeRestart("muffleMessage")
[10:55:42.594]                       }
[10:55:42.594]                       else if (inherits(cond, "warning")) {
[10:55:42.594]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.594]                         if (muffled) 
[10:55:42.594]                           invokeRestart("muffleWarning")
[10:55:42.594]                       }
[10:55:42.594]                       else if (inherits(cond, "condition")) {
[10:55:42.594]                         if (!is.null(pattern)) {
[10:55:42.594]                           computeRestarts <- base::computeRestarts
[10:55:42.594]                           grepl <- base::grepl
[10:55:42.594]                           restarts <- computeRestarts(cond)
[10:55:42.594]                           for (restart in restarts) {
[10:55:42.594]                             name <- restart$name
[10:55:42.594]                             if (is.null(name)) 
[10:55:42.594]                               next
[10:55:42.594]                             if (!grepl(pattern, name)) 
[10:55:42.594]                               next
[10:55:42.594]                             invokeRestart(restart)
[10:55:42.594]                             muffled <- TRUE
[10:55:42.594]                             break
[10:55:42.594]                           }
[10:55:42.594]                         }
[10:55:42.594]                       }
[10:55:42.594]                       invisible(muffled)
[10:55:42.594]                     }
[10:55:42.594]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.594]                   }
[10:55:42.594]                 }
[10:55:42.594]             }
[10:55:42.594]         }))
[10:55:42.594]     }, error = function(ex) {
[10:55:42.594]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.594]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.594]                 ...future.rng), started = ...future.startTime, 
[10:55:42.594]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.594]             version = "1.8"), class = "FutureResult")
[10:55:42.594]     }, finally = {
[10:55:42.594]         if (!identical(...future.workdir, getwd())) 
[10:55:42.594]             setwd(...future.workdir)
[10:55:42.594]         {
[10:55:42.594]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.594]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.594]             }
[10:55:42.594]             base::options(...future.oldOptions)
[10:55:42.594]             if (.Platform$OS.type == "windows") {
[10:55:42.594]                 old_names <- names(...future.oldEnvVars)
[10:55:42.594]                 envs <- base::Sys.getenv()
[10:55:42.594]                 names <- names(envs)
[10:55:42.594]                 common <- intersect(names, old_names)
[10:55:42.594]                 added <- setdiff(names, old_names)
[10:55:42.594]                 removed <- setdiff(old_names, names)
[10:55:42.594]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.594]                   envs[common]]
[10:55:42.594]                 NAMES <- toupper(changed)
[10:55:42.594]                 args <- list()
[10:55:42.594]                 for (kk in seq_along(NAMES)) {
[10:55:42.594]                   name <- changed[[kk]]
[10:55:42.594]                   NAME <- NAMES[[kk]]
[10:55:42.594]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.594]                     next
[10:55:42.594]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.594]                 }
[10:55:42.594]                 NAMES <- toupper(added)
[10:55:42.594]                 for (kk in seq_along(NAMES)) {
[10:55:42.594]                   name <- added[[kk]]
[10:55:42.594]                   NAME <- NAMES[[kk]]
[10:55:42.594]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.594]                     next
[10:55:42.594]                   args[[name]] <- ""
[10:55:42.594]                 }
[10:55:42.594]                 NAMES <- toupper(removed)
[10:55:42.594]                 for (kk in seq_along(NAMES)) {
[10:55:42.594]                   name <- removed[[kk]]
[10:55:42.594]                   NAME <- NAMES[[kk]]
[10:55:42.594]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.594]                     next
[10:55:42.594]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.594]                 }
[10:55:42.594]                 if (length(args) > 0) 
[10:55:42.594]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.594]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.594]             }
[10:55:42.594]             else {
[10:55:42.594]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.594]             }
[10:55:42.594]             {
[10:55:42.594]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.594]                   0L) {
[10:55:42.594]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.594]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.594]                   base::options(opts)
[10:55:42.594]                 }
[10:55:42.594]                 {
[10:55:42.594]                   NULL
[10:55:42.594]                   options(future.plan = NULL)
[10:55:42.594]                   if (is.na(NA_character_)) 
[10:55:42.594]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.594]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.594]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.594]                     .init = FALSE)
[10:55:42.594]                 }
[10:55:42.594]             }
[10:55:42.594]         }
[10:55:42.594]     })
[10:55:42.594]     if (TRUE) {
[10:55:42.594]         base::sink(type = "output", split = FALSE)
[10:55:42.594]         if (TRUE) {
[10:55:42.594]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.594]         }
[10:55:42.594]         else {
[10:55:42.594]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.594]         }
[10:55:42.594]         base::close(...future.stdout)
[10:55:42.594]         ...future.stdout <- NULL
[10:55:42.594]     }
[10:55:42.594]     ...future.result$conditions <- ...future.conditions
[10:55:42.594]     ...future.result$finished <- base::Sys.time()
[10:55:42.594]     ...future.result
[10:55:42.594] }
[10:55:42.710] plan(): plan_init() of 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ... DONE
[10:55:42.710] plan(): nbrOfWorkers() = 2
[10:55:42.710] getGlobalsAndPackages() ...
[10:55:42.710] Searching for globals...
[10:55:42.713] 
[10:55:42.713] Searching for globals ... DONE
[10:55:42.714] - globals: [0] <none>
[10:55:42.714] getGlobalsAndPackages() ... DONE
[10:55:42.714] getGlobalsAndPackages() ...
[10:55:42.714] 
[10:55:42.714] - globals: [0] <none>
[10:55:42.714] getGlobalsAndPackages() ... DONE
[10:55:42.715] Packages needed by the future expression (n = 0): <none>
[10:55:42.715] Packages needed by future strategies (n = 0): <none>
[10:55:42.716] {
[10:55:42.716]     {
[10:55:42.716]         {
[10:55:42.716]             ...future.startTime <- base::Sys.time()
[10:55:42.716]             {
[10:55:42.716]                 {
[10:55:42.716]                   {
[10:55:42.716]                     base::local({
[10:55:42.716]                       has_future <- base::requireNamespace("future", 
[10:55:42.716]                         quietly = TRUE)
[10:55:42.716]                       if (has_future) {
[10:55:42.716]                         ns <- base::getNamespace("future")
[10:55:42.716]                         version <- ns[[".package"]][["version"]]
[10:55:42.716]                         if (is.null(version)) 
[10:55:42.716]                           version <- utils::packageVersion("future")
[10:55:42.716]                       }
[10:55:42.716]                       else {
[10:55:42.716]                         version <- NULL
[10:55:42.716]                       }
[10:55:42.716]                       if (!has_future || version < "1.8.0") {
[10:55:42.716]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.716]                           "", base::R.version$version.string), 
[10:55:42.716]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.716]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.716]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.716]                             "release", "version")], collapse = " "), 
[10:55:42.716]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.716]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.716]                           info)
[10:55:42.716]                         info <- base::paste(info, collapse = "; ")
[10:55:42.716]                         if (!has_future) {
[10:55:42.716]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.716]                             info)
[10:55:42.716]                         }
[10:55:42.716]                         else {
[10:55:42.716]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.716]                             info, version)
[10:55:42.716]                         }
[10:55:42.716]                         base::stop(msg)
[10:55:42.716]                       }
[10:55:42.716]                     })
[10:55:42.716]                   }
[10:55:42.716]                   ...future.strategy.old <- future::plan("list")
[10:55:42.716]                   options(future.plan = NULL)
[10:55:42.716]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.716]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.716]                 }
[10:55:42.716]                 ...future.workdir <- getwd()
[10:55:42.716]             }
[10:55:42.716]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.716]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.716]         }
[10:55:42.716]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.716]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.716]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.716]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.716]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.716]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.716]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.716]             base::names(...future.oldOptions))
[10:55:42.716]     }
[10:55:42.716]     if (FALSE) {
[10:55:42.716]     }
[10:55:42.716]     else {
[10:55:42.716]         if (TRUE) {
[10:55:42.716]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.716]                 open = "w")
[10:55:42.716]         }
[10:55:42.716]         else {
[10:55:42.716]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.716]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.716]         }
[10:55:42.716]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.716]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.716]             base::sink(type = "output", split = FALSE)
[10:55:42.716]             base::close(...future.stdout)
[10:55:42.716]         }, add = TRUE)
[10:55:42.716]     }
[10:55:42.716]     ...future.frame <- base::sys.nframe()
[10:55:42.716]     ...future.conditions <- base::list()
[10:55:42.716]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.716]     if (FALSE) {
[10:55:42.716]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.716]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.716]     }
[10:55:42.716]     ...future.result <- base::tryCatch({
[10:55:42.716]         base::withCallingHandlers({
[10:55:42.716]             ...future.value <- base::withVisible(base::local(42))
[10:55:42.716]             future::FutureResult(value = ...future.value$value, 
[10:55:42.716]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.716]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.716]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.716]                     ...future.globalenv.names))
[10:55:42.716]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.716]         }, condition = base::local({
[10:55:42.716]             c <- base::c
[10:55:42.716]             inherits <- base::inherits
[10:55:42.716]             invokeRestart <- base::invokeRestart
[10:55:42.716]             length <- base::length
[10:55:42.716]             list <- base::list
[10:55:42.716]             seq.int <- base::seq.int
[10:55:42.716]             signalCondition <- base::signalCondition
[10:55:42.716]             sys.calls <- base::sys.calls
[10:55:42.716]             `[[` <- base::`[[`
[10:55:42.716]             `+` <- base::`+`
[10:55:42.716]             `<<-` <- base::`<<-`
[10:55:42.716]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.716]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.716]                   3L)]
[10:55:42.716]             }
[10:55:42.716]             function(cond) {
[10:55:42.716]                 is_error <- inherits(cond, "error")
[10:55:42.716]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.716]                   NULL)
[10:55:42.716]                 if (is_error) {
[10:55:42.716]                   sessionInformation <- function() {
[10:55:42.716]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.716]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.716]                       search = base::search(), system = base::Sys.info())
[10:55:42.716]                   }
[10:55:42.716]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.716]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.716]                     cond$call), session = sessionInformation(), 
[10:55:42.716]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.716]                   signalCondition(cond)
[10:55:42.716]                 }
[10:55:42.716]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.716]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.716]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.716]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.716]                   if (FALSE && !signal) {
[10:55:42.716]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.716]                     {
[10:55:42.716]                       inherits <- base::inherits
[10:55:42.716]                       invokeRestart <- base::invokeRestart
[10:55:42.716]                       is.null <- base::is.null
[10:55:42.716]                       muffled <- FALSE
[10:55:42.716]                       if (inherits(cond, "message")) {
[10:55:42.716]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.716]                         if (muffled) 
[10:55:42.716]                           invokeRestart("muffleMessage")
[10:55:42.716]                       }
[10:55:42.716]                       else if (inherits(cond, "warning")) {
[10:55:42.716]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.716]                         if (muffled) 
[10:55:42.716]                           invokeRestart("muffleWarning")
[10:55:42.716]                       }
[10:55:42.716]                       else if (inherits(cond, "condition")) {
[10:55:42.716]                         if (!is.null(pattern)) {
[10:55:42.716]                           computeRestarts <- base::computeRestarts
[10:55:42.716]                           grepl <- base::grepl
[10:55:42.716]                           restarts <- computeRestarts(cond)
[10:55:42.716]                           for (restart in restarts) {
[10:55:42.716]                             name <- restart$name
[10:55:42.716]                             if (is.null(name)) 
[10:55:42.716]                               next
[10:55:42.716]                             if (!grepl(pattern, name)) 
[10:55:42.716]                               next
[10:55:42.716]                             invokeRestart(restart)
[10:55:42.716]                             muffled <- TRUE
[10:55:42.716]                             break
[10:55:42.716]                           }
[10:55:42.716]                         }
[10:55:42.716]                       }
[10:55:42.716]                       invisible(muffled)
[10:55:42.716]                     }
[10:55:42.716]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.716]                   }
[10:55:42.716]                 }
[10:55:42.716]                 else {
[10:55:42.716]                   if (TRUE) {
[10:55:42.716]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.716]                     {
[10:55:42.716]                       inherits <- base::inherits
[10:55:42.716]                       invokeRestart <- base::invokeRestart
[10:55:42.716]                       is.null <- base::is.null
[10:55:42.716]                       muffled <- FALSE
[10:55:42.716]                       if (inherits(cond, "message")) {
[10:55:42.716]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.716]                         if (muffled) 
[10:55:42.716]                           invokeRestart("muffleMessage")
[10:55:42.716]                       }
[10:55:42.716]                       else if (inherits(cond, "warning")) {
[10:55:42.716]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.716]                         if (muffled) 
[10:55:42.716]                           invokeRestart("muffleWarning")
[10:55:42.716]                       }
[10:55:42.716]                       else if (inherits(cond, "condition")) {
[10:55:42.716]                         if (!is.null(pattern)) {
[10:55:42.716]                           computeRestarts <- base::computeRestarts
[10:55:42.716]                           grepl <- base::grepl
[10:55:42.716]                           restarts <- computeRestarts(cond)
[10:55:42.716]                           for (restart in restarts) {
[10:55:42.716]                             name <- restart$name
[10:55:42.716]                             if (is.null(name)) 
[10:55:42.716]                               next
[10:55:42.716]                             if (!grepl(pattern, name)) 
[10:55:42.716]                               next
[10:55:42.716]                             invokeRestart(restart)
[10:55:42.716]                             muffled <- TRUE
[10:55:42.716]                             break
[10:55:42.716]                           }
[10:55:42.716]                         }
[10:55:42.716]                       }
[10:55:42.716]                       invisible(muffled)
[10:55:42.716]                     }
[10:55:42.716]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.716]                   }
[10:55:42.716]                 }
[10:55:42.716]             }
[10:55:42.716]         }))
[10:55:42.716]     }, error = function(ex) {
[10:55:42.716]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.716]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.716]                 ...future.rng), started = ...future.startTime, 
[10:55:42.716]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.716]             version = "1.8"), class = "FutureResult")
[10:55:42.716]     }, finally = {
[10:55:42.716]         if (!identical(...future.workdir, getwd())) 
[10:55:42.716]             setwd(...future.workdir)
[10:55:42.716]         {
[10:55:42.716]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.716]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.716]             }
[10:55:42.716]             base::options(...future.oldOptions)
[10:55:42.716]             if (.Platform$OS.type == "windows") {
[10:55:42.716]                 old_names <- names(...future.oldEnvVars)
[10:55:42.716]                 envs <- base::Sys.getenv()
[10:55:42.716]                 names <- names(envs)
[10:55:42.716]                 common <- intersect(names, old_names)
[10:55:42.716]                 added <- setdiff(names, old_names)
[10:55:42.716]                 removed <- setdiff(old_names, names)
[10:55:42.716]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.716]                   envs[common]]
[10:55:42.716]                 NAMES <- toupper(changed)
[10:55:42.716]                 args <- list()
[10:55:42.716]                 for (kk in seq_along(NAMES)) {
[10:55:42.716]                   name <- changed[[kk]]
[10:55:42.716]                   NAME <- NAMES[[kk]]
[10:55:42.716]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.716]                     next
[10:55:42.716]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.716]                 }
[10:55:42.716]                 NAMES <- toupper(added)
[10:55:42.716]                 for (kk in seq_along(NAMES)) {
[10:55:42.716]                   name <- added[[kk]]
[10:55:42.716]                   NAME <- NAMES[[kk]]
[10:55:42.716]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.716]                     next
[10:55:42.716]                   args[[name]] <- ""
[10:55:42.716]                 }
[10:55:42.716]                 NAMES <- toupper(removed)
[10:55:42.716]                 for (kk in seq_along(NAMES)) {
[10:55:42.716]                   name <- removed[[kk]]
[10:55:42.716]                   NAME <- NAMES[[kk]]
[10:55:42.716]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.716]                     next
[10:55:42.716]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.716]                 }
[10:55:42.716]                 if (length(args) > 0) 
[10:55:42.716]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.716]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.716]             }
[10:55:42.716]             else {
[10:55:42.716]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.716]             }
[10:55:42.716]             {
[10:55:42.716]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.716]                   0L) {
[10:55:42.716]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.716]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.716]                   base::options(opts)
[10:55:42.716]                 }
[10:55:42.716]                 {
[10:55:42.716]                   NULL
[10:55:42.716]                   options(future.plan = NULL)
[10:55:42.716]                   if (is.na(NA_character_)) 
[10:55:42.716]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.716]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.716]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.716]                     .init = FALSE)
[10:55:42.716]                 }
[10:55:42.716]             }
[10:55:42.716]         }
[10:55:42.716]     })
[10:55:42.716]     if (TRUE) {
[10:55:42.716]         base::sink(type = "output", split = FALSE)
[10:55:42.716]         if (TRUE) {
[10:55:42.716]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.716]         }
[10:55:42.716]         else {
[10:55:42.716]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.716]         }
[10:55:42.716]         base::close(...future.stdout)
[10:55:42.716]         ...future.stdout <- NULL
[10:55:42.716]     }
[10:55:42.716]     ...future.result$conditions <- ...future.conditions
[10:55:42.716]     ...future.result$finished <- base::Sys.time()
[10:55:42.716]     ...future.result
[10:55:42.716] }
MiraiFuture:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:55:42.721] resolved() for 'MiraiFuture' ...
[10:55:42.721] - state: 'running'
[10:55:42.721] - run: TRUE
[10:55:42.721] - result: 'NULL'
[10:55:42.721] - resolved: FALSE
[10:55:42.722] resolved() for 'MiraiFuture' ... done
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b859a48e-c511-ea97-6436-2c6143ec3048
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.722] getGlobalsAndPackages() ...
[10:55:42.723] Searching for globals...
[10:55:42.723] 
[10:55:42.723] Searching for globals ... DONE
[10:55:42.723] - globals: [0] <none>
[10:55:42.724] getGlobalsAndPackages() ... DONE
[10:55:42.724] run() for 'Future' ...
[10:55:42.724] - state: 'created'
[10:55:42.725] - Future backend: 'FutureStrategy', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[10:55:42.725] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.725] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[10:55:42.725]   - Field: 'label'
[10:55:42.726]   - Field: 'local'
[10:55:42.726]   - Field: 'owner'
[10:55:42.726]   - Field: 'envir'
[10:55:42.726]   - Field: 'packages'
[10:55:42.726]   - Field: 'gc'
[10:55:42.726]   - Field: 'conditions'
[10:55:42.727]   - Field: 'expr'
[10:55:42.727]   - Field: 'uuid'
[10:55:42.727]   - Field: 'seed'
[10:55:42.727]   - Field: 'version'
[10:55:42.727]   - Field: 'result'
[10:55:42.727]   - Field: 'asynchronous'
[10:55:42.728]   - Field: 'calls'
[10:55:42.728]   - Field: 'globals'
[10:55:42.728]   - Field: 'stdout'
[10:55:42.728]   - Field: 'earlySignal'
[10:55:42.728]   - Field: 'lazy'
[10:55:42.729]   - Field: 'state'
[10:55:42.729]   - Field: '.cluster'
[10:55:42.729] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[10:55:42.729] - Launch lazy future ...
[10:55:42.729] Packages needed by the future expression (n = 0): <none>
[10:55:42.729] Packages needed by future strategies (n = 0): <none>
[10:55:42.730] {
[10:55:42.730]     {
[10:55:42.730]         {
[10:55:42.730]             ...future.startTime <- base::Sys.time()
[10:55:42.730]             {
[10:55:42.730]                 {
[10:55:42.730]                   {
[10:55:42.730]                     base::local({
[10:55:42.730]                       has_future <- base::requireNamespace("future", 
[10:55:42.730]                         quietly = TRUE)
[10:55:42.730]                       if (has_future) {
[10:55:42.730]                         ns <- base::getNamespace("future")
[10:55:42.730]                         version <- ns[[".package"]][["version"]]
[10:55:42.730]                         if (is.null(version)) 
[10:55:42.730]                           version <- utils::packageVersion("future")
[10:55:42.730]                       }
[10:55:42.730]                       else {
[10:55:42.730]                         version <- NULL
[10:55:42.730]                       }
[10:55:42.730]                       if (!has_future || version < "1.8.0") {
[10:55:42.730]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.730]                           "", base::R.version$version.string), 
[10:55:42.730]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.730]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.730]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.730]                             "release", "version")], collapse = " "), 
[10:55:42.730]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.730]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.730]                           info)
[10:55:42.730]                         info <- base::paste(info, collapse = "; ")
[10:55:42.730]                         if (!has_future) {
[10:55:42.730]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.730]                             info)
[10:55:42.730]                         }
[10:55:42.730]                         else {
[10:55:42.730]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.730]                             info, version)
[10:55:42.730]                         }
[10:55:42.730]                         base::stop(msg)
[10:55:42.730]                       }
[10:55:42.730]                     })
[10:55:42.730]                   }
[10:55:42.730]                   ...future.strategy.old <- future::plan("list")
[10:55:42.730]                   options(future.plan = NULL)
[10:55:42.730]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.730]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.730]                 }
[10:55:42.730]                 ...future.workdir <- getwd()
[10:55:42.730]             }
[10:55:42.730]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.730]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.730]         }
[10:55:42.730]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.730]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.730]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.730]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.730]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.730]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.730]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.730]             base::names(...future.oldOptions))
[10:55:42.730]     }
[10:55:42.730]     if (FALSE) {
[10:55:42.730]     }
[10:55:42.730]     else {
[10:55:42.730]         if (TRUE) {
[10:55:42.730]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.730]                 open = "w")
[10:55:42.730]         }
[10:55:42.730]         else {
[10:55:42.730]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.730]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.730]         }
[10:55:42.730]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.730]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.730]             base::sink(type = "output", split = FALSE)
[10:55:42.730]             base::close(...future.stdout)
[10:55:42.730]         }, add = TRUE)
[10:55:42.730]     }
[10:55:42.730]     ...future.frame <- base::sys.nframe()
[10:55:42.730]     ...future.conditions <- base::list()
[10:55:42.730]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.730]     if (FALSE) {
[10:55:42.730]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.730]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.730]     }
[10:55:42.730]     ...future.result <- base::tryCatch({
[10:55:42.730]         base::withCallingHandlers({
[10:55:42.730]             ...future.value <- base::withVisible(base::local(42))
[10:55:42.730]             future::FutureResult(value = ...future.value$value, 
[10:55:42.730]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.730]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.730]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.730]                     ...future.globalenv.names))
[10:55:42.730]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.730]         }, condition = base::local({
[10:55:42.730]             c <- base::c
[10:55:42.730]             inherits <- base::inherits
[10:55:42.730]             invokeRestart <- base::invokeRestart
[10:55:42.730]             length <- base::length
[10:55:42.730]             list <- base::list
[10:55:42.730]             seq.int <- base::seq.int
[10:55:42.730]             signalCondition <- base::signalCondition
[10:55:42.730]             sys.calls <- base::sys.calls
[10:55:42.730]             `[[` <- base::`[[`
[10:55:42.730]             `+` <- base::`+`
[10:55:42.730]             `<<-` <- base::`<<-`
[10:55:42.730]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.730]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.730]                   3L)]
[10:55:42.730]             }
[10:55:42.730]             function(cond) {
[10:55:42.730]                 is_error <- inherits(cond, "error")
[10:55:42.730]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.730]                   NULL)
[10:55:42.730]                 if (is_error) {
[10:55:42.730]                   sessionInformation <- function() {
[10:55:42.730]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.730]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.730]                       search = base::search(), system = base::Sys.info())
[10:55:42.730]                   }
[10:55:42.730]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.730]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.730]                     cond$call), session = sessionInformation(), 
[10:55:42.730]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.730]                   signalCondition(cond)
[10:55:42.730]                 }
[10:55:42.730]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.730]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.730]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.730]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.730]                   if (FALSE && !signal) {
[10:55:42.730]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.730]                     {
[10:55:42.730]                       inherits <- base::inherits
[10:55:42.730]                       invokeRestart <- base::invokeRestart
[10:55:42.730]                       is.null <- base::is.null
[10:55:42.730]                       muffled <- FALSE
[10:55:42.730]                       if (inherits(cond, "message")) {
[10:55:42.730]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.730]                         if (muffled) 
[10:55:42.730]                           invokeRestart("muffleMessage")
[10:55:42.730]                       }
[10:55:42.730]                       else if (inherits(cond, "warning")) {
[10:55:42.730]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.730]                         if (muffled) 
[10:55:42.730]                           invokeRestart("muffleWarning")
[10:55:42.730]                       }
[10:55:42.730]                       else if (inherits(cond, "condition")) {
[10:55:42.730]                         if (!is.null(pattern)) {
[10:55:42.730]                           computeRestarts <- base::computeRestarts
[10:55:42.730]                           grepl <- base::grepl
[10:55:42.730]                           restarts <- computeRestarts(cond)
[10:55:42.730]                           for (restart in restarts) {
[10:55:42.730]                             name <- restart$name
[10:55:42.730]                             if (is.null(name)) 
[10:55:42.730]                               next
[10:55:42.730]                             if (!grepl(pattern, name)) 
[10:55:42.730]                               next
[10:55:42.730]                             invokeRestart(restart)
[10:55:42.730]                             muffled <- TRUE
[10:55:42.730]                             break
[10:55:42.730]                           }
[10:55:42.730]                         }
[10:55:42.730]                       }
[10:55:42.730]                       invisible(muffled)
[10:55:42.730]                     }
[10:55:42.730]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.730]                   }
[10:55:42.730]                 }
[10:55:42.730]                 else {
[10:55:42.730]                   if (TRUE) {
[10:55:42.730]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.730]                     {
[10:55:42.730]                       inherits <- base::inherits
[10:55:42.730]                       invokeRestart <- base::invokeRestart
[10:55:42.730]                       is.null <- base::is.null
[10:55:42.730]                       muffled <- FALSE
[10:55:42.730]                       if (inherits(cond, "message")) {
[10:55:42.730]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.730]                         if (muffled) 
[10:55:42.730]                           invokeRestart("muffleMessage")
[10:55:42.730]                       }
[10:55:42.730]                       else if (inherits(cond, "warning")) {
[10:55:42.730]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.730]                         if (muffled) 
[10:55:42.730]                           invokeRestart("muffleWarning")
[10:55:42.730]                       }
[10:55:42.730]                       else if (inherits(cond, "condition")) {
[10:55:42.730]                         if (!is.null(pattern)) {
[10:55:42.730]                           computeRestarts <- base::computeRestarts
[10:55:42.730]                           grepl <- base::grepl
[10:55:42.730]                           restarts <- computeRestarts(cond)
[10:55:42.730]                           for (restart in restarts) {
[10:55:42.730]                             name <- restart$name
[10:55:42.730]                             if (is.null(name)) 
[10:55:42.730]                               next
[10:55:42.730]                             if (!grepl(pattern, name)) 
[10:55:42.730]                               next
[10:55:42.730]                             invokeRestart(restart)
[10:55:42.730]                             muffled <- TRUE
[10:55:42.730]                             break
[10:55:42.730]                           }
[10:55:42.730]                         }
[10:55:42.730]                       }
[10:55:42.730]                       invisible(muffled)
[10:55:42.730]                     }
[10:55:42.730]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.730]                   }
[10:55:42.730]                 }
[10:55:42.730]             }
[10:55:42.730]         }))
[10:55:42.730]     }, error = function(ex) {
[10:55:42.730]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.730]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.730]                 ...future.rng), started = ...future.startTime, 
[10:55:42.730]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.730]             version = "1.8"), class = "FutureResult")
[10:55:42.730]     }, finally = {
[10:55:42.730]         if (!identical(...future.workdir, getwd())) 
[10:55:42.730]             setwd(...future.workdir)
[10:55:42.730]         {
[10:55:42.730]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.730]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.730]             }
[10:55:42.730]             base::options(...future.oldOptions)
[10:55:42.730]             if (.Platform$OS.type == "windows") {
[10:55:42.730]                 old_names <- names(...future.oldEnvVars)
[10:55:42.730]                 envs <- base::Sys.getenv()
[10:55:42.730]                 names <- names(envs)
[10:55:42.730]                 common <- intersect(names, old_names)
[10:55:42.730]                 added <- setdiff(names, old_names)
[10:55:42.730]                 removed <- setdiff(old_names, names)
[10:55:42.730]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.730]                   envs[common]]
[10:55:42.730]                 NAMES <- toupper(changed)
[10:55:42.730]                 args <- list()
[10:55:42.730]                 for (kk in seq_along(NAMES)) {
[10:55:42.730]                   name <- changed[[kk]]
[10:55:42.730]                   NAME <- NAMES[[kk]]
[10:55:42.730]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.730]                     next
[10:55:42.730]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.730]                 }
[10:55:42.730]                 NAMES <- toupper(added)
[10:55:42.730]                 for (kk in seq_along(NAMES)) {
[10:55:42.730]                   name <- added[[kk]]
[10:55:42.730]                   NAME <- NAMES[[kk]]
[10:55:42.730]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.730]                     next
[10:55:42.730]                   args[[name]] <- ""
[10:55:42.730]                 }
[10:55:42.730]                 NAMES <- toupper(removed)
[10:55:42.730]                 for (kk in seq_along(NAMES)) {
[10:55:42.730]                   name <- removed[[kk]]
[10:55:42.730]                   NAME <- NAMES[[kk]]
[10:55:42.730]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.730]                     next
[10:55:42.730]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.730]                 }
[10:55:42.730]                 if (length(args) > 0) 
[10:55:42.730]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.730]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.730]             }
[10:55:42.730]             else {
[10:55:42.730]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.730]             }
[10:55:42.730]             {
[10:55:42.730]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.730]                   0L) {
[10:55:42.730]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.730]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.730]                   base::options(opts)
[10:55:42.730]                 }
[10:55:42.730]                 {
[10:55:42.730]                   NULL
[10:55:42.730]                   options(future.plan = NULL)
[10:55:42.730]                   if (is.na(NA_character_)) 
[10:55:42.730]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.730]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.730]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.730]                     .init = FALSE)
[10:55:42.730]                 }
[10:55:42.730]             }
[10:55:42.730]         }
[10:55:42.730]     })
[10:55:42.730]     if (TRUE) {
[10:55:42.730]         base::sink(type = "output", split = FALSE)
[10:55:42.730]         if (TRUE) {
[10:55:42.730]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.730]         }
[10:55:42.730]         else {
[10:55:42.730]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.730]         }
[10:55:42.730]         base::close(...future.stdout)
[10:55:42.730]         ...future.stdout <- NULL
[10:55:42.730]     }
[10:55:42.730]     ...future.result$conditions <- ...future.conditions
[10:55:42.730]     ...future.result$finished <- base::Sys.time()
[10:55:42.730]     ...future.result
[10:55:42.730] }
[10:55:42.734] - Launch lazy future ... done
[10:55:42.734] run() for 'MiraiFuture' ... done
MiraiFuture:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:55:42.735] resolved() for 'MiraiFuture' ...
[10:55:42.735] - state: 'running'
[10:55:42.735] - run: TRUE
[10:55:42.735] - result: 'NULL'
[10:55:42.738] - resolved: FALSE
[10:55:42.738] resolved() for 'MiraiFuture' ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b859a48e-c511-ea97-6436-2c6143ec3048
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.740] getGlobalsAndPackages() ...
[10:55:42.740] Searching for globals...
[10:55:42.742] - globals found: [1] '{'
[10:55:42.742] Searching for globals ... DONE
[10:55:42.742] Resolving globals: FALSE
[10:55:42.743] 
[10:55:42.743] 
[10:55:42.743] getGlobalsAndPackages() ... DONE
[10:55:42.743] run() for 'Future' ...
[10:55:42.743] - state: 'created'
[10:55:42.744] - Future backend: 'FutureStrategy', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[10:55:42.744] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.744] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[10:55:42.744]   - Field: 'label'
[10:55:42.745]   - Field: 'local'
[10:55:42.745]   - Field: 'owner'
[10:55:42.745]   - Field: 'envir'
[10:55:42.745]   - Field: 'packages'
[10:55:42.745]   - Field: 'gc'
[10:55:42.745]   - Field: 'conditions'
[10:55:42.746]   - Field: 'expr'
[10:55:42.746]   - Field: 'uuid'
[10:55:42.746]   - Field: 'seed'
[10:55:42.746]   - Field: 'version'
[10:55:42.746]   - Field: 'result'
[10:55:42.747]   - Field: 'asynchronous'
[10:55:42.747]   - Field: 'calls'
[10:55:42.747]   - Field: 'globals'
[10:55:42.747]   - Field: 'stdout'
[10:55:42.747]   - Field: 'earlySignal'
[10:55:42.747]   - Field: 'lazy'
[10:55:42.748]   - Field: 'state'
[10:55:42.748]   - Field: '.cluster'
[10:55:42.748] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[10:55:42.748] - Launch lazy future ...
[10:55:42.748] Packages needed by the future expression (n = 0): <none>
[10:55:42.748] Packages needed by future strategies (n = 0): <none>
[10:55:42.749] {
[10:55:42.749]     {
[10:55:42.749]         {
[10:55:42.749]             ...future.startTime <- base::Sys.time()
[10:55:42.749]             {
[10:55:42.749]                 {
[10:55:42.749]                   {
[10:55:42.749]                     base::local({
[10:55:42.749]                       has_future <- base::requireNamespace("future", 
[10:55:42.749]                         quietly = TRUE)
[10:55:42.749]                       if (has_future) {
[10:55:42.749]                         ns <- base::getNamespace("future")
[10:55:42.749]                         version <- ns[[".package"]][["version"]]
[10:55:42.749]                         if (is.null(version)) 
[10:55:42.749]                           version <- utils::packageVersion("future")
[10:55:42.749]                       }
[10:55:42.749]                       else {
[10:55:42.749]                         version <- NULL
[10:55:42.749]                       }
[10:55:42.749]                       if (!has_future || version < "1.8.0") {
[10:55:42.749]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.749]                           "", base::R.version$version.string), 
[10:55:42.749]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.749]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.749]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.749]                             "release", "version")], collapse = " "), 
[10:55:42.749]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.749]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.749]                           info)
[10:55:42.749]                         info <- base::paste(info, collapse = "; ")
[10:55:42.749]                         if (!has_future) {
[10:55:42.749]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.749]                             info)
[10:55:42.749]                         }
[10:55:42.749]                         else {
[10:55:42.749]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.749]                             info, version)
[10:55:42.749]                         }
[10:55:42.749]                         base::stop(msg)
[10:55:42.749]                       }
[10:55:42.749]                     })
[10:55:42.749]                   }
[10:55:42.749]                   ...future.strategy.old <- future::plan("list")
[10:55:42.749]                   options(future.plan = NULL)
[10:55:42.749]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.749]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.749]                 }
[10:55:42.749]                 ...future.workdir <- getwd()
[10:55:42.749]             }
[10:55:42.749]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.749]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.749]         }
[10:55:42.749]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.749]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.749]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.749]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.749]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.749]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.749]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.749]             base::names(...future.oldOptions))
[10:55:42.749]     }
[10:55:42.749]     if (FALSE) {
[10:55:42.749]     }
[10:55:42.749]     else {
[10:55:42.749]         if (TRUE) {
[10:55:42.749]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.749]                 open = "w")
[10:55:42.749]         }
[10:55:42.749]         else {
[10:55:42.749]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.749]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.749]         }
[10:55:42.749]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.749]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.749]             base::sink(type = "output", split = FALSE)
[10:55:42.749]             base::close(...future.stdout)
[10:55:42.749]         }, add = TRUE)
[10:55:42.749]     }
[10:55:42.749]     ...future.frame <- base::sys.nframe()
[10:55:42.749]     ...future.conditions <- base::list()
[10:55:42.749]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.749]     if (FALSE) {
[10:55:42.749]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.749]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.749]     }
[10:55:42.749]     ...future.result <- base::tryCatch({
[10:55:42.749]         base::withCallingHandlers({
[10:55:42.749]             ...future.value <- base::withVisible(base::local({
[10:55:42.749]                 42
[10:55:42.749]             }))
[10:55:42.749]             future::FutureResult(value = ...future.value$value, 
[10:55:42.749]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.749]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.749]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.749]                     ...future.globalenv.names))
[10:55:42.749]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.749]         }, condition = base::local({
[10:55:42.749]             c <- base::c
[10:55:42.749]             inherits <- base::inherits
[10:55:42.749]             invokeRestart <- base::invokeRestart
[10:55:42.749]             length <- base::length
[10:55:42.749]             list <- base::list
[10:55:42.749]             seq.int <- base::seq.int
[10:55:42.749]             signalCondition <- base::signalCondition
[10:55:42.749]             sys.calls <- base::sys.calls
[10:55:42.749]             `[[` <- base::`[[`
[10:55:42.749]             `+` <- base::`+`
[10:55:42.749]             `<<-` <- base::`<<-`
[10:55:42.749]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.749]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.749]                   3L)]
[10:55:42.749]             }
[10:55:42.749]             function(cond) {
[10:55:42.749]                 is_error <- inherits(cond, "error")
[10:55:42.749]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.749]                   NULL)
[10:55:42.749]                 if (is_error) {
[10:55:42.749]                   sessionInformation <- function() {
[10:55:42.749]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.749]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.749]                       search = base::search(), system = base::Sys.info())
[10:55:42.749]                   }
[10:55:42.749]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.749]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.749]                     cond$call), session = sessionInformation(), 
[10:55:42.749]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.749]                   signalCondition(cond)
[10:55:42.749]                 }
[10:55:42.749]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.749]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.749]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.749]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.749]                   if (FALSE && !signal) {
[10:55:42.749]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.749]                     {
[10:55:42.749]                       inherits <- base::inherits
[10:55:42.749]                       invokeRestart <- base::invokeRestart
[10:55:42.749]                       is.null <- base::is.null
[10:55:42.749]                       muffled <- FALSE
[10:55:42.749]                       if (inherits(cond, "message")) {
[10:55:42.749]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.749]                         if (muffled) 
[10:55:42.749]                           invokeRestart("muffleMessage")
[10:55:42.749]                       }
[10:55:42.749]                       else if (inherits(cond, "warning")) {
[10:55:42.749]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.749]                         if (muffled) 
[10:55:42.749]                           invokeRestart("muffleWarning")
[10:55:42.749]                       }
[10:55:42.749]                       else if (inherits(cond, "condition")) {
[10:55:42.749]                         if (!is.null(pattern)) {
[10:55:42.749]                           computeRestarts <- base::computeRestarts
[10:55:42.749]                           grepl <- base::grepl
[10:55:42.749]                           restarts <- computeRestarts(cond)
[10:55:42.749]                           for (restart in restarts) {
[10:55:42.749]                             name <- restart$name
[10:55:42.749]                             if (is.null(name)) 
[10:55:42.749]                               next
[10:55:42.749]                             if (!grepl(pattern, name)) 
[10:55:42.749]                               next
[10:55:42.749]                             invokeRestart(restart)
[10:55:42.749]                             muffled <- TRUE
[10:55:42.749]                             break
[10:55:42.749]                           }
[10:55:42.749]                         }
[10:55:42.749]                       }
[10:55:42.749]                       invisible(muffled)
[10:55:42.749]                     }
[10:55:42.749]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.749]                   }
[10:55:42.749]                 }
[10:55:42.749]                 else {
[10:55:42.749]                   if (TRUE) {
[10:55:42.749]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.749]                     {
[10:55:42.749]                       inherits <- base::inherits
[10:55:42.749]                       invokeRestart <- base::invokeRestart
[10:55:42.749]                       is.null <- base::is.null
[10:55:42.749]                       muffled <- FALSE
[10:55:42.749]                       if (inherits(cond, "message")) {
[10:55:42.749]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.749]                         if (muffled) 
[10:55:42.749]                           invokeRestart("muffleMessage")
[10:55:42.749]                       }
[10:55:42.749]                       else if (inherits(cond, "warning")) {
[10:55:42.749]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.749]                         if (muffled) 
[10:55:42.749]                           invokeRestart("muffleWarning")
[10:55:42.749]                       }
[10:55:42.749]                       else if (inherits(cond, "condition")) {
[10:55:42.749]                         if (!is.null(pattern)) {
[10:55:42.749]                           computeRestarts <- base::computeRestarts
[10:55:42.749]                           grepl <- base::grepl
[10:55:42.749]                           restarts <- computeRestarts(cond)
[10:55:42.749]                           for (restart in restarts) {
[10:55:42.749]                             name <- restart$name
[10:55:42.749]                             if (is.null(name)) 
[10:55:42.749]                               next
[10:55:42.749]                             if (!grepl(pattern, name)) 
[10:55:42.749]                               next
[10:55:42.749]                             invokeRestart(restart)
[10:55:42.749]                             muffled <- TRUE
[10:55:42.749]                             break
[10:55:42.749]                           }
[10:55:42.749]                         }
[10:55:42.749]                       }
[10:55:42.749]                       invisible(muffled)
[10:55:42.749]                     }
[10:55:42.749]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.749]                   }
[10:55:42.749]                 }
[10:55:42.749]             }
[10:55:42.749]         }))
[10:55:42.749]     }, error = function(ex) {
[10:55:42.749]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.749]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.749]                 ...future.rng), started = ...future.startTime, 
[10:55:42.749]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.749]             version = "1.8"), class = "FutureResult")
[10:55:42.749]     }, finally = {
[10:55:42.749]         if (!identical(...future.workdir, getwd())) 
[10:55:42.749]             setwd(...future.workdir)
[10:55:42.749]         {
[10:55:42.749]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.749]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.749]             }
[10:55:42.749]             base::options(...future.oldOptions)
[10:55:42.749]             if (.Platform$OS.type == "windows") {
[10:55:42.749]                 old_names <- names(...future.oldEnvVars)
[10:55:42.749]                 envs <- base::Sys.getenv()
[10:55:42.749]                 names <- names(envs)
[10:55:42.749]                 common <- intersect(names, old_names)
[10:55:42.749]                 added <- setdiff(names, old_names)
[10:55:42.749]                 removed <- setdiff(old_names, names)
[10:55:42.749]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.749]                   envs[common]]
[10:55:42.749]                 NAMES <- toupper(changed)
[10:55:42.749]                 args <- list()
[10:55:42.749]                 for (kk in seq_along(NAMES)) {
[10:55:42.749]                   name <- changed[[kk]]
[10:55:42.749]                   NAME <- NAMES[[kk]]
[10:55:42.749]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.749]                     next
[10:55:42.749]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.749]                 }
[10:55:42.749]                 NAMES <- toupper(added)
[10:55:42.749]                 for (kk in seq_along(NAMES)) {
[10:55:42.749]                   name <- added[[kk]]
[10:55:42.749]                   NAME <- NAMES[[kk]]
[10:55:42.749]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.749]                     next
[10:55:42.749]                   args[[name]] <- ""
[10:55:42.749]                 }
[10:55:42.749]                 NAMES <- toupper(removed)
[10:55:42.749]                 for (kk in seq_along(NAMES)) {
[10:55:42.749]                   name <- removed[[kk]]
[10:55:42.749]                   NAME <- NAMES[[kk]]
[10:55:42.749]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.749]                     next
[10:55:42.749]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.749]                 }
[10:55:42.749]                 if (length(args) > 0) 
[10:55:42.749]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.749]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.749]             }
[10:55:42.749]             else {
[10:55:42.749]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.749]             }
[10:55:42.749]             {
[10:55:42.749]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.749]                   0L) {
[10:55:42.749]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.749]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.749]                   base::options(opts)
[10:55:42.749]                 }
[10:55:42.749]                 {
[10:55:42.749]                   NULL
[10:55:42.749]                   options(future.plan = NULL)
[10:55:42.749]                   if (is.na(NA_character_)) 
[10:55:42.749]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.749]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.749]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.749]                     .init = FALSE)
[10:55:42.749]                 }
[10:55:42.749]             }
[10:55:42.749]         }
[10:55:42.749]     })
[10:55:42.749]     if (TRUE) {
[10:55:42.749]         base::sink(type = "output", split = FALSE)
[10:55:42.749]         if (TRUE) {
[10:55:42.749]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.749]         }
[10:55:42.749]         else {
[10:55:42.749]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.749]         }
[10:55:42.749]         base::close(...future.stdout)
[10:55:42.749]         ...future.stdout <- NULL
[10:55:42.749]     }
[10:55:42.749]     ...future.result$conditions <- ...future.conditions
[10:55:42.749]     ...future.result$finished <- base::Sys.time()
[10:55:42.749]     ...future.result
[10:55:42.749] }
[10:55:42.753] - Launch lazy future ... done
[10:55:42.753] run() for 'MiraiFuture' ... done
MiraiFuture:
Label: '<none>'
Expression:
{
    42
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:55:42.754] resolved() for 'MiraiFuture' ...
[10:55:42.754] - state: 'running'
[10:55:42.755] - run: TRUE
[10:55:42.755] - result: 'NULL'
[10:55:42.755] - resolved: FALSE
[10:55:42.756] resolved() for 'MiraiFuture' ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b859a48e-c511-ea97-6436-2c6143ec3048
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.756] getGlobalsAndPackages() ...
[10:55:42.757] Searching for globals...
[10:55:42.757] 
[10:55:42.758] Searching for globals ... DONE
[10:55:42.758] - globals: [0] <none>
[10:55:42.758] getGlobalsAndPackages() ... DONE
[10:55:42.758] getGlobalsAndPackages() ...
[10:55:42.759] 
[10:55:42.759] - globals: [0] <none>
[10:55:42.759] getGlobalsAndPackages() ... DONE
[10:55:42.760] Packages needed by the future expression (n = 0): <none>
[10:55:42.760] Packages needed by future strategies (n = 0): <none>
[10:55:42.761] {
[10:55:42.761]     {
[10:55:42.761]         {
[10:55:42.761]             ...future.startTime <- base::Sys.time()
[10:55:42.761]             {
[10:55:42.761]                 {
[10:55:42.761]                   {
[10:55:42.761]                     base::local({
[10:55:42.761]                       has_future <- base::requireNamespace("future", 
[10:55:42.761]                         quietly = TRUE)
[10:55:42.761]                       if (has_future) {
[10:55:42.761]                         ns <- base::getNamespace("future")
[10:55:42.761]                         version <- ns[[".package"]][["version"]]
[10:55:42.761]                         if (is.null(version)) 
[10:55:42.761]                           version <- utils::packageVersion("future")
[10:55:42.761]                       }
[10:55:42.761]                       else {
[10:55:42.761]                         version <- NULL
[10:55:42.761]                       }
[10:55:42.761]                       if (!has_future || version < "1.8.0") {
[10:55:42.761]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.761]                           "", base::R.version$version.string), 
[10:55:42.761]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.761]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.761]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.761]                             "release", "version")], collapse = " "), 
[10:55:42.761]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.761]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.761]                           info)
[10:55:42.761]                         info <- base::paste(info, collapse = "; ")
[10:55:42.761]                         if (!has_future) {
[10:55:42.761]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.761]                             info)
[10:55:42.761]                         }
[10:55:42.761]                         else {
[10:55:42.761]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.761]                             info, version)
[10:55:42.761]                         }
[10:55:42.761]                         base::stop(msg)
[10:55:42.761]                       }
[10:55:42.761]                     })
[10:55:42.761]                   }
[10:55:42.761]                   ...future.strategy.old <- future::plan("list")
[10:55:42.761]                   options(future.plan = NULL)
[10:55:42.761]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.761]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.761]                 }
[10:55:42.761]                 ...future.workdir <- getwd()
[10:55:42.761]             }
[10:55:42.761]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.761]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.761]         }
[10:55:42.761]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.761]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.761]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.761]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.761]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.761]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.761]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.761]             base::names(...future.oldOptions))
[10:55:42.761]     }
[10:55:42.761]     if (FALSE) {
[10:55:42.761]     }
[10:55:42.761]     else {
[10:55:42.761]         if (TRUE) {
[10:55:42.761]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.761]                 open = "w")
[10:55:42.761]         }
[10:55:42.761]         else {
[10:55:42.761]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.761]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.761]         }
[10:55:42.761]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.761]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.761]             base::sink(type = "output", split = FALSE)
[10:55:42.761]             base::close(...future.stdout)
[10:55:42.761]         }, add = TRUE)
[10:55:42.761]     }
[10:55:42.761]     ...future.frame <- base::sys.nframe()
[10:55:42.761]     ...future.conditions <- base::list()
[10:55:42.761]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.761]     if (FALSE) {
[10:55:42.761]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.761]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.761]     }
[10:55:42.761]     ...future.result <- base::tryCatch({
[10:55:42.761]         base::withCallingHandlers({
[10:55:42.761]             ...future.value <- base::withVisible(base::local(42))
[10:55:42.761]             future::FutureResult(value = ...future.value$value, 
[10:55:42.761]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.761]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.761]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.761]                     ...future.globalenv.names))
[10:55:42.761]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.761]         }, condition = base::local({
[10:55:42.761]             c <- base::c
[10:55:42.761]             inherits <- base::inherits
[10:55:42.761]             invokeRestart <- base::invokeRestart
[10:55:42.761]             length <- base::length
[10:55:42.761]             list <- base::list
[10:55:42.761]             seq.int <- base::seq.int
[10:55:42.761]             signalCondition <- base::signalCondition
[10:55:42.761]             sys.calls <- base::sys.calls
[10:55:42.761]             `[[` <- base::`[[`
[10:55:42.761]             `+` <- base::`+`
[10:55:42.761]             `<<-` <- base::`<<-`
[10:55:42.761]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.761]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.761]                   3L)]
[10:55:42.761]             }
[10:55:42.761]             function(cond) {
[10:55:42.761]                 is_error <- inherits(cond, "error")
[10:55:42.761]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.761]                   NULL)
[10:55:42.761]                 if (is_error) {
[10:55:42.761]                   sessionInformation <- function() {
[10:55:42.761]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.761]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.761]                       search = base::search(), system = base::Sys.info())
[10:55:42.761]                   }
[10:55:42.761]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.761]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.761]                     cond$call), session = sessionInformation(), 
[10:55:42.761]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.761]                   signalCondition(cond)
[10:55:42.761]                 }
[10:55:42.761]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.761]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.761]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.761]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.761]                   if (FALSE && !signal) {
[10:55:42.761]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.761]                     {
[10:55:42.761]                       inherits <- base::inherits
[10:55:42.761]                       invokeRestart <- base::invokeRestart
[10:55:42.761]                       is.null <- base::is.null
[10:55:42.761]                       muffled <- FALSE
[10:55:42.761]                       if (inherits(cond, "message")) {
[10:55:42.761]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.761]                         if (muffled) 
[10:55:42.761]                           invokeRestart("muffleMessage")
[10:55:42.761]                       }
[10:55:42.761]                       else if (inherits(cond, "warning")) {
[10:55:42.761]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.761]                         if (muffled) 
[10:55:42.761]                           invokeRestart("muffleWarning")
[10:55:42.761]                       }
[10:55:42.761]                       else if (inherits(cond, "condition")) {
[10:55:42.761]                         if (!is.null(pattern)) {
[10:55:42.761]                           computeRestarts <- base::computeRestarts
[10:55:42.761]                           grepl <- base::grepl
[10:55:42.761]                           restarts <- computeRestarts(cond)
[10:55:42.761]                           for (restart in restarts) {
[10:55:42.761]                             name <- restart$name
[10:55:42.761]                             if (is.null(name)) 
[10:55:42.761]                               next
[10:55:42.761]                             if (!grepl(pattern, name)) 
[10:55:42.761]                               next
[10:55:42.761]                             invokeRestart(restart)
[10:55:42.761]                             muffled <- TRUE
[10:55:42.761]                             break
[10:55:42.761]                           }
[10:55:42.761]                         }
[10:55:42.761]                       }
[10:55:42.761]                       invisible(muffled)
[10:55:42.761]                     }
[10:55:42.761]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.761]                   }
[10:55:42.761]                 }
[10:55:42.761]                 else {
[10:55:42.761]                   if (TRUE) {
[10:55:42.761]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.761]                     {
[10:55:42.761]                       inherits <- base::inherits
[10:55:42.761]                       invokeRestart <- base::invokeRestart
[10:55:42.761]                       is.null <- base::is.null
[10:55:42.761]                       muffled <- FALSE
[10:55:42.761]                       if (inherits(cond, "message")) {
[10:55:42.761]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.761]                         if (muffled) 
[10:55:42.761]                           invokeRestart("muffleMessage")
[10:55:42.761]                       }
[10:55:42.761]                       else if (inherits(cond, "warning")) {
[10:55:42.761]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.761]                         if (muffled) 
[10:55:42.761]                           invokeRestart("muffleWarning")
[10:55:42.761]                       }
[10:55:42.761]                       else if (inherits(cond, "condition")) {
[10:55:42.761]                         if (!is.null(pattern)) {
[10:55:42.761]                           computeRestarts <- base::computeRestarts
[10:55:42.761]                           grepl <- base::grepl
[10:55:42.761]                           restarts <- computeRestarts(cond)
[10:55:42.761]                           for (restart in restarts) {
[10:55:42.761]                             name <- restart$name
[10:55:42.761]                             if (is.null(name)) 
[10:55:42.761]                               next
[10:55:42.761]                             if (!grepl(pattern, name)) 
[10:55:42.761]                               next
[10:55:42.761]                             invokeRestart(restart)
[10:55:42.761]                             muffled <- TRUE
[10:55:42.761]                             break
[10:55:42.761]                           }
[10:55:42.761]                         }
[10:55:42.761]                       }
[10:55:42.761]                       invisible(muffled)
[10:55:42.761]                     }
[10:55:42.761]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.761]                   }
[10:55:42.761]                 }
[10:55:42.761]             }
[10:55:42.761]         }))
[10:55:42.761]     }, error = function(ex) {
[10:55:42.761]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.761]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.761]                 ...future.rng), started = ...future.startTime, 
[10:55:42.761]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.761]             version = "1.8"), class = "FutureResult")
[10:55:42.761]     }, finally = {
[10:55:42.761]         if (!identical(...future.workdir, getwd())) 
[10:55:42.761]             setwd(...future.workdir)
[10:55:42.761]         {
[10:55:42.761]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.761]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.761]             }
[10:55:42.761]             base::options(...future.oldOptions)
[10:55:42.761]             if (.Platform$OS.type == "windows") {
[10:55:42.761]                 old_names <- names(...future.oldEnvVars)
[10:55:42.761]                 envs <- base::Sys.getenv()
[10:55:42.761]                 names <- names(envs)
[10:55:42.761]                 common <- intersect(names, old_names)
[10:55:42.761]                 added <- setdiff(names, old_names)
[10:55:42.761]                 removed <- setdiff(old_names, names)
[10:55:42.761]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.761]                   envs[common]]
[10:55:42.761]                 NAMES <- toupper(changed)
[10:55:42.761]                 args <- list()
[10:55:42.761]                 for (kk in seq_along(NAMES)) {
[10:55:42.761]                   name <- changed[[kk]]
[10:55:42.761]                   NAME <- NAMES[[kk]]
[10:55:42.761]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.761]                     next
[10:55:42.761]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.761]                 }
[10:55:42.761]                 NAMES <- toupper(added)
[10:55:42.761]                 for (kk in seq_along(NAMES)) {
[10:55:42.761]                   name <- added[[kk]]
[10:55:42.761]                   NAME <- NAMES[[kk]]
[10:55:42.761]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.761]                     next
[10:55:42.761]                   args[[name]] <- ""
[10:55:42.761]                 }
[10:55:42.761]                 NAMES <- toupper(removed)
[10:55:42.761]                 for (kk in seq_along(NAMES)) {
[10:55:42.761]                   name <- removed[[kk]]
[10:55:42.761]                   NAME <- NAMES[[kk]]
[10:55:42.761]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.761]                     next
[10:55:42.761]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.761]                 }
[10:55:42.761]                 if (length(args) > 0) 
[10:55:42.761]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.761]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.761]             }
[10:55:42.761]             else {
[10:55:42.761]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.761]             }
[10:55:42.761]             {
[10:55:42.761]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.761]                   0L) {
[10:55:42.761]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.761]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.761]                   base::options(opts)
[10:55:42.761]                 }
[10:55:42.761]                 {
[10:55:42.761]                   NULL
[10:55:42.761]                   options(future.plan = NULL)
[10:55:42.761]                   if (is.na(NA_character_)) 
[10:55:42.761]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.761]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.761]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.761]                     .init = FALSE)
[10:55:42.761]                 }
[10:55:42.761]             }
[10:55:42.761]         }
[10:55:42.761]     })
[10:55:42.761]     if (TRUE) {
[10:55:42.761]         base::sink(type = "output", split = FALSE)
[10:55:42.761]         if (TRUE) {
[10:55:42.761]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.761]         }
[10:55:42.761]         else {
[10:55:42.761]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.761]         }
[10:55:42.761]         base::close(...future.stdout)
[10:55:42.761]         ...future.stdout <- NULL
[10:55:42.761]     }
[10:55:42.761]     ...future.result$conditions <- ...future.conditions
[10:55:42.761]     ...future.result$finished <- base::Sys.time()
[10:55:42.761]     ...future.result
[10:55:42.761] }
MiraiFuture:
Label: 'strategy_mirai_cluster'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:55:42.768] resolved() for 'MiraiFuture' ...
[10:55:42.768] - state: 'running'
[10:55:42.769] - run: TRUE
[10:55:42.769] - result: 'NULL'
[10:55:42.769] - resolved: FALSE
[10:55:42.770] resolved() for 'MiraiFuture' ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b859a48e-c511-ea97-6436-2c6143ec3048
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.770] getGlobalsAndPackages() ...
[10:55:42.771] Searching for globals...
[10:55:42.771] 
[10:55:42.772] Searching for globals ... DONE
[10:55:42.772] - globals: [0] <none>
[10:55:42.772] getGlobalsAndPackages() ... DONE
[10:55:42.773] run() for 'Future' ...
[10:55:42.773] - state: 'created'
[10:55:42.773] - Future backend: 'FutureStrategy', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[10:55:42.774] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.774] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[10:55:42.774]   - Field: 'label'
[10:55:42.775]   - Field: 'local'
[10:55:42.775]   - Field: 'owner'
[10:55:42.775]   - Field: 'envir'
[10:55:42.775]   - Field: 'packages'
[10:55:42.776]   - Field: 'gc'
[10:55:42.776]   - Field: 'conditions'
[10:55:42.776]   - Field: 'expr'
[10:55:42.777]   - Field: 'uuid'
[10:55:42.777]   - Field: 'seed'
[10:55:42.777]   - Field: 'version'
[10:55:42.777]   - Field: 'result'
[10:55:42.778]   - Field: 'asynchronous'
[10:55:42.778]   - Field: 'calls'
[10:55:42.778]   - Field: 'globals'
[10:55:42.779]   - Field: 'stdout'
[10:55:42.779]   - Field: 'earlySignal'
[10:55:42.779]   - Field: 'lazy'
[10:55:42.780]   - Field: 'state'
[10:55:42.780]   - Field: '.cluster'
[10:55:42.780] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[10:55:42.780] - Launch lazy future ...
[10:55:42.781] Packages needed by the future expression (n = 0): <none>
[10:55:42.781] Packages needed by future strategies (n = 0): <none>
[10:55:42.782] {
[10:55:42.782]     {
[10:55:42.782]         {
[10:55:42.782]             ...future.startTime <- base::Sys.time()
[10:55:42.782]             {
[10:55:42.782]                 {
[10:55:42.782]                   {
[10:55:42.782]                     base::local({
[10:55:42.782]                       has_future <- base::requireNamespace("future", 
[10:55:42.782]                         quietly = TRUE)
[10:55:42.782]                       if (has_future) {
[10:55:42.782]                         ns <- base::getNamespace("future")
[10:55:42.782]                         version <- ns[[".package"]][["version"]]
[10:55:42.782]                         if (is.null(version)) 
[10:55:42.782]                           version <- utils::packageVersion("future")
[10:55:42.782]                       }
[10:55:42.782]                       else {
[10:55:42.782]                         version <- NULL
[10:55:42.782]                       }
[10:55:42.782]                       if (!has_future || version < "1.8.0") {
[10:55:42.782]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.782]                           "", base::R.version$version.string), 
[10:55:42.782]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.782]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.782]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.782]                             "release", "version")], collapse = " "), 
[10:55:42.782]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.782]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.782]                           info)
[10:55:42.782]                         info <- base::paste(info, collapse = "; ")
[10:55:42.782]                         if (!has_future) {
[10:55:42.782]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.782]                             info)
[10:55:42.782]                         }
[10:55:42.782]                         else {
[10:55:42.782]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.782]                             info, version)
[10:55:42.782]                         }
[10:55:42.782]                         base::stop(msg)
[10:55:42.782]                       }
[10:55:42.782]                     })
[10:55:42.782]                   }
[10:55:42.782]                   ...future.strategy.old <- future::plan("list")
[10:55:42.782]                   options(future.plan = NULL)
[10:55:42.782]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.782]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.782]                 }
[10:55:42.782]                 ...future.workdir <- getwd()
[10:55:42.782]             }
[10:55:42.782]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.782]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.782]         }
[10:55:42.782]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.782]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.782]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.782]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.782]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.782]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.782]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.782]             base::names(...future.oldOptions))
[10:55:42.782]     }
[10:55:42.782]     if (FALSE) {
[10:55:42.782]     }
[10:55:42.782]     else {
[10:55:42.782]         if (TRUE) {
[10:55:42.782]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.782]                 open = "w")
[10:55:42.782]         }
[10:55:42.782]         else {
[10:55:42.782]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.782]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.782]         }
[10:55:42.782]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.782]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.782]             base::sink(type = "output", split = FALSE)
[10:55:42.782]             base::close(...future.stdout)
[10:55:42.782]         }, add = TRUE)
[10:55:42.782]     }
[10:55:42.782]     ...future.frame <- base::sys.nframe()
[10:55:42.782]     ...future.conditions <- base::list()
[10:55:42.782]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.782]     if (FALSE) {
[10:55:42.782]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.782]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.782]     }
[10:55:42.782]     ...future.result <- base::tryCatch({
[10:55:42.782]         base::withCallingHandlers({
[10:55:42.782]             ...future.value <- base::withVisible(base::local(42))
[10:55:42.782]             future::FutureResult(value = ...future.value$value, 
[10:55:42.782]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.782]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.782]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.782]                     ...future.globalenv.names))
[10:55:42.782]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.782]         }, condition = base::local({
[10:55:42.782]             c <- base::c
[10:55:42.782]             inherits <- base::inherits
[10:55:42.782]             invokeRestart <- base::invokeRestart
[10:55:42.782]             length <- base::length
[10:55:42.782]             list <- base::list
[10:55:42.782]             seq.int <- base::seq.int
[10:55:42.782]             signalCondition <- base::signalCondition
[10:55:42.782]             sys.calls <- base::sys.calls
[10:55:42.782]             `[[` <- base::`[[`
[10:55:42.782]             `+` <- base::`+`
[10:55:42.782]             `<<-` <- base::`<<-`
[10:55:42.782]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.782]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.782]                   3L)]
[10:55:42.782]             }
[10:55:42.782]             function(cond) {
[10:55:42.782]                 is_error <- inherits(cond, "error")
[10:55:42.782]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.782]                   NULL)
[10:55:42.782]                 if (is_error) {
[10:55:42.782]                   sessionInformation <- function() {
[10:55:42.782]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.782]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.782]                       search = base::search(), system = base::Sys.info())
[10:55:42.782]                   }
[10:55:42.782]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.782]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.782]                     cond$call), session = sessionInformation(), 
[10:55:42.782]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.782]                   signalCondition(cond)
[10:55:42.782]                 }
[10:55:42.782]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.782]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.782]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.782]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.782]                   if (FALSE && !signal) {
[10:55:42.782]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.782]                     {
[10:55:42.782]                       inherits <- base::inherits
[10:55:42.782]                       invokeRestart <- base::invokeRestart
[10:55:42.782]                       is.null <- base::is.null
[10:55:42.782]                       muffled <- FALSE
[10:55:42.782]                       if (inherits(cond, "message")) {
[10:55:42.782]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.782]                         if (muffled) 
[10:55:42.782]                           invokeRestart("muffleMessage")
[10:55:42.782]                       }
[10:55:42.782]                       else if (inherits(cond, "warning")) {
[10:55:42.782]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.782]                         if (muffled) 
[10:55:42.782]                           invokeRestart("muffleWarning")
[10:55:42.782]                       }
[10:55:42.782]                       else if (inherits(cond, "condition")) {
[10:55:42.782]                         if (!is.null(pattern)) {
[10:55:42.782]                           computeRestarts <- base::computeRestarts
[10:55:42.782]                           grepl <- base::grepl
[10:55:42.782]                           restarts <- computeRestarts(cond)
[10:55:42.782]                           for (restart in restarts) {
[10:55:42.782]                             name <- restart$name
[10:55:42.782]                             if (is.null(name)) 
[10:55:42.782]                               next
[10:55:42.782]                             if (!grepl(pattern, name)) 
[10:55:42.782]                               next
[10:55:42.782]                             invokeRestart(restart)
[10:55:42.782]                             muffled <- TRUE
[10:55:42.782]                             break
[10:55:42.782]                           }
[10:55:42.782]                         }
[10:55:42.782]                       }
[10:55:42.782]                       invisible(muffled)
[10:55:42.782]                     }
[10:55:42.782]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.782]                   }
[10:55:42.782]                 }
[10:55:42.782]                 else {
[10:55:42.782]                   if (TRUE) {
[10:55:42.782]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.782]                     {
[10:55:42.782]                       inherits <- base::inherits
[10:55:42.782]                       invokeRestart <- base::invokeRestart
[10:55:42.782]                       is.null <- base::is.null
[10:55:42.782]                       muffled <- FALSE
[10:55:42.782]                       if (inherits(cond, "message")) {
[10:55:42.782]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.782]                         if (muffled) 
[10:55:42.782]                           invokeRestart("muffleMessage")
[10:55:42.782]                       }
[10:55:42.782]                       else if (inherits(cond, "warning")) {
[10:55:42.782]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.782]                         if (muffled) 
[10:55:42.782]                           invokeRestart("muffleWarning")
[10:55:42.782]                       }
[10:55:42.782]                       else if (inherits(cond, "condition")) {
[10:55:42.782]                         if (!is.null(pattern)) {
[10:55:42.782]                           computeRestarts <- base::computeRestarts
[10:55:42.782]                           grepl <- base::grepl
[10:55:42.782]                           restarts <- computeRestarts(cond)
[10:55:42.782]                           for (restart in restarts) {
[10:55:42.782]                             name <- restart$name
[10:55:42.782]                             if (is.null(name)) 
[10:55:42.782]                               next
[10:55:42.782]                             if (!grepl(pattern, name)) 
[10:55:42.782]                               next
[10:55:42.782]                             invokeRestart(restart)
[10:55:42.782]                             muffled <- TRUE
[10:55:42.782]                             break
[10:55:42.782]                           }
[10:55:42.782]                         }
[10:55:42.782]                       }
[10:55:42.782]                       invisible(muffled)
[10:55:42.782]                     }
[10:55:42.782]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.782]                   }
[10:55:42.782]                 }
[10:55:42.782]             }
[10:55:42.782]         }))
[10:55:42.782]     }, error = function(ex) {
[10:55:42.782]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.782]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.782]                 ...future.rng), started = ...future.startTime, 
[10:55:42.782]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.782]             version = "1.8"), class = "FutureResult")
[10:55:42.782]     }, finally = {
[10:55:42.782]         if (!identical(...future.workdir, getwd())) 
[10:55:42.782]             setwd(...future.workdir)
[10:55:42.782]         {
[10:55:42.782]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.782]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.782]             }
[10:55:42.782]             base::options(...future.oldOptions)
[10:55:42.782]             if (.Platform$OS.type == "windows") {
[10:55:42.782]                 old_names <- names(...future.oldEnvVars)
[10:55:42.782]                 envs <- base::Sys.getenv()
[10:55:42.782]                 names <- names(envs)
[10:55:42.782]                 common <- intersect(names, old_names)
[10:55:42.782]                 added <- setdiff(names, old_names)
[10:55:42.782]                 removed <- setdiff(old_names, names)
[10:55:42.782]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.782]                   envs[common]]
[10:55:42.782]                 NAMES <- toupper(changed)
[10:55:42.782]                 args <- list()
[10:55:42.782]                 for (kk in seq_along(NAMES)) {
[10:55:42.782]                   name <- changed[[kk]]
[10:55:42.782]                   NAME <- NAMES[[kk]]
[10:55:42.782]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.782]                     next
[10:55:42.782]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.782]                 }
[10:55:42.782]                 NAMES <- toupper(added)
[10:55:42.782]                 for (kk in seq_along(NAMES)) {
[10:55:42.782]                   name <- added[[kk]]
[10:55:42.782]                   NAME <- NAMES[[kk]]
[10:55:42.782]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.782]                     next
[10:55:42.782]                   args[[name]] <- ""
[10:55:42.782]                 }
[10:55:42.782]                 NAMES <- toupper(removed)
[10:55:42.782]                 for (kk in seq_along(NAMES)) {
[10:55:42.782]                   name <- removed[[kk]]
[10:55:42.782]                   NAME <- NAMES[[kk]]
[10:55:42.782]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.782]                     next
[10:55:42.782]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.782]                 }
[10:55:42.782]                 if (length(args) > 0) 
[10:55:42.782]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.782]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.782]             }
[10:55:42.782]             else {
[10:55:42.782]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.782]             }
[10:55:42.782]             {
[10:55:42.782]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.782]                   0L) {
[10:55:42.782]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.782]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.782]                   base::options(opts)
[10:55:42.782]                 }
[10:55:42.782]                 {
[10:55:42.782]                   NULL
[10:55:42.782]                   options(future.plan = NULL)
[10:55:42.782]                   if (is.na(NA_character_)) 
[10:55:42.782]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.782]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.782]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.782]                     .init = FALSE)
[10:55:42.782]                 }
[10:55:42.782]             }
[10:55:42.782]         }
[10:55:42.782]     })
[10:55:42.782]     if (TRUE) {
[10:55:42.782]         base::sink(type = "output", split = FALSE)
[10:55:42.782]         if (TRUE) {
[10:55:42.782]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.782]         }
[10:55:42.782]         else {
[10:55:42.782]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.782]         }
[10:55:42.782]         base::close(...future.stdout)
[10:55:42.782]         ...future.stdout <- NULL
[10:55:42.782]     }
[10:55:42.782]     ...future.result$conditions <- ...future.conditions
[10:55:42.782]     ...future.result$finished <- base::Sys.time()
[10:55:42.782]     ...future.result
[10:55:42.782] }
[10:55:42.789] - Launch lazy future ... done
[10:55:42.789] run() for 'MiraiFuture' ... done
MiraiFuture:
Label: 'strategy_mirai_cluster'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:55:42.790] resolved() for 'MiraiFuture' ...
[10:55:42.790] - state: 'running'
[10:55:42.790] - run: TRUE
[10:55:42.791] - result: 'NULL'
[10:55:42.791] - resolved: FALSE
[10:55:42.791] resolved() for 'MiraiFuture' ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b859a48e-c511-ea97-6436-2c6143ec3048
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.792] getGlobalsAndPackages() ...
[10:55:42.792] Searching for globals...
[10:55:42.794] - globals found: [1] '{'
[10:55:42.794] Searching for globals ... DONE
[10:55:42.794] Resolving globals: FALSE
[10:55:42.795] 
[10:55:42.795] 
[10:55:42.795] getGlobalsAndPackages() ... DONE
[10:55:42.796] run() for 'Future' ...
[10:55:42.796] - state: 'created'
[10:55:42.796] - Future backend: 'FutureStrategy', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[10:55:42.797] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.797] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[10:55:42.797]   - Field: 'label'
[10:55:42.798]   - Field: 'local'
[10:55:42.798]   - Field: 'owner'
[10:55:42.798]   - Field: 'envir'
[10:55:42.799]   - Field: 'packages'
[10:55:42.799]   - Field: 'gc'
[10:55:42.799]   - Field: 'conditions'
[10:55:42.799]   - Field: 'expr'
[10:55:42.800]   - Field: 'uuid'
[10:55:42.800]   - Field: 'seed'
[10:55:42.800]   - Field: 'version'
[10:55:42.801]   - Field: 'result'
[10:55:42.801]   - Field: 'asynchronous'
[10:55:42.804]   - Field: 'calls'
[10:55:42.805]   - Field: 'globals'
[10:55:42.805]   - Field: 'stdout'
[10:55:42.805]   - Field: 'earlySignal'
[10:55:42.805]   - Field: 'lazy'
[10:55:42.806]   - Field: 'state'
[10:55:42.806]   - Field: '.cluster'
[10:55:42.806] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[10:55:42.807] - Launch lazy future ...
[10:55:42.807] Packages needed by the future expression (n = 0): <none>
[10:55:42.807] Packages needed by future strategies (n = 0): <none>
[10:55:42.808] {
[10:55:42.808]     {
[10:55:42.808]         {
[10:55:42.808]             ...future.startTime <- base::Sys.time()
[10:55:42.808]             {
[10:55:42.808]                 {
[10:55:42.808]                   {
[10:55:42.808]                     base::local({
[10:55:42.808]                       has_future <- base::requireNamespace("future", 
[10:55:42.808]                         quietly = TRUE)
[10:55:42.808]                       if (has_future) {
[10:55:42.808]                         ns <- base::getNamespace("future")
[10:55:42.808]                         version <- ns[[".package"]][["version"]]
[10:55:42.808]                         if (is.null(version)) 
[10:55:42.808]                           version <- utils::packageVersion("future")
[10:55:42.808]                       }
[10:55:42.808]                       else {
[10:55:42.808]                         version <- NULL
[10:55:42.808]                       }
[10:55:42.808]                       if (!has_future || version < "1.8.0") {
[10:55:42.808]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.808]                           "", base::R.version$version.string), 
[10:55:42.808]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.808]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.808]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.808]                             "release", "version")], collapse = " "), 
[10:55:42.808]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.808]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.808]                           info)
[10:55:42.808]                         info <- base::paste(info, collapse = "; ")
[10:55:42.808]                         if (!has_future) {
[10:55:42.808]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.808]                             info)
[10:55:42.808]                         }
[10:55:42.808]                         else {
[10:55:42.808]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.808]                             info, version)
[10:55:42.808]                         }
[10:55:42.808]                         base::stop(msg)
[10:55:42.808]                       }
[10:55:42.808]                     })
[10:55:42.808]                   }
[10:55:42.808]                   ...future.strategy.old <- future::plan("list")
[10:55:42.808]                   options(future.plan = NULL)
[10:55:42.808]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.808]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.808]                 }
[10:55:42.808]                 ...future.workdir <- getwd()
[10:55:42.808]             }
[10:55:42.808]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.808]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.808]         }
[10:55:42.808]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.808]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.808]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.808]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.808]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.808]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.808]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.808]             base::names(...future.oldOptions))
[10:55:42.808]     }
[10:55:42.808]     if (FALSE) {
[10:55:42.808]     }
[10:55:42.808]     else {
[10:55:42.808]         if (TRUE) {
[10:55:42.808]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.808]                 open = "w")
[10:55:42.808]         }
[10:55:42.808]         else {
[10:55:42.808]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.808]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.808]         }
[10:55:42.808]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.808]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.808]             base::sink(type = "output", split = FALSE)
[10:55:42.808]             base::close(...future.stdout)
[10:55:42.808]         }, add = TRUE)
[10:55:42.808]     }
[10:55:42.808]     ...future.frame <- base::sys.nframe()
[10:55:42.808]     ...future.conditions <- base::list()
[10:55:42.808]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.808]     if (FALSE) {
[10:55:42.808]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.808]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.808]     }
[10:55:42.808]     ...future.result <- base::tryCatch({
[10:55:42.808]         base::withCallingHandlers({
[10:55:42.808]             ...future.value <- base::withVisible(base::local({
[10:55:42.808]                 42
[10:55:42.808]             }))
[10:55:42.808]             future::FutureResult(value = ...future.value$value, 
[10:55:42.808]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.808]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.808]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.808]                     ...future.globalenv.names))
[10:55:42.808]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.808]         }, condition = base::local({
[10:55:42.808]             c <- base::c
[10:55:42.808]             inherits <- base::inherits
[10:55:42.808]             invokeRestart <- base::invokeRestart
[10:55:42.808]             length <- base::length
[10:55:42.808]             list <- base::list
[10:55:42.808]             seq.int <- base::seq.int
[10:55:42.808]             signalCondition <- base::signalCondition
[10:55:42.808]             sys.calls <- base::sys.calls
[10:55:42.808]             `[[` <- base::`[[`
[10:55:42.808]             `+` <- base::`+`
[10:55:42.808]             `<<-` <- base::`<<-`
[10:55:42.808]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.808]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.808]                   3L)]
[10:55:42.808]             }
[10:55:42.808]             function(cond) {
[10:55:42.808]                 is_error <- inherits(cond, "error")
[10:55:42.808]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.808]                   NULL)
[10:55:42.808]                 if (is_error) {
[10:55:42.808]                   sessionInformation <- function() {
[10:55:42.808]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.808]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.808]                       search = base::search(), system = base::Sys.info())
[10:55:42.808]                   }
[10:55:42.808]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.808]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.808]                     cond$call), session = sessionInformation(), 
[10:55:42.808]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.808]                   signalCondition(cond)
[10:55:42.808]                 }
[10:55:42.808]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.808]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.808]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.808]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.808]                   if (FALSE && !signal) {
[10:55:42.808]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.808]                     {
[10:55:42.808]                       inherits <- base::inherits
[10:55:42.808]                       invokeRestart <- base::invokeRestart
[10:55:42.808]                       is.null <- base::is.null
[10:55:42.808]                       muffled <- FALSE
[10:55:42.808]                       if (inherits(cond, "message")) {
[10:55:42.808]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.808]                         if (muffled) 
[10:55:42.808]                           invokeRestart("muffleMessage")
[10:55:42.808]                       }
[10:55:42.808]                       else if (inherits(cond, "warning")) {
[10:55:42.808]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.808]                         if (muffled) 
[10:55:42.808]                           invokeRestart("muffleWarning")
[10:55:42.808]                       }
[10:55:42.808]                       else if (inherits(cond, "condition")) {
[10:55:42.808]                         if (!is.null(pattern)) {
[10:55:42.808]                           computeRestarts <- base::computeRestarts
[10:55:42.808]                           grepl <- base::grepl
[10:55:42.808]                           restarts <- computeRestarts(cond)
[10:55:42.808]                           for (restart in restarts) {
[10:55:42.808]                             name <- restart$name
[10:55:42.808]                             if (is.null(name)) 
[10:55:42.808]                               next
[10:55:42.808]                             if (!grepl(pattern, name)) 
[10:55:42.808]                               next
[10:55:42.808]                             invokeRestart(restart)
[10:55:42.808]                             muffled <- TRUE
[10:55:42.808]                             break
[10:55:42.808]                           }
[10:55:42.808]                         }
[10:55:42.808]                       }
[10:55:42.808]                       invisible(muffled)
[10:55:42.808]                     }
[10:55:42.808]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.808]                   }
[10:55:42.808]                 }
[10:55:42.808]                 else {
[10:55:42.808]                   if (TRUE) {
[10:55:42.808]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.808]                     {
[10:55:42.808]                       inherits <- base::inherits
[10:55:42.808]                       invokeRestart <- base::invokeRestart
[10:55:42.808]                       is.null <- base::is.null
[10:55:42.808]                       muffled <- FALSE
[10:55:42.808]                       if (inherits(cond, "message")) {
[10:55:42.808]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.808]                         if (muffled) 
[10:55:42.808]                           invokeRestart("muffleMessage")
[10:55:42.808]                       }
[10:55:42.808]                       else if (inherits(cond, "warning")) {
[10:55:42.808]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.808]                         if (muffled) 
[10:55:42.808]                           invokeRestart("muffleWarning")
[10:55:42.808]                       }
[10:55:42.808]                       else if (inherits(cond, "condition")) {
[10:55:42.808]                         if (!is.null(pattern)) {
[10:55:42.808]                           computeRestarts <- base::computeRestarts
[10:55:42.808]                           grepl <- base::grepl
[10:55:42.808]                           restarts <- computeRestarts(cond)
[10:55:42.808]                           for (restart in restarts) {
[10:55:42.808]                             name <- restart$name
[10:55:42.808]                             if (is.null(name)) 
[10:55:42.808]                               next
[10:55:42.808]                             if (!grepl(pattern, name)) 
[10:55:42.808]                               next
[10:55:42.808]                             invokeRestart(restart)
[10:55:42.808]                             muffled <- TRUE
[10:55:42.808]                             break
[10:55:42.808]                           }
[10:55:42.808]                         }
[10:55:42.808]                       }
[10:55:42.808]                       invisible(muffled)
[10:55:42.808]                     }
[10:55:42.808]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.808]                   }
[10:55:42.808]                 }
[10:55:42.808]             }
[10:55:42.808]         }))
[10:55:42.808]     }, error = function(ex) {
[10:55:42.808]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.808]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.808]                 ...future.rng), started = ...future.startTime, 
[10:55:42.808]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.808]             version = "1.8"), class = "FutureResult")
[10:55:42.808]     }, finally = {
[10:55:42.808]         if (!identical(...future.workdir, getwd())) 
[10:55:42.808]             setwd(...future.workdir)
[10:55:42.808]         {
[10:55:42.808]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.808]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.808]             }
[10:55:42.808]             base::options(...future.oldOptions)
[10:55:42.808]             if (.Platform$OS.type == "windows") {
[10:55:42.808]                 old_names <- names(...future.oldEnvVars)
[10:55:42.808]                 envs <- base::Sys.getenv()
[10:55:42.808]                 names <- names(envs)
[10:55:42.808]                 common <- intersect(names, old_names)
[10:55:42.808]                 added <- setdiff(names, old_names)
[10:55:42.808]                 removed <- setdiff(old_names, names)
[10:55:42.808]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.808]                   envs[common]]
[10:55:42.808]                 NAMES <- toupper(changed)
[10:55:42.808]                 args <- list()
[10:55:42.808]                 for (kk in seq_along(NAMES)) {
[10:55:42.808]                   name <- changed[[kk]]
[10:55:42.808]                   NAME <- NAMES[[kk]]
[10:55:42.808]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.808]                     next
[10:55:42.808]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.808]                 }
[10:55:42.808]                 NAMES <- toupper(added)
[10:55:42.808]                 for (kk in seq_along(NAMES)) {
[10:55:42.808]                   name <- added[[kk]]
[10:55:42.808]                   NAME <- NAMES[[kk]]
[10:55:42.808]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.808]                     next
[10:55:42.808]                   args[[name]] <- ""
[10:55:42.808]                 }
[10:55:42.808]                 NAMES <- toupper(removed)
[10:55:42.808]                 for (kk in seq_along(NAMES)) {
[10:55:42.808]                   name <- removed[[kk]]
[10:55:42.808]                   NAME <- NAMES[[kk]]
[10:55:42.808]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.808]                     next
[10:55:42.808]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.808]                 }
[10:55:42.808]                 if (length(args) > 0) 
[10:55:42.808]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.808]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.808]             }
[10:55:42.808]             else {
[10:55:42.808]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.808]             }
[10:55:42.808]             {
[10:55:42.808]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.808]                   0L) {
[10:55:42.808]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.808]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.808]                   base::options(opts)
[10:55:42.808]                 }
[10:55:42.808]                 {
[10:55:42.808]                   NULL
[10:55:42.808]                   options(future.plan = NULL)
[10:55:42.808]                   if (is.na(NA_character_)) 
[10:55:42.808]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.808]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.808]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.808]                     .init = FALSE)
[10:55:42.808]                 }
[10:55:42.808]             }
[10:55:42.808]         }
[10:55:42.808]     })
[10:55:42.808]     if (TRUE) {
[10:55:42.808]         base::sink(type = "output", split = FALSE)
[10:55:42.808]         if (TRUE) {
[10:55:42.808]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.808]         }
[10:55:42.808]         else {
[10:55:42.808]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.808]         }
[10:55:42.808]         base::close(...future.stdout)
[10:55:42.808]         ...future.stdout <- NULL
[10:55:42.808]     }
[10:55:42.808]     ...future.result$conditions <- ...future.conditions
[10:55:42.808]     ...future.result$finished <- base::Sys.time()
[10:55:42.808]     ...future.result
[10:55:42.808] }
[10:55:42.814] - Launch lazy future ... done
[10:55:42.815] run() for 'MiraiFuture' ... done
MiraiFuture:
Label: 'strategy_mirai_cluster'
Expression:
{
    42
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:55:42.816] resolved() for 'MiraiFuture' ...
[10:55:42.816] - state: 'running'
[10:55:42.816] - run: TRUE
[10:55:42.817] - result: 'NULL'
[10:55:42.817] - resolved: FALSE
[10:55:42.817] resolved() for 'MiraiFuture' ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b859a48e-c511-ea97-6436-2c6143ec3048
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.818] - plan('mirai_cluster') ... DONE[10:55:42.818] - plan('mirai_multisession') ...[10:55:42.819] plan(): Setting new future strategy stack:
[10:55:42.819] List of future strategies:
[10:55:42.819] 1. mirai_multisession:
[10:55:42.819]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
[10:55:42.819]    - tweaked: FALSE
[10:55:42.819]    - call: plan(strategy)
[10:55:42.820] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
[10:55:42.820] < mirai | $data >
[10:55:42.824] getGlobalsAndPackages() ...
[10:55:42.824] Not searching for globals
[10:55:42.824] - globals: [0] <none>
[10:55:42.824] getGlobalsAndPackages() ... DONE
[10:55:42.825] getGlobalsAndPackages() ...
[10:55:42.825] 
[10:55:42.825] - globals: [0] <none>
[10:55:42.826] getGlobalsAndPackages() ... DONE
[10:55:42.826] Packages needed by the future expression (n = 0): <none>
[10:55:42.826] Packages needed by future strategies (n = 0): <none>
[10:55:42.827] {
[10:55:42.827]     {
[10:55:42.827]         {
[10:55:42.827]             ...future.startTime <- base::Sys.time()
[10:55:42.827]             {
[10:55:42.827]                 {
[10:55:42.827]                   {
[10:55:42.827]                     base::local({
[10:55:42.827]                       has_future <- base::requireNamespace("future", 
[10:55:42.827]                         quietly = TRUE)
[10:55:42.827]                       if (has_future) {
[10:55:42.827]                         ns <- base::getNamespace("future")
[10:55:42.827]                         version <- ns[[".package"]][["version"]]
[10:55:42.827]                         if (is.null(version)) 
[10:55:42.827]                           version <- utils::packageVersion("future")
[10:55:42.827]                       }
[10:55:42.827]                       else {
[10:55:42.827]                         version <- NULL
[10:55:42.827]                       }
[10:55:42.827]                       if (!has_future || version < "1.8.0") {
[10:55:42.827]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.827]                           "", base::R.version$version.string), 
[10:55:42.827]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.827]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.827]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.827]                             "release", "version")], collapse = " "), 
[10:55:42.827]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.827]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.827]                           info)
[10:55:42.827]                         info <- base::paste(info, collapse = "; ")
[10:55:42.827]                         if (!has_future) {
[10:55:42.827]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.827]                             info)
[10:55:42.827]                         }
[10:55:42.827]                         else {
[10:55:42.827]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.827]                             info, version)
[10:55:42.827]                         }
[10:55:42.827]                         base::stop(msg)
[10:55:42.827]                       }
[10:55:42.827]                     })
[10:55:42.827]                   }
[10:55:42.827]                   ...future.strategy.old <- future::plan("list")
[10:55:42.827]                   options(future.plan = NULL)
[10:55:42.827]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.827]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.827]                 }
[10:55:42.827]                 ...future.workdir <- getwd()
[10:55:42.827]             }
[10:55:42.827]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.827]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.827]         }
[10:55:42.827]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.827]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.827]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.827]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.827]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.827]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.827]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.827]             base::names(...future.oldOptions))
[10:55:42.827]     }
[10:55:42.827]     if (FALSE) {
[10:55:42.827]     }
[10:55:42.827]     else {
[10:55:42.827]         if (TRUE) {
[10:55:42.827]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.827]                 open = "w")
[10:55:42.827]         }
[10:55:42.827]         else {
[10:55:42.827]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.827]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.827]         }
[10:55:42.827]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.827]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.827]             base::sink(type = "output", split = FALSE)
[10:55:42.827]             base::close(...future.stdout)
[10:55:42.827]         }, add = TRUE)
[10:55:42.827]     }
[10:55:42.827]     ...future.frame <- base::sys.nframe()
[10:55:42.827]     ...future.conditions <- base::list()
[10:55:42.827]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.827]     if (FALSE) {
[10:55:42.827]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.827]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.827]     }
[10:55:42.827]     ...future.result <- base::tryCatch({
[10:55:42.827]         base::withCallingHandlers({
[10:55:42.827]             ...future.value <- base::withVisible(base::local(NA))
[10:55:42.827]             future::FutureResult(value = ...future.value$value, 
[10:55:42.827]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.827]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.827]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.827]                     ...future.globalenv.names))
[10:55:42.827]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.827]         }, condition = base::local({
[10:55:42.827]             c <- base::c
[10:55:42.827]             inherits <- base::inherits
[10:55:42.827]             invokeRestart <- base::invokeRestart
[10:55:42.827]             length <- base::length
[10:55:42.827]             list <- base::list
[10:55:42.827]             seq.int <- base::seq.int
[10:55:42.827]             signalCondition <- base::signalCondition
[10:55:42.827]             sys.calls <- base::sys.calls
[10:55:42.827]             `[[` <- base::`[[`
[10:55:42.827]             `+` <- base::`+`
[10:55:42.827]             `<<-` <- base::`<<-`
[10:55:42.827]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.827]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.827]                   3L)]
[10:55:42.827]             }
[10:55:42.827]             function(cond) {
[10:55:42.827]                 is_error <- inherits(cond, "error")
[10:55:42.827]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.827]                   NULL)
[10:55:42.827]                 if (is_error) {
[10:55:42.827]                   sessionInformation <- function() {
[10:55:42.827]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.827]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.827]                       search = base::search(), system = base::Sys.info())
[10:55:42.827]                   }
[10:55:42.827]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.827]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.827]                     cond$call), session = sessionInformation(), 
[10:55:42.827]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.827]                   signalCondition(cond)
[10:55:42.827]                 }
[10:55:42.827]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.827]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.827]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.827]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.827]                   if (FALSE && !signal) {
[10:55:42.827]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.827]                     {
[10:55:42.827]                       inherits <- base::inherits
[10:55:42.827]                       invokeRestart <- base::invokeRestart
[10:55:42.827]                       is.null <- base::is.null
[10:55:42.827]                       muffled <- FALSE
[10:55:42.827]                       if (inherits(cond, "message")) {
[10:55:42.827]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.827]                         if (muffled) 
[10:55:42.827]                           invokeRestart("muffleMessage")
[10:55:42.827]                       }
[10:55:42.827]                       else if (inherits(cond, "warning")) {
[10:55:42.827]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.827]                         if (muffled) 
[10:55:42.827]                           invokeRestart("muffleWarning")
[10:55:42.827]                       }
[10:55:42.827]                       else if (inherits(cond, "condition")) {
[10:55:42.827]                         if (!is.null(pattern)) {
[10:55:42.827]                           computeRestarts <- base::computeRestarts
[10:55:42.827]                           grepl <- base::grepl
[10:55:42.827]                           restarts <- computeRestarts(cond)
[10:55:42.827]                           for (restart in restarts) {
[10:55:42.827]                             name <- restart$name
[10:55:42.827]                             if (is.null(name)) 
[10:55:42.827]                               next
[10:55:42.827]                             if (!grepl(pattern, name)) 
[10:55:42.827]                               next
[10:55:42.827]                             invokeRestart(restart)
[10:55:42.827]                             muffled <- TRUE
[10:55:42.827]                             break
[10:55:42.827]                           }
[10:55:42.827]                         }
[10:55:42.827]                       }
[10:55:42.827]                       invisible(muffled)
[10:55:42.827]                     }
[10:55:42.827]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.827]                   }
[10:55:42.827]                 }
[10:55:42.827]                 else {
[10:55:42.827]                   if (TRUE) {
[10:55:42.827]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.827]                     {
[10:55:42.827]                       inherits <- base::inherits
[10:55:42.827]                       invokeRestart <- base::invokeRestart
[10:55:42.827]                       is.null <- base::is.null
[10:55:42.827]                       muffled <- FALSE
[10:55:42.827]                       if (inherits(cond, "message")) {
[10:55:42.827]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.827]                         if (muffled) 
[10:55:42.827]                           invokeRestart("muffleMessage")
[10:55:42.827]                       }
[10:55:42.827]                       else if (inherits(cond, "warning")) {
[10:55:42.827]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.827]                         if (muffled) 
[10:55:42.827]                           invokeRestart("muffleWarning")
[10:55:42.827]                       }
[10:55:42.827]                       else if (inherits(cond, "condition")) {
[10:55:42.827]                         if (!is.null(pattern)) {
[10:55:42.827]                           computeRestarts <- base::computeRestarts
[10:55:42.827]                           grepl <- base::grepl
[10:55:42.827]                           restarts <- computeRestarts(cond)
[10:55:42.827]                           for (restart in restarts) {
[10:55:42.827]                             name <- restart$name
[10:55:42.827]                             if (is.null(name)) 
[10:55:42.827]                               next
[10:55:42.827]                             if (!grepl(pattern, name)) 
[10:55:42.827]                               next
[10:55:42.827]                             invokeRestart(restart)
[10:55:42.827]                             muffled <- TRUE
[10:55:42.827]                             break
[10:55:42.827]                           }
[10:55:42.827]                         }
[10:55:42.827]                       }
[10:55:42.827]                       invisible(muffled)
[10:55:42.827]                     }
[10:55:42.827]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.827]                   }
[10:55:42.827]                 }
[10:55:42.827]             }
[10:55:42.827]         }))
[10:55:42.827]     }, error = function(ex) {
[10:55:42.827]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.827]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.827]                 ...future.rng), started = ...future.startTime, 
[10:55:42.827]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.827]             version = "1.8"), class = "FutureResult")
[10:55:42.827]     }, finally = {
[10:55:42.827]         if (!identical(...future.workdir, getwd())) 
[10:55:42.827]             setwd(...future.workdir)
[10:55:42.827]         {
[10:55:42.827]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.827]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.827]             }
[10:55:42.827]             base::options(...future.oldOptions)
[10:55:42.827]             if (.Platform$OS.type == "windows") {
[10:55:42.827]                 old_names <- names(...future.oldEnvVars)
[10:55:42.827]                 envs <- base::Sys.getenv()
[10:55:42.827]                 names <- names(envs)
[10:55:42.827]                 common <- intersect(names, old_names)
[10:55:42.827]                 added <- setdiff(names, old_names)
[10:55:42.827]                 removed <- setdiff(old_names, names)
[10:55:42.827]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.827]                   envs[common]]
[10:55:42.827]                 NAMES <- toupper(changed)
[10:55:42.827]                 args <- list()
[10:55:42.827]                 for (kk in seq_along(NAMES)) {
[10:55:42.827]                   name <- changed[[kk]]
[10:55:42.827]                   NAME <- NAMES[[kk]]
[10:55:42.827]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.827]                     next
[10:55:42.827]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.827]                 }
[10:55:42.827]                 NAMES <- toupper(added)
[10:55:42.827]                 for (kk in seq_along(NAMES)) {
[10:55:42.827]                   name <- added[[kk]]
[10:55:42.827]                   NAME <- NAMES[[kk]]
[10:55:42.827]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.827]                     next
[10:55:42.827]                   args[[name]] <- ""
[10:55:42.827]                 }
[10:55:42.827]                 NAMES <- toupper(removed)
[10:55:42.827]                 for (kk in seq_along(NAMES)) {
[10:55:42.827]                   name <- removed[[kk]]
[10:55:42.827]                   NAME <- NAMES[[kk]]
[10:55:42.827]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.827]                     next
[10:55:42.827]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.827]                 }
[10:55:42.827]                 if (length(args) > 0) 
[10:55:42.827]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.827]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.827]             }
[10:55:42.827]             else {
[10:55:42.827]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.827]             }
[10:55:42.827]             {
[10:55:42.827]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.827]                   0L) {
[10:55:42.827]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.827]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.827]                   base::options(opts)
[10:55:42.827]                 }
[10:55:42.827]                 {
[10:55:42.827]                   NULL
[10:55:42.827]                   options(future.plan = NULL)
[10:55:42.827]                   if (is.na(NA_character_)) 
[10:55:42.827]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.827]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.827]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.827]                     .init = FALSE)
[10:55:42.827]                 }
[10:55:42.827]             }
[10:55:42.827]         }
[10:55:42.827]     })
[10:55:42.827]     if (TRUE) {
[10:55:42.827]         base::sink(type = "output", split = FALSE)
[10:55:42.827]         if (TRUE) {
[10:55:42.827]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.827]         }
[10:55:42.827]         else {
[10:55:42.827]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.827]         }
[10:55:42.827]         base::close(...future.stdout)
[10:55:42.827]         ...future.stdout <- NULL
[10:55:42.827]     }
[10:55:42.827]     ...future.result$conditions <- ...future.conditions
[10:55:42.827]     ...future.result$finished <- base::Sys.time()
[10:55:42.827]     ...future.result
[10:55:42.827] }
[10:55:42.836] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ... DONE
[10:55:42.836] plan(): nbrOfWorkers() = 2
[10:55:42.840] getGlobalsAndPackages() ...
[10:55:42.840] Searching for globals...
[10:55:42.841] 
[10:55:42.841] Searching for globals ... DONE
[10:55:42.842] - globals: [0] <none>
[10:55:42.842] getGlobalsAndPackages() ... DONE
[10:55:42.842] getGlobalsAndPackages() ...
[10:55:42.842] 
[10:55:42.843] - globals: [0] <none>
[10:55:42.843] getGlobalsAndPackages() ... DONE
[10:55:42.844] Packages needed by the future expression (n = 0): <none>
[10:55:42.844] Packages needed by future strategies (n = 0): <none>
[10:55:42.845] {
[10:55:42.845]     {
[10:55:42.845]         {
[10:55:42.845]             ...future.startTime <- base::Sys.time()
[10:55:42.845]             {
[10:55:42.845]                 {
[10:55:42.845]                   {
[10:55:42.845]                     base::local({
[10:55:42.845]                       has_future <- base::requireNamespace("future", 
[10:55:42.845]                         quietly = TRUE)
[10:55:42.845]                       if (has_future) {
[10:55:42.845]                         ns <- base::getNamespace("future")
[10:55:42.845]                         version <- ns[[".package"]][["version"]]
[10:55:42.845]                         if (is.null(version)) 
[10:55:42.845]                           version <- utils::packageVersion("future")
[10:55:42.845]                       }
[10:55:42.845]                       else {
[10:55:42.845]                         version <- NULL
[10:55:42.845]                       }
[10:55:42.845]                       if (!has_future || version < "1.8.0") {
[10:55:42.845]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.845]                           "", base::R.version$version.string), 
[10:55:42.845]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.845]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.845]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.845]                             "release", "version")], collapse = " "), 
[10:55:42.845]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.845]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.845]                           info)
[10:55:42.845]                         info <- base::paste(info, collapse = "; ")
[10:55:42.845]                         if (!has_future) {
[10:55:42.845]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.845]                             info)
[10:55:42.845]                         }
[10:55:42.845]                         else {
[10:55:42.845]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.845]                             info, version)
[10:55:42.845]                         }
[10:55:42.845]                         base::stop(msg)
[10:55:42.845]                       }
[10:55:42.845]                     })
[10:55:42.845]                   }
[10:55:42.845]                   ...future.strategy.old <- future::plan("list")
[10:55:42.845]                   options(future.plan = NULL)
[10:55:42.845]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.845]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.845]                 }
[10:55:42.845]                 ...future.workdir <- getwd()
[10:55:42.845]             }
[10:55:42.845]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.845]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.845]         }
[10:55:42.845]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.845]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.845]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.845]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.845]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.845]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.845]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.845]             base::names(...future.oldOptions))
[10:55:42.845]     }
[10:55:42.845]     if (FALSE) {
[10:55:42.845]     }
[10:55:42.845]     else {
[10:55:42.845]         if (TRUE) {
[10:55:42.845]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.845]                 open = "w")
[10:55:42.845]         }
[10:55:42.845]         else {
[10:55:42.845]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.845]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.845]         }
[10:55:42.845]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.845]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.845]             base::sink(type = "output", split = FALSE)
[10:55:42.845]             base::close(...future.stdout)
[10:55:42.845]         }, add = TRUE)
[10:55:42.845]     }
[10:55:42.845]     ...future.frame <- base::sys.nframe()
[10:55:42.845]     ...future.conditions <- base::list()
[10:55:42.845]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.845]     if (FALSE) {
[10:55:42.845]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.845]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.845]     }
[10:55:42.845]     ...future.result <- base::tryCatch({
[10:55:42.845]         base::withCallingHandlers({
[10:55:42.845]             ...future.value <- base::withVisible(base::local(42))
[10:55:42.845]             future::FutureResult(value = ...future.value$value, 
[10:55:42.845]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.845]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.845]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.845]                     ...future.globalenv.names))
[10:55:42.845]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.845]         }, condition = base::local({
[10:55:42.845]             c <- base::c
[10:55:42.845]             inherits <- base::inherits
[10:55:42.845]             invokeRestart <- base::invokeRestart
[10:55:42.845]             length <- base::length
[10:55:42.845]             list <- base::list
[10:55:42.845]             seq.int <- base::seq.int
[10:55:42.845]             signalCondition <- base::signalCondition
[10:55:42.845]             sys.calls <- base::sys.calls
[10:55:42.845]             `[[` <- base::`[[`
[10:55:42.845]             `+` <- base::`+`
[10:55:42.845]             `<<-` <- base::`<<-`
[10:55:42.845]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.845]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.845]                   3L)]
[10:55:42.845]             }
[10:55:42.845]             function(cond) {
[10:55:42.845]                 is_error <- inherits(cond, "error")
[10:55:42.845]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.845]                   NULL)
[10:55:42.845]                 if (is_error) {
[10:55:42.845]                   sessionInformation <- function() {
[10:55:42.845]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.845]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.845]                       search = base::search(), system = base::Sys.info())
[10:55:42.845]                   }
[10:55:42.845]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.845]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.845]                     cond$call), session = sessionInformation(), 
[10:55:42.845]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.845]                   signalCondition(cond)
[10:55:42.845]                 }
[10:55:42.845]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.845]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.845]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.845]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.845]                   if (FALSE && !signal) {
[10:55:42.845]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.845]                     {
[10:55:42.845]                       inherits <- base::inherits
[10:55:42.845]                       invokeRestart <- base::invokeRestart
[10:55:42.845]                       is.null <- base::is.null
[10:55:42.845]                       muffled <- FALSE
[10:55:42.845]                       if (inherits(cond, "message")) {
[10:55:42.845]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.845]                         if (muffled) 
[10:55:42.845]                           invokeRestart("muffleMessage")
[10:55:42.845]                       }
[10:55:42.845]                       else if (inherits(cond, "warning")) {
[10:55:42.845]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.845]                         if (muffled) 
[10:55:42.845]                           invokeRestart("muffleWarning")
[10:55:42.845]                       }
[10:55:42.845]                       else if (inherits(cond, "condition")) {
[10:55:42.845]                         if (!is.null(pattern)) {
[10:55:42.845]                           computeRestarts <- base::computeRestarts
[10:55:42.845]                           grepl <- base::grepl
[10:55:42.845]                           restarts <- computeRestarts(cond)
[10:55:42.845]                           for (restart in restarts) {
[10:55:42.845]                             name <- restart$name
[10:55:42.845]                             if (is.null(name)) 
[10:55:42.845]                               next
[10:55:42.845]                             if (!grepl(pattern, name)) 
[10:55:42.845]                               next
[10:55:42.845]                             invokeRestart(restart)
[10:55:42.845]                             muffled <- TRUE
[10:55:42.845]                             break
[10:55:42.845]                           }
[10:55:42.845]                         }
[10:55:42.845]                       }
[10:55:42.845]                       invisible(muffled)
[10:55:42.845]                     }
[10:55:42.845]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.845]                   }
[10:55:42.845]                 }
[10:55:42.845]                 else {
[10:55:42.845]                   if (TRUE) {
[10:55:42.845]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.845]                     {
[10:55:42.845]                       inherits <- base::inherits
[10:55:42.845]                       invokeRestart <- base::invokeRestart
[10:55:42.845]                       is.null <- base::is.null
[10:55:42.845]                       muffled <- FALSE
[10:55:42.845]                       if (inherits(cond, "message")) {
[10:55:42.845]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.845]                         if (muffled) 
[10:55:42.845]                           invokeRestart("muffleMessage")
[10:55:42.845]                       }
[10:55:42.845]                       else if (inherits(cond, "warning")) {
[10:55:42.845]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.845]                         if (muffled) 
[10:55:42.845]                           invokeRestart("muffleWarning")
[10:55:42.845]                       }
[10:55:42.845]                       else if (inherits(cond, "condition")) {
[10:55:42.845]                         if (!is.null(pattern)) {
[10:55:42.845]                           computeRestarts <- base::computeRestarts
[10:55:42.845]                           grepl <- base::grepl
[10:55:42.845]                           restarts <- computeRestarts(cond)
[10:55:42.845]                           for (restart in restarts) {
[10:55:42.845]                             name <- restart$name
[10:55:42.845]                             if (is.null(name)) 
[10:55:42.845]                               next
[10:55:42.845]                             if (!grepl(pattern, name)) 
[10:55:42.845]                               next
[10:55:42.845]                             invokeRestart(restart)
[10:55:42.845]                             muffled <- TRUE
[10:55:42.845]                             break
[10:55:42.845]                           }
[10:55:42.845]                         }
[10:55:42.845]                       }
[10:55:42.845]                       invisible(muffled)
[10:55:42.845]                     }
[10:55:42.845]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.845]                   }
[10:55:42.845]                 }
[10:55:42.845]             }
[10:55:42.845]         }))
[10:55:42.845]     }, error = function(ex) {
[10:55:42.845]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.845]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.845]                 ...future.rng), started = ...future.startTime, 
[10:55:42.845]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.845]             version = "1.8"), class = "FutureResult")
[10:55:42.845]     }, finally = {
[10:55:42.845]         if (!identical(...future.workdir, getwd())) 
[10:55:42.845]             setwd(...future.workdir)
[10:55:42.845]         {
[10:55:42.845]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.845]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.845]             }
[10:55:42.845]             base::options(...future.oldOptions)
[10:55:42.845]             if (.Platform$OS.type == "windows") {
[10:55:42.845]                 old_names <- names(...future.oldEnvVars)
[10:55:42.845]                 envs <- base::Sys.getenv()
[10:55:42.845]                 names <- names(envs)
[10:55:42.845]                 common <- intersect(names, old_names)
[10:55:42.845]                 added <- setdiff(names, old_names)
[10:55:42.845]                 removed <- setdiff(old_names, names)
[10:55:42.845]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.845]                   envs[common]]
[10:55:42.845]                 NAMES <- toupper(changed)
[10:55:42.845]                 args <- list()
[10:55:42.845]                 for (kk in seq_along(NAMES)) {
[10:55:42.845]                   name <- changed[[kk]]
[10:55:42.845]                   NAME <- NAMES[[kk]]
[10:55:42.845]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.845]                     next
[10:55:42.845]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.845]                 }
[10:55:42.845]                 NAMES <- toupper(added)
[10:55:42.845]                 for (kk in seq_along(NAMES)) {
[10:55:42.845]                   name <- added[[kk]]
[10:55:42.845]                   NAME <- NAMES[[kk]]
[10:55:42.845]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.845]                     next
[10:55:42.845]                   args[[name]] <- ""
[10:55:42.845]                 }
[10:55:42.845]                 NAMES <- toupper(removed)
[10:55:42.845]                 for (kk in seq_along(NAMES)) {
[10:55:42.845]                   name <- removed[[kk]]
[10:55:42.845]                   NAME <- NAMES[[kk]]
[10:55:42.845]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.845]                     next
[10:55:42.845]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.845]                 }
[10:55:42.845]                 if (length(args) > 0) 
[10:55:42.845]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.845]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.845]             }
[10:55:42.845]             else {
[10:55:42.845]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.845]             }
[10:55:42.845]             {
[10:55:42.845]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.845]                   0L) {
[10:55:42.845]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.845]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.845]                   base::options(opts)
[10:55:42.845]                 }
[10:55:42.845]                 {
[10:55:42.845]                   NULL
[10:55:42.845]                   options(future.plan = NULL)
[10:55:42.845]                   if (is.na(NA_character_)) 
[10:55:42.845]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.845]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.845]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.845]                     .init = FALSE)
[10:55:42.845]                 }
[10:55:42.845]             }
[10:55:42.845]         }
[10:55:42.845]     })
[10:55:42.845]     if (TRUE) {
[10:55:42.845]         base::sink(type = "output", split = FALSE)
[10:55:42.845]         if (TRUE) {
[10:55:42.845]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.845]         }
[10:55:42.845]         else {
[10:55:42.845]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.845]         }
[10:55:42.845]         base::close(...future.stdout)
[10:55:42.845]         ...future.stdout <- NULL
[10:55:42.845]     }
[10:55:42.845]     ...future.result$conditions <- ...future.conditions
[10:55:42.845]     ...future.result$finished <- base::Sys.time()
[10:55:42.845]     ...future.result
[10:55:42.845] }
MiraiFuture:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:55:42.852] resolved() for 'MiraiFuture' ...
[10:55:42.852] - state: 'running'
[10:55:42.853] - run: TRUE
[10:55:42.853] - result: 'NULL'
[10:55:42.853] - resolved: FALSE
[10:55:42.854] resolved() for 'MiraiFuture' ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b859a48e-c511-ea97-6436-2c6143ec3048
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.854] getGlobalsAndPackages() ...
[10:55:42.855] Searching for globals...
[10:55:42.855] 
[10:55:42.855] Searching for globals ... DONE
[10:55:42.856] - globals: [0] <none>
[10:55:42.856] getGlobalsAndPackages() ... DONE
[10:55:42.856] run() for 'Future' ...
[10:55:42.857] - state: 'created'
[10:55:42.857] - Future backend: 'FutureStrategy', 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[10:55:42.861] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.862] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[10:55:42.862]   - Field: 'label'
[10:55:42.862]   - Field: 'local'
[10:55:42.863]   - Field: 'owner'
[10:55:42.863]   - Field: 'envir'
[10:55:42.863]   - Field: 'packages'
[10:55:42.864]   - Field: 'gc'
[10:55:42.864]   - Field: 'conditions'
[10:55:42.864]   - Field: 'expr'
[10:55:42.865]   - Field: 'uuid'
[10:55:42.865]   - Field: 'seed'
[10:55:42.865]   - Field: 'version'
[10:55:42.866]   - Field: 'result'
[10:55:42.866]   - Field: 'asynchronous'
[10:55:42.866]   - Field: 'calls'
[10:55:42.867]   - Field: 'globals'
[10:55:42.867]   - Field: 'stdout'
[10:55:42.867]   - Field: 'earlySignal'
[10:55:42.868]   - Field: 'lazy'
[10:55:42.868]   - Field: 'state'
[10:55:42.868]   - Field: '.cluster'
[10:55:42.868] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[10:55:42.869] - Launch lazy future ...
[10:55:42.869] Packages needed by the future expression (n = 0): <none>
[10:55:42.869] Packages needed by future strategies (n = 0): <none>
[10:55:42.870] {
[10:55:42.870]     {
[10:55:42.870]         {
[10:55:42.870]             ...future.startTime <- base::Sys.time()
[10:55:42.870]             {
[10:55:42.870]                 {
[10:55:42.870]                   {
[10:55:42.870]                     base::local({
[10:55:42.870]                       has_future <- base::requireNamespace("future", 
[10:55:42.870]                         quietly = TRUE)
[10:55:42.870]                       if (has_future) {
[10:55:42.870]                         ns <- base::getNamespace("future")
[10:55:42.870]                         version <- ns[[".package"]][["version"]]
[10:55:42.870]                         if (is.null(version)) 
[10:55:42.870]                           version <- utils::packageVersion("future")
[10:55:42.870]                       }
[10:55:42.870]                       else {
[10:55:42.870]                         version <- NULL
[10:55:42.870]                       }
[10:55:42.870]                       if (!has_future || version < "1.8.0") {
[10:55:42.870]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.870]                           "", base::R.version$version.string), 
[10:55:42.870]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.870]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.870]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.870]                             "release", "version")], collapse = " "), 
[10:55:42.870]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.870]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.870]                           info)
[10:55:42.870]                         info <- base::paste(info, collapse = "; ")
[10:55:42.870]                         if (!has_future) {
[10:55:42.870]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.870]                             info)
[10:55:42.870]                         }
[10:55:42.870]                         else {
[10:55:42.870]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.870]                             info, version)
[10:55:42.870]                         }
[10:55:42.870]                         base::stop(msg)
[10:55:42.870]                       }
[10:55:42.870]                     })
[10:55:42.870]                   }
[10:55:42.870]                   ...future.strategy.old <- future::plan("list")
[10:55:42.870]                   options(future.plan = NULL)
[10:55:42.870]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.870]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.870]                 }
[10:55:42.870]                 ...future.workdir <- getwd()
[10:55:42.870]             }
[10:55:42.870]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.870]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.870]         }
[10:55:42.870]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.870]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.870]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.870]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.870]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.870]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.870]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.870]             base::names(...future.oldOptions))
[10:55:42.870]     }
[10:55:42.870]     if (FALSE) {
[10:55:42.870]     }
[10:55:42.870]     else {
[10:55:42.870]         if (TRUE) {
[10:55:42.870]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.870]                 open = "w")
[10:55:42.870]         }
[10:55:42.870]         else {
[10:55:42.870]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.870]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.870]         }
[10:55:42.870]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.870]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.870]             base::sink(type = "output", split = FALSE)
[10:55:42.870]             base::close(...future.stdout)
[10:55:42.870]         }, add = TRUE)
[10:55:42.870]     }
[10:55:42.870]     ...future.frame <- base::sys.nframe()
[10:55:42.870]     ...future.conditions <- base::list()
[10:55:42.870]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.870]     if (FALSE) {
[10:55:42.870]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.870]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.870]     }
[10:55:42.870]     ...future.result <- base::tryCatch({
[10:55:42.870]         base::withCallingHandlers({
[10:55:42.870]             ...future.value <- base::withVisible(base::local(42))
[10:55:42.870]             future::FutureResult(value = ...future.value$value, 
[10:55:42.870]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.870]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.870]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.870]                     ...future.globalenv.names))
[10:55:42.870]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.870]         }, condition = base::local({
[10:55:42.870]             c <- base::c
[10:55:42.870]             inherits <- base::inherits
[10:55:42.870]             invokeRestart <- base::invokeRestart
[10:55:42.870]             length <- base::length
[10:55:42.870]             list <- base::list
[10:55:42.870]             seq.int <- base::seq.int
[10:55:42.870]             signalCondition <- base::signalCondition
[10:55:42.870]             sys.calls <- base::sys.calls
[10:55:42.870]             `[[` <- base::`[[`
[10:55:42.870]             `+` <- base::`+`
[10:55:42.870]             `<<-` <- base::`<<-`
[10:55:42.870]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.870]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.870]                   3L)]
[10:55:42.870]             }
[10:55:42.870]             function(cond) {
[10:55:42.870]                 is_error <- inherits(cond, "error")
[10:55:42.870]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.870]                   NULL)
[10:55:42.870]                 if (is_error) {
[10:55:42.870]                   sessionInformation <- function() {
[10:55:42.870]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.870]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.870]                       search = base::search(), system = base::Sys.info())
[10:55:42.870]                   }
[10:55:42.870]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.870]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.870]                     cond$call), session = sessionInformation(), 
[10:55:42.870]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.870]                   signalCondition(cond)
[10:55:42.870]                 }
[10:55:42.870]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.870]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.870]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.870]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.870]                   if (FALSE && !signal) {
[10:55:42.870]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.870]                     {
[10:55:42.870]                       inherits <- base::inherits
[10:55:42.870]                       invokeRestart <- base::invokeRestart
[10:55:42.870]                       is.null <- base::is.null
[10:55:42.870]                       muffled <- FALSE
[10:55:42.870]                       if (inherits(cond, "message")) {
[10:55:42.870]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.870]                         if (muffled) 
[10:55:42.870]                           invokeRestart("muffleMessage")
[10:55:42.870]                       }
[10:55:42.870]                       else if (inherits(cond, "warning")) {
[10:55:42.870]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.870]                         if (muffled) 
[10:55:42.870]                           invokeRestart("muffleWarning")
[10:55:42.870]                       }
[10:55:42.870]                       else if (inherits(cond, "condition")) {
[10:55:42.870]                         if (!is.null(pattern)) {
[10:55:42.870]                           computeRestarts <- base::computeRestarts
[10:55:42.870]                           grepl <- base::grepl
[10:55:42.870]                           restarts <- computeRestarts(cond)
[10:55:42.870]                           for (restart in restarts) {
[10:55:42.870]                             name <- restart$name
[10:55:42.870]                             if (is.null(name)) 
[10:55:42.870]                               next
[10:55:42.870]                             if (!grepl(pattern, name)) 
[10:55:42.870]                               next
[10:55:42.870]                             invokeRestart(restart)
[10:55:42.870]                             muffled <- TRUE
[10:55:42.870]                             break
[10:55:42.870]                           }
[10:55:42.870]                         }
[10:55:42.870]                       }
[10:55:42.870]                       invisible(muffled)
[10:55:42.870]                     }
[10:55:42.870]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.870]                   }
[10:55:42.870]                 }
[10:55:42.870]                 else {
[10:55:42.870]                   if (TRUE) {
[10:55:42.870]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.870]                     {
[10:55:42.870]                       inherits <- base::inherits
[10:55:42.870]                       invokeRestart <- base::invokeRestart
[10:55:42.870]                       is.null <- base::is.null
[10:55:42.870]                       muffled <- FALSE
[10:55:42.870]                       if (inherits(cond, "message")) {
[10:55:42.870]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.870]                         if (muffled) 
[10:55:42.870]                           invokeRestart("muffleMessage")
[10:55:42.870]                       }
[10:55:42.870]                       else if (inherits(cond, "warning")) {
[10:55:42.870]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.870]                         if (muffled) 
[10:55:42.870]                           invokeRestart("muffleWarning")
[10:55:42.870]                       }
[10:55:42.870]                       else if (inherits(cond, "condition")) {
[10:55:42.870]                         if (!is.null(pattern)) {
[10:55:42.870]                           computeRestarts <- base::computeRestarts
[10:55:42.870]                           grepl <- base::grepl
[10:55:42.870]                           restarts <- computeRestarts(cond)
[10:55:42.870]                           for (restart in restarts) {
[10:55:42.870]                             name <- restart$name
[10:55:42.870]                             if (is.null(name)) 
[10:55:42.870]                               next
[10:55:42.870]                             if (!grepl(pattern, name)) 
[10:55:42.870]                               next
[10:55:42.870]                             invokeRestart(restart)
[10:55:42.870]                             muffled <- TRUE
[10:55:42.870]                             break
[10:55:42.870]                           }
[10:55:42.870]                         }
[10:55:42.870]                       }
[10:55:42.870]                       invisible(muffled)
[10:55:42.870]                     }
[10:55:42.870]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.870]                   }
[10:55:42.870]                 }
[10:55:42.870]             }
[10:55:42.870]         }))
[10:55:42.870]     }, error = function(ex) {
[10:55:42.870]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.870]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.870]                 ...future.rng), started = ...future.startTime, 
[10:55:42.870]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.870]             version = "1.8"), class = "FutureResult")
[10:55:42.870]     }, finally = {
[10:55:42.870]         if (!identical(...future.workdir, getwd())) 
[10:55:42.870]             setwd(...future.workdir)
[10:55:42.870]         {
[10:55:42.870]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.870]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.870]             }
[10:55:42.870]             base::options(...future.oldOptions)
[10:55:42.870]             if (.Platform$OS.type == "windows") {
[10:55:42.870]                 old_names <- names(...future.oldEnvVars)
[10:55:42.870]                 envs <- base::Sys.getenv()
[10:55:42.870]                 names <- names(envs)
[10:55:42.870]                 common <- intersect(names, old_names)
[10:55:42.870]                 added <- setdiff(names, old_names)
[10:55:42.870]                 removed <- setdiff(old_names, names)
[10:55:42.870]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.870]                   envs[common]]
[10:55:42.870]                 NAMES <- toupper(changed)
[10:55:42.870]                 args <- list()
[10:55:42.870]                 for (kk in seq_along(NAMES)) {
[10:55:42.870]                   name <- changed[[kk]]
[10:55:42.870]                   NAME <- NAMES[[kk]]
[10:55:42.870]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.870]                     next
[10:55:42.870]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.870]                 }
[10:55:42.870]                 NAMES <- toupper(added)
[10:55:42.870]                 for (kk in seq_along(NAMES)) {
[10:55:42.870]                   name <- added[[kk]]
[10:55:42.870]                   NAME <- NAMES[[kk]]
[10:55:42.870]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.870]                     next
[10:55:42.870]                   args[[name]] <- ""
[10:55:42.870]                 }
[10:55:42.870]                 NAMES <- toupper(removed)
[10:55:42.870]                 for (kk in seq_along(NAMES)) {
[10:55:42.870]                   name <- removed[[kk]]
[10:55:42.870]                   NAME <- NAMES[[kk]]
[10:55:42.870]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.870]                     next
[10:55:42.870]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.870]                 }
[10:55:42.870]                 if (length(args) > 0) 
[10:55:42.870]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.870]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.870]             }
[10:55:42.870]             else {
[10:55:42.870]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.870]             }
[10:55:42.870]             {
[10:55:42.870]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.870]                   0L) {
[10:55:42.870]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.870]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.870]                   base::options(opts)
[10:55:42.870]                 }
[10:55:42.870]                 {
[10:55:42.870]                   NULL
[10:55:42.870]                   options(future.plan = NULL)
[10:55:42.870]                   if (is.na(NA_character_)) 
[10:55:42.870]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.870]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.870]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.870]                     .init = FALSE)
[10:55:42.870]                 }
[10:55:42.870]             }
[10:55:42.870]         }
[10:55:42.870]     })
[10:55:42.870]     if (TRUE) {
[10:55:42.870]         base::sink(type = "output", split = FALSE)
[10:55:42.870]         if (TRUE) {
[10:55:42.870]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.870]         }
[10:55:42.870]         else {
[10:55:42.870]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.870]         }
[10:55:42.870]         base::close(...future.stdout)
[10:55:42.870]         ...future.stdout <- NULL
[10:55:42.870]     }
[10:55:42.870]     ...future.result$conditions <- ...future.conditions
[10:55:42.870]     ...future.result$finished <- base::Sys.time()
[10:55:42.870]     ...future.result
[10:55:42.870] }
[10:55:42.877] - Launch lazy future ... done
[10:55:42.877] run() for 'MiraiFuture' ... done
MiraiFuture:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:55:42.878] resolved() for 'MiraiFuture' ...
[10:55:42.879] - state: 'running'
[10:55:42.879] - run: TRUE
[10:55:42.879] - result: 'NULL'
[10:55:42.880] - resolved: FALSE
[10:55:42.880] resolved() for 'MiraiFuture' ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b859a48e-c511-ea97-6436-2c6143ec3048
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.881] getGlobalsAndPackages() ...
[10:55:42.881] Searching for globals...
[10:55:42.882] - globals found: [1] '{'
[10:55:42.883] Searching for globals ... DONE
[10:55:42.883] Resolving globals: FALSE
[10:55:42.884] 
[10:55:42.884] 
[10:55:42.884] getGlobalsAndPackages() ... DONE
[10:55:42.885] run() for 'Future' ...
[10:55:42.888] - state: 'created'
[10:55:42.888] - Future backend: 'FutureStrategy', 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[10:55:42.892] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.892] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[10:55:42.893]   - Field: 'label'
[10:55:42.893]   - Field: 'local'
[10:55:42.893]   - Field: 'owner'
[10:55:42.894]   - Field: 'envir'
[10:55:42.894]   - Field: 'packages'
[10:55:42.894]   - Field: 'gc'
[10:55:42.895]   - Field: 'conditions'
[10:55:42.895]   - Field: 'expr'
[10:55:42.895]   - Field: 'uuid'
[10:55:42.896]   - Field: 'seed'
[10:55:42.896]   - Field: 'version'
[10:55:42.896]   - Field: 'result'
[10:55:42.897]   - Field: 'asynchronous'
[10:55:42.897]   - Field: 'calls'
[10:55:42.897]   - Field: 'globals'
[10:55:42.898]   - Field: 'stdout'
[10:55:42.898]   - Field: 'earlySignal'
[10:55:42.898]   - Field: 'lazy'
[10:55:42.899]   - Field: 'state'
[10:55:42.899]   - Field: '.cluster'
[10:55:42.899] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[10:55:42.899] - Launch lazy future ...
[10:55:42.900] Packages needed by the future expression (n = 0): <none>
[10:55:42.900] Packages needed by future strategies (n = 0): <none>
[10:55:42.901] {
[10:55:42.901]     {
[10:55:42.901]         {
[10:55:42.901]             ...future.startTime <- base::Sys.time()
[10:55:42.901]             {
[10:55:42.901]                 {
[10:55:42.901]                   {
[10:55:42.901]                     base::local({
[10:55:42.901]                       has_future <- base::requireNamespace("future", 
[10:55:42.901]                         quietly = TRUE)
[10:55:42.901]                       if (has_future) {
[10:55:42.901]                         ns <- base::getNamespace("future")
[10:55:42.901]                         version <- ns[[".package"]][["version"]]
[10:55:42.901]                         if (is.null(version)) 
[10:55:42.901]                           version <- utils::packageVersion("future")
[10:55:42.901]                       }
[10:55:42.901]                       else {
[10:55:42.901]                         version <- NULL
[10:55:42.901]                       }
[10:55:42.901]                       if (!has_future || version < "1.8.0") {
[10:55:42.901]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.901]                           "", base::R.version$version.string), 
[10:55:42.901]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.901]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.901]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.901]                             "release", "version")], collapse = " "), 
[10:55:42.901]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.901]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.901]                           info)
[10:55:42.901]                         info <- base::paste(info, collapse = "; ")
[10:55:42.901]                         if (!has_future) {
[10:55:42.901]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.901]                             info)
[10:55:42.901]                         }
[10:55:42.901]                         else {
[10:55:42.901]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.901]                             info, version)
[10:55:42.901]                         }
[10:55:42.901]                         base::stop(msg)
[10:55:42.901]                       }
[10:55:42.901]                     })
[10:55:42.901]                   }
[10:55:42.901]                   ...future.strategy.old <- future::plan("list")
[10:55:42.901]                   options(future.plan = NULL)
[10:55:42.901]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.901]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.901]                 }
[10:55:42.901]                 ...future.workdir <- getwd()
[10:55:42.901]             }
[10:55:42.901]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.901]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.901]         }
[10:55:42.901]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.901]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.901]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.901]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.901]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.901]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.901]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.901]             base::names(...future.oldOptions))
[10:55:42.901]     }
[10:55:42.901]     if (FALSE) {
[10:55:42.901]     }
[10:55:42.901]     else {
[10:55:42.901]         if (TRUE) {
[10:55:42.901]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.901]                 open = "w")
[10:55:42.901]         }
[10:55:42.901]         else {
[10:55:42.901]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.901]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.901]         }
[10:55:42.901]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.901]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.901]             base::sink(type = "output", split = FALSE)
[10:55:42.901]             base::close(...future.stdout)
[10:55:42.901]         }, add = TRUE)
[10:55:42.901]     }
[10:55:42.901]     ...future.frame <- base::sys.nframe()
[10:55:42.901]     ...future.conditions <- base::list()
[10:55:42.901]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.901]     if (FALSE) {
[10:55:42.901]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.901]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.901]     }
[10:55:42.901]     ...future.result <- base::tryCatch({
[10:55:42.901]         base::withCallingHandlers({
[10:55:42.901]             ...future.value <- base::withVisible(base::local({
[10:55:42.901]                 42
[10:55:42.901]             }))
[10:55:42.901]             future::FutureResult(value = ...future.value$value, 
[10:55:42.901]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.901]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.901]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.901]                     ...future.globalenv.names))
[10:55:42.901]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.901]         }, condition = base::local({
[10:55:42.901]             c <- base::c
[10:55:42.901]             inherits <- base::inherits
[10:55:42.901]             invokeRestart <- base::invokeRestart
[10:55:42.901]             length <- base::length
[10:55:42.901]             list <- base::list
[10:55:42.901]             seq.int <- base::seq.int
[10:55:42.901]             signalCondition <- base::signalCondition
[10:55:42.901]             sys.calls <- base::sys.calls
[10:55:42.901]             `[[` <- base::`[[`
[10:55:42.901]             `+` <- base::`+`
[10:55:42.901]             `<<-` <- base::`<<-`
[10:55:42.901]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.901]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.901]                   3L)]
[10:55:42.901]             }
[10:55:42.901]             function(cond) {
[10:55:42.901]                 is_error <- inherits(cond, "error")
[10:55:42.901]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.901]                   NULL)
[10:55:42.901]                 if (is_error) {
[10:55:42.901]                   sessionInformation <- function() {
[10:55:42.901]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.901]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.901]                       search = base::search(), system = base::Sys.info())
[10:55:42.901]                   }
[10:55:42.901]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.901]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.901]                     cond$call), session = sessionInformation(), 
[10:55:42.901]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.901]                   signalCondition(cond)
[10:55:42.901]                 }
[10:55:42.901]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.901]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.901]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.901]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.901]                   if (FALSE && !signal) {
[10:55:42.901]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.901]                     {
[10:55:42.901]                       inherits <- base::inherits
[10:55:42.901]                       invokeRestart <- base::invokeRestart
[10:55:42.901]                       is.null <- base::is.null
[10:55:42.901]                       muffled <- FALSE
[10:55:42.901]                       if (inherits(cond, "message")) {
[10:55:42.901]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.901]                         if (muffled) 
[10:55:42.901]                           invokeRestart("muffleMessage")
[10:55:42.901]                       }
[10:55:42.901]                       else if (inherits(cond, "warning")) {
[10:55:42.901]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.901]                         if (muffled) 
[10:55:42.901]                           invokeRestart("muffleWarning")
[10:55:42.901]                       }
[10:55:42.901]                       else if (inherits(cond, "condition")) {
[10:55:42.901]                         if (!is.null(pattern)) {
[10:55:42.901]                           computeRestarts <- base::computeRestarts
[10:55:42.901]                           grepl <- base::grepl
[10:55:42.901]                           restarts <- computeRestarts(cond)
[10:55:42.901]                           for (restart in restarts) {
[10:55:42.901]                             name <- restart$name
[10:55:42.901]                             if (is.null(name)) 
[10:55:42.901]                               next
[10:55:42.901]                             if (!grepl(pattern, name)) 
[10:55:42.901]                               next
[10:55:42.901]                             invokeRestart(restart)
[10:55:42.901]                             muffled <- TRUE
[10:55:42.901]                             break
[10:55:42.901]                           }
[10:55:42.901]                         }
[10:55:42.901]                       }
[10:55:42.901]                       invisible(muffled)
[10:55:42.901]                     }
[10:55:42.901]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.901]                   }
[10:55:42.901]                 }
[10:55:42.901]                 else {
[10:55:42.901]                   if (TRUE) {
[10:55:42.901]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.901]                     {
[10:55:42.901]                       inherits <- base::inherits
[10:55:42.901]                       invokeRestart <- base::invokeRestart
[10:55:42.901]                       is.null <- base::is.null
[10:55:42.901]                       muffled <- FALSE
[10:55:42.901]                       if (inherits(cond, "message")) {
[10:55:42.901]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.901]                         if (muffled) 
[10:55:42.901]                           invokeRestart("muffleMessage")
[10:55:42.901]                       }
[10:55:42.901]                       else if (inherits(cond, "warning")) {
[10:55:42.901]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.901]                         if (muffled) 
[10:55:42.901]                           invokeRestart("muffleWarning")
[10:55:42.901]                       }
[10:55:42.901]                       else if (inherits(cond, "condition")) {
[10:55:42.901]                         if (!is.null(pattern)) {
[10:55:42.901]                           computeRestarts <- base::computeRestarts
[10:55:42.901]                           grepl <- base::grepl
[10:55:42.901]                           restarts <- computeRestarts(cond)
[10:55:42.901]                           for (restart in restarts) {
[10:55:42.901]                             name <- restart$name
[10:55:42.901]                             if (is.null(name)) 
[10:55:42.901]                               next
[10:55:42.901]                             if (!grepl(pattern, name)) 
[10:55:42.901]                               next
[10:55:42.901]                             invokeRestart(restart)
[10:55:42.901]                             muffled <- TRUE
[10:55:42.901]                             break
[10:55:42.901]                           }
[10:55:42.901]                         }
[10:55:42.901]                       }
[10:55:42.901]                       invisible(muffled)
[10:55:42.901]                     }
[10:55:42.901]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.901]                   }
[10:55:42.901]                 }
[10:55:42.901]             }
[10:55:42.901]         }))
[10:55:42.901]     }, error = function(ex) {
[10:55:42.901]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.901]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.901]                 ...future.rng), started = ...future.startTime, 
[10:55:42.901]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.901]             version = "1.8"), class = "FutureResult")
[10:55:42.901]     }, finally = {
[10:55:42.901]         if (!identical(...future.workdir, getwd())) 
[10:55:42.901]             setwd(...future.workdir)
[10:55:42.901]         {
[10:55:42.901]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.901]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.901]             }
[10:55:42.901]             base::options(...future.oldOptions)
[10:55:42.901]             if (.Platform$OS.type == "windows") {
[10:55:42.901]                 old_names <- names(...future.oldEnvVars)
[10:55:42.901]                 envs <- base::Sys.getenv()
[10:55:42.901]                 names <- names(envs)
[10:55:42.901]                 common <- intersect(names, old_names)
[10:55:42.901]                 added <- setdiff(names, old_names)
[10:55:42.901]                 removed <- setdiff(old_names, names)
[10:55:42.901]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.901]                   envs[common]]
[10:55:42.901]                 NAMES <- toupper(changed)
[10:55:42.901]                 args <- list()
[10:55:42.901]                 for (kk in seq_along(NAMES)) {
[10:55:42.901]                   name <- changed[[kk]]
[10:55:42.901]                   NAME <- NAMES[[kk]]
[10:55:42.901]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.901]                     next
[10:55:42.901]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.901]                 }
[10:55:42.901]                 NAMES <- toupper(added)
[10:55:42.901]                 for (kk in seq_along(NAMES)) {
[10:55:42.901]                   name <- added[[kk]]
[10:55:42.901]                   NAME <- NAMES[[kk]]
[10:55:42.901]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.901]                     next
[10:55:42.901]                   args[[name]] <- ""
[10:55:42.901]                 }
[10:55:42.901]                 NAMES <- toupper(removed)
[10:55:42.901]                 for (kk in seq_along(NAMES)) {
[10:55:42.901]                   name <- removed[[kk]]
[10:55:42.901]                   NAME <- NAMES[[kk]]
[10:55:42.901]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.901]                     next
[10:55:42.901]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.901]                 }
[10:55:42.901]                 if (length(args) > 0) 
[10:55:42.901]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.901]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.901]             }
[10:55:42.901]             else {
[10:55:42.901]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.901]             }
[10:55:42.901]             {
[10:55:42.901]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.901]                   0L) {
[10:55:42.901]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.901]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.901]                   base::options(opts)
[10:55:42.901]                 }
[10:55:42.901]                 {
[10:55:42.901]                   NULL
[10:55:42.901]                   options(future.plan = NULL)
[10:55:42.901]                   if (is.na(NA_character_)) 
[10:55:42.901]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.901]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.901]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.901]                     .init = FALSE)
[10:55:42.901]                 }
[10:55:42.901]             }
[10:55:42.901]         }
[10:55:42.901]     })
[10:55:42.901]     if (TRUE) {
[10:55:42.901]         base::sink(type = "output", split = FALSE)
[10:55:42.901]         if (TRUE) {
[10:55:42.901]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.901]         }
[10:55:42.901]         else {
[10:55:42.901]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.901]         }
[10:55:42.901]         base::close(...future.stdout)
[10:55:42.901]         ...future.stdout <- NULL
[10:55:42.901]     }
[10:55:42.901]     ...future.result$conditions <- ...future.conditions
[10:55:42.901]     ...future.result$finished <- base::Sys.time()
[10:55:42.901]     ...future.result
[10:55:42.901] }
[10:55:42.908] - Launch lazy future ... done
[10:55:42.908] run() for 'MiraiFuture' ... done
MiraiFuture:
Label: '<none>'
Expression:
{
    42
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:55:42.909] resolved() for 'MiraiFuture' ...
[10:55:42.909] - state: 'running'
[10:55:42.910] - run: TRUE
[10:55:42.910] - result: 'NULL'
[10:55:42.910] - resolved: FALSE
[10:55:42.910] resolved() for 'MiraiFuture' ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b859a48e-c511-ea97-6436-2c6143ec3048
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.914] getGlobalsAndPackages() ...
[10:55:42.915] Searching for globals...
[10:55:42.915] 
[10:55:42.915] Searching for globals ... DONE
[10:55:42.916] - globals: [0] <none>
[10:55:42.916] getGlobalsAndPackages() ... DONE
[10:55:42.916] getGlobalsAndPackages() ...
[10:55:42.917] 
[10:55:42.917] - globals: [0] <none>
[10:55:42.917] getGlobalsAndPackages() ... DONE
[10:55:42.918] Packages needed by the future expression (n = 0): <none>
[10:55:42.918] Packages needed by future strategies (n = 0): <none>
[10:55:42.919] {
[10:55:42.919]     {
[10:55:42.919]         {
[10:55:42.919]             ...future.startTime <- base::Sys.time()
[10:55:42.919]             {
[10:55:42.919]                 {
[10:55:42.919]                   {
[10:55:42.919]                     base::local({
[10:55:42.919]                       has_future <- base::requireNamespace("future", 
[10:55:42.919]                         quietly = TRUE)
[10:55:42.919]                       if (has_future) {
[10:55:42.919]                         ns <- base::getNamespace("future")
[10:55:42.919]                         version <- ns[[".package"]][["version"]]
[10:55:42.919]                         if (is.null(version)) 
[10:55:42.919]                           version <- utils::packageVersion("future")
[10:55:42.919]                       }
[10:55:42.919]                       else {
[10:55:42.919]                         version <- NULL
[10:55:42.919]                       }
[10:55:42.919]                       if (!has_future || version < "1.8.0") {
[10:55:42.919]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.919]                           "", base::R.version$version.string), 
[10:55:42.919]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.919]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.919]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.919]                             "release", "version")], collapse = " "), 
[10:55:42.919]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.919]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.919]                           info)
[10:55:42.919]                         info <- base::paste(info, collapse = "; ")
[10:55:42.919]                         if (!has_future) {
[10:55:42.919]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.919]                             info)
[10:55:42.919]                         }
[10:55:42.919]                         else {
[10:55:42.919]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.919]                             info, version)
[10:55:42.919]                         }
[10:55:42.919]                         base::stop(msg)
[10:55:42.919]                       }
[10:55:42.919]                     })
[10:55:42.919]                   }
[10:55:42.919]                   ...future.strategy.old <- future::plan("list")
[10:55:42.919]                   options(future.plan = NULL)
[10:55:42.919]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.919]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.919]                 }
[10:55:42.919]                 ...future.workdir <- getwd()
[10:55:42.919]             }
[10:55:42.919]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.919]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.919]         }
[10:55:42.919]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.919]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.919]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.919]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.919]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.919]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.919]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.919]             base::names(...future.oldOptions))
[10:55:42.919]     }
[10:55:42.919]     if (FALSE) {
[10:55:42.919]     }
[10:55:42.919]     else {
[10:55:42.919]         if (TRUE) {
[10:55:42.919]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.919]                 open = "w")
[10:55:42.919]         }
[10:55:42.919]         else {
[10:55:42.919]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.919]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.919]         }
[10:55:42.919]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.919]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.919]             base::sink(type = "output", split = FALSE)
[10:55:42.919]             base::close(...future.stdout)
[10:55:42.919]         }, add = TRUE)
[10:55:42.919]     }
[10:55:42.919]     ...future.frame <- base::sys.nframe()
[10:55:42.919]     ...future.conditions <- base::list()
[10:55:42.919]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.919]     if (FALSE) {
[10:55:42.919]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.919]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.919]     }
[10:55:42.919]     ...future.result <- base::tryCatch({
[10:55:42.919]         base::withCallingHandlers({
[10:55:42.919]             ...future.value <- base::withVisible(base::local(42))
[10:55:42.919]             future::FutureResult(value = ...future.value$value, 
[10:55:42.919]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.919]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.919]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.919]                     ...future.globalenv.names))
[10:55:42.919]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.919]         }, condition = base::local({
[10:55:42.919]             c <- base::c
[10:55:42.919]             inherits <- base::inherits
[10:55:42.919]             invokeRestart <- base::invokeRestart
[10:55:42.919]             length <- base::length
[10:55:42.919]             list <- base::list
[10:55:42.919]             seq.int <- base::seq.int
[10:55:42.919]             signalCondition <- base::signalCondition
[10:55:42.919]             sys.calls <- base::sys.calls
[10:55:42.919]             `[[` <- base::`[[`
[10:55:42.919]             `+` <- base::`+`
[10:55:42.919]             `<<-` <- base::`<<-`
[10:55:42.919]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.919]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.919]                   3L)]
[10:55:42.919]             }
[10:55:42.919]             function(cond) {
[10:55:42.919]                 is_error <- inherits(cond, "error")
[10:55:42.919]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.919]                   NULL)
[10:55:42.919]                 if (is_error) {
[10:55:42.919]                   sessionInformation <- function() {
[10:55:42.919]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.919]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.919]                       search = base::search(), system = base::Sys.info())
[10:55:42.919]                   }
[10:55:42.919]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.919]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.919]                     cond$call), session = sessionInformation(), 
[10:55:42.919]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.919]                   signalCondition(cond)
[10:55:42.919]                 }
[10:55:42.919]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.919]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.919]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.919]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.919]                   if (FALSE && !signal) {
[10:55:42.919]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.919]                     {
[10:55:42.919]                       inherits <- base::inherits
[10:55:42.919]                       invokeRestart <- base::invokeRestart
[10:55:42.919]                       is.null <- base::is.null
[10:55:42.919]                       muffled <- FALSE
[10:55:42.919]                       if (inherits(cond, "message")) {
[10:55:42.919]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.919]                         if (muffled) 
[10:55:42.919]                           invokeRestart("muffleMessage")
[10:55:42.919]                       }
[10:55:42.919]                       else if (inherits(cond, "warning")) {
[10:55:42.919]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.919]                         if (muffled) 
[10:55:42.919]                           invokeRestart("muffleWarning")
[10:55:42.919]                       }
[10:55:42.919]                       else if (inherits(cond, "condition")) {
[10:55:42.919]                         if (!is.null(pattern)) {
[10:55:42.919]                           computeRestarts <- base::computeRestarts
[10:55:42.919]                           grepl <- base::grepl
[10:55:42.919]                           restarts <- computeRestarts(cond)
[10:55:42.919]                           for (restart in restarts) {
[10:55:42.919]                             name <- restart$name
[10:55:42.919]                             if (is.null(name)) 
[10:55:42.919]                               next
[10:55:42.919]                             if (!grepl(pattern, name)) 
[10:55:42.919]                               next
[10:55:42.919]                             invokeRestart(restart)
[10:55:42.919]                             muffled <- TRUE
[10:55:42.919]                             break
[10:55:42.919]                           }
[10:55:42.919]                         }
[10:55:42.919]                       }
[10:55:42.919]                       invisible(muffled)
[10:55:42.919]                     }
[10:55:42.919]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.919]                   }
[10:55:42.919]                 }
[10:55:42.919]                 else {
[10:55:42.919]                   if (TRUE) {
[10:55:42.919]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.919]                     {
[10:55:42.919]                       inherits <- base::inherits
[10:55:42.919]                       invokeRestart <- base::invokeRestart
[10:55:42.919]                       is.null <- base::is.null
[10:55:42.919]                       muffled <- FALSE
[10:55:42.919]                       if (inherits(cond, "message")) {
[10:55:42.919]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.919]                         if (muffled) 
[10:55:42.919]                           invokeRestart("muffleMessage")
[10:55:42.919]                       }
[10:55:42.919]                       else if (inherits(cond, "warning")) {
[10:55:42.919]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.919]                         if (muffled) 
[10:55:42.919]                           invokeRestart("muffleWarning")
[10:55:42.919]                       }
[10:55:42.919]                       else if (inherits(cond, "condition")) {
[10:55:42.919]                         if (!is.null(pattern)) {
[10:55:42.919]                           computeRestarts <- base::computeRestarts
[10:55:42.919]                           grepl <- base::grepl
[10:55:42.919]                           restarts <- computeRestarts(cond)
[10:55:42.919]                           for (restart in restarts) {
[10:55:42.919]                             name <- restart$name
[10:55:42.919]                             if (is.null(name)) 
[10:55:42.919]                               next
[10:55:42.919]                             if (!grepl(pattern, name)) 
[10:55:42.919]                               next
[10:55:42.919]                             invokeRestart(restart)
[10:55:42.919]                             muffled <- TRUE
[10:55:42.919]                             break
[10:55:42.919]                           }
[10:55:42.919]                         }
[10:55:42.919]                       }
[10:55:42.919]                       invisible(muffled)
[10:55:42.919]                     }
[10:55:42.919]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.919]                   }
[10:55:42.919]                 }
[10:55:42.919]             }
[10:55:42.919]         }))
[10:55:42.919]     }, error = function(ex) {
[10:55:42.919]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.919]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.919]                 ...future.rng), started = ...future.startTime, 
[10:55:42.919]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.919]             version = "1.8"), class = "FutureResult")
[10:55:42.919]     }, finally = {
[10:55:42.919]         if (!identical(...future.workdir, getwd())) 
[10:55:42.919]             setwd(...future.workdir)
[10:55:42.919]         {
[10:55:42.919]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.919]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.919]             }
[10:55:42.919]             base::options(...future.oldOptions)
[10:55:42.919]             if (.Platform$OS.type == "windows") {
[10:55:42.919]                 old_names <- names(...future.oldEnvVars)
[10:55:42.919]                 envs <- base::Sys.getenv()
[10:55:42.919]                 names <- names(envs)
[10:55:42.919]                 common <- intersect(names, old_names)
[10:55:42.919]                 added <- setdiff(names, old_names)
[10:55:42.919]                 removed <- setdiff(old_names, names)
[10:55:42.919]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.919]                   envs[common]]
[10:55:42.919]                 NAMES <- toupper(changed)
[10:55:42.919]                 args <- list()
[10:55:42.919]                 for (kk in seq_along(NAMES)) {
[10:55:42.919]                   name <- changed[[kk]]
[10:55:42.919]                   NAME <- NAMES[[kk]]
[10:55:42.919]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.919]                     next
[10:55:42.919]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.919]                 }
[10:55:42.919]                 NAMES <- toupper(added)
[10:55:42.919]                 for (kk in seq_along(NAMES)) {
[10:55:42.919]                   name <- added[[kk]]
[10:55:42.919]                   NAME <- NAMES[[kk]]
[10:55:42.919]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.919]                     next
[10:55:42.919]                   args[[name]] <- ""
[10:55:42.919]                 }
[10:55:42.919]                 NAMES <- toupper(removed)
[10:55:42.919]                 for (kk in seq_along(NAMES)) {
[10:55:42.919]                   name <- removed[[kk]]
[10:55:42.919]                   NAME <- NAMES[[kk]]
[10:55:42.919]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.919]                     next
[10:55:42.919]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.919]                 }
[10:55:42.919]                 if (length(args) > 0) 
[10:55:42.919]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.919]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.919]             }
[10:55:42.919]             else {
[10:55:42.919]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.919]             }
[10:55:42.919]             {
[10:55:42.919]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.919]                   0L) {
[10:55:42.919]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.919]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.919]                   base::options(opts)
[10:55:42.919]                 }
[10:55:42.919]                 {
[10:55:42.919]                   NULL
[10:55:42.919]                   options(future.plan = NULL)
[10:55:42.919]                   if (is.na(NA_character_)) 
[10:55:42.919]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.919]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.919]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.919]                     .init = FALSE)
[10:55:42.919]                 }
[10:55:42.919]             }
[10:55:42.919]         }
[10:55:42.919]     })
[10:55:42.919]     if (TRUE) {
[10:55:42.919]         base::sink(type = "output", split = FALSE)
[10:55:42.919]         if (TRUE) {
[10:55:42.919]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.919]         }
[10:55:42.919]         else {
[10:55:42.919]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.919]         }
[10:55:42.919]         base::close(...future.stdout)
[10:55:42.919]         ...future.stdout <- NULL
[10:55:42.919]     }
[10:55:42.919]     ...future.result$conditions <- ...future.conditions
[10:55:42.919]     ...future.result$finished <- base::Sys.time()
[10:55:42.919]     ...future.result
[10:55:42.919] }
MiraiFuture:
Label: 'strategy_mirai_multisession'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:55:42.926] resolved() for 'MiraiFuture' ...
[10:55:42.926] - state: 'running'
[10:55:42.927] - run: TRUE
[10:55:42.927] - result: 'NULL'
[10:55:42.927] - resolved: FALSE
[10:55:42.927] resolved() for 'MiraiFuture' ... done
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b859a48e-c511-ea97-6436-2c6143ec3048
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.931] getGlobalsAndPackages() ...
[10:55:42.931] Searching for globals...
[10:55:42.932] 
[10:55:42.932] Searching for globals ... DONE
[10:55:42.932] - globals: [0] <none>
[10:55:42.933] getGlobalsAndPackages() ... DONE
[10:55:42.933] run() for 'Future' ...
[10:55:42.933] - state: 'created'
[10:55:42.934] - Future backend: 'FutureStrategy', 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[10:55:42.937] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.938] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[10:55:42.938]   - Field: 'label'
[10:55:42.938]   - Field: 'local'
[10:55:42.938]   - Field: 'owner'
[10:55:42.939]   - Field: 'envir'
[10:55:42.939]   - Field: 'packages'
[10:55:42.939]   - Field: 'gc'
[10:55:42.940]   - Field: 'conditions'
[10:55:42.940]   - Field: 'expr'
[10:55:42.940]   - Field: 'uuid'
[10:55:42.940]   - Field: 'seed'
[10:55:42.941]   - Field: 'version'
[10:55:42.941]   - Field: 'result'
[10:55:42.941]   - Field: 'asynchronous'
[10:55:42.942]   - Field: 'calls'
[10:55:42.942]   - Field: 'globals'
[10:55:42.942]   - Field: 'stdout'
[10:55:42.942]   - Field: 'earlySignal'
[10:55:42.943]   - Field: 'lazy'
[10:55:42.943]   - Field: 'state'
[10:55:42.943]   - Field: '.cluster'
[10:55:42.944] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[10:55:42.944] - Launch lazy future ...
[10:55:42.944] Packages needed by the future expression (n = 0): <none>
[10:55:42.944] Packages needed by future strategies (n = 0): <none>
[10:55:42.945] {
[10:55:42.945]     {
[10:55:42.945]         {
[10:55:42.945]             ...future.startTime <- base::Sys.time()
[10:55:42.945]             {
[10:55:42.945]                 {
[10:55:42.945]                   {
[10:55:42.945]                     base::local({
[10:55:42.945]                       has_future <- base::requireNamespace("future", 
[10:55:42.945]                         quietly = TRUE)
[10:55:42.945]                       if (has_future) {
[10:55:42.945]                         ns <- base::getNamespace("future")
[10:55:42.945]                         version <- ns[[".package"]][["version"]]
[10:55:42.945]                         if (is.null(version)) 
[10:55:42.945]                           version <- utils::packageVersion("future")
[10:55:42.945]                       }
[10:55:42.945]                       else {
[10:55:42.945]                         version <- NULL
[10:55:42.945]                       }
[10:55:42.945]                       if (!has_future || version < "1.8.0") {
[10:55:42.945]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.945]                           "", base::R.version$version.string), 
[10:55:42.945]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.945]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.945]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.945]                             "release", "version")], collapse = " "), 
[10:55:42.945]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.945]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.945]                           info)
[10:55:42.945]                         info <- base::paste(info, collapse = "; ")
[10:55:42.945]                         if (!has_future) {
[10:55:42.945]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.945]                             info)
[10:55:42.945]                         }
[10:55:42.945]                         else {
[10:55:42.945]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.945]                             info, version)
[10:55:42.945]                         }
[10:55:42.945]                         base::stop(msg)
[10:55:42.945]                       }
[10:55:42.945]                     })
[10:55:42.945]                   }
[10:55:42.945]                   ...future.strategy.old <- future::plan("list")
[10:55:42.945]                   options(future.plan = NULL)
[10:55:42.945]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.945]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.945]                 }
[10:55:42.945]                 ...future.workdir <- getwd()
[10:55:42.945]             }
[10:55:42.945]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.945]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.945]         }
[10:55:42.945]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.945]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.945]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.945]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.945]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.945]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.945]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.945]             base::names(...future.oldOptions))
[10:55:42.945]     }
[10:55:42.945]     if (FALSE) {
[10:55:42.945]     }
[10:55:42.945]     else {
[10:55:42.945]         if (TRUE) {
[10:55:42.945]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.945]                 open = "w")
[10:55:42.945]         }
[10:55:42.945]         else {
[10:55:42.945]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.945]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.945]         }
[10:55:42.945]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.945]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.945]             base::sink(type = "output", split = FALSE)
[10:55:42.945]             base::close(...future.stdout)
[10:55:42.945]         }, add = TRUE)
[10:55:42.945]     }
[10:55:42.945]     ...future.frame <- base::sys.nframe()
[10:55:42.945]     ...future.conditions <- base::list()
[10:55:42.945]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.945]     if (FALSE) {
[10:55:42.945]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.945]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.945]     }
[10:55:42.945]     ...future.result <- base::tryCatch({
[10:55:42.945]         base::withCallingHandlers({
[10:55:42.945]             ...future.value <- base::withVisible(base::local(42))
[10:55:42.945]             future::FutureResult(value = ...future.value$value, 
[10:55:42.945]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.945]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.945]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.945]                     ...future.globalenv.names))
[10:55:42.945]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.945]         }, condition = base::local({
[10:55:42.945]             c <- base::c
[10:55:42.945]             inherits <- base::inherits
[10:55:42.945]             invokeRestart <- base::invokeRestart
[10:55:42.945]             length <- base::length
[10:55:42.945]             list <- base::list
[10:55:42.945]             seq.int <- base::seq.int
[10:55:42.945]             signalCondition <- base::signalCondition
[10:55:42.945]             sys.calls <- base::sys.calls
[10:55:42.945]             `[[` <- base::`[[`
[10:55:42.945]             `+` <- base::`+`
[10:55:42.945]             `<<-` <- base::`<<-`
[10:55:42.945]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.945]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.945]                   3L)]
[10:55:42.945]             }
[10:55:42.945]             function(cond) {
[10:55:42.945]                 is_error <- inherits(cond, "error")
[10:55:42.945]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.945]                   NULL)
[10:55:42.945]                 if (is_error) {
[10:55:42.945]                   sessionInformation <- function() {
[10:55:42.945]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.945]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.945]                       search = base::search(), system = base::Sys.info())
[10:55:42.945]                   }
[10:55:42.945]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.945]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.945]                     cond$call), session = sessionInformation(), 
[10:55:42.945]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.945]                   signalCondition(cond)
[10:55:42.945]                 }
[10:55:42.945]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.945]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.945]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.945]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.945]                   if (FALSE && !signal) {
[10:55:42.945]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.945]                     {
[10:55:42.945]                       inherits <- base::inherits
[10:55:42.945]                       invokeRestart <- base::invokeRestart
[10:55:42.945]                       is.null <- base::is.null
[10:55:42.945]                       muffled <- FALSE
[10:55:42.945]                       if (inherits(cond, "message")) {
[10:55:42.945]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.945]                         if (muffled) 
[10:55:42.945]                           invokeRestart("muffleMessage")
[10:55:42.945]                       }
[10:55:42.945]                       else if (inherits(cond, "warning")) {
[10:55:42.945]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.945]                         if (muffled) 
[10:55:42.945]                           invokeRestart("muffleWarning")
[10:55:42.945]                       }
[10:55:42.945]                       else if (inherits(cond, "condition")) {
[10:55:42.945]                         if (!is.null(pattern)) {
[10:55:42.945]                           computeRestarts <- base::computeRestarts
[10:55:42.945]                           grepl <- base::grepl
[10:55:42.945]                           restarts <- computeRestarts(cond)
[10:55:42.945]                           for (restart in restarts) {
[10:55:42.945]                             name <- restart$name
[10:55:42.945]                             if (is.null(name)) 
[10:55:42.945]                               next
[10:55:42.945]                             if (!grepl(pattern, name)) 
[10:55:42.945]                               next
[10:55:42.945]                             invokeRestart(restart)
[10:55:42.945]                             muffled <- TRUE
[10:55:42.945]                             break
[10:55:42.945]                           }
[10:55:42.945]                         }
[10:55:42.945]                       }
[10:55:42.945]                       invisible(muffled)
[10:55:42.945]                     }
[10:55:42.945]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.945]                   }
[10:55:42.945]                 }
[10:55:42.945]                 else {
[10:55:42.945]                   if (TRUE) {
[10:55:42.945]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.945]                     {
[10:55:42.945]                       inherits <- base::inherits
[10:55:42.945]                       invokeRestart <- base::invokeRestart
[10:55:42.945]                       is.null <- base::is.null
[10:55:42.945]                       muffled <- FALSE
[10:55:42.945]                       if (inherits(cond, "message")) {
[10:55:42.945]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.945]                         if (muffled) 
[10:55:42.945]                           invokeRestart("muffleMessage")
[10:55:42.945]                       }
[10:55:42.945]                       else if (inherits(cond, "warning")) {
[10:55:42.945]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.945]                         if (muffled) 
[10:55:42.945]                           invokeRestart("muffleWarning")
[10:55:42.945]                       }
[10:55:42.945]                       else if (inherits(cond, "condition")) {
[10:55:42.945]                         if (!is.null(pattern)) {
[10:55:42.945]                           computeRestarts <- base::computeRestarts
[10:55:42.945]                           grepl <- base::grepl
[10:55:42.945]                           restarts <- computeRestarts(cond)
[10:55:42.945]                           for (restart in restarts) {
[10:55:42.945]                             name <- restart$name
[10:55:42.945]                             if (is.null(name)) 
[10:55:42.945]                               next
[10:55:42.945]                             if (!grepl(pattern, name)) 
[10:55:42.945]                               next
[10:55:42.945]                             invokeRestart(restart)
[10:55:42.945]                             muffled <- TRUE
[10:55:42.945]                             break
[10:55:42.945]                           }
[10:55:42.945]                         }
[10:55:42.945]                       }
[10:55:42.945]                       invisible(muffled)
[10:55:42.945]                     }
[10:55:42.945]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.945]                   }
[10:55:42.945]                 }
[10:55:42.945]             }
[10:55:42.945]         }))
[10:55:42.945]     }, error = function(ex) {
[10:55:42.945]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.945]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.945]                 ...future.rng), started = ...future.startTime, 
[10:55:42.945]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.945]             version = "1.8"), class = "FutureResult")
[10:55:42.945]     }, finally = {
[10:55:42.945]         if (!identical(...future.workdir, getwd())) 
[10:55:42.945]             setwd(...future.workdir)
[10:55:42.945]         {
[10:55:42.945]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.945]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.945]             }
[10:55:42.945]             base::options(...future.oldOptions)
[10:55:42.945]             if (.Platform$OS.type == "windows") {
[10:55:42.945]                 old_names <- names(...future.oldEnvVars)
[10:55:42.945]                 envs <- base::Sys.getenv()
[10:55:42.945]                 names <- names(envs)
[10:55:42.945]                 common <- intersect(names, old_names)
[10:55:42.945]                 added <- setdiff(names, old_names)
[10:55:42.945]                 removed <- setdiff(old_names, names)
[10:55:42.945]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.945]                   envs[common]]
[10:55:42.945]                 NAMES <- toupper(changed)
[10:55:42.945]                 args <- list()
[10:55:42.945]                 for (kk in seq_along(NAMES)) {
[10:55:42.945]                   name <- changed[[kk]]
[10:55:42.945]                   NAME <- NAMES[[kk]]
[10:55:42.945]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.945]                     next
[10:55:42.945]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.945]                 }
[10:55:42.945]                 NAMES <- toupper(added)
[10:55:42.945]                 for (kk in seq_along(NAMES)) {
[10:55:42.945]                   name <- added[[kk]]
[10:55:42.945]                   NAME <- NAMES[[kk]]
[10:55:42.945]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.945]                     next
[10:55:42.945]                   args[[name]] <- ""
[10:55:42.945]                 }
[10:55:42.945]                 NAMES <- toupper(removed)
[10:55:42.945]                 for (kk in seq_along(NAMES)) {
[10:55:42.945]                   name <- removed[[kk]]
[10:55:42.945]                   NAME <- NAMES[[kk]]
[10:55:42.945]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.945]                     next
[10:55:42.945]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.945]                 }
[10:55:42.945]                 if (length(args) > 0) 
[10:55:42.945]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.945]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.945]             }
[10:55:42.945]             else {
[10:55:42.945]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.945]             }
[10:55:42.945]             {
[10:55:42.945]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.945]                   0L) {
[10:55:42.945]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.945]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.945]                   base::options(opts)
[10:55:42.945]                 }
[10:55:42.945]                 {
[10:55:42.945]                   NULL
[10:55:42.945]                   options(future.plan = NULL)
[10:55:42.945]                   if (is.na(NA_character_)) 
[10:55:42.945]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.945]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.945]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.945]                     .init = FALSE)
[10:55:42.945]                 }
[10:55:42.945]             }
[10:55:42.945]         }
[10:55:42.945]     })
[10:55:42.945]     if (TRUE) {
[10:55:42.945]         base::sink(type = "output", split = FALSE)
[10:55:42.945]         if (TRUE) {
[10:55:42.945]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.945]         }
[10:55:42.945]         else {
[10:55:42.945]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.945]         }
[10:55:42.945]         base::close(...future.stdout)
[10:55:42.945]         ...future.stdout <- NULL
[10:55:42.945]     }
[10:55:42.945]     ...future.result$conditions <- ...future.conditions
[10:55:42.945]     ...future.result$finished <- base::Sys.time()
[10:55:42.945]     ...future.result
[10:55:42.945] }
[10:55:42.952] - Launch lazy future ... done
[10:55:42.952] run() for 'MiraiFuture' ... done
MiraiFuture:
Label: 'strategy_mirai_multisession'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:55:42.953] resolved() for 'MiraiFuture' ...
[10:55:42.953] - state: 'running'
[10:55:42.953] - run: TRUE
[10:55:42.954] - result: 'NULL'
[10:55:42.954] - resolved: FALSE
[10:55:42.954] resolved() for 'MiraiFuture' ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b859a48e-c511-ea97-6436-2c6143ec3048
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.955] getGlobalsAndPackages() ...
[10:55:42.955] Searching for globals...
[10:55:42.957] - globals found: [1] '{'
[10:55:42.957] Searching for globals ... DONE
[10:55:42.957] Resolving globals: FALSE
[10:55:42.958] 
[10:55:42.958] 
[10:55:42.958] getGlobalsAndPackages() ... DONE
[10:55:42.959] run() for 'Future' ...
[10:55:42.959] - state: 'created'
[10:55:42.959] - Future backend: 'FutureStrategy', 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[10:55:42.965] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.966] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[10:55:42.966]   - Field: 'label'
[10:55:42.966]   - Field: 'local'
[10:55:42.967]   - Field: 'owner'
[10:55:42.967]   - Field: 'envir'
[10:55:42.967]   - Field: 'packages'
[10:55:42.967]   - Field: 'gc'
[10:55:42.968]   - Field: 'conditions'
[10:55:42.968]   - Field: 'expr'
[10:55:42.968]   - Field: 'uuid'
[10:55:42.969]   - Field: 'seed'
[10:55:42.969]   - Field: 'version'
[10:55:42.969]   - Field: 'result'
[10:55:42.969]   - Field: 'asynchronous'
[10:55:42.970]   - Field: 'calls'
[10:55:42.970]   - Field: 'globals'
[10:55:42.970]   - Field: 'stdout'
[10:55:42.971]   - Field: 'earlySignal'
[10:55:42.971]   - Field: 'lazy'
[10:55:42.971]   - Field: 'state'
[10:55:42.971]   - Field: '.cluster'
[10:55:42.972] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[10:55:42.972] - Launch lazy future ...
[10:55:42.972] Packages needed by the future expression (n = 0): <none>
[10:55:42.972] Packages needed by future strategies (n = 0): <none>
[10:55:42.973] {
[10:55:42.973]     {
[10:55:42.973]         {
[10:55:42.973]             ...future.startTime <- base::Sys.time()
[10:55:42.973]             {
[10:55:42.973]                 {
[10:55:42.973]                   {
[10:55:42.973]                     base::local({
[10:55:42.973]                       has_future <- base::requireNamespace("future", 
[10:55:42.973]                         quietly = TRUE)
[10:55:42.973]                       if (has_future) {
[10:55:42.973]                         ns <- base::getNamespace("future")
[10:55:42.973]                         version <- ns[[".package"]][["version"]]
[10:55:42.973]                         if (is.null(version)) 
[10:55:42.973]                           version <- utils::packageVersion("future")
[10:55:42.973]                       }
[10:55:42.973]                       else {
[10:55:42.973]                         version <- NULL
[10:55:42.973]                       }
[10:55:42.973]                       if (!has_future || version < "1.8.0") {
[10:55:42.973]                         info <- base::c(r_version = base::gsub("R version ", 
[10:55:42.973]                           "", base::R.version$version.string), 
[10:55:42.973]                           platform = base::sprintf("%s (%s-bit)", 
[10:55:42.973]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[10:55:42.973]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[10:55:42.973]                             "release", "version")], collapse = " "), 
[10:55:42.973]                           hostname = base::Sys.info()[["nodename"]])
[10:55:42.973]                         info <- base::sprintf("%s: %s", base::names(info), 
[10:55:42.973]                           info)
[10:55:42.973]                         info <- base::paste(info, collapse = "; ")
[10:55:42.973]                         if (!has_future) {
[10:55:42.973]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[10:55:42.973]                             info)
[10:55:42.973]                         }
[10:55:42.973]                         else {
[10:55:42.973]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[10:55:42.973]                             info, version)
[10:55:42.973]                         }
[10:55:42.973]                         base::stop(msg)
[10:55:42.973]                       }
[10:55:42.973]                     })
[10:55:42.973]                   }
[10:55:42.973]                   ...future.strategy.old <- future::plan("list")
[10:55:42.973]                   options(future.plan = NULL)
[10:55:42.973]                   Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.973]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[10:55:42.973]                 }
[10:55:42.973]                 ...future.workdir <- getwd()
[10:55:42.973]             }
[10:55:42.973]             ...future.oldOptions <- base::as.list(base::.Options)
[10:55:42.973]             ...future.oldEnvVars <- base::Sys.getenv()
[10:55:42.973]         }
[10:55:42.973]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[10:55:42.973]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[10:55:42.973]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[10:55:42.973]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[10:55:42.973]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[10:55:42.973]             future.stdout.windows.reencode = NULL, width = 80L)
[10:55:42.973]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[10:55:42.973]             base::names(...future.oldOptions))
[10:55:42.973]     }
[10:55:42.973]     if (FALSE) {
[10:55:42.973]     }
[10:55:42.973]     else {
[10:55:42.973]         if (TRUE) {
[10:55:42.973]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[10:55:42.973]                 open = "w")
[10:55:42.973]         }
[10:55:42.973]         else {
[10:55:42.973]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[10:55:42.973]                 windows = "NUL", "/dev/null"), open = "w")
[10:55:42.973]         }
[10:55:42.973]         base::sink(...future.stdout, type = "output", split = FALSE)
[10:55:42.973]         base::on.exit(if (!base::is.null(...future.stdout)) {
[10:55:42.973]             base::sink(type = "output", split = FALSE)
[10:55:42.973]             base::close(...future.stdout)
[10:55:42.973]         }, add = TRUE)
[10:55:42.973]     }
[10:55:42.973]     ...future.frame <- base::sys.nframe()
[10:55:42.973]     ...future.conditions <- base::list()
[10:55:42.973]     ...future.rng <- base::globalenv()$.Random.seed
[10:55:42.973]     if (FALSE) {
[10:55:42.973]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[10:55:42.973]             "...future.value", "...future.globalenv.names", ".Random.seed")
[10:55:42.973]     }
[10:55:42.973]     ...future.result <- base::tryCatch({
[10:55:42.973]         base::withCallingHandlers({
[10:55:42.973]             ...future.value <- base::withVisible(base::local({
[10:55:42.973]                 42
[10:55:42.973]             }))
[10:55:42.973]             future::FutureResult(value = ...future.value$value, 
[10:55:42.973]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.973]                   ...future.rng), globalenv = if (FALSE) 
[10:55:42.973]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[10:55:42.973]                     ...future.globalenv.names))
[10:55:42.973]                 else NULL, started = ...future.startTime, version = "1.8")
[10:55:42.973]         }, condition = base::local({
[10:55:42.973]             c <- base::c
[10:55:42.973]             inherits <- base::inherits
[10:55:42.973]             invokeRestart <- base::invokeRestart
[10:55:42.973]             length <- base::length
[10:55:42.973]             list <- base::list
[10:55:42.973]             seq.int <- base::seq.int
[10:55:42.973]             signalCondition <- base::signalCondition
[10:55:42.973]             sys.calls <- base::sys.calls
[10:55:42.973]             `[[` <- base::`[[`
[10:55:42.973]             `+` <- base::`+`
[10:55:42.973]             `<<-` <- base::`<<-`
[10:55:42.973]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[10:55:42.973]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[10:55:42.973]                   3L)]
[10:55:42.973]             }
[10:55:42.973]             function(cond) {
[10:55:42.973]                 is_error <- inherits(cond, "error")
[10:55:42.973]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[10:55:42.973]                   NULL)
[10:55:42.973]                 if (is_error) {
[10:55:42.973]                   sessionInformation <- function() {
[10:55:42.973]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[10:55:42.973]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[10:55:42.973]                       search = base::search(), system = base::Sys.info())
[10:55:42.973]                   }
[10:55:42.973]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.973]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[10:55:42.973]                     cond$call), session = sessionInformation(), 
[10:55:42.973]                     timestamp = base::Sys.time(), signaled = 0L)
[10:55:42.973]                   signalCondition(cond)
[10:55:42.973]                 }
[10:55:42.973]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
[10:55:42.973]                   signal <- FALSE && inherits(cond, character(0))
[10:55:42.973]                   ...future.conditions[[length(...future.conditions) + 
[10:55:42.973]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[10:55:42.973]                   if (FALSE && !signal) {
[10:55:42.973]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.973]                     {
[10:55:42.973]                       inherits <- base::inherits
[10:55:42.973]                       invokeRestart <- base::invokeRestart
[10:55:42.973]                       is.null <- base::is.null
[10:55:42.973]                       muffled <- FALSE
[10:55:42.973]                       if (inherits(cond, "message")) {
[10:55:42.973]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.973]                         if (muffled) 
[10:55:42.973]                           invokeRestart("muffleMessage")
[10:55:42.973]                       }
[10:55:42.973]                       else if (inherits(cond, "warning")) {
[10:55:42.973]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.973]                         if (muffled) 
[10:55:42.973]                           invokeRestart("muffleWarning")
[10:55:42.973]                       }
[10:55:42.973]                       else if (inherits(cond, "condition")) {
[10:55:42.973]                         if (!is.null(pattern)) {
[10:55:42.973]                           computeRestarts <- base::computeRestarts
[10:55:42.973]                           grepl <- base::grepl
[10:55:42.973]                           restarts <- computeRestarts(cond)
[10:55:42.973]                           for (restart in restarts) {
[10:55:42.973]                             name <- restart$name
[10:55:42.973]                             if (is.null(name)) 
[10:55:42.973]                               next
[10:55:42.973]                             if (!grepl(pattern, name)) 
[10:55:42.973]                               next
[10:55:42.973]                             invokeRestart(restart)
[10:55:42.973]                             muffled <- TRUE
[10:55:42.973]                             break
[10:55:42.973]                           }
[10:55:42.973]                         }
[10:55:42.973]                       }
[10:55:42.973]                       invisible(muffled)
[10:55:42.973]                     }
[10:55:42.973]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.973]                   }
[10:55:42.973]                 }
[10:55:42.973]                 else {
[10:55:42.973]                   if (TRUE) {
[10:55:42.973]                     muffleCondition <- function (cond, pattern = "^muffle") 
[10:55:42.973]                     {
[10:55:42.973]                       inherits <- base::inherits
[10:55:42.973]                       invokeRestart <- base::invokeRestart
[10:55:42.973]                       is.null <- base::is.null
[10:55:42.973]                       muffled <- FALSE
[10:55:42.973]                       if (inherits(cond, "message")) {
[10:55:42.973]                         muffled <- grepl(pattern, "muffleMessage")
[10:55:42.973]                         if (muffled) 
[10:55:42.973]                           invokeRestart("muffleMessage")
[10:55:42.973]                       }
[10:55:42.973]                       else if (inherits(cond, "warning")) {
[10:55:42.973]                         muffled <- grepl(pattern, "muffleWarning")
[10:55:42.973]                         if (muffled) 
[10:55:42.973]                           invokeRestart("muffleWarning")
[10:55:42.973]                       }
[10:55:42.973]                       else if (inherits(cond, "condition")) {
[10:55:42.973]                         if (!is.null(pattern)) {
[10:55:42.973]                           computeRestarts <- base::computeRestarts
[10:55:42.973]                           grepl <- base::grepl
[10:55:42.973]                           restarts <- computeRestarts(cond)
[10:55:42.973]                           for (restart in restarts) {
[10:55:42.973]                             name <- restart$name
[10:55:42.973]                             if (is.null(name)) 
[10:55:42.973]                               next
[10:55:42.973]                             if (!grepl(pattern, name)) 
[10:55:42.973]                               next
[10:55:42.973]                             invokeRestart(restart)
[10:55:42.973]                             muffled <- TRUE
[10:55:42.973]                             break
[10:55:42.973]                           }
[10:55:42.973]                         }
[10:55:42.973]                       }
[10:55:42.973]                       invisible(muffled)
[10:55:42.973]                     }
[10:55:42.973]                     muffleCondition(cond, pattern = "^muffle")
[10:55:42.973]                   }
[10:55:42.973]                 }
[10:55:42.973]             }
[10:55:42.973]         }))
[10:55:42.973]     }, error = function(ex) {
[10:55:42.973]         base::structure(base::list(value = NULL, visible = NULL, 
[10:55:42.973]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[10:55:42.973]                 ...future.rng), started = ...future.startTime, 
[10:55:42.973]             finished = Sys.time(), session_uuid = NA_character_, 
[10:55:42.973]             version = "1.8"), class = "FutureResult")
[10:55:42.973]     }, finally = {
[10:55:42.973]         if (!identical(...future.workdir, getwd())) 
[10:55:42.973]             setwd(...future.workdir)
[10:55:42.973]         {
[10:55:42.973]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[10:55:42.973]                 ...future.oldOptions$nwarnings <- NULL
[10:55:42.973]             }
[10:55:42.973]             base::options(...future.oldOptions)
[10:55:42.973]             if (.Platform$OS.type == "windows") {
[10:55:42.973]                 old_names <- names(...future.oldEnvVars)
[10:55:42.973]                 envs <- base::Sys.getenv()
[10:55:42.973]                 names <- names(envs)
[10:55:42.973]                 common <- intersect(names, old_names)
[10:55:42.973]                 added <- setdiff(names, old_names)
[10:55:42.973]                 removed <- setdiff(old_names, names)
[10:55:42.973]                 changed <- common[...future.oldEnvVars[common] != 
[10:55:42.973]                   envs[common]]
[10:55:42.973]                 NAMES <- toupper(changed)
[10:55:42.973]                 args <- list()
[10:55:42.973]                 for (kk in seq_along(NAMES)) {
[10:55:42.973]                   name <- changed[[kk]]
[10:55:42.973]                   NAME <- NAMES[[kk]]
[10:55:42.973]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.973]                     next
[10:55:42.973]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.973]                 }
[10:55:42.973]                 NAMES <- toupper(added)
[10:55:42.973]                 for (kk in seq_along(NAMES)) {
[10:55:42.973]                   name <- added[[kk]]
[10:55:42.973]                   NAME <- NAMES[[kk]]
[10:55:42.973]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.973]                     next
[10:55:42.973]                   args[[name]] <- ""
[10:55:42.973]                 }
[10:55:42.973]                 NAMES <- toupper(removed)
[10:55:42.973]                 for (kk in seq_along(NAMES)) {
[10:55:42.973]                   name <- removed[[kk]]
[10:55:42.973]                   NAME <- NAMES[[kk]]
[10:55:42.973]                   if (name != NAME && is.element(NAME, old_names)) 
[10:55:42.973]                     next
[10:55:42.973]                   args[[name]] <- ...future.oldEnvVars[[name]]
[10:55:42.973]                 }
[10:55:42.973]                 if (length(args) > 0) 
[10:55:42.973]                   base::do.call(base::Sys.setenv, args = args)
[10:55:42.973]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[10:55:42.973]             }
[10:55:42.973]             else {
[10:55:42.973]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[10:55:42.973]             }
[10:55:42.973]             {
[10:55:42.973]                 if (base::length(...future.futureOptionsAdded) > 
[10:55:42.973]                   0L) {
[10:55:42.973]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[10:55:42.973]                   base::names(opts) <- ...future.futureOptionsAdded
[10:55:42.973]                   base::options(opts)
[10:55:42.973]                 }
[10:55:42.973]                 {
[10:55:42.973]                   NULL
[10:55:42.973]                   options(future.plan = NULL)
[10:55:42.973]                   if (is.na(NA_character_)) 
[10:55:42.973]                     Sys.unsetenv("R_FUTURE_PLAN")
[10:55:42.973]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[10:55:42.973]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[10:55:42.973]                     .init = FALSE)
[10:55:42.973]                 }
[10:55:42.973]             }
[10:55:42.973]         }
[10:55:42.973]     })
[10:55:42.973]     if (TRUE) {
[10:55:42.973]         base::sink(type = "output", split = FALSE)
[10:55:42.973]         if (TRUE) {
[10:55:42.973]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[10:55:42.973]         }
[10:55:42.973]         else {
[10:55:42.973]             ...future.result["stdout"] <- base::list(NULL)
[10:55:42.973]         }
[10:55:42.973]         base::close(...future.stdout)
[10:55:42.973]         ...future.stdout <- NULL
[10:55:42.973]     }
[10:55:42.973]     ...future.result$conditions <- ...future.conditions
[10:55:42.973]     ...future.result$finished <- base::Sys.time()
[10:55:42.973]     ...future.result
[10:55:42.973] }
[10:55:42.980] - Launch lazy future ... done
[10:55:42.980] run() for 'MiraiFuture' ... done
MiraiFuture:
Label: 'strategy_mirai_multisession'
Expression:
{
    42
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[10:55:42.981] resolved() for 'MiraiFuture' ...
[10:55:42.981] - state: 'running'
[10:55:42.982] - run: TRUE
[10:55:42.982] - result: 'NULL'
[10:55:42.982] - resolved: FALSE
[10:55:42.983] resolved() for 'MiraiFuture' ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b859a48e-c511-ea97-6436-2c6143ec3048
Class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[10:55:42.983] - plan('mirai_multisession') ... DONE> 
> message("*** Futures - labels ... DONE")
*** Futures - labels ... DONE
> 
> source("incl/end.R")
> 
> proc.time()
   user  system elapsed 
   0.57    0.15    1.15