R Under development (unstable) (2023-12-20 r85713 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2023 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

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

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

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

> source("incl/start.R")
[01:29:37.543] plan(): Setting new future strategy stack:
[01:29:37.545] List of future strategies:
[01:29:37.545] 1. sequential:
[01:29:37.545]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.545]    - tweaked: FALSE
[01:29:37.545]    - call: future::plan("sequential")
[01:29:37.566] plan(): nbrOfWorkers() = 1
> 
> message("*** Standard output ...")
*** Standard output ...
> 
> truth_rows <- utils::capture.output({
+   print(1:50)
+   str(1:50)
+   cat(letters, sep = "-")
+   cat(1:6, collapse = "\n")
+   write.table(datasets::iris[1:10,], sep = "\t")
+ })
> truth <- paste0(paste(truth_rows, collapse = "\n"), "\n")
> print(truth)
[1] " [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50\n int [1:50] 1 2 3 4 5 6 7 8 9 10 ...\na-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 \n\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\"\n\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\"\n\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\"\n\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\"\n\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\"\n\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\"\n\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\"\n\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\"\n\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\"\n\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\"\n\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\"\n"
> 
> for (cores in seq_len(min(2L, availCores))) {
+   message(sprintf("Testing with %d cores ...", cores))
+   options(mc.cores = cores)
+ 
+   for (strategy in supportedStrategies(cores)) {
+     message(sprintf("%s ...", strategy))
+     plan(strategy)
+ 
+     for (stdout in c(TRUE, FALSE, NA)) {
+       message(sprintf("- stdout = %s", stdout))
+ 
+       f <- future({
+         print(1:50)
+         str(1:50)
+         cat(letters, sep = "-")
+         cat(1:6, collapse = "\n")
+         write.table(datasets::iris[1:10,], sep = "\t")
+         42L
+       }, stdout = stdout)
+       r <- result(f)
+       str(r)
+       stopifnot(value(f) == 42L)
+       if (is.na(stdout)) {
+         stopifnot(is.null(r$stdout) || r$stdout == "")
+       } else if (stdout) {
+         print(r)
+         stopifnot(identical(r$stdout, truth))
+       } else {
+         stopifnot(is.null(r$stdout))
+       }
+ 
+       v %<-% {
+         print(1:50)
+         str(1:50)
+         cat(letters, sep = "-")
+         cat(1:6, collapse = "\n")
+         write.table(datasets::iris[1:10,], sep = "\t")
+         42L
+       } %stdout% stdout
+       out <- utils::capture.output(y <- v)
+       stopifnot(y == 42L)
+       if (is.na(stdout)) {
+         ## Single-core multisession => sequential
+         if (cores > 1L || strategy != "multisession") {
+           stopifnot(out == "")
+         }
+       } else if (stdout) {
+         print(out)
+         stopifnot(identical(out, truth_rows))
+       } else {
+         stopifnot(out == "")
+       }
+ 
+       message("- stdout = structure(TRUE, drop = TRUE)")
+       f <- future(print(42), stdout = structure(TRUE, drop = TRUE))
+       r <- result(f)
+       stopifnot(inherits(r$stdout, "character"))
+       v <- value(f)
+       r <- result(f)
+       stopifnot(is.null(r$stdout))
+     } ## for (stdout ...)
+ 
+     message(sprintf("%s ... done", strategy))
+   } ## for (strategy ...)
+ 
+   message(sprintf("Testing with %d cores ... done", cores))
+ } ## for (cores ...)
Testing with 1 cores ...
sequential ...
[01:29:37.626] plan(): Setting new future strategy stack:
[01:29:37.626] List of future strategies:
[01:29:37.626] 1. sequential:
[01:29:37.626]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.626]    - tweaked: FALSE
[01:29:37.626]    - call: plan(strategy)
[01:29:37.641] plan(): nbrOfWorkers() = 1
- stdout = TRUE
[01:29:37.642] getGlobalsAndPackages() ...
[01:29:37.642] Searching for globals...
[01:29:37.652] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[01:29:37.653] Searching for globals ... DONE
[01:29:37.653] Resolving globals: FALSE
[01:29:37.654] 
[01:29:37.654] - packages: [1] 'utils'
[01:29:37.654] getGlobalsAndPackages() ... DONE
[01:29:37.656] run() for 'Future' ...
[01:29:37.656] - state: 'created'
[01:29:37.657] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:37.657] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:37.657] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:37.658]   - Field: 'label'
[01:29:37.658]   - Field: 'local'
[01:29:37.658]   - Field: 'owner'
[01:29:37.658]   - Field: 'envir'
[01:29:37.658]   - Field: 'packages'
[01:29:37.659]   - Field: 'gc'
[01:29:37.659]   - Field: 'conditions'
[01:29:37.659]   - Field: 'expr'
[01:29:37.659]   - Field: 'uuid'
[01:29:37.660]   - Field: 'seed'
[01:29:37.660]   - Field: 'version'
[01:29:37.660]   - Field: 'result'
[01:29:37.660]   - Field: 'asynchronous'
[01:29:37.660]   - Field: 'calls'
[01:29:37.661]   - Field: 'globals'
[01:29:37.661]   - Field: 'stdout'
[01:29:37.661]   - Field: 'earlySignal'
[01:29:37.661]   - Field: 'lazy'
[01:29:37.661]   - Field: 'state'
[01:29:37.662] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:37.662] - Launch lazy future ...
[01:29:37.663] Packages needed by the future expression (n = 1): 'utils'
[01:29:37.663] Packages needed by future strategies (n = 0): <none>
[01:29:37.664] {
[01:29:37.664]     {
[01:29:37.664]         {
[01:29:37.664]             ...future.startTime <- base::Sys.time()
[01:29:37.664]             {
[01:29:37.664]                 {
[01:29:37.664]                   {
[01:29:37.664]                     {
[01:29:37.664]                       base::local({
[01:29:37.664]                         has_future <- base::requireNamespace("future", 
[01:29:37.664]                           quietly = TRUE)
[01:29:37.664]                         if (has_future) {
[01:29:37.664]                           ns <- base::getNamespace("future")
[01:29:37.664]                           version <- ns[[".package"]][["version"]]
[01:29:37.664]                           if (is.null(version)) 
[01:29:37.664]                             version <- utils::packageVersion("future")
[01:29:37.664]                         }
[01:29:37.664]                         else {
[01:29:37.664]                           version <- NULL
[01:29:37.664]                         }
[01:29:37.664]                         if (!has_future || version < "1.8.0") {
[01:29:37.664]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:37.664]                             "", base::R.version$version.string), 
[01:29:37.664]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:37.664]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:37.664]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:37.664]                               "release", "version")], collapse = " "), 
[01:29:37.664]                             hostname = base::Sys.info()[["nodename"]])
[01:29:37.664]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:37.664]                             info)
[01:29:37.664]                           info <- base::paste(info, collapse = "; ")
[01:29:37.664]                           if (!has_future) {
[01:29:37.664]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:37.664]                               info)
[01:29:37.664]                           }
[01:29:37.664]                           else {
[01:29:37.664]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:37.664]                               info, version)
[01:29:37.664]                           }
[01:29:37.664]                           base::stop(msg)
[01:29:37.664]                         }
[01:29:37.664]                       })
[01:29:37.664]                     }
[01:29:37.664]                     base::local({
[01:29:37.664]                       for (pkg in "utils") {
[01:29:37.664]                         base::loadNamespace(pkg)
[01:29:37.664]                         base::library(pkg, character.only = TRUE)
[01:29:37.664]                       }
[01:29:37.664]                     })
[01:29:37.664]                   }
[01:29:37.664]                   options(future.plan = NULL)
[01:29:37.664]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.664]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:37.664]                 }
[01:29:37.664]                 ...future.workdir <- getwd()
[01:29:37.664]             }
[01:29:37.664]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:37.664]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:37.664]         }
[01:29:37.664]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:37.664]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:37.664]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:37.664]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:37.664]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:37.664]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:37.664]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:37.664]             base::names(...future.oldOptions))
[01:29:37.664]     }
[01:29:37.664]     if (FALSE) {
[01:29:37.664]     }
[01:29:37.664]     else {
[01:29:37.664]         if (TRUE) {
[01:29:37.664]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:37.664]                 open = "w")
[01:29:37.664]         }
[01:29:37.664]         else {
[01:29:37.664]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:37.664]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:37.664]         }
[01:29:37.664]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:37.664]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:37.664]             base::sink(type = "output", split = FALSE)
[01:29:37.664]             base::close(...future.stdout)
[01:29:37.664]         }, add = TRUE)
[01:29:37.664]     }
[01:29:37.664]     ...future.frame <- base::sys.nframe()
[01:29:37.664]     ...future.conditions <- base::list()
[01:29:37.664]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:37.664]     if (FALSE) {
[01:29:37.664]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:37.664]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:37.664]     }
[01:29:37.664]     ...future.result <- base::tryCatch({
[01:29:37.664]         base::withCallingHandlers({
[01:29:37.664]             ...future.value <- base::withVisible(base::local({
[01:29:37.664]                 print(1:50)
[01:29:37.664]                 str(1:50)
[01:29:37.664]                 cat(letters, sep = "-")
[01:29:37.664]                 cat(1:6, collapse = "\n")
[01:29:37.664]                 write.table(datasets::iris[1:10, ], sep = "\t")
[01:29:37.664]                 42L
[01:29:37.664]             }))
[01:29:37.664]             future::FutureResult(value = ...future.value$value, 
[01:29:37.664]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.664]                   ...future.rng), globalenv = if (FALSE) 
[01:29:37.664]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:37.664]                     ...future.globalenv.names))
[01:29:37.664]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:37.664]         }, condition = base::local({
[01:29:37.664]             c <- base::c
[01:29:37.664]             inherits <- base::inherits
[01:29:37.664]             invokeRestart <- base::invokeRestart
[01:29:37.664]             length <- base::length
[01:29:37.664]             list <- base::list
[01:29:37.664]             seq.int <- base::seq.int
[01:29:37.664]             signalCondition <- base::signalCondition
[01:29:37.664]             sys.calls <- base::sys.calls
[01:29:37.664]             `[[` <- base::`[[`
[01:29:37.664]             `+` <- base::`+`
[01:29:37.664]             `<<-` <- base::`<<-`
[01:29:37.664]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:37.664]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:37.664]                   3L)]
[01:29:37.664]             }
[01:29:37.664]             function(cond) {
[01:29:37.664]                 is_error <- inherits(cond, "error")
[01:29:37.664]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:37.664]                   NULL)
[01:29:37.664]                 if (is_error) {
[01:29:37.664]                   sessionInformation <- function() {
[01:29:37.664]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:37.664]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:37.664]                       search = base::search(), system = base::Sys.info())
[01:29:37.664]                   }
[01:29:37.664]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.664]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:37.664]                     cond$call), session = sessionInformation(), 
[01:29:37.664]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:37.664]                   signalCondition(cond)
[01:29:37.664]                 }
[01:29:37.664]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:37.664]                 "immediateCondition"))) {
[01:29:37.664]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:37.664]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.664]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:37.664]                   if (TRUE && !signal) {
[01:29:37.664]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.664]                     {
[01:29:37.664]                       inherits <- base::inherits
[01:29:37.664]                       invokeRestart <- base::invokeRestart
[01:29:37.664]                       is.null <- base::is.null
[01:29:37.664]                       muffled <- FALSE
[01:29:37.664]                       if (inherits(cond, "message")) {
[01:29:37.664]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.664]                         if (muffled) 
[01:29:37.664]                           invokeRestart("muffleMessage")
[01:29:37.664]                       }
[01:29:37.664]                       else if (inherits(cond, "warning")) {
[01:29:37.664]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.664]                         if (muffled) 
[01:29:37.664]                           invokeRestart("muffleWarning")
[01:29:37.664]                       }
[01:29:37.664]                       else if (inherits(cond, "condition")) {
[01:29:37.664]                         if (!is.null(pattern)) {
[01:29:37.664]                           computeRestarts <- base::computeRestarts
[01:29:37.664]                           grepl <- base::grepl
[01:29:37.664]                           restarts <- computeRestarts(cond)
[01:29:37.664]                           for (restart in restarts) {
[01:29:37.664]                             name <- restart$name
[01:29:37.664]                             if (is.null(name)) 
[01:29:37.664]                               next
[01:29:37.664]                             if (!grepl(pattern, name)) 
[01:29:37.664]                               next
[01:29:37.664]                             invokeRestart(restart)
[01:29:37.664]                             muffled <- TRUE
[01:29:37.664]                             break
[01:29:37.664]                           }
[01:29:37.664]                         }
[01:29:37.664]                       }
[01:29:37.664]                       invisible(muffled)
[01:29:37.664]                     }
[01:29:37.664]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.664]                   }
[01:29:37.664]                 }
[01:29:37.664]                 else {
[01:29:37.664]                   if (TRUE) {
[01:29:37.664]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.664]                     {
[01:29:37.664]                       inherits <- base::inherits
[01:29:37.664]                       invokeRestart <- base::invokeRestart
[01:29:37.664]                       is.null <- base::is.null
[01:29:37.664]                       muffled <- FALSE
[01:29:37.664]                       if (inherits(cond, "message")) {
[01:29:37.664]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.664]                         if (muffled) 
[01:29:37.664]                           invokeRestart("muffleMessage")
[01:29:37.664]                       }
[01:29:37.664]                       else if (inherits(cond, "warning")) {
[01:29:37.664]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.664]                         if (muffled) 
[01:29:37.664]                           invokeRestart("muffleWarning")
[01:29:37.664]                       }
[01:29:37.664]                       else if (inherits(cond, "condition")) {
[01:29:37.664]                         if (!is.null(pattern)) {
[01:29:37.664]                           computeRestarts <- base::computeRestarts
[01:29:37.664]                           grepl <- base::grepl
[01:29:37.664]                           restarts <- computeRestarts(cond)
[01:29:37.664]                           for (restart in restarts) {
[01:29:37.664]                             name <- restart$name
[01:29:37.664]                             if (is.null(name)) 
[01:29:37.664]                               next
[01:29:37.664]                             if (!grepl(pattern, name)) 
[01:29:37.664]                               next
[01:29:37.664]                             invokeRestart(restart)
[01:29:37.664]                             muffled <- TRUE
[01:29:37.664]                             break
[01:29:37.664]                           }
[01:29:37.664]                         }
[01:29:37.664]                       }
[01:29:37.664]                       invisible(muffled)
[01:29:37.664]                     }
[01:29:37.664]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.664]                   }
[01:29:37.664]                 }
[01:29:37.664]             }
[01:29:37.664]         }))
[01:29:37.664]     }, error = function(ex) {
[01:29:37.664]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:37.664]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.664]                 ...future.rng), started = ...future.startTime, 
[01:29:37.664]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:37.664]             version = "1.8"), class = "FutureResult")
[01:29:37.664]     }, finally = {
[01:29:37.664]         if (!identical(...future.workdir, getwd())) 
[01:29:37.664]             setwd(...future.workdir)
[01:29:37.664]         {
[01:29:37.664]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:37.664]                 ...future.oldOptions$nwarnings <- NULL
[01:29:37.664]             }
[01:29:37.664]             base::options(...future.oldOptions)
[01:29:37.664]             if (.Platform$OS.type == "windows") {
[01:29:37.664]                 old_names <- names(...future.oldEnvVars)
[01:29:37.664]                 envs <- base::Sys.getenv()
[01:29:37.664]                 names <- names(envs)
[01:29:37.664]                 common <- intersect(names, old_names)
[01:29:37.664]                 added <- setdiff(names, old_names)
[01:29:37.664]                 removed <- setdiff(old_names, names)
[01:29:37.664]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:37.664]                   envs[common]]
[01:29:37.664]                 NAMES <- toupper(changed)
[01:29:37.664]                 args <- list()
[01:29:37.664]                 for (kk in seq_along(NAMES)) {
[01:29:37.664]                   name <- changed[[kk]]
[01:29:37.664]                   NAME <- NAMES[[kk]]
[01:29:37.664]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.664]                     next
[01:29:37.664]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.664]                 }
[01:29:37.664]                 NAMES <- toupper(added)
[01:29:37.664]                 for (kk in seq_along(NAMES)) {
[01:29:37.664]                   name <- added[[kk]]
[01:29:37.664]                   NAME <- NAMES[[kk]]
[01:29:37.664]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.664]                     next
[01:29:37.664]                   args[[name]] <- ""
[01:29:37.664]                 }
[01:29:37.664]                 NAMES <- toupper(removed)
[01:29:37.664]                 for (kk in seq_along(NAMES)) {
[01:29:37.664]                   name <- removed[[kk]]
[01:29:37.664]                   NAME <- NAMES[[kk]]
[01:29:37.664]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.664]                     next
[01:29:37.664]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.664]                 }
[01:29:37.664]                 if (length(args) > 0) 
[01:29:37.664]                   base::do.call(base::Sys.setenv, args = args)
[01:29:37.664]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:37.664]             }
[01:29:37.664]             else {
[01:29:37.664]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:37.664]             }
[01:29:37.664]             {
[01:29:37.664]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:37.664]                   0L) {
[01:29:37.664]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:37.664]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:37.664]                   base::options(opts)
[01:29:37.664]                 }
[01:29:37.664]                 {
[01:29:37.664]                   {
[01:29:37.664]                     NULL
[01:29:37.664]                     RNGkind("Mersenne-Twister")
[01:29:37.664]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:29:37.664]                       inherits = FALSE)
[01:29:37.664]                   }
[01:29:37.664]                   options(future.plan = NULL)
[01:29:37.664]                   if (is.na(NA_character_)) 
[01:29:37.664]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.664]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:37.664]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:37.664]                   {
[01:29:37.664]                     future <- SequentialFuture(..., envir = envir)
[01:29:37.664]                     if (!future$lazy) 
[01:29:37.664]                       future <- run(future)
[01:29:37.664]                     invisible(future)
[01:29:37.664]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:37.664]                 }
[01:29:37.664]             }
[01:29:37.664]         }
[01:29:37.664]     })
[01:29:37.664]     if (TRUE) {
[01:29:37.664]         base::sink(type = "output", split = FALSE)
[01:29:37.664]         if (TRUE) {
[01:29:37.664]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:37.664]         }
[01:29:37.664]         else {
[01:29:37.664]             ...future.result["stdout"] <- base::list(NULL)
[01:29:37.664]         }
[01:29:37.664]         base::close(...future.stdout)
[01:29:37.664]         ...future.stdout <- NULL
[01:29:37.664]     }
[01:29:37.664]     ...future.result$conditions <- ...future.conditions
[01:29:37.664]     ...future.result$finished <- base::Sys.time()
[01:29:37.664]     ...future.result
[01:29:37.664] }
[01:29:37.669] plan(): Setting new future strategy stack:
[01:29:37.669] List of future strategies:
[01:29:37.669] 1. sequential:
[01:29:37.669]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.669]    - tweaked: FALSE
[01:29:37.669]    - call: NULL
[01:29:37.670] plan(): nbrOfWorkers() = 1
[01:29:37.673] plan(): Setting new future strategy stack:
[01:29:37.673] List of future strategies:
[01:29:37.673] 1. sequential:
[01:29:37.673]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.673]    - tweaked: FALSE
[01:29:37.673]    - call: plan(strategy)
[01:29:37.674] plan(): nbrOfWorkers() = 1
[01:29:37.674] SequentialFuture started (and completed)
[01:29:37.675] - Launch lazy future ... done
[01:29:37.675] run() for 'SequentialFuture' ... done
List of 11
 $ value       : int 42
 $ visible     : logi TRUE
 $ stdout      : chr " [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 3"| __truncated__
 $ conditions  : list()
 $ rng         : logi FALSE
 $ globalenv   : NULL
 $ started     : POSIXct[1:1], format: "2023-12-22 01:29:37"
 $ finished    : POSIXct[1:1], format: "2023-12-22 01:29:37"
 $ session_uuid: chr "4310f9ea-29aa-4571-e277-b54ae8a03ba6"
  ..- attr(*, "source")=List of 5
  .. ..$ host  : Named chr "CRANWIN3"
  .. .. ..- attr(*, "names")= chr "COMPUTERNAME"
  .. ..$ info  : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...
  .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...
  .. ..$ pid   : int 6628
  .. ..$ time  : POSIXct[1:1], format: "2023-12-22 01:29:37"
  .. ..$ random: int 2147483647
 $ r_info      :List of 4
  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1
  .. ..$ : int [1:3] 4 4 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
 int [1:50] 1 2 3 4 5 6 7 8 9 10 ...
a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 
"Sepal.Length"	"Sepal.Width"	"Petal.Length"	"Petal.Width"	"Species"
"1"	5.1	3.5	1.4	0.2	"setosa"
"2"	4.9	3	1.4	0.2	"setosa"
"3"	4.7	3.2	1.3	0.2	"setosa"
"4"	4.6	3.1	1.5	0.2	"setosa"
"5"	5	3.6	1.4	0.2	"setosa"
"6"	5.4	3.9	1.7	0.4	"setosa"
"7"	4.6	3.4	1.4	0.3	"setosa"
"8"	5	3.4	1.5	0.2	"setosa"
"9"	4.4	2.9	1.4	0.2	"setosa"
"10"	4.9	3.1	1.5	0.1	"setosa"
FutureResult:
value: 'integer'
visible: TRUE
stdout: character
conditions: [n = 0] 
RNG used: FALSE
duration: 0.005724907 secs (started 2023-12-22 01:29:37.668767)
version: 1.8
[01:29:37.688] getGlobalsAndPackages() ...
[01:29:37.688] Searching for globals...
[01:29:37.692] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[01:29:37.692] Searching for globals ... DONE
[01:29:37.692] Resolving globals: FALSE
[01:29:37.694] 
[01:29:37.694] - packages: [1] 'utils'
[01:29:37.695] getGlobalsAndPackages() ... DONE
[01:29:37.695] run() for 'Future' ...
[01:29:37.695] - state: 'created'
[01:29:37.695] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:37.696] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:37.696] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:37.696]   - Field: 'label'
[01:29:37.696]   - Field: 'local'
[01:29:37.697]   - Field: 'owner'
[01:29:37.697]   - Field: 'envir'
[01:29:37.697]   - Field: 'packages'
[01:29:37.697]   - Field: 'gc'
[01:29:37.697]   - Field: 'conditions'
[01:29:37.698]   - Field: 'expr'
[01:29:37.698]   - Field: 'uuid'
[01:29:37.698]   - Field: 'seed'
[01:29:37.698]   - Field: 'version'
[01:29:37.698]   - Field: 'result'
[01:29:37.698]   - Field: 'asynchronous'
[01:29:37.699]   - Field: 'calls'
[01:29:37.699]   - Field: 'globals'
[01:29:37.699]   - Field: 'stdout'
[01:29:37.699]   - Field: 'earlySignal'
[01:29:37.699]   - Field: 'lazy'
[01:29:37.700]   - Field: 'state'
[01:29:37.700] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:37.700] - Launch lazy future ...
[01:29:37.700] Packages needed by the future expression (n = 1): 'utils'
[01:29:37.701] Packages needed by future strategies (n = 0): <none>
[01:29:37.701] {
[01:29:37.701]     {
[01:29:37.701]         {
[01:29:37.701]             ...future.startTime <- base::Sys.time()
[01:29:37.701]             {
[01:29:37.701]                 {
[01:29:37.701]                   {
[01:29:37.701]                     {
[01:29:37.701]                       base::local({
[01:29:37.701]                         has_future <- base::requireNamespace("future", 
[01:29:37.701]                           quietly = TRUE)
[01:29:37.701]                         if (has_future) {
[01:29:37.701]                           ns <- base::getNamespace("future")
[01:29:37.701]                           version <- ns[[".package"]][["version"]]
[01:29:37.701]                           if (is.null(version)) 
[01:29:37.701]                             version <- utils::packageVersion("future")
[01:29:37.701]                         }
[01:29:37.701]                         else {
[01:29:37.701]                           version <- NULL
[01:29:37.701]                         }
[01:29:37.701]                         if (!has_future || version < "1.8.0") {
[01:29:37.701]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:37.701]                             "", base::R.version$version.string), 
[01:29:37.701]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:37.701]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:37.701]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:37.701]                               "release", "version")], collapse = " "), 
[01:29:37.701]                             hostname = base::Sys.info()[["nodename"]])
[01:29:37.701]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:37.701]                             info)
[01:29:37.701]                           info <- base::paste(info, collapse = "; ")
[01:29:37.701]                           if (!has_future) {
[01:29:37.701]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:37.701]                               info)
[01:29:37.701]                           }
[01:29:37.701]                           else {
[01:29:37.701]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:37.701]                               info, version)
[01:29:37.701]                           }
[01:29:37.701]                           base::stop(msg)
[01:29:37.701]                         }
[01:29:37.701]                       })
[01:29:37.701]                     }
[01:29:37.701]                     base::local({
[01:29:37.701]                       for (pkg in "utils") {
[01:29:37.701]                         base::loadNamespace(pkg)
[01:29:37.701]                         base::library(pkg, character.only = TRUE)
[01:29:37.701]                       }
[01:29:37.701]                     })
[01:29:37.701]                   }
[01:29:37.701]                   options(future.plan = NULL)
[01:29:37.701]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.701]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:37.701]                 }
[01:29:37.701]                 ...future.workdir <- getwd()
[01:29:37.701]             }
[01:29:37.701]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:37.701]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:37.701]         }
[01:29:37.701]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:37.701]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:37.701]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:37.701]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:37.701]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:37.701]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:37.701]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:37.701]             base::names(...future.oldOptions))
[01:29:37.701]     }
[01:29:37.701]     if (FALSE) {
[01:29:37.701]     }
[01:29:37.701]     else {
[01:29:37.701]         if (TRUE) {
[01:29:37.701]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:37.701]                 open = "w")
[01:29:37.701]         }
[01:29:37.701]         else {
[01:29:37.701]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:37.701]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:37.701]         }
[01:29:37.701]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:37.701]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:37.701]             base::sink(type = "output", split = FALSE)
[01:29:37.701]             base::close(...future.stdout)
[01:29:37.701]         }, add = TRUE)
[01:29:37.701]     }
[01:29:37.701]     ...future.frame <- base::sys.nframe()
[01:29:37.701]     ...future.conditions <- base::list()
[01:29:37.701]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:37.701]     if (FALSE) {
[01:29:37.701]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:37.701]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:37.701]     }
[01:29:37.701]     ...future.result <- base::tryCatch({
[01:29:37.701]         base::withCallingHandlers({
[01:29:37.701]             ...future.value <- base::withVisible(base::local({
[01:29:37.701]                 print(1:50)
[01:29:37.701]                 str(1:50)
[01:29:37.701]                 cat(letters, sep = "-")
[01:29:37.701]                 cat(1:6, collapse = "\n")
[01:29:37.701]                 write.table(datasets::iris[1:10, ], sep = "\t")
[01:29:37.701]                 42L
[01:29:37.701]             }))
[01:29:37.701]             future::FutureResult(value = ...future.value$value, 
[01:29:37.701]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.701]                   ...future.rng), globalenv = if (FALSE) 
[01:29:37.701]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:37.701]                     ...future.globalenv.names))
[01:29:37.701]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:37.701]         }, condition = base::local({
[01:29:37.701]             c <- base::c
[01:29:37.701]             inherits <- base::inherits
[01:29:37.701]             invokeRestart <- base::invokeRestart
[01:29:37.701]             length <- base::length
[01:29:37.701]             list <- base::list
[01:29:37.701]             seq.int <- base::seq.int
[01:29:37.701]             signalCondition <- base::signalCondition
[01:29:37.701]             sys.calls <- base::sys.calls
[01:29:37.701]             `[[` <- base::`[[`
[01:29:37.701]             `+` <- base::`+`
[01:29:37.701]             `<<-` <- base::`<<-`
[01:29:37.701]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:37.701]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:37.701]                   3L)]
[01:29:37.701]             }
[01:29:37.701]             function(cond) {
[01:29:37.701]                 is_error <- inherits(cond, "error")
[01:29:37.701]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:37.701]                   NULL)
[01:29:37.701]                 if (is_error) {
[01:29:37.701]                   sessionInformation <- function() {
[01:29:37.701]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:37.701]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:37.701]                       search = base::search(), system = base::Sys.info())
[01:29:37.701]                   }
[01:29:37.701]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.701]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:37.701]                     cond$call), session = sessionInformation(), 
[01:29:37.701]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:37.701]                   signalCondition(cond)
[01:29:37.701]                 }
[01:29:37.701]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:37.701]                 "immediateCondition"))) {
[01:29:37.701]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:37.701]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.701]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:37.701]                   if (TRUE && !signal) {
[01:29:37.701]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.701]                     {
[01:29:37.701]                       inherits <- base::inherits
[01:29:37.701]                       invokeRestart <- base::invokeRestart
[01:29:37.701]                       is.null <- base::is.null
[01:29:37.701]                       muffled <- FALSE
[01:29:37.701]                       if (inherits(cond, "message")) {
[01:29:37.701]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.701]                         if (muffled) 
[01:29:37.701]                           invokeRestart("muffleMessage")
[01:29:37.701]                       }
[01:29:37.701]                       else if (inherits(cond, "warning")) {
[01:29:37.701]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.701]                         if (muffled) 
[01:29:37.701]                           invokeRestart("muffleWarning")
[01:29:37.701]                       }
[01:29:37.701]                       else if (inherits(cond, "condition")) {
[01:29:37.701]                         if (!is.null(pattern)) {
[01:29:37.701]                           computeRestarts <- base::computeRestarts
[01:29:37.701]                           grepl <- base::grepl
[01:29:37.701]                           restarts <- computeRestarts(cond)
[01:29:37.701]                           for (restart in restarts) {
[01:29:37.701]                             name <- restart$name
[01:29:37.701]                             if (is.null(name)) 
[01:29:37.701]                               next
[01:29:37.701]                             if (!grepl(pattern, name)) 
[01:29:37.701]                               next
[01:29:37.701]                             invokeRestart(restart)
[01:29:37.701]                             muffled <- TRUE
[01:29:37.701]                             break
[01:29:37.701]                           }
[01:29:37.701]                         }
[01:29:37.701]                       }
[01:29:37.701]                       invisible(muffled)
[01:29:37.701]                     }
[01:29:37.701]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.701]                   }
[01:29:37.701]                 }
[01:29:37.701]                 else {
[01:29:37.701]                   if (TRUE) {
[01:29:37.701]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.701]                     {
[01:29:37.701]                       inherits <- base::inherits
[01:29:37.701]                       invokeRestart <- base::invokeRestart
[01:29:37.701]                       is.null <- base::is.null
[01:29:37.701]                       muffled <- FALSE
[01:29:37.701]                       if (inherits(cond, "message")) {
[01:29:37.701]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.701]                         if (muffled) 
[01:29:37.701]                           invokeRestart("muffleMessage")
[01:29:37.701]                       }
[01:29:37.701]                       else if (inherits(cond, "warning")) {
[01:29:37.701]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.701]                         if (muffled) 
[01:29:37.701]                           invokeRestart("muffleWarning")
[01:29:37.701]                       }
[01:29:37.701]                       else if (inherits(cond, "condition")) {
[01:29:37.701]                         if (!is.null(pattern)) {
[01:29:37.701]                           computeRestarts <- base::computeRestarts
[01:29:37.701]                           grepl <- base::grepl
[01:29:37.701]                           restarts <- computeRestarts(cond)
[01:29:37.701]                           for (restart in restarts) {
[01:29:37.701]                             name <- restart$name
[01:29:37.701]                             if (is.null(name)) 
[01:29:37.701]                               next
[01:29:37.701]                             if (!grepl(pattern, name)) 
[01:29:37.701]                               next
[01:29:37.701]                             invokeRestart(restart)
[01:29:37.701]                             muffled <- TRUE
[01:29:37.701]                             break
[01:29:37.701]                           }
[01:29:37.701]                         }
[01:29:37.701]                       }
[01:29:37.701]                       invisible(muffled)
[01:29:37.701]                     }
[01:29:37.701]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.701]                   }
[01:29:37.701]                 }
[01:29:37.701]             }
[01:29:37.701]         }))
[01:29:37.701]     }, error = function(ex) {
[01:29:37.701]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:37.701]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.701]                 ...future.rng), started = ...future.startTime, 
[01:29:37.701]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:37.701]             version = "1.8"), class = "FutureResult")
[01:29:37.701]     }, finally = {
[01:29:37.701]         if (!identical(...future.workdir, getwd())) 
[01:29:37.701]             setwd(...future.workdir)
[01:29:37.701]         {
[01:29:37.701]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:37.701]                 ...future.oldOptions$nwarnings <- NULL
[01:29:37.701]             }
[01:29:37.701]             base::options(...future.oldOptions)
[01:29:37.701]             if (.Platform$OS.type == "windows") {
[01:29:37.701]                 old_names <- names(...future.oldEnvVars)
[01:29:37.701]                 envs <- base::Sys.getenv()
[01:29:37.701]                 names <- names(envs)
[01:29:37.701]                 common <- intersect(names, old_names)
[01:29:37.701]                 added <- setdiff(names, old_names)
[01:29:37.701]                 removed <- setdiff(old_names, names)
[01:29:37.701]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:37.701]                   envs[common]]
[01:29:37.701]                 NAMES <- toupper(changed)
[01:29:37.701]                 args <- list()
[01:29:37.701]                 for (kk in seq_along(NAMES)) {
[01:29:37.701]                   name <- changed[[kk]]
[01:29:37.701]                   NAME <- NAMES[[kk]]
[01:29:37.701]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.701]                     next
[01:29:37.701]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.701]                 }
[01:29:37.701]                 NAMES <- toupper(added)
[01:29:37.701]                 for (kk in seq_along(NAMES)) {
[01:29:37.701]                   name <- added[[kk]]
[01:29:37.701]                   NAME <- NAMES[[kk]]
[01:29:37.701]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.701]                     next
[01:29:37.701]                   args[[name]] <- ""
[01:29:37.701]                 }
[01:29:37.701]                 NAMES <- toupper(removed)
[01:29:37.701]                 for (kk in seq_along(NAMES)) {
[01:29:37.701]                   name <- removed[[kk]]
[01:29:37.701]                   NAME <- NAMES[[kk]]
[01:29:37.701]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.701]                     next
[01:29:37.701]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.701]                 }
[01:29:37.701]                 if (length(args) > 0) 
[01:29:37.701]                   base::do.call(base::Sys.setenv, args = args)
[01:29:37.701]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:37.701]             }
[01:29:37.701]             else {
[01:29:37.701]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:37.701]             }
[01:29:37.701]             {
[01:29:37.701]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:37.701]                   0L) {
[01:29:37.701]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:37.701]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:37.701]                   base::options(opts)
[01:29:37.701]                 }
[01:29:37.701]                 {
[01:29:37.701]                   {
[01:29:37.701]                     NULL
[01:29:37.701]                     RNGkind("Mersenne-Twister")
[01:29:37.701]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:29:37.701]                       inherits = FALSE)
[01:29:37.701]                   }
[01:29:37.701]                   options(future.plan = NULL)
[01:29:37.701]                   if (is.na(NA_character_)) 
[01:29:37.701]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.701]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:37.701]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:37.701]                   {
[01:29:37.701]                     future <- SequentialFuture(..., envir = envir)
[01:29:37.701]                     if (!future$lazy) 
[01:29:37.701]                       future <- run(future)
[01:29:37.701]                     invisible(future)
[01:29:37.701]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:37.701]                 }
[01:29:37.701]             }
[01:29:37.701]         }
[01:29:37.701]     })
[01:29:37.701]     if (TRUE) {
[01:29:37.701]         base::sink(type = "output", split = FALSE)
[01:29:37.701]         if (TRUE) {
[01:29:37.701]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:37.701]         }
[01:29:37.701]         else {
[01:29:37.701]             ...future.result["stdout"] <- base::list(NULL)
[01:29:37.701]         }
[01:29:37.701]         base::close(...future.stdout)
[01:29:37.701]         ...future.stdout <- NULL
[01:29:37.701]     }
[01:29:37.701]     ...future.result$conditions <- ...future.conditions
[01:29:37.701]     ...future.result$finished <- base::Sys.time()
[01:29:37.701]     ...future.result
[01:29:37.701] }
[01:29:37.706] plan(): Setting new future strategy stack:
[01:29:37.706] List of future strategies:
[01:29:37.706] 1. sequential:
[01:29:37.706]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.706]    - tweaked: FALSE
[01:29:37.706]    - call: NULL
[01:29:37.707] plan(): nbrOfWorkers() = 1
[01:29:37.709] plan(): Setting new future strategy stack:
[01:29:37.709] List of future strategies:
[01:29:37.709] 1. sequential:
[01:29:37.709]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.709]    - tweaked: FALSE
[01:29:37.709]    - call: plan(strategy)
[01:29:37.709] plan(): nbrOfWorkers() = 1
[01:29:37.710] SequentialFuture started (and completed)
[01:29:37.710] - Launch lazy future ... done
[01:29:37.710] run() for 'SequentialFuture' ... done
 [1] " [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25"  
 [2] "[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50"  
 [3] " int [1:50] 1 2 3 4 5 6 7 8 9 10 ..."                                             
 [4] "a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 "                  
 [5] "\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\""
 [6] "\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\""                                            
 [7] "\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\""                                              
 [8] "\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\""                                            
 [9] "\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\""                                            
[10] "\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\""                                              
[11] "\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\""                                            
[12] "\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\""                                            
[13] "\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\""                                              
[14] "\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\""                                            
[15] "\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\""                                           
- stdout = structure(TRUE, drop = TRUE)
[01:29:37.711] getGlobalsAndPackages() ...
[01:29:37.711] Searching for globals...
[01:29:37.712] - globals found: [1] 'print'
[01:29:37.712] Searching for globals ... DONE
[01:29:37.712] Resolving globals: FALSE
[01:29:37.712] 
[01:29:37.713] 
[01:29:37.713] getGlobalsAndPackages() ... DONE
[01:29:37.713] run() for 'Future' ...
[01:29:37.713] - state: 'created'
[01:29:37.714] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:37.714] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:37.714] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:37.714]   - Field: 'label'
[01:29:37.714]   - Field: 'local'
[01:29:37.715]   - Field: 'owner'
[01:29:37.715]   - Field: 'envir'
[01:29:37.715]   - Field: 'packages'
[01:29:37.715]   - Field: 'gc'
[01:29:37.715]   - Field: 'conditions'
[01:29:37.716]   - Field: 'expr'
[01:29:37.716]   - Field: 'uuid'
[01:29:37.716]   - Field: 'seed'
[01:29:37.716]   - Field: 'version'
[01:29:37.716]   - Field: 'result'
[01:29:37.716]   - Field: 'asynchronous'
[01:29:37.717]   - Field: 'calls'
[01:29:37.717]   - Field: 'globals'
[01:29:37.717]   - Field: 'stdout'
[01:29:37.717]   - Field: 'earlySignal'
[01:29:37.717]   - Field: 'lazy'
[01:29:37.717]   - Field: 'state'
[01:29:37.718] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:37.718] - Launch lazy future ...
[01:29:37.718] Packages needed by the future expression (n = 0): <none>
[01:29:37.718] Packages needed by future strategies (n = 0): <none>
[01:29:37.719] {
[01:29:37.719]     {
[01:29:37.719]         {
[01:29:37.719]             ...future.startTime <- base::Sys.time()
[01:29:37.719]             {
[01:29:37.719]                 {
[01:29:37.719]                   {
[01:29:37.719]                     base::local({
[01:29:37.719]                       has_future <- base::requireNamespace("future", 
[01:29:37.719]                         quietly = TRUE)
[01:29:37.719]                       if (has_future) {
[01:29:37.719]                         ns <- base::getNamespace("future")
[01:29:37.719]                         version <- ns[[".package"]][["version"]]
[01:29:37.719]                         if (is.null(version)) 
[01:29:37.719]                           version <- utils::packageVersion("future")
[01:29:37.719]                       }
[01:29:37.719]                       else {
[01:29:37.719]                         version <- NULL
[01:29:37.719]                       }
[01:29:37.719]                       if (!has_future || version < "1.8.0") {
[01:29:37.719]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:37.719]                           "", base::R.version$version.string), 
[01:29:37.719]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:37.719]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:37.719]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:37.719]                             "release", "version")], collapse = " "), 
[01:29:37.719]                           hostname = base::Sys.info()[["nodename"]])
[01:29:37.719]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:37.719]                           info)
[01:29:37.719]                         info <- base::paste(info, collapse = "; ")
[01:29:37.719]                         if (!has_future) {
[01:29:37.719]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:37.719]                             info)
[01:29:37.719]                         }
[01:29:37.719]                         else {
[01:29:37.719]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:37.719]                             info, version)
[01:29:37.719]                         }
[01:29:37.719]                         base::stop(msg)
[01:29:37.719]                       }
[01:29:37.719]                     })
[01:29:37.719]                   }
[01:29:37.719]                   options(future.plan = NULL)
[01:29:37.719]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.719]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:37.719]                 }
[01:29:37.719]                 ...future.workdir <- getwd()
[01:29:37.719]             }
[01:29:37.719]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:37.719]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:37.719]         }
[01:29:37.719]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:37.719]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:37.719]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:37.719]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:37.719]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:37.719]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:37.719]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:37.719]             base::names(...future.oldOptions))
[01:29:37.719]     }
[01:29:37.719]     if (FALSE) {
[01:29:37.719]     }
[01:29:37.719]     else {
[01:29:37.719]         if (TRUE) {
[01:29:37.719]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:37.719]                 open = "w")
[01:29:37.719]         }
[01:29:37.719]         else {
[01:29:37.719]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:37.719]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:37.719]         }
[01:29:37.719]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:37.719]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:37.719]             base::sink(type = "output", split = FALSE)
[01:29:37.719]             base::close(...future.stdout)
[01:29:37.719]         }, add = TRUE)
[01:29:37.719]     }
[01:29:37.719]     ...future.frame <- base::sys.nframe()
[01:29:37.719]     ...future.conditions <- base::list()
[01:29:37.719]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:37.719]     if (FALSE) {
[01:29:37.719]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:37.719]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:37.719]     }
[01:29:37.719]     ...future.result <- base::tryCatch({
[01:29:37.719]         base::withCallingHandlers({
[01:29:37.719]             ...future.value <- base::withVisible(base::local(print(42)))
[01:29:37.719]             future::FutureResult(value = ...future.value$value, 
[01:29:37.719]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.719]                   ...future.rng), globalenv = if (FALSE) 
[01:29:37.719]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:37.719]                     ...future.globalenv.names))
[01:29:37.719]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:37.719]         }, condition = base::local({
[01:29:37.719]             c <- base::c
[01:29:37.719]             inherits <- base::inherits
[01:29:37.719]             invokeRestart <- base::invokeRestart
[01:29:37.719]             length <- base::length
[01:29:37.719]             list <- base::list
[01:29:37.719]             seq.int <- base::seq.int
[01:29:37.719]             signalCondition <- base::signalCondition
[01:29:37.719]             sys.calls <- base::sys.calls
[01:29:37.719]             `[[` <- base::`[[`
[01:29:37.719]             `+` <- base::`+`
[01:29:37.719]             `<<-` <- base::`<<-`
[01:29:37.719]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:37.719]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:37.719]                   3L)]
[01:29:37.719]             }
[01:29:37.719]             function(cond) {
[01:29:37.719]                 is_error <- inherits(cond, "error")
[01:29:37.719]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:37.719]                   NULL)
[01:29:37.719]                 if (is_error) {
[01:29:37.719]                   sessionInformation <- function() {
[01:29:37.719]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:37.719]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:37.719]                       search = base::search(), system = base::Sys.info())
[01:29:37.719]                   }
[01:29:37.719]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.719]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:37.719]                     cond$call), session = sessionInformation(), 
[01:29:37.719]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:37.719]                   signalCondition(cond)
[01:29:37.719]                 }
[01:29:37.719]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:37.719]                 "immediateCondition"))) {
[01:29:37.719]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:37.719]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.719]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:37.719]                   if (TRUE && !signal) {
[01:29:37.719]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.719]                     {
[01:29:37.719]                       inherits <- base::inherits
[01:29:37.719]                       invokeRestart <- base::invokeRestart
[01:29:37.719]                       is.null <- base::is.null
[01:29:37.719]                       muffled <- FALSE
[01:29:37.719]                       if (inherits(cond, "message")) {
[01:29:37.719]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.719]                         if (muffled) 
[01:29:37.719]                           invokeRestart("muffleMessage")
[01:29:37.719]                       }
[01:29:37.719]                       else if (inherits(cond, "warning")) {
[01:29:37.719]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.719]                         if (muffled) 
[01:29:37.719]                           invokeRestart("muffleWarning")
[01:29:37.719]                       }
[01:29:37.719]                       else if (inherits(cond, "condition")) {
[01:29:37.719]                         if (!is.null(pattern)) {
[01:29:37.719]                           computeRestarts <- base::computeRestarts
[01:29:37.719]                           grepl <- base::grepl
[01:29:37.719]                           restarts <- computeRestarts(cond)
[01:29:37.719]                           for (restart in restarts) {
[01:29:37.719]                             name <- restart$name
[01:29:37.719]                             if (is.null(name)) 
[01:29:37.719]                               next
[01:29:37.719]                             if (!grepl(pattern, name)) 
[01:29:37.719]                               next
[01:29:37.719]                             invokeRestart(restart)
[01:29:37.719]                             muffled <- TRUE
[01:29:37.719]                             break
[01:29:37.719]                           }
[01:29:37.719]                         }
[01:29:37.719]                       }
[01:29:37.719]                       invisible(muffled)
[01:29:37.719]                     }
[01:29:37.719]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.719]                   }
[01:29:37.719]                 }
[01:29:37.719]                 else {
[01:29:37.719]                   if (TRUE) {
[01:29:37.719]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.719]                     {
[01:29:37.719]                       inherits <- base::inherits
[01:29:37.719]                       invokeRestart <- base::invokeRestart
[01:29:37.719]                       is.null <- base::is.null
[01:29:37.719]                       muffled <- FALSE
[01:29:37.719]                       if (inherits(cond, "message")) {
[01:29:37.719]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.719]                         if (muffled) 
[01:29:37.719]                           invokeRestart("muffleMessage")
[01:29:37.719]                       }
[01:29:37.719]                       else if (inherits(cond, "warning")) {
[01:29:37.719]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.719]                         if (muffled) 
[01:29:37.719]                           invokeRestart("muffleWarning")
[01:29:37.719]                       }
[01:29:37.719]                       else if (inherits(cond, "condition")) {
[01:29:37.719]                         if (!is.null(pattern)) {
[01:29:37.719]                           computeRestarts <- base::computeRestarts
[01:29:37.719]                           grepl <- base::grepl
[01:29:37.719]                           restarts <- computeRestarts(cond)
[01:29:37.719]                           for (restart in restarts) {
[01:29:37.719]                             name <- restart$name
[01:29:37.719]                             if (is.null(name)) 
[01:29:37.719]                               next
[01:29:37.719]                             if (!grepl(pattern, name)) 
[01:29:37.719]                               next
[01:29:37.719]                             invokeRestart(restart)
[01:29:37.719]                             muffled <- TRUE
[01:29:37.719]                             break
[01:29:37.719]                           }
[01:29:37.719]                         }
[01:29:37.719]                       }
[01:29:37.719]                       invisible(muffled)
[01:29:37.719]                     }
[01:29:37.719]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.719]                   }
[01:29:37.719]                 }
[01:29:37.719]             }
[01:29:37.719]         }))
[01:29:37.719]     }, error = function(ex) {
[01:29:37.719]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:37.719]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.719]                 ...future.rng), started = ...future.startTime, 
[01:29:37.719]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:37.719]             version = "1.8"), class = "FutureResult")
[01:29:37.719]     }, finally = {
[01:29:37.719]         if (!identical(...future.workdir, getwd())) 
[01:29:37.719]             setwd(...future.workdir)
[01:29:37.719]         {
[01:29:37.719]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:37.719]                 ...future.oldOptions$nwarnings <- NULL
[01:29:37.719]             }
[01:29:37.719]             base::options(...future.oldOptions)
[01:29:37.719]             if (.Platform$OS.type == "windows") {
[01:29:37.719]                 old_names <- names(...future.oldEnvVars)
[01:29:37.719]                 envs <- base::Sys.getenv()
[01:29:37.719]                 names <- names(envs)
[01:29:37.719]                 common <- intersect(names, old_names)
[01:29:37.719]                 added <- setdiff(names, old_names)
[01:29:37.719]                 removed <- setdiff(old_names, names)
[01:29:37.719]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:37.719]                   envs[common]]
[01:29:37.719]                 NAMES <- toupper(changed)
[01:29:37.719]                 args <- list()
[01:29:37.719]                 for (kk in seq_along(NAMES)) {
[01:29:37.719]                   name <- changed[[kk]]
[01:29:37.719]                   NAME <- NAMES[[kk]]
[01:29:37.719]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.719]                     next
[01:29:37.719]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.719]                 }
[01:29:37.719]                 NAMES <- toupper(added)
[01:29:37.719]                 for (kk in seq_along(NAMES)) {
[01:29:37.719]                   name <- added[[kk]]
[01:29:37.719]                   NAME <- NAMES[[kk]]
[01:29:37.719]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.719]                     next
[01:29:37.719]                   args[[name]] <- ""
[01:29:37.719]                 }
[01:29:37.719]                 NAMES <- toupper(removed)
[01:29:37.719]                 for (kk in seq_along(NAMES)) {
[01:29:37.719]                   name <- removed[[kk]]
[01:29:37.719]                   NAME <- NAMES[[kk]]
[01:29:37.719]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.719]                     next
[01:29:37.719]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.719]                 }
[01:29:37.719]                 if (length(args) > 0) 
[01:29:37.719]                   base::do.call(base::Sys.setenv, args = args)
[01:29:37.719]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:37.719]             }
[01:29:37.719]             else {
[01:29:37.719]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:37.719]             }
[01:29:37.719]             {
[01:29:37.719]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:37.719]                   0L) {
[01:29:37.719]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:37.719]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:37.719]                   base::options(opts)
[01:29:37.719]                 }
[01:29:37.719]                 {
[01:29:37.719]                   {
[01:29:37.719]                     NULL
[01:29:37.719]                     RNGkind("Mersenne-Twister")
[01:29:37.719]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:29:37.719]                       inherits = FALSE)
[01:29:37.719]                   }
[01:29:37.719]                   options(future.plan = NULL)
[01:29:37.719]                   if (is.na(NA_character_)) 
[01:29:37.719]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.719]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:37.719]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:37.719]                   {
[01:29:37.719]                     future <- SequentialFuture(..., envir = envir)
[01:29:37.719]                     if (!future$lazy) 
[01:29:37.719]                       future <- run(future)
[01:29:37.719]                     invisible(future)
[01:29:37.719]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:37.719]                 }
[01:29:37.719]             }
[01:29:37.719]         }
[01:29:37.719]     })
[01:29:37.719]     if (TRUE) {
[01:29:37.719]         base::sink(type = "output", split = FALSE)
[01:29:37.719]         if (TRUE) {
[01:29:37.719]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:37.719]         }
[01:29:37.719]         else {
[01:29:37.719]             ...future.result["stdout"] <- base::list(NULL)
[01:29:37.719]         }
[01:29:37.719]         base::close(...future.stdout)
[01:29:37.719]         ...future.stdout <- NULL
[01:29:37.719]     }
[01:29:37.719]     ...future.result$conditions <- ...future.conditions
[01:29:37.719]     ...future.result$finished <- base::Sys.time()
[01:29:37.719]     ...future.result
[01:29:37.719] }
[01:29:37.723] plan(): Setting new future strategy stack:
[01:29:37.723] List of future strategies:
[01:29:37.723] 1. sequential:
[01:29:37.723]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.723]    - tweaked: FALSE
[01:29:37.723]    - call: NULL
[01:29:37.724] plan(): nbrOfWorkers() = 1
[01:29:37.725] plan(): Setting new future strategy stack:
[01:29:37.725] List of future strategies:
[01:29:37.725] 1. sequential:
[01:29:37.725]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.725]    - tweaked: FALSE
[01:29:37.725]    - call: plan(strategy)
[01:29:37.726] plan(): nbrOfWorkers() = 1
[01:29:37.726] SequentialFuture started (and completed)
[01:29:37.726] - Launch lazy future ... done
[01:29:37.726] run() for 'SequentialFuture' ... done
[1] 42
- stdout = FALSE
[01:29:37.727] getGlobalsAndPackages() ...
[01:29:37.727] Searching for globals...
[01:29:37.731] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[01:29:37.731] Searching for globals ... DONE
[01:29:37.731] Resolving globals: FALSE
[01:29:37.733] 
[01:29:37.733] - packages: [1] 'utils'
[01:29:37.733] getGlobalsAndPackages() ... DONE
[01:29:37.733] run() for 'Future' ...
[01:29:37.734] - state: 'created'
[01:29:37.734] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:37.734] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:37.734] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:37.735]   - Field: 'label'
[01:29:37.735]   - Field: 'local'
[01:29:37.735]   - Field: 'owner'
[01:29:37.735]   - Field: 'envir'
[01:29:37.735]   - Field: 'packages'
[01:29:37.736]   - Field: 'gc'
[01:29:37.736]   - Field: 'conditions'
[01:29:37.736]   - Field: 'expr'
[01:29:37.736]   - Field: 'uuid'
[01:29:37.736]   - Field: 'seed'
[01:29:37.737]   - Field: 'version'
[01:29:37.737]   - Field: 'result'
[01:29:37.737]   - Field: 'asynchronous'
[01:29:37.737]   - Field: 'calls'
[01:29:37.737]   - Field: 'globals'
[01:29:37.738]   - Field: 'stdout'
[01:29:37.738]   - Field: 'earlySignal'
[01:29:37.738]   - Field: 'lazy'
[01:29:37.738]   - Field: 'state'
[01:29:37.738] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:37.739] - Launch lazy future ...
[01:29:37.739] Packages needed by the future expression (n = 1): 'utils'
[01:29:37.739] Packages needed by future strategies (n = 0): <none>
[01:29:37.740] {
[01:29:37.740]     {
[01:29:37.740]         {
[01:29:37.740]             ...future.startTime <- base::Sys.time()
[01:29:37.740]             {
[01:29:37.740]                 {
[01:29:37.740]                   {
[01:29:37.740]                     {
[01:29:37.740]                       base::local({
[01:29:37.740]                         has_future <- base::requireNamespace("future", 
[01:29:37.740]                           quietly = TRUE)
[01:29:37.740]                         if (has_future) {
[01:29:37.740]                           ns <- base::getNamespace("future")
[01:29:37.740]                           version <- ns[[".package"]][["version"]]
[01:29:37.740]                           if (is.null(version)) 
[01:29:37.740]                             version <- utils::packageVersion("future")
[01:29:37.740]                         }
[01:29:37.740]                         else {
[01:29:37.740]                           version <- NULL
[01:29:37.740]                         }
[01:29:37.740]                         if (!has_future || version < "1.8.0") {
[01:29:37.740]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:37.740]                             "", base::R.version$version.string), 
[01:29:37.740]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:37.740]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:37.740]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:37.740]                               "release", "version")], collapse = " "), 
[01:29:37.740]                             hostname = base::Sys.info()[["nodename"]])
[01:29:37.740]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:37.740]                             info)
[01:29:37.740]                           info <- base::paste(info, collapse = "; ")
[01:29:37.740]                           if (!has_future) {
[01:29:37.740]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:37.740]                               info)
[01:29:37.740]                           }
[01:29:37.740]                           else {
[01:29:37.740]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:37.740]                               info, version)
[01:29:37.740]                           }
[01:29:37.740]                           base::stop(msg)
[01:29:37.740]                         }
[01:29:37.740]                       })
[01:29:37.740]                     }
[01:29:37.740]                     base::local({
[01:29:37.740]                       for (pkg in "utils") {
[01:29:37.740]                         base::loadNamespace(pkg)
[01:29:37.740]                         base::library(pkg, character.only = TRUE)
[01:29:37.740]                       }
[01:29:37.740]                     })
[01:29:37.740]                   }
[01:29:37.740]                   options(future.plan = NULL)
[01:29:37.740]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.740]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:37.740]                 }
[01:29:37.740]                 ...future.workdir <- getwd()
[01:29:37.740]             }
[01:29:37.740]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:37.740]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:37.740]         }
[01:29:37.740]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:37.740]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:37.740]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:37.740]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:37.740]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:37.740]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:37.740]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:37.740]             base::names(...future.oldOptions))
[01:29:37.740]     }
[01:29:37.740]     if (FALSE) {
[01:29:37.740]     }
[01:29:37.740]     else {
[01:29:37.740]         if (FALSE) {
[01:29:37.740]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:37.740]                 open = "w")
[01:29:37.740]         }
[01:29:37.740]         else {
[01:29:37.740]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:37.740]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:37.740]         }
[01:29:37.740]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:37.740]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:37.740]             base::sink(type = "output", split = FALSE)
[01:29:37.740]             base::close(...future.stdout)
[01:29:37.740]         }, add = TRUE)
[01:29:37.740]     }
[01:29:37.740]     ...future.frame <- base::sys.nframe()
[01:29:37.740]     ...future.conditions <- base::list()
[01:29:37.740]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:37.740]     if (FALSE) {
[01:29:37.740]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:37.740]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:37.740]     }
[01:29:37.740]     ...future.result <- base::tryCatch({
[01:29:37.740]         base::withCallingHandlers({
[01:29:37.740]             ...future.value <- base::withVisible(base::local({
[01:29:37.740]                 print(1:50)
[01:29:37.740]                 str(1:50)
[01:29:37.740]                 cat(letters, sep = "-")
[01:29:37.740]                 cat(1:6, collapse = "\n")
[01:29:37.740]                 write.table(datasets::iris[1:10, ], sep = "\t")
[01:29:37.740]                 42L
[01:29:37.740]             }))
[01:29:37.740]             future::FutureResult(value = ...future.value$value, 
[01:29:37.740]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.740]                   ...future.rng), globalenv = if (FALSE) 
[01:29:37.740]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:37.740]                     ...future.globalenv.names))
[01:29:37.740]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:37.740]         }, condition = base::local({
[01:29:37.740]             c <- base::c
[01:29:37.740]             inherits <- base::inherits
[01:29:37.740]             invokeRestart <- base::invokeRestart
[01:29:37.740]             length <- base::length
[01:29:37.740]             list <- base::list
[01:29:37.740]             seq.int <- base::seq.int
[01:29:37.740]             signalCondition <- base::signalCondition
[01:29:37.740]             sys.calls <- base::sys.calls
[01:29:37.740]             `[[` <- base::`[[`
[01:29:37.740]             `+` <- base::`+`
[01:29:37.740]             `<<-` <- base::`<<-`
[01:29:37.740]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:37.740]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:37.740]                   3L)]
[01:29:37.740]             }
[01:29:37.740]             function(cond) {
[01:29:37.740]                 is_error <- inherits(cond, "error")
[01:29:37.740]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:37.740]                   NULL)
[01:29:37.740]                 if (is_error) {
[01:29:37.740]                   sessionInformation <- function() {
[01:29:37.740]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:37.740]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:37.740]                       search = base::search(), system = base::Sys.info())
[01:29:37.740]                   }
[01:29:37.740]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.740]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:37.740]                     cond$call), session = sessionInformation(), 
[01:29:37.740]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:37.740]                   signalCondition(cond)
[01:29:37.740]                 }
[01:29:37.740]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:37.740]                 "immediateCondition"))) {
[01:29:37.740]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:37.740]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.740]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:37.740]                   if (TRUE && !signal) {
[01:29:37.740]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.740]                     {
[01:29:37.740]                       inherits <- base::inherits
[01:29:37.740]                       invokeRestart <- base::invokeRestart
[01:29:37.740]                       is.null <- base::is.null
[01:29:37.740]                       muffled <- FALSE
[01:29:37.740]                       if (inherits(cond, "message")) {
[01:29:37.740]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.740]                         if (muffled) 
[01:29:37.740]                           invokeRestart("muffleMessage")
[01:29:37.740]                       }
[01:29:37.740]                       else if (inherits(cond, "warning")) {
[01:29:37.740]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.740]                         if (muffled) 
[01:29:37.740]                           invokeRestart("muffleWarning")
[01:29:37.740]                       }
[01:29:37.740]                       else if (inherits(cond, "condition")) {
[01:29:37.740]                         if (!is.null(pattern)) {
[01:29:37.740]                           computeRestarts <- base::computeRestarts
[01:29:37.740]                           grepl <- base::grepl
[01:29:37.740]                           restarts <- computeRestarts(cond)
[01:29:37.740]                           for (restart in restarts) {
[01:29:37.740]                             name <- restart$name
[01:29:37.740]                             if (is.null(name)) 
[01:29:37.740]                               next
[01:29:37.740]                             if (!grepl(pattern, name)) 
[01:29:37.740]                               next
[01:29:37.740]                             invokeRestart(restart)
[01:29:37.740]                             muffled <- TRUE
[01:29:37.740]                             break
[01:29:37.740]                           }
[01:29:37.740]                         }
[01:29:37.740]                       }
[01:29:37.740]                       invisible(muffled)
[01:29:37.740]                     }
[01:29:37.740]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.740]                   }
[01:29:37.740]                 }
[01:29:37.740]                 else {
[01:29:37.740]                   if (TRUE) {
[01:29:37.740]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.740]                     {
[01:29:37.740]                       inherits <- base::inherits
[01:29:37.740]                       invokeRestart <- base::invokeRestart
[01:29:37.740]                       is.null <- base::is.null
[01:29:37.740]                       muffled <- FALSE
[01:29:37.740]                       if (inherits(cond, "message")) {
[01:29:37.740]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.740]                         if (muffled) 
[01:29:37.740]                           invokeRestart("muffleMessage")
[01:29:37.740]                       }
[01:29:37.740]                       else if (inherits(cond, "warning")) {
[01:29:37.740]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.740]                         if (muffled) 
[01:29:37.740]                           invokeRestart("muffleWarning")
[01:29:37.740]                       }
[01:29:37.740]                       else if (inherits(cond, "condition")) {
[01:29:37.740]                         if (!is.null(pattern)) {
[01:29:37.740]                           computeRestarts <- base::computeRestarts
[01:29:37.740]                           grepl <- base::grepl
[01:29:37.740]                           restarts <- computeRestarts(cond)
[01:29:37.740]                           for (restart in restarts) {
[01:29:37.740]                             name <- restart$name
[01:29:37.740]                             if (is.null(name)) 
[01:29:37.740]                               next
[01:29:37.740]                             if (!grepl(pattern, name)) 
[01:29:37.740]                               next
[01:29:37.740]                             invokeRestart(restart)
[01:29:37.740]                             muffled <- TRUE
[01:29:37.740]                             break
[01:29:37.740]                           }
[01:29:37.740]                         }
[01:29:37.740]                       }
[01:29:37.740]                       invisible(muffled)
[01:29:37.740]                     }
[01:29:37.740]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.740]                   }
[01:29:37.740]                 }
[01:29:37.740]             }
[01:29:37.740]         }))
[01:29:37.740]     }, error = function(ex) {
[01:29:37.740]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:37.740]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.740]                 ...future.rng), started = ...future.startTime, 
[01:29:37.740]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:37.740]             version = "1.8"), class = "FutureResult")
[01:29:37.740]     }, finally = {
[01:29:37.740]         if (!identical(...future.workdir, getwd())) 
[01:29:37.740]             setwd(...future.workdir)
[01:29:37.740]         {
[01:29:37.740]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:37.740]                 ...future.oldOptions$nwarnings <- NULL
[01:29:37.740]             }
[01:29:37.740]             base::options(...future.oldOptions)
[01:29:37.740]             if (.Platform$OS.type == "windows") {
[01:29:37.740]                 old_names <- names(...future.oldEnvVars)
[01:29:37.740]                 envs <- base::Sys.getenv()
[01:29:37.740]                 names <- names(envs)
[01:29:37.740]                 common <- intersect(names, old_names)
[01:29:37.740]                 added <- setdiff(names, old_names)
[01:29:37.740]                 removed <- setdiff(old_names, names)
[01:29:37.740]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:37.740]                   envs[common]]
[01:29:37.740]                 NAMES <- toupper(changed)
[01:29:37.740]                 args <- list()
[01:29:37.740]                 for (kk in seq_along(NAMES)) {
[01:29:37.740]                   name <- changed[[kk]]
[01:29:37.740]                   NAME <- NAMES[[kk]]
[01:29:37.740]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.740]                     next
[01:29:37.740]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.740]                 }
[01:29:37.740]                 NAMES <- toupper(added)
[01:29:37.740]                 for (kk in seq_along(NAMES)) {
[01:29:37.740]                   name <- added[[kk]]
[01:29:37.740]                   NAME <- NAMES[[kk]]
[01:29:37.740]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.740]                     next
[01:29:37.740]                   args[[name]] <- ""
[01:29:37.740]                 }
[01:29:37.740]                 NAMES <- toupper(removed)
[01:29:37.740]                 for (kk in seq_along(NAMES)) {
[01:29:37.740]                   name <- removed[[kk]]
[01:29:37.740]                   NAME <- NAMES[[kk]]
[01:29:37.740]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.740]                     next
[01:29:37.740]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.740]                 }
[01:29:37.740]                 if (length(args) > 0) 
[01:29:37.740]                   base::do.call(base::Sys.setenv, args = args)
[01:29:37.740]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:37.740]             }
[01:29:37.740]             else {
[01:29:37.740]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:37.740]             }
[01:29:37.740]             {
[01:29:37.740]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:37.740]                   0L) {
[01:29:37.740]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:37.740]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:37.740]                   base::options(opts)
[01:29:37.740]                 }
[01:29:37.740]                 {
[01:29:37.740]                   {
[01:29:37.740]                     NULL
[01:29:37.740]                     RNGkind("Mersenne-Twister")
[01:29:37.740]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:29:37.740]                       inherits = FALSE)
[01:29:37.740]                   }
[01:29:37.740]                   options(future.plan = NULL)
[01:29:37.740]                   if (is.na(NA_character_)) 
[01:29:37.740]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.740]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:37.740]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:37.740]                   {
[01:29:37.740]                     future <- SequentialFuture(..., envir = envir)
[01:29:37.740]                     if (!future$lazy) 
[01:29:37.740]                       future <- run(future)
[01:29:37.740]                     invisible(future)
[01:29:37.740]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:37.740]                 }
[01:29:37.740]             }
[01:29:37.740]         }
[01:29:37.740]     })
[01:29:37.740]     if (TRUE) {
[01:29:37.740]         base::sink(type = "output", split = FALSE)
[01:29:37.740]         if (FALSE) {
[01:29:37.740]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:37.740]         }
[01:29:37.740]         else {
[01:29:37.740]             ...future.result["stdout"] <- base::list(NULL)
[01:29:37.740]         }
[01:29:37.740]         base::close(...future.stdout)
[01:29:37.740]         ...future.stdout <- NULL
[01:29:37.740]     }
[01:29:37.740]     ...future.result$conditions <- ...future.conditions
[01:29:37.740]     ...future.result$finished <- base::Sys.time()
[01:29:37.740]     ...future.result
[01:29:37.740] }
[01:29:37.744] plan(): Setting new future strategy stack:
[01:29:37.744] List of future strategies:
[01:29:37.744] 1. sequential:
[01:29:37.744]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.744]    - tweaked: FALSE
[01:29:37.744]    - call: NULL
[01:29:37.745] plan(): nbrOfWorkers() = 1
[01:29:37.747] plan(): Setting new future strategy stack:
[01:29:37.747] List of future strategies:
[01:29:37.747] 1. sequential:
[01:29:37.747]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.747]    - tweaked: FALSE
[01:29:37.747]    - call: plan(strategy)
[01:29:37.748] plan(): nbrOfWorkers() = 1
[01:29:37.748] SequentialFuture started (and completed)
[01:29:37.748] - Launch lazy future ... done
[01:29:37.749] run() for 'SequentialFuture' ... done
List of 11
 $ value       : int 42
 $ visible     : logi TRUE
 $ stdout      : NULL
 $ conditions  : list()
 $ rng         : logi FALSE
 $ globalenv   : NULL
 $ started     : POSIXct[1:1], format: "2023-12-22 01:29:37"
 $ finished    : POSIXct[1:1], format: "2023-12-22 01:29:37"
 $ session_uuid: chr "4310f9ea-29aa-4571-e277-b54ae8a03ba6"
  ..- attr(*, "source")=List of 5
  .. ..$ host  : Named chr "CRANWIN3"
  .. .. ..- attr(*, "names")= chr "COMPUTERNAME"
  .. ..$ info  : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...
  .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...
  .. ..$ pid   : int 6628
  .. ..$ time  : POSIXct[1:1], format: "2023-12-22 01:29:37"
  .. ..$ random: int 2147483647
 $ r_info      :List of 4
  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1
  .. ..$ : int [1:3] 4 4 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[01:29:37.758] getGlobalsAndPackages() ...
[01:29:37.759] Searching for globals...
[01:29:37.762] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[01:29:37.763] Searching for globals ... DONE
[01:29:37.763] Resolving globals: FALSE
[01:29:37.765] 
[01:29:37.765] - packages: [1] 'utils'
[01:29:37.765] getGlobalsAndPackages() ... DONE
[01:29:37.766] run() for 'Future' ...
[01:29:37.766] - state: 'created'
[01:29:37.766] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:37.766] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:37.767] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:37.767]   - Field: 'label'
[01:29:37.767]   - Field: 'local'
[01:29:37.767]   - Field: 'owner'
[01:29:37.767]   - Field: 'envir'
[01:29:37.768]   - Field: 'packages'
[01:29:37.768]   - Field: 'gc'
[01:29:37.768]   - Field: 'conditions'
[01:29:37.768]   - Field: 'expr'
[01:29:37.768]   - Field: 'uuid'
[01:29:37.769]   - Field: 'seed'
[01:29:37.769]   - Field: 'version'
[01:29:37.769]   - Field: 'result'
[01:29:37.769]   - Field: 'asynchronous'
[01:29:37.769]   - Field: 'calls'
[01:29:37.770]   - Field: 'globals'
[01:29:37.770]   - Field: 'stdout'
[01:29:37.770]   - Field: 'earlySignal'
[01:29:37.770]   - Field: 'lazy'
[01:29:37.770]   - Field: 'state'
[01:29:37.771] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:37.771] - Launch lazy future ...
[01:29:37.771] Packages needed by the future expression (n = 1): 'utils'
[01:29:37.771] Packages needed by future strategies (n = 0): <none>
[01:29:37.772] {
[01:29:37.772]     {
[01:29:37.772]         {
[01:29:37.772]             ...future.startTime <- base::Sys.time()
[01:29:37.772]             {
[01:29:37.772]                 {
[01:29:37.772]                   {
[01:29:37.772]                     {
[01:29:37.772]                       base::local({
[01:29:37.772]                         has_future <- base::requireNamespace("future", 
[01:29:37.772]                           quietly = TRUE)
[01:29:37.772]                         if (has_future) {
[01:29:37.772]                           ns <- base::getNamespace("future")
[01:29:37.772]                           version <- ns[[".package"]][["version"]]
[01:29:37.772]                           if (is.null(version)) 
[01:29:37.772]                             version <- utils::packageVersion("future")
[01:29:37.772]                         }
[01:29:37.772]                         else {
[01:29:37.772]                           version <- NULL
[01:29:37.772]                         }
[01:29:37.772]                         if (!has_future || version < "1.8.0") {
[01:29:37.772]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:37.772]                             "", base::R.version$version.string), 
[01:29:37.772]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:37.772]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:37.772]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:37.772]                               "release", "version")], collapse = " "), 
[01:29:37.772]                             hostname = base::Sys.info()[["nodename"]])
[01:29:37.772]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:37.772]                             info)
[01:29:37.772]                           info <- base::paste(info, collapse = "; ")
[01:29:37.772]                           if (!has_future) {
[01:29:37.772]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:37.772]                               info)
[01:29:37.772]                           }
[01:29:37.772]                           else {
[01:29:37.772]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:37.772]                               info, version)
[01:29:37.772]                           }
[01:29:37.772]                           base::stop(msg)
[01:29:37.772]                         }
[01:29:37.772]                       })
[01:29:37.772]                     }
[01:29:37.772]                     base::local({
[01:29:37.772]                       for (pkg in "utils") {
[01:29:37.772]                         base::loadNamespace(pkg)
[01:29:37.772]                         base::library(pkg, character.only = TRUE)
[01:29:37.772]                       }
[01:29:37.772]                     })
[01:29:37.772]                   }
[01:29:37.772]                   options(future.plan = NULL)
[01:29:37.772]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.772]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:37.772]                 }
[01:29:37.772]                 ...future.workdir <- getwd()
[01:29:37.772]             }
[01:29:37.772]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:37.772]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:37.772]         }
[01:29:37.772]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:37.772]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:37.772]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:37.772]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:37.772]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:37.772]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:37.772]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:37.772]             base::names(...future.oldOptions))
[01:29:37.772]     }
[01:29:37.772]     if (FALSE) {
[01:29:37.772]     }
[01:29:37.772]     else {
[01:29:37.772]         if (FALSE) {
[01:29:37.772]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:37.772]                 open = "w")
[01:29:37.772]         }
[01:29:37.772]         else {
[01:29:37.772]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:37.772]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:37.772]         }
[01:29:37.772]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:37.772]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:37.772]             base::sink(type = "output", split = FALSE)
[01:29:37.772]             base::close(...future.stdout)
[01:29:37.772]         }, add = TRUE)
[01:29:37.772]     }
[01:29:37.772]     ...future.frame <- base::sys.nframe()
[01:29:37.772]     ...future.conditions <- base::list()
[01:29:37.772]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:37.772]     if (FALSE) {
[01:29:37.772]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:37.772]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:37.772]     }
[01:29:37.772]     ...future.result <- base::tryCatch({
[01:29:37.772]         base::withCallingHandlers({
[01:29:37.772]             ...future.value <- base::withVisible(base::local({
[01:29:37.772]                 print(1:50)
[01:29:37.772]                 str(1:50)
[01:29:37.772]                 cat(letters, sep = "-")
[01:29:37.772]                 cat(1:6, collapse = "\n")
[01:29:37.772]                 write.table(datasets::iris[1:10, ], sep = "\t")
[01:29:37.772]                 42L
[01:29:37.772]             }))
[01:29:37.772]             future::FutureResult(value = ...future.value$value, 
[01:29:37.772]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.772]                   ...future.rng), globalenv = if (FALSE) 
[01:29:37.772]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:37.772]                     ...future.globalenv.names))
[01:29:37.772]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:37.772]         }, condition = base::local({
[01:29:37.772]             c <- base::c
[01:29:37.772]             inherits <- base::inherits
[01:29:37.772]             invokeRestart <- base::invokeRestart
[01:29:37.772]             length <- base::length
[01:29:37.772]             list <- base::list
[01:29:37.772]             seq.int <- base::seq.int
[01:29:37.772]             signalCondition <- base::signalCondition
[01:29:37.772]             sys.calls <- base::sys.calls
[01:29:37.772]             `[[` <- base::`[[`
[01:29:37.772]             `+` <- base::`+`
[01:29:37.772]             `<<-` <- base::`<<-`
[01:29:37.772]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:37.772]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:37.772]                   3L)]
[01:29:37.772]             }
[01:29:37.772]             function(cond) {
[01:29:37.772]                 is_error <- inherits(cond, "error")
[01:29:37.772]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:37.772]                   NULL)
[01:29:37.772]                 if (is_error) {
[01:29:37.772]                   sessionInformation <- function() {
[01:29:37.772]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:37.772]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:37.772]                       search = base::search(), system = base::Sys.info())
[01:29:37.772]                   }
[01:29:37.772]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.772]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:37.772]                     cond$call), session = sessionInformation(), 
[01:29:37.772]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:37.772]                   signalCondition(cond)
[01:29:37.772]                 }
[01:29:37.772]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:37.772]                 "immediateCondition"))) {
[01:29:37.772]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:37.772]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.772]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:37.772]                   if (TRUE && !signal) {
[01:29:37.772]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.772]                     {
[01:29:37.772]                       inherits <- base::inherits
[01:29:37.772]                       invokeRestart <- base::invokeRestart
[01:29:37.772]                       is.null <- base::is.null
[01:29:37.772]                       muffled <- FALSE
[01:29:37.772]                       if (inherits(cond, "message")) {
[01:29:37.772]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.772]                         if (muffled) 
[01:29:37.772]                           invokeRestart("muffleMessage")
[01:29:37.772]                       }
[01:29:37.772]                       else if (inherits(cond, "warning")) {
[01:29:37.772]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.772]                         if (muffled) 
[01:29:37.772]                           invokeRestart("muffleWarning")
[01:29:37.772]                       }
[01:29:37.772]                       else if (inherits(cond, "condition")) {
[01:29:37.772]                         if (!is.null(pattern)) {
[01:29:37.772]                           computeRestarts <- base::computeRestarts
[01:29:37.772]                           grepl <- base::grepl
[01:29:37.772]                           restarts <- computeRestarts(cond)
[01:29:37.772]                           for (restart in restarts) {
[01:29:37.772]                             name <- restart$name
[01:29:37.772]                             if (is.null(name)) 
[01:29:37.772]                               next
[01:29:37.772]                             if (!grepl(pattern, name)) 
[01:29:37.772]                               next
[01:29:37.772]                             invokeRestart(restart)
[01:29:37.772]                             muffled <- TRUE
[01:29:37.772]                             break
[01:29:37.772]                           }
[01:29:37.772]                         }
[01:29:37.772]                       }
[01:29:37.772]                       invisible(muffled)
[01:29:37.772]                     }
[01:29:37.772]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.772]                   }
[01:29:37.772]                 }
[01:29:37.772]                 else {
[01:29:37.772]                   if (TRUE) {
[01:29:37.772]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.772]                     {
[01:29:37.772]                       inherits <- base::inherits
[01:29:37.772]                       invokeRestart <- base::invokeRestart
[01:29:37.772]                       is.null <- base::is.null
[01:29:37.772]                       muffled <- FALSE
[01:29:37.772]                       if (inherits(cond, "message")) {
[01:29:37.772]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.772]                         if (muffled) 
[01:29:37.772]                           invokeRestart("muffleMessage")
[01:29:37.772]                       }
[01:29:37.772]                       else if (inherits(cond, "warning")) {
[01:29:37.772]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.772]                         if (muffled) 
[01:29:37.772]                           invokeRestart("muffleWarning")
[01:29:37.772]                       }
[01:29:37.772]                       else if (inherits(cond, "condition")) {
[01:29:37.772]                         if (!is.null(pattern)) {
[01:29:37.772]                           computeRestarts <- base::computeRestarts
[01:29:37.772]                           grepl <- base::grepl
[01:29:37.772]                           restarts <- computeRestarts(cond)
[01:29:37.772]                           for (restart in restarts) {
[01:29:37.772]                             name <- restart$name
[01:29:37.772]                             if (is.null(name)) 
[01:29:37.772]                               next
[01:29:37.772]                             if (!grepl(pattern, name)) 
[01:29:37.772]                               next
[01:29:37.772]                             invokeRestart(restart)
[01:29:37.772]                             muffled <- TRUE
[01:29:37.772]                             break
[01:29:37.772]                           }
[01:29:37.772]                         }
[01:29:37.772]                       }
[01:29:37.772]                       invisible(muffled)
[01:29:37.772]                     }
[01:29:37.772]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.772]                   }
[01:29:37.772]                 }
[01:29:37.772]             }
[01:29:37.772]         }))
[01:29:37.772]     }, error = function(ex) {
[01:29:37.772]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:37.772]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.772]                 ...future.rng), started = ...future.startTime, 
[01:29:37.772]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:37.772]             version = "1.8"), class = "FutureResult")
[01:29:37.772]     }, finally = {
[01:29:37.772]         if (!identical(...future.workdir, getwd())) 
[01:29:37.772]             setwd(...future.workdir)
[01:29:37.772]         {
[01:29:37.772]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:37.772]                 ...future.oldOptions$nwarnings <- NULL
[01:29:37.772]             }
[01:29:37.772]             base::options(...future.oldOptions)
[01:29:37.772]             if (.Platform$OS.type == "windows") {
[01:29:37.772]                 old_names <- names(...future.oldEnvVars)
[01:29:37.772]                 envs <- base::Sys.getenv()
[01:29:37.772]                 names <- names(envs)
[01:29:37.772]                 common <- intersect(names, old_names)
[01:29:37.772]                 added <- setdiff(names, old_names)
[01:29:37.772]                 removed <- setdiff(old_names, names)
[01:29:37.772]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:37.772]                   envs[common]]
[01:29:37.772]                 NAMES <- toupper(changed)
[01:29:37.772]                 args <- list()
[01:29:37.772]                 for (kk in seq_along(NAMES)) {
[01:29:37.772]                   name <- changed[[kk]]
[01:29:37.772]                   NAME <- NAMES[[kk]]
[01:29:37.772]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.772]                     next
[01:29:37.772]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.772]                 }
[01:29:37.772]                 NAMES <- toupper(added)
[01:29:37.772]                 for (kk in seq_along(NAMES)) {
[01:29:37.772]                   name <- added[[kk]]
[01:29:37.772]                   NAME <- NAMES[[kk]]
[01:29:37.772]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.772]                     next
[01:29:37.772]                   args[[name]] <- ""
[01:29:37.772]                 }
[01:29:37.772]                 NAMES <- toupper(removed)
[01:29:37.772]                 for (kk in seq_along(NAMES)) {
[01:29:37.772]                   name <- removed[[kk]]
[01:29:37.772]                   NAME <- NAMES[[kk]]
[01:29:37.772]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.772]                     next
[01:29:37.772]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.772]                 }
[01:29:37.772]                 if (length(args) > 0) 
[01:29:37.772]                   base::do.call(base::Sys.setenv, args = args)
[01:29:37.772]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:37.772]             }
[01:29:37.772]             else {
[01:29:37.772]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:37.772]             }
[01:29:37.772]             {
[01:29:37.772]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:37.772]                   0L) {
[01:29:37.772]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:37.772]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:37.772]                   base::options(opts)
[01:29:37.772]                 }
[01:29:37.772]                 {
[01:29:37.772]                   {
[01:29:37.772]                     NULL
[01:29:37.772]                     RNGkind("Mersenne-Twister")
[01:29:37.772]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:29:37.772]                       inherits = FALSE)
[01:29:37.772]                   }
[01:29:37.772]                   options(future.plan = NULL)
[01:29:37.772]                   if (is.na(NA_character_)) 
[01:29:37.772]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.772]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:37.772]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:37.772]                   {
[01:29:37.772]                     future <- SequentialFuture(..., envir = envir)
[01:29:37.772]                     if (!future$lazy) 
[01:29:37.772]                       future <- run(future)
[01:29:37.772]                     invisible(future)
[01:29:37.772]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:37.772]                 }
[01:29:37.772]             }
[01:29:37.772]         }
[01:29:37.772]     })
[01:29:37.772]     if (TRUE) {
[01:29:37.772]         base::sink(type = "output", split = FALSE)
[01:29:37.772]         if (FALSE) {
[01:29:37.772]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:37.772]         }
[01:29:37.772]         else {
[01:29:37.772]             ...future.result["stdout"] <- base::list(NULL)
[01:29:37.772]         }
[01:29:37.772]         base::close(...future.stdout)
[01:29:37.772]         ...future.stdout <- NULL
[01:29:37.772]     }
[01:29:37.772]     ...future.result$conditions <- ...future.conditions
[01:29:37.772]     ...future.result$finished <- base::Sys.time()
[01:29:37.772]     ...future.result
[01:29:37.772] }
[01:29:37.776] plan(): Setting new future strategy stack:
[01:29:37.777] List of future strategies:
[01:29:37.777] 1. sequential:
[01:29:37.777]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.777]    - tweaked: FALSE
[01:29:37.777]    - call: NULL
[01:29:37.777] plan(): nbrOfWorkers() = 1
[01:29:37.779] plan(): Setting new future strategy stack:
[01:29:37.780] List of future strategies:
[01:29:37.780] 1. sequential:
[01:29:37.780]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.780]    - tweaked: FALSE
[01:29:37.780]    - call: plan(strategy)
[01:29:37.780] plan(): nbrOfWorkers() = 1
[01:29:37.781] SequentialFuture started (and completed)
[01:29:37.781] - Launch lazy future ... done
[01:29:37.781] run() for 'SequentialFuture' ... done
- stdout = structure(TRUE, drop = TRUE)
[01:29:37.782] getGlobalsAndPackages() ...
[01:29:37.782] Searching for globals...
[01:29:37.782] - globals found: [1] 'print'
[01:29:37.783] Searching for globals ... DONE
[01:29:37.783] Resolving globals: FALSE
[01:29:37.783] 
[01:29:37.783] 
[01:29:37.783] getGlobalsAndPackages() ... DONE
[01:29:37.784] run() for 'Future' ...
[01:29:37.784] - state: 'created'
[01:29:37.784] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:37.785] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:37.785] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:37.785]   - Field: 'label'
[01:29:37.785]   - Field: 'local'
[01:29:37.785]   - Field: 'owner'
[01:29:37.786]   - Field: 'envir'
[01:29:37.786]   - Field: 'packages'
[01:29:37.786]   - Field: 'gc'
[01:29:37.786]   - Field: 'conditions'
[01:29:37.786]   - Field: 'expr'
[01:29:37.787]   - Field: 'uuid'
[01:29:37.787]   - Field: 'seed'
[01:29:37.787]   - Field: 'version'
[01:29:37.787]   - Field: 'result'
[01:29:37.787]   - Field: 'asynchronous'
[01:29:37.787]   - Field: 'calls'
[01:29:37.788]   - Field: 'globals'
[01:29:37.788]   - Field: 'stdout'
[01:29:37.788]   - Field: 'earlySignal'
[01:29:37.788]   - Field: 'lazy'
[01:29:37.788]   - Field: 'state'
[01:29:37.788] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:37.789] - Launch lazy future ...
[01:29:37.789] Packages needed by the future expression (n = 0): <none>
[01:29:37.789] Packages needed by future strategies (n = 0): <none>
[01:29:37.790] {
[01:29:37.790]     {
[01:29:37.790]         {
[01:29:37.790]             ...future.startTime <- base::Sys.time()
[01:29:37.790]             {
[01:29:37.790]                 {
[01:29:37.790]                   {
[01:29:37.790]                     base::local({
[01:29:37.790]                       has_future <- base::requireNamespace("future", 
[01:29:37.790]                         quietly = TRUE)
[01:29:37.790]                       if (has_future) {
[01:29:37.790]                         ns <- base::getNamespace("future")
[01:29:37.790]                         version <- ns[[".package"]][["version"]]
[01:29:37.790]                         if (is.null(version)) 
[01:29:37.790]                           version <- utils::packageVersion("future")
[01:29:37.790]                       }
[01:29:37.790]                       else {
[01:29:37.790]                         version <- NULL
[01:29:37.790]                       }
[01:29:37.790]                       if (!has_future || version < "1.8.0") {
[01:29:37.790]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:37.790]                           "", base::R.version$version.string), 
[01:29:37.790]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:37.790]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:37.790]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:37.790]                             "release", "version")], collapse = " "), 
[01:29:37.790]                           hostname = base::Sys.info()[["nodename"]])
[01:29:37.790]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:37.790]                           info)
[01:29:37.790]                         info <- base::paste(info, collapse = "; ")
[01:29:37.790]                         if (!has_future) {
[01:29:37.790]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:37.790]                             info)
[01:29:37.790]                         }
[01:29:37.790]                         else {
[01:29:37.790]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:37.790]                             info, version)
[01:29:37.790]                         }
[01:29:37.790]                         base::stop(msg)
[01:29:37.790]                       }
[01:29:37.790]                     })
[01:29:37.790]                   }
[01:29:37.790]                   options(future.plan = NULL)
[01:29:37.790]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.790]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:37.790]                 }
[01:29:37.790]                 ...future.workdir <- getwd()
[01:29:37.790]             }
[01:29:37.790]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:37.790]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:37.790]         }
[01:29:37.790]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:37.790]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:37.790]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:37.790]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:37.790]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:37.790]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:37.790]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:37.790]             base::names(...future.oldOptions))
[01:29:37.790]     }
[01:29:37.790]     if (FALSE) {
[01:29:37.790]     }
[01:29:37.790]     else {
[01:29:37.790]         if (TRUE) {
[01:29:37.790]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:37.790]                 open = "w")
[01:29:37.790]         }
[01:29:37.790]         else {
[01:29:37.790]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:37.790]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:37.790]         }
[01:29:37.790]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:37.790]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:37.790]             base::sink(type = "output", split = FALSE)
[01:29:37.790]             base::close(...future.stdout)
[01:29:37.790]         }, add = TRUE)
[01:29:37.790]     }
[01:29:37.790]     ...future.frame <- base::sys.nframe()
[01:29:37.790]     ...future.conditions <- base::list()
[01:29:37.790]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:37.790]     if (FALSE) {
[01:29:37.790]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:37.790]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:37.790]     }
[01:29:37.790]     ...future.result <- base::tryCatch({
[01:29:37.790]         base::withCallingHandlers({
[01:29:37.790]             ...future.value <- base::withVisible(base::local(print(42)))
[01:29:37.790]             future::FutureResult(value = ...future.value$value, 
[01:29:37.790]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.790]                   ...future.rng), globalenv = if (FALSE) 
[01:29:37.790]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:37.790]                     ...future.globalenv.names))
[01:29:37.790]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:37.790]         }, condition = base::local({
[01:29:37.790]             c <- base::c
[01:29:37.790]             inherits <- base::inherits
[01:29:37.790]             invokeRestart <- base::invokeRestart
[01:29:37.790]             length <- base::length
[01:29:37.790]             list <- base::list
[01:29:37.790]             seq.int <- base::seq.int
[01:29:37.790]             signalCondition <- base::signalCondition
[01:29:37.790]             sys.calls <- base::sys.calls
[01:29:37.790]             `[[` <- base::`[[`
[01:29:37.790]             `+` <- base::`+`
[01:29:37.790]             `<<-` <- base::`<<-`
[01:29:37.790]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:37.790]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:37.790]                   3L)]
[01:29:37.790]             }
[01:29:37.790]             function(cond) {
[01:29:37.790]                 is_error <- inherits(cond, "error")
[01:29:37.790]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:37.790]                   NULL)
[01:29:37.790]                 if (is_error) {
[01:29:37.790]                   sessionInformation <- function() {
[01:29:37.790]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:37.790]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:37.790]                       search = base::search(), system = base::Sys.info())
[01:29:37.790]                   }
[01:29:37.790]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.790]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:37.790]                     cond$call), session = sessionInformation(), 
[01:29:37.790]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:37.790]                   signalCondition(cond)
[01:29:37.790]                 }
[01:29:37.790]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:37.790]                 "immediateCondition"))) {
[01:29:37.790]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:37.790]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.790]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:37.790]                   if (TRUE && !signal) {
[01:29:37.790]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.790]                     {
[01:29:37.790]                       inherits <- base::inherits
[01:29:37.790]                       invokeRestart <- base::invokeRestart
[01:29:37.790]                       is.null <- base::is.null
[01:29:37.790]                       muffled <- FALSE
[01:29:37.790]                       if (inherits(cond, "message")) {
[01:29:37.790]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.790]                         if (muffled) 
[01:29:37.790]                           invokeRestart("muffleMessage")
[01:29:37.790]                       }
[01:29:37.790]                       else if (inherits(cond, "warning")) {
[01:29:37.790]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.790]                         if (muffled) 
[01:29:37.790]                           invokeRestart("muffleWarning")
[01:29:37.790]                       }
[01:29:37.790]                       else if (inherits(cond, "condition")) {
[01:29:37.790]                         if (!is.null(pattern)) {
[01:29:37.790]                           computeRestarts <- base::computeRestarts
[01:29:37.790]                           grepl <- base::grepl
[01:29:37.790]                           restarts <- computeRestarts(cond)
[01:29:37.790]                           for (restart in restarts) {
[01:29:37.790]                             name <- restart$name
[01:29:37.790]                             if (is.null(name)) 
[01:29:37.790]                               next
[01:29:37.790]                             if (!grepl(pattern, name)) 
[01:29:37.790]                               next
[01:29:37.790]                             invokeRestart(restart)
[01:29:37.790]                             muffled <- TRUE
[01:29:37.790]                             break
[01:29:37.790]                           }
[01:29:37.790]                         }
[01:29:37.790]                       }
[01:29:37.790]                       invisible(muffled)
[01:29:37.790]                     }
[01:29:37.790]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.790]                   }
[01:29:37.790]                 }
[01:29:37.790]                 else {
[01:29:37.790]                   if (TRUE) {
[01:29:37.790]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.790]                     {
[01:29:37.790]                       inherits <- base::inherits
[01:29:37.790]                       invokeRestart <- base::invokeRestart
[01:29:37.790]                       is.null <- base::is.null
[01:29:37.790]                       muffled <- FALSE
[01:29:37.790]                       if (inherits(cond, "message")) {
[01:29:37.790]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.790]                         if (muffled) 
[01:29:37.790]                           invokeRestart("muffleMessage")
[01:29:37.790]                       }
[01:29:37.790]                       else if (inherits(cond, "warning")) {
[01:29:37.790]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.790]                         if (muffled) 
[01:29:37.790]                           invokeRestart("muffleWarning")
[01:29:37.790]                       }
[01:29:37.790]                       else if (inherits(cond, "condition")) {
[01:29:37.790]                         if (!is.null(pattern)) {
[01:29:37.790]                           computeRestarts <- base::computeRestarts
[01:29:37.790]                           grepl <- base::grepl
[01:29:37.790]                           restarts <- computeRestarts(cond)
[01:29:37.790]                           for (restart in restarts) {
[01:29:37.790]                             name <- restart$name
[01:29:37.790]                             if (is.null(name)) 
[01:29:37.790]                               next
[01:29:37.790]                             if (!grepl(pattern, name)) 
[01:29:37.790]                               next
[01:29:37.790]                             invokeRestart(restart)
[01:29:37.790]                             muffled <- TRUE
[01:29:37.790]                             break
[01:29:37.790]                           }
[01:29:37.790]                         }
[01:29:37.790]                       }
[01:29:37.790]                       invisible(muffled)
[01:29:37.790]                     }
[01:29:37.790]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.790]                   }
[01:29:37.790]                 }
[01:29:37.790]             }
[01:29:37.790]         }))
[01:29:37.790]     }, error = function(ex) {
[01:29:37.790]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:37.790]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.790]                 ...future.rng), started = ...future.startTime, 
[01:29:37.790]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:37.790]             version = "1.8"), class = "FutureResult")
[01:29:37.790]     }, finally = {
[01:29:37.790]         if (!identical(...future.workdir, getwd())) 
[01:29:37.790]             setwd(...future.workdir)
[01:29:37.790]         {
[01:29:37.790]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:37.790]                 ...future.oldOptions$nwarnings <- NULL
[01:29:37.790]             }
[01:29:37.790]             base::options(...future.oldOptions)
[01:29:37.790]             if (.Platform$OS.type == "windows") {
[01:29:37.790]                 old_names <- names(...future.oldEnvVars)
[01:29:37.790]                 envs <- base::Sys.getenv()
[01:29:37.790]                 names <- names(envs)
[01:29:37.790]                 common <- intersect(names, old_names)
[01:29:37.790]                 added <- setdiff(names, old_names)
[01:29:37.790]                 removed <- setdiff(old_names, names)
[01:29:37.790]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:37.790]                   envs[common]]
[01:29:37.790]                 NAMES <- toupper(changed)
[01:29:37.790]                 args <- list()
[01:29:37.790]                 for (kk in seq_along(NAMES)) {
[01:29:37.790]                   name <- changed[[kk]]
[01:29:37.790]                   NAME <- NAMES[[kk]]
[01:29:37.790]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.790]                     next
[01:29:37.790]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.790]                 }
[01:29:37.790]                 NAMES <- toupper(added)
[01:29:37.790]                 for (kk in seq_along(NAMES)) {
[01:29:37.790]                   name <- added[[kk]]
[01:29:37.790]                   NAME <- NAMES[[kk]]
[01:29:37.790]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.790]                     next
[01:29:37.790]                   args[[name]] <- ""
[01:29:37.790]                 }
[01:29:37.790]                 NAMES <- toupper(removed)
[01:29:37.790]                 for (kk in seq_along(NAMES)) {
[01:29:37.790]                   name <- removed[[kk]]
[01:29:37.790]                   NAME <- NAMES[[kk]]
[01:29:37.790]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.790]                     next
[01:29:37.790]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.790]                 }
[01:29:37.790]                 if (length(args) > 0) 
[01:29:37.790]                   base::do.call(base::Sys.setenv, args = args)
[01:29:37.790]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:37.790]             }
[01:29:37.790]             else {
[01:29:37.790]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:37.790]             }
[01:29:37.790]             {
[01:29:37.790]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:37.790]                   0L) {
[01:29:37.790]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:37.790]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:37.790]                   base::options(opts)
[01:29:37.790]                 }
[01:29:37.790]                 {
[01:29:37.790]                   {
[01:29:37.790]                     NULL
[01:29:37.790]                     RNGkind("Mersenne-Twister")
[01:29:37.790]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:29:37.790]                       inherits = FALSE)
[01:29:37.790]                   }
[01:29:37.790]                   options(future.plan = NULL)
[01:29:37.790]                   if (is.na(NA_character_)) 
[01:29:37.790]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.790]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:37.790]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:37.790]                   {
[01:29:37.790]                     future <- SequentialFuture(..., envir = envir)
[01:29:37.790]                     if (!future$lazy) 
[01:29:37.790]                       future <- run(future)
[01:29:37.790]                     invisible(future)
[01:29:37.790]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:37.790]                 }
[01:29:37.790]             }
[01:29:37.790]         }
[01:29:37.790]     })
[01:29:37.790]     if (TRUE) {
[01:29:37.790]         base::sink(type = "output", split = FALSE)
[01:29:37.790]         if (TRUE) {
[01:29:37.790]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:37.790]         }
[01:29:37.790]         else {
[01:29:37.790]             ...future.result["stdout"] <- base::list(NULL)
[01:29:37.790]         }
[01:29:37.790]         base::close(...future.stdout)
[01:29:37.790]         ...future.stdout <- NULL
[01:29:37.790]     }
[01:29:37.790]     ...future.result$conditions <- ...future.conditions
[01:29:37.790]     ...future.result$finished <- base::Sys.time()
[01:29:37.790]     ...future.result
[01:29:37.790] }
[01:29:37.794] plan(): Setting new future strategy stack:
[01:29:37.794] List of future strategies:
[01:29:37.794] 1. sequential:
[01:29:37.794]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.794]    - tweaked: FALSE
[01:29:37.794]    - call: NULL
[01:29:37.795] plan(): nbrOfWorkers() = 1
[01:29:37.796] plan(): Setting new future strategy stack:
[01:29:37.796] List of future strategies:
[01:29:37.796] 1. sequential:
[01:29:37.796]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.796]    - tweaked: FALSE
[01:29:37.796]    - call: plan(strategy)
[01:29:37.797] plan(): nbrOfWorkers() = 1
[01:29:37.797] SequentialFuture started (and completed)
[01:29:37.797] - Launch lazy future ... done
[01:29:37.798] run() for 'SequentialFuture' ... done
[1] 42
- stdout = NA
[01:29:37.798] getGlobalsAndPackages() ...
[01:29:37.798] Searching for globals...
[01:29:37.802] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[01:29:37.802] Searching for globals ... DONE
[01:29:37.802] Resolving globals: FALSE
[01:29:37.804] 
[01:29:37.805] - packages: [1] 'utils'
[01:29:37.805] getGlobalsAndPackages() ... DONE
[01:29:37.805] run() for 'Future' ...
[01:29:37.805] - state: 'created'
[01:29:37.806] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:37.806] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:37.806] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:37.806]   - Field: 'label'
[01:29:37.807]   - Field: 'local'
[01:29:37.807]   - Field: 'owner'
[01:29:37.807]   - Field: 'envir'
[01:29:37.807]   - Field: 'packages'
[01:29:37.807]   - Field: 'gc'
[01:29:37.807]   - Field: 'conditions'
[01:29:37.808]   - Field: 'expr'
[01:29:37.808]   - Field: 'uuid'
[01:29:37.808]   - Field: 'seed'
[01:29:37.808]   - Field: 'version'
[01:29:37.808]   - Field: 'result'
[01:29:37.809]   - Field: 'asynchronous'
[01:29:37.809]   - Field: 'calls'
[01:29:37.809]   - Field: 'globals'
[01:29:37.809]   - Field: 'stdout'
[01:29:37.809]   - Field: 'earlySignal'
[01:29:37.810]   - Field: 'lazy'
[01:29:37.810]   - Field: 'state'
[01:29:37.810] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:37.810] - Launch lazy future ...
[01:29:37.810] Packages needed by the future expression (n = 1): 'utils'
[01:29:37.811] Packages needed by future strategies (n = 0): <none>
[01:29:37.811] {
[01:29:37.811]     {
[01:29:37.811]         {
[01:29:37.811]             ...future.startTime <- base::Sys.time()
[01:29:37.811]             {
[01:29:37.811]                 {
[01:29:37.811]                   {
[01:29:37.811]                     {
[01:29:37.811]                       base::local({
[01:29:37.811]                         has_future <- base::requireNamespace("future", 
[01:29:37.811]                           quietly = TRUE)
[01:29:37.811]                         if (has_future) {
[01:29:37.811]                           ns <- base::getNamespace("future")
[01:29:37.811]                           version <- ns[[".package"]][["version"]]
[01:29:37.811]                           if (is.null(version)) 
[01:29:37.811]                             version <- utils::packageVersion("future")
[01:29:37.811]                         }
[01:29:37.811]                         else {
[01:29:37.811]                           version <- NULL
[01:29:37.811]                         }
[01:29:37.811]                         if (!has_future || version < "1.8.0") {
[01:29:37.811]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:37.811]                             "", base::R.version$version.string), 
[01:29:37.811]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:37.811]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:37.811]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:37.811]                               "release", "version")], collapse = " "), 
[01:29:37.811]                             hostname = base::Sys.info()[["nodename"]])
[01:29:37.811]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:37.811]                             info)
[01:29:37.811]                           info <- base::paste(info, collapse = "; ")
[01:29:37.811]                           if (!has_future) {
[01:29:37.811]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:37.811]                               info)
[01:29:37.811]                           }
[01:29:37.811]                           else {
[01:29:37.811]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:37.811]                               info, version)
[01:29:37.811]                           }
[01:29:37.811]                           base::stop(msg)
[01:29:37.811]                         }
[01:29:37.811]                       })
[01:29:37.811]                     }
[01:29:37.811]                     base::local({
[01:29:37.811]                       for (pkg in "utils") {
[01:29:37.811]                         base::loadNamespace(pkg)
[01:29:37.811]                         base::library(pkg, character.only = TRUE)
[01:29:37.811]                       }
[01:29:37.811]                     })
[01:29:37.811]                   }
[01:29:37.811]                   options(future.plan = NULL)
[01:29:37.811]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.811]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:37.811]                 }
[01:29:37.811]                 ...future.workdir <- getwd()
[01:29:37.811]             }
[01:29:37.811]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:37.811]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:37.811]         }
[01:29:37.811]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:37.811]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:37.811]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:37.811]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:37.811]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:37.811]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:37.811]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:37.811]             base::names(...future.oldOptions))
[01:29:37.811]     }
[01:29:37.811]     if (TRUE) {
[01:29:37.811]     }
[01:29:37.811]     else {
[01:29:37.811]         if (NA) {
[01:29:37.811]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:37.811]                 open = "w")
[01:29:37.811]         }
[01:29:37.811]         else {
[01:29:37.811]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:37.811]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:37.811]         }
[01:29:37.811]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:37.811]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:37.811]             base::sink(type = "output", split = FALSE)
[01:29:37.811]             base::close(...future.stdout)
[01:29:37.811]         }, add = TRUE)
[01:29:37.811]     }
[01:29:37.811]     ...future.frame <- base::sys.nframe()
[01:29:37.811]     ...future.conditions <- base::list()
[01:29:37.811]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:37.811]     if (FALSE) {
[01:29:37.811]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:37.811]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:37.811]     }
[01:29:37.811]     ...future.result <- base::tryCatch({
[01:29:37.811]         base::withCallingHandlers({
[01:29:37.811]             ...future.value <- base::withVisible(base::local({
[01:29:37.811]                 print(1:50)
[01:29:37.811]                 str(1:50)
[01:29:37.811]                 cat(letters, sep = "-")
[01:29:37.811]                 cat(1:6, collapse = "\n")
[01:29:37.811]                 write.table(datasets::iris[1:10, ], sep = "\t")
[01:29:37.811]                 42L
[01:29:37.811]             }))
[01:29:37.811]             future::FutureResult(value = ...future.value$value, 
[01:29:37.811]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.811]                   ...future.rng), globalenv = if (FALSE) 
[01:29:37.811]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:37.811]                     ...future.globalenv.names))
[01:29:37.811]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:37.811]         }, condition = base::local({
[01:29:37.811]             c <- base::c
[01:29:37.811]             inherits <- base::inherits
[01:29:37.811]             invokeRestart <- base::invokeRestart
[01:29:37.811]             length <- base::length
[01:29:37.811]             list <- base::list
[01:29:37.811]             seq.int <- base::seq.int
[01:29:37.811]             signalCondition <- base::signalCondition
[01:29:37.811]             sys.calls <- base::sys.calls
[01:29:37.811]             `[[` <- base::`[[`
[01:29:37.811]             `+` <- base::`+`
[01:29:37.811]             `<<-` <- base::`<<-`
[01:29:37.811]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:37.811]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:37.811]                   3L)]
[01:29:37.811]             }
[01:29:37.811]             function(cond) {
[01:29:37.811]                 is_error <- inherits(cond, "error")
[01:29:37.811]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:37.811]                   NULL)
[01:29:37.811]                 if (is_error) {
[01:29:37.811]                   sessionInformation <- function() {
[01:29:37.811]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:37.811]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:37.811]                       search = base::search(), system = base::Sys.info())
[01:29:37.811]                   }
[01:29:37.811]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.811]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:37.811]                     cond$call), session = sessionInformation(), 
[01:29:37.811]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:37.811]                   signalCondition(cond)
[01:29:37.811]                 }
[01:29:37.811]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:37.811]                 "immediateCondition"))) {
[01:29:37.811]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:37.811]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.811]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:37.811]                   if (TRUE && !signal) {
[01:29:37.811]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.811]                     {
[01:29:37.811]                       inherits <- base::inherits
[01:29:37.811]                       invokeRestart <- base::invokeRestart
[01:29:37.811]                       is.null <- base::is.null
[01:29:37.811]                       muffled <- FALSE
[01:29:37.811]                       if (inherits(cond, "message")) {
[01:29:37.811]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.811]                         if (muffled) 
[01:29:37.811]                           invokeRestart("muffleMessage")
[01:29:37.811]                       }
[01:29:37.811]                       else if (inherits(cond, "warning")) {
[01:29:37.811]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.811]                         if (muffled) 
[01:29:37.811]                           invokeRestart("muffleWarning")
[01:29:37.811]                       }
[01:29:37.811]                       else if (inherits(cond, "condition")) {
[01:29:37.811]                         if (!is.null(pattern)) {
[01:29:37.811]                           computeRestarts <- base::computeRestarts
[01:29:37.811]                           grepl <- base::grepl
[01:29:37.811]                           restarts <- computeRestarts(cond)
[01:29:37.811]                           for (restart in restarts) {
[01:29:37.811]                             name <- restart$name
[01:29:37.811]                             if (is.null(name)) 
[01:29:37.811]                               next
[01:29:37.811]                             if (!grepl(pattern, name)) 
[01:29:37.811]                               next
[01:29:37.811]                             invokeRestart(restart)
[01:29:37.811]                             muffled <- TRUE
[01:29:37.811]                             break
[01:29:37.811]                           }
[01:29:37.811]                         }
[01:29:37.811]                       }
[01:29:37.811]                       invisible(muffled)
[01:29:37.811]                     }
[01:29:37.811]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.811]                   }
[01:29:37.811]                 }
[01:29:37.811]                 else {
[01:29:37.811]                   if (TRUE) {
[01:29:37.811]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.811]                     {
[01:29:37.811]                       inherits <- base::inherits
[01:29:37.811]                       invokeRestart <- base::invokeRestart
[01:29:37.811]                       is.null <- base::is.null
[01:29:37.811]                       muffled <- FALSE
[01:29:37.811]                       if (inherits(cond, "message")) {
[01:29:37.811]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.811]                         if (muffled) 
[01:29:37.811]                           invokeRestart("muffleMessage")
[01:29:37.811]                       }
[01:29:37.811]                       else if (inherits(cond, "warning")) {
[01:29:37.811]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.811]                         if (muffled) 
[01:29:37.811]                           invokeRestart("muffleWarning")
[01:29:37.811]                       }
[01:29:37.811]                       else if (inherits(cond, "condition")) {
[01:29:37.811]                         if (!is.null(pattern)) {
[01:29:37.811]                           computeRestarts <- base::computeRestarts
[01:29:37.811]                           grepl <- base::grepl
[01:29:37.811]                           restarts <- computeRestarts(cond)
[01:29:37.811]                           for (restart in restarts) {
[01:29:37.811]                             name <- restart$name
[01:29:37.811]                             if (is.null(name)) 
[01:29:37.811]                               next
[01:29:37.811]                             if (!grepl(pattern, name)) 
[01:29:37.811]                               next
[01:29:37.811]                             invokeRestart(restart)
[01:29:37.811]                             muffled <- TRUE
[01:29:37.811]                             break
[01:29:37.811]                           }
[01:29:37.811]                         }
[01:29:37.811]                       }
[01:29:37.811]                       invisible(muffled)
[01:29:37.811]                     }
[01:29:37.811]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.811]                   }
[01:29:37.811]                 }
[01:29:37.811]             }
[01:29:37.811]         }))
[01:29:37.811]     }, error = function(ex) {
[01:29:37.811]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:37.811]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.811]                 ...future.rng), started = ...future.startTime, 
[01:29:37.811]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:37.811]             version = "1.8"), class = "FutureResult")
[01:29:37.811]     }, finally = {
[01:29:37.811]         if (!identical(...future.workdir, getwd())) 
[01:29:37.811]             setwd(...future.workdir)
[01:29:37.811]         {
[01:29:37.811]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:37.811]                 ...future.oldOptions$nwarnings <- NULL
[01:29:37.811]             }
[01:29:37.811]             base::options(...future.oldOptions)
[01:29:37.811]             if (.Platform$OS.type == "windows") {
[01:29:37.811]                 old_names <- names(...future.oldEnvVars)
[01:29:37.811]                 envs <- base::Sys.getenv()
[01:29:37.811]                 names <- names(envs)
[01:29:37.811]                 common <- intersect(names, old_names)
[01:29:37.811]                 added <- setdiff(names, old_names)
[01:29:37.811]                 removed <- setdiff(old_names, names)
[01:29:37.811]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:37.811]                   envs[common]]
[01:29:37.811]                 NAMES <- toupper(changed)
[01:29:37.811]                 args <- list()
[01:29:37.811]                 for (kk in seq_along(NAMES)) {
[01:29:37.811]                   name <- changed[[kk]]
[01:29:37.811]                   NAME <- NAMES[[kk]]
[01:29:37.811]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.811]                     next
[01:29:37.811]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.811]                 }
[01:29:37.811]                 NAMES <- toupper(added)
[01:29:37.811]                 for (kk in seq_along(NAMES)) {
[01:29:37.811]                   name <- added[[kk]]
[01:29:37.811]                   NAME <- NAMES[[kk]]
[01:29:37.811]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.811]                     next
[01:29:37.811]                   args[[name]] <- ""
[01:29:37.811]                 }
[01:29:37.811]                 NAMES <- toupper(removed)
[01:29:37.811]                 for (kk in seq_along(NAMES)) {
[01:29:37.811]                   name <- removed[[kk]]
[01:29:37.811]                   NAME <- NAMES[[kk]]
[01:29:37.811]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.811]                     next
[01:29:37.811]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.811]                 }
[01:29:37.811]                 if (length(args) > 0) 
[01:29:37.811]                   base::do.call(base::Sys.setenv, args = args)
[01:29:37.811]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:37.811]             }
[01:29:37.811]             else {
[01:29:37.811]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:37.811]             }
[01:29:37.811]             {
[01:29:37.811]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:37.811]                   0L) {
[01:29:37.811]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:37.811]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:37.811]                   base::options(opts)
[01:29:37.811]                 }
[01:29:37.811]                 {
[01:29:37.811]                   {
[01:29:37.811]                     NULL
[01:29:37.811]                     RNGkind("Mersenne-Twister")
[01:29:37.811]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:29:37.811]                       inherits = FALSE)
[01:29:37.811]                   }
[01:29:37.811]                   options(future.plan = NULL)
[01:29:37.811]                   if (is.na(NA_character_)) 
[01:29:37.811]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.811]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:37.811]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:37.811]                   {
[01:29:37.811]                     future <- SequentialFuture(..., envir = envir)
[01:29:37.811]                     if (!future$lazy) 
[01:29:37.811]                       future <- run(future)
[01:29:37.811]                     invisible(future)
[01:29:37.811]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:37.811]                 }
[01:29:37.811]             }
[01:29:37.811]         }
[01:29:37.811]     })
[01:29:37.811]     if (FALSE) {
[01:29:37.811]         base::sink(type = "output", split = FALSE)
[01:29:37.811]         if (NA) {
[01:29:37.811]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:37.811]         }
[01:29:37.811]         else {
[01:29:37.811]             ...future.result["stdout"] <- base::list(NULL)
[01:29:37.811]         }
[01:29:37.811]         base::close(...future.stdout)
[01:29:37.811]         ...future.stdout <- NULL
[01:29:37.811]     }
[01:29:37.811]     ...future.result$conditions <- ...future.conditions
[01:29:37.811]     ...future.result$finished <- base::Sys.time()
[01:29:37.811]     ...future.result
[01:29:37.811] }
[01:29:37.816] plan(): Setting new future strategy stack:
[01:29:37.816] List of future strategies:
[01:29:37.816] 1. sequential:
[01:29:37.816]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.816]    - tweaked: FALSE
[01:29:37.816]    - call: NULL
[01:29:37.817] plan(): nbrOfWorkers() = 1
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
 int [1:50] 1 2 3 4 5 6 7 8 9 10 ...
a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 
"Sepal.Length"	"Sepal.Width"	"Petal.Length"	"Petal.Width"	"Species"
"1"	5.1	3.5	1.4	0.2	"setosa"
"2"	4.9	3	1.4	0.2	"setosa"
"3"	4.7	3.2	1.3	0.2	"setosa"
"4"	4.6	3.1	1.5	0.2	"setosa"
"5"	5	3.6	1.4	0.2	"setosa"
"6"	5.4	3.9	1.7	0.4	"setosa"
"7"	4.6	3.4	1.4	0.3	"setosa"
"8"	5	3.4	1.5	0.2	"setosa"
"9"	4.4	2.9	1.4	0.2	"setosa"
"10"	4.9	3.1	1.5	0.1	"setosa"
[01:29:37.819] plan(): Setting new future strategy stack:
[01:29:37.819] List of future strategies:
[01:29:37.819] 1. sequential:
[01:29:37.819]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.819]    - tweaked: FALSE
[01:29:37.819]    - call: plan(strategy)
[01:29:37.820] plan(): nbrOfWorkers() = 1
[01:29:37.820] SequentialFuture started (and completed)
[01:29:37.820] - Launch lazy future ... done
[01:29:37.820] run() for 'SequentialFuture' ... done
List of 11
 $ value       : int 42
 $ visible     : logi TRUE
 $ stdout      : NULL
 $ conditions  : list()
 $ rng         : logi FALSE
 $ globalenv   : NULL
 $ started     : POSIXct[1:1], format: "2023-12-22 01:29:37"
 $ finished    : POSIXct[1:1], format: "2023-12-22 01:29:37"
 $ session_uuid: chr "4310f9ea-29aa-4571-e277-b54ae8a03ba6"
  ..- attr(*, "source")=List of 5
  .. ..$ host  : Named chr "CRANWIN3"
  .. .. ..- attr(*, "names")= chr "COMPUTERNAME"
  .. ..$ info  : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...
  .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...
  .. ..$ pid   : int 6628
  .. ..$ time  : POSIXct[1:1], format: "2023-12-22 01:29:37"
  .. ..$ random: int 2147483647
 $ r_info      :List of 4
  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1
  .. ..$ : int [1:3] 4 4 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[01:29:37.830] getGlobalsAndPackages() ...
[01:29:37.830] Searching for globals...
[01:29:37.834] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[01:29:37.834] Searching for globals ... DONE
[01:29:37.834] Resolving globals: FALSE
[01:29:37.836] 
[01:29:37.836] - packages: [1] 'utils'
[01:29:37.836] getGlobalsAndPackages() ... DONE
[01:29:37.836] run() for 'Future' ...
[01:29:37.837] - state: 'created'
[01:29:37.837] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:37.837] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:37.838] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:37.838]   - Field: 'label'
[01:29:37.838]   - Field: 'local'
[01:29:37.838]   - Field: 'owner'
[01:29:37.838]   - Field: 'envir'
[01:29:37.838]   - Field: 'packages'
[01:29:37.839]   - Field: 'gc'
[01:29:37.839]   - Field: 'conditions'
[01:29:37.839]   - Field: 'expr'
[01:29:37.839]   - Field: 'uuid'
[01:29:37.839]   - Field: 'seed'
[01:29:37.840]   - Field: 'version'
[01:29:37.840]   - Field: 'result'
[01:29:37.840]   - Field: 'asynchronous'
[01:29:37.840]   - Field: 'calls'
[01:29:37.840]   - Field: 'globals'
[01:29:37.840]   - Field: 'stdout'
[01:29:37.841]   - Field: 'earlySignal'
[01:29:37.841]   - Field: 'lazy'
[01:29:37.841]   - Field: 'state'
[01:29:37.841] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:37.841] - Launch lazy future ...
[01:29:37.842] Packages needed by the future expression (n = 1): 'utils'
[01:29:37.842] Packages needed by future strategies (n = 0): <none>
[01:29:37.842] {
[01:29:37.842]     {
[01:29:37.842]         {
[01:29:37.842]             ...future.startTime <- base::Sys.time()
[01:29:37.842]             {
[01:29:37.842]                 {
[01:29:37.842]                   {
[01:29:37.842]                     {
[01:29:37.842]                       base::local({
[01:29:37.842]                         has_future <- base::requireNamespace("future", 
[01:29:37.842]                           quietly = TRUE)
[01:29:37.842]                         if (has_future) {
[01:29:37.842]                           ns <- base::getNamespace("future")
[01:29:37.842]                           version <- ns[[".package"]][["version"]]
[01:29:37.842]                           if (is.null(version)) 
[01:29:37.842]                             version <- utils::packageVersion("future")
[01:29:37.842]                         }
[01:29:37.842]                         else {
[01:29:37.842]                           version <- NULL
[01:29:37.842]                         }
[01:29:37.842]                         if (!has_future || version < "1.8.0") {
[01:29:37.842]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:37.842]                             "", base::R.version$version.string), 
[01:29:37.842]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:37.842]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:37.842]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:37.842]                               "release", "version")], collapse = " "), 
[01:29:37.842]                             hostname = base::Sys.info()[["nodename"]])
[01:29:37.842]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:37.842]                             info)
[01:29:37.842]                           info <- base::paste(info, collapse = "; ")
[01:29:37.842]                           if (!has_future) {
[01:29:37.842]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:37.842]                               info)
[01:29:37.842]                           }
[01:29:37.842]                           else {
[01:29:37.842]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:37.842]                               info, version)
[01:29:37.842]                           }
[01:29:37.842]                           base::stop(msg)
[01:29:37.842]                         }
[01:29:37.842]                       })
[01:29:37.842]                     }
[01:29:37.842]                     base::local({
[01:29:37.842]                       for (pkg in "utils") {
[01:29:37.842]                         base::loadNamespace(pkg)
[01:29:37.842]                         base::library(pkg, character.only = TRUE)
[01:29:37.842]                       }
[01:29:37.842]                     })
[01:29:37.842]                   }
[01:29:37.842]                   options(future.plan = NULL)
[01:29:37.842]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.842]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:37.842]                 }
[01:29:37.842]                 ...future.workdir <- getwd()
[01:29:37.842]             }
[01:29:37.842]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:37.842]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:37.842]         }
[01:29:37.842]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:37.842]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:37.842]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:37.842]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:37.842]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:37.842]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:37.842]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:37.842]             base::names(...future.oldOptions))
[01:29:37.842]     }
[01:29:37.842]     if (TRUE) {
[01:29:37.842]     }
[01:29:37.842]     else {
[01:29:37.842]         if (NA) {
[01:29:37.842]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:37.842]                 open = "w")
[01:29:37.842]         }
[01:29:37.842]         else {
[01:29:37.842]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:37.842]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:37.842]         }
[01:29:37.842]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:37.842]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:37.842]             base::sink(type = "output", split = FALSE)
[01:29:37.842]             base::close(...future.stdout)
[01:29:37.842]         }, add = TRUE)
[01:29:37.842]     }
[01:29:37.842]     ...future.frame <- base::sys.nframe()
[01:29:37.842]     ...future.conditions <- base::list()
[01:29:37.842]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:37.842]     if (FALSE) {
[01:29:37.842]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:37.842]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:37.842]     }
[01:29:37.842]     ...future.result <- base::tryCatch({
[01:29:37.842]         base::withCallingHandlers({
[01:29:37.842]             ...future.value <- base::withVisible(base::local({
[01:29:37.842]                 print(1:50)
[01:29:37.842]                 str(1:50)
[01:29:37.842]                 cat(letters, sep = "-")
[01:29:37.842]                 cat(1:6, collapse = "\n")
[01:29:37.842]                 write.table(datasets::iris[1:10, ], sep = "\t")
[01:29:37.842]                 42L
[01:29:37.842]             }))
[01:29:37.842]             future::FutureResult(value = ...future.value$value, 
[01:29:37.842]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.842]                   ...future.rng), globalenv = if (FALSE) 
[01:29:37.842]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:37.842]                     ...future.globalenv.names))
[01:29:37.842]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:37.842]         }, condition = base::local({
[01:29:37.842]             c <- base::c
[01:29:37.842]             inherits <- base::inherits
[01:29:37.842]             invokeRestart <- base::invokeRestart
[01:29:37.842]             length <- base::length
[01:29:37.842]             list <- base::list
[01:29:37.842]             seq.int <- base::seq.int
[01:29:37.842]             signalCondition <- base::signalCondition
[01:29:37.842]             sys.calls <- base::sys.calls
[01:29:37.842]             `[[` <- base::`[[`
[01:29:37.842]             `+` <- base::`+`
[01:29:37.842]             `<<-` <- base::`<<-`
[01:29:37.842]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:37.842]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:37.842]                   3L)]
[01:29:37.842]             }
[01:29:37.842]             function(cond) {
[01:29:37.842]                 is_error <- inherits(cond, "error")
[01:29:37.842]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:37.842]                   NULL)
[01:29:37.842]                 if (is_error) {
[01:29:37.842]                   sessionInformation <- function() {
[01:29:37.842]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:37.842]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:37.842]                       search = base::search(), system = base::Sys.info())
[01:29:37.842]                   }
[01:29:37.842]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.842]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:37.842]                     cond$call), session = sessionInformation(), 
[01:29:37.842]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:37.842]                   signalCondition(cond)
[01:29:37.842]                 }
[01:29:37.842]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:37.842]                 "immediateCondition"))) {
[01:29:37.842]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:37.842]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.842]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:37.842]                   if (TRUE && !signal) {
[01:29:37.842]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.842]                     {
[01:29:37.842]                       inherits <- base::inherits
[01:29:37.842]                       invokeRestart <- base::invokeRestart
[01:29:37.842]                       is.null <- base::is.null
[01:29:37.842]                       muffled <- FALSE
[01:29:37.842]                       if (inherits(cond, "message")) {
[01:29:37.842]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.842]                         if (muffled) 
[01:29:37.842]                           invokeRestart("muffleMessage")
[01:29:37.842]                       }
[01:29:37.842]                       else if (inherits(cond, "warning")) {
[01:29:37.842]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.842]                         if (muffled) 
[01:29:37.842]                           invokeRestart("muffleWarning")
[01:29:37.842]                       }
[01:29:37.842]                       else if (inherits(cond, "condition")) {
[01:29:37.842]                         if (!is.null(pattern)) {
[01:29:37.842]                           computeRestarts <- base::computeRestarts
[01:29:37.842]                           grepl <- base::grepl
[01:29:37.842]                           restarts <- computeRestarts(cond)
[01:29:37.842]                           for (restart in restarts) {
[01:29:37.842]                             name <- restart$name
[01:29:37.842]                             if (is.null(name)) 
[01:29:37.842]                               next
[01:29:37.842]                             if (!grepl(pattern, name)) 
[01:29:37.842]                               next
[01:29:37.842]                             invokeRestart(restart)
[01:29:37.842]                             muffled <- TRUE
[01:29:37.842]                             break
[01:29:37.842]                           }
[01:29:37.842]                         }
[01:29:37.842]                       }
[01:29:37.842]                       invisible(muffled)
[01:29:37.842]                     }
[01:29:37.842]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.842]                   }
[01:29:37.842]                 }
[01:29:37.842]                 else {
[01:29:37.842]                   if (TRUE) {
[01:29:37.842]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.842]                     {
[01:29:37.842]                       inherits <- base::inherits
[01:29:37.842]                       invokeRestart <- base::invokeRestart
[01:29:37.842]                       is.null <- base::is.null
[01:29:37.842]                       muffled <- FALSE
[01:29:37.842]                       if (inherits(cond, "message")) {
[01:29:37.842]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.842]                         if (muffled) 
[01:29:37.842]                           invokeRestart("muffleMessage")
[01:29:37.842]                       }
[01:29:37.842]                       else if (inherits(cond, "warning")) {
[01:29:37.842]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.842]                         if (muffled) 
[01:29:37.842]                           invokeRestart("muffleWarning")
[01:29:37.842]                       }
[01:29:37.842]                       else if (inherits(cond, "condition")) {
[01:29:37.842]                         if (!is.null(pattern)) {
[01:29:37.842]                           computeRestarts <- base::computeRestarts
[01:29:37.842]                           grepl <- base::grepl
[01:29:37.842]                           restarts <- computeRestarts(cond)
[01:29:37.842]                           for (restart in restarts) {
[01:29:37.842]                             name <- restart$name
[01:29:37.842]                             if (is.null(name)) 
[01:29:37.842]                               next
[01:29:37.842]                             if (!grepl(pattern, name)) 
[01:29:37.842]                               next
[01:29:37.842]                             invokeRestart(restart)
[01:29:37.842]                             muffled <- TRUE
[01:29:37.842]                             break
[01:29:37.842]                           }
[01:29:37.842]                         }
[01:29:37.842]                       }
[01:29:37.842]                       invisible(muffled)
[01:29:37.842]                     }
[01:29:37.842]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.842]                   }
[01:29:37.842]                 }
[01:29:37.842]             }
[01:29:37.842]         }))
[01:29:37.842]     }, error = function(ex) {
[01:29:37.842]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:37.842]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.842]                 ...future.rng), started = ...future.startTime, 
[01:29:37.842]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:37.842]             version = "1.8"), class = "FutureResult")
[01:29:37.842]     }, finally = {
[01:29:37.842]         if (!identical(...future.workdir, getwd())) 
[01:29:37.842]             setwd(...future.workdir)
[01:29:37.842]         {
[01:29:37.842]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:37.842]                 ...future.oldOptions$nwarnings <- NULL
[01:29:37.842]             }
[01:29:37.842]             base::options(...future.oldOptions)
[01:29:37.842]             if (.Platform$OS.type == "windows") {
[01:29:37.842]                 old_names <- names(...future.oldEnvVars)
[01:29:37.842]                 envs <- base::Sys.getenv()
[01:29:37.842]                 names <- names(envs)
[01:29:37.842]                 common <- intersect(names, old_names)
[01:29:37.842]                 added <- setdiff(names, old_names)
[01:29:37.842]                 removed <- setdiff(old_names, names)
[01:29:37.842]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:37.842]                   envs[common]]
[01:29:37.842]                 NAMES <- toupper(changed)
[01:29:37.842]                 args <- list()
[01:29:37.842]                 for (kk in seq_along(NAMES)) {
[01:29:37.842]                   name <- changed[[kk]]
[01:29:37.842]                   NAME <- NAMES[[kk]]
[01:29:37.842]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.842]                     next
[01:29:37.842]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.842]                 }
[01:29:37.842]                 NAMES <- toupper(added)
[01:29:37.842]                 for (kk in seq_along(NAMES)) {
[01:29:37.842]                   name <- added[[kk]]
[01:29:37.842]                   NAME <- NAMES[[kk]]
[01:29:37.842]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.842]                     next
[01:29:37.842]                   args[[name]] <- ""
[01:29:37.842]                 }
[01:29:37.842]                 NAMES <- toupper(removed)
[01:29:37.842]                 for (kk in seq_along(NAMES)) {
[01:29:37.842]                   name <- removed[[kk]]
[01:29:37.842]                   NAME <- NAMES[[kk]]
[01:29:37.842]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.842]                     next
[01:29:37.842]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.842]                 }
[01:29:37.842]                 if (length(args) > 0) 
[01:29:37.842]                   base::do.call(base::Sys.setenv, args = args)
[01:29:37.842]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:37.842]             }
[01:29:37.842]             else {
[01:29:37.842]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:37.842]             }
[01:29:37.842]             {
[01:29:37.842]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:37.842]                   0L) {
[01:29:37.842]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:37.842]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:37.842]                   base::options(opts)
[01:29:37.842]                 }
[01:29:37.842]                 {
[01:29:37.842]                   {
[01:29:37.842]                     NULL
[01:29:37.842]                     RNGkind("Mersenne-Twister")
[01:29:37.842]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:29:37.842]                       inherits = FALSE)
[01:29:37.842]                   }
[01:29:37.842]                   options(future.plan = NULL)
[01:29:37.842]                   if (is.na(NA_character_)) 
[01:29:37.842]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.842]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:37.842]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:37.842]                   {
[01:29:37.842]                     future <- SequentialFuture(..., envir = envir)
[01:29:37.842]                     if (!future$lazy) 
[01:29:37.842]                       future <- run(future)
[01:29:37.842]                     invisible(future)
[01:29:37.842]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:37.842]                 }
[01:29:37.842]             }
[01:29:37.842]         }
[01:29:37.842]     })
[01:29:37.842]     if (FALSE) {
[01:29:37.842]         base::sink(type = "output", split = FALSE)
[01:29:37.842]         if (NA) {
[01:29:37.842]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:37.842]         }
[01:29:37.842]         else {
[01:29:37.842]             ...future.result["stdout"] <- base::list(NULL)
[01:29:37.842]         }
[01:29:37.842]         base::close(...future.stdout)
[01:29:37.842]         ...future.stdout <- NULL
[01:29:37.842]     }
[01:29:37.842]     ...future.result$conditions <- ...future.conditions
[01:29:37.842]     ...future.result$finished <- base::Sys.time()
[01:29:37.842]     ...future.result
[01:29:37.842] }
[01:29:37.847] plan(): Setting new future strategy stack:
[01:29:37.847] List of future strategies:
[01:29:37.847] 1. sequential:
[01:29:37.847]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.847]    - tweaked: FALSE
[01:29:37.847]    - call: NULL
[01:29:37.848] plan(): nbrOfWorkers() = 1
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
 int [1:50] 1 2 3 4 5 6 7 8 9 10 ...
a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 
"Sepal.Length"	"Sepal.Width"	"Petal.Length"	"Petal.Width"	"Species"
"1"	5.1	3.5	1.4	0.2	"setosa"
"2"	4.9	3	1.4	0.2	"setosa"
"3"	4.7	3.2	1.3	0.2	"setosa"
"4"	4.6	3.1	1.5	0.2	"setosa"
"5"	5	3.6	1.4	0.2	"setosa"
"6"	5.4	3.9	1.7	0.4	"setosa"
"7"	4.6	3.4	1.4	0.3	"setosa"
"8"	5	3.4	1.5	0.2	"setosa"
"9"	4.4	2.9	1.4	0.2	"setosa"
"10"	4.9	3.1	1.5	0.1	"setosa"
[01:29:37.850] plan(): Setting new future strategy stack:
[01:29:37.850] List of future strategies:
[01:29:37.850] 1. sequential:
[01:29:37.850]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.850]    - tweaked: FALSE
[01:29:37.850]    - call: plan(strategy)
[01:29:37.850] plan(): nbrOfWorkers() = 1
[01:29:37.851] SequentialFuture started (and completed)
[01:29:37.851] - Launch lazy future ... done
[01:29:37.851] run() for 'SequentialFuture' ... done
- stdout = structure(TRUE, drop = TRUE)
[01:29:37.852] getGlobalsAndPackages() ...
[01:29:37.852] Searching for globals...
[01:29:37.852] - globals found: [1] 'print'
[01:29:37.853] Searching for globals ... DONE
[01:29:37.853] Resolving globals: FALSE
[01:29:37.853] 
[01:29:37.853] 
[01:29:37.853] getGlobalsAndPackages() ... DONE
[01:29:37.854] run() for 'Future' ...
[01:29:37.854] - state: 'created'
[01:29:37.854] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:37.855] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:37.855] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:37.855]   - Field: 'label'
[01:29:37.855]   - Field: 'local'
[01:29:37.855]   - Field: 'owner'
[01:29:37.855]   - Field: 'envir'
[01:29:37.856]   - Field: 'packages'
[01:29:37.856]   - Field: 'gc'
[01:29:37.856]   - Field: 'conditions'
[01:29:37.856]   - Field: 'expr'
[01:29:37.856]   - Field: 'uuid'
[01:29:37.857]   - Field: 'seed'
[01:29:37.857]   - Field: 'version'
[01:29:37.857]   - Field: 'result'
[01:29:37.857]   - Field: 'asynchronous'
[01:29:37.857]   - Field: 'calls'
[01:29:37.857]   - Field: 'globals'
[01:29:37.858]   - Field: 'stdout'
[01:29:37.858]   - Field: 'earlySignal'
[01:29:37.858]   - Field: 'lazy'
[01:29:37.858]   - Field: 'state'
[01:29:37.858] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:37.858] - Launch lazy future ...
[01:29:37.859] Packages needed by the future expression (n = 0): <none>
[01:29:37.859] Packages needed by future strategies (n = 0): <none>
[01:29:37.859] {
[01:29:37.859]     {
[01:29:37.859]         {
[01:29:37.859]             ...future.startTime <- base::Sys.time()
[01:29:37.859]             {
[01:29:37.859]                 {
[01:29:37.859]                   {
[01:29:37.859]                     base::local({
[01:29:37.859]                       has_future <- base::requireNamespace("future", 
[01:29:37.859]                         quietly = TRUE)
[01:29:37.859]                       if (has_future) {
[01:29:37.859]                         ns <- base::getNamespace("future")
[01:29:37.859]                         version <- ns[[".package"]][["version"]]
[01:29:37.859]                         if (is.null(version)) 
[01:29:37.859]                           version <- utils::packageVersion("future")
[01:29:37.859]                       }
[01:29:37.859]                       else {
[01:29:37.859]                         version <- NULL
[01:29:37.859]                       }
[01:29:37.859]                       if (!has_future || version < "1.8.0") {
[01:29:37.859]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:37.859]                           "", base::R.version$version.string), 
[01:29:37.859]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:37.859]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:37.859]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:37.859]                             "release", "version")], collapse = " "), 
[01:29:37.859]                           hostname = base::Sys.info()[["nodename"]])
[01:29:37.859]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:37.859]                           info)
[01:29:37.859]                         info <- base::paste(info, collapse = "; ")
[01:29:37.859]                         if (!has_future) {
[01:29:37.859]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:37.859]                             info)
[01:29:37.859]                         }
[01:29:37.859]                         else {
[01:29:37.859]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:37.859]                             info, version)
[01:29:37.859]                         }
[01:29:37.859]                         base::stop(msg)
[01:29:37.859]                       }
[01:29:37.859]                     })
[01:29:37.859]                   }
[01:29:37.859]                   options(future.plan = NULL)
[01:29:37.859]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.859]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:37.859]                 }
[01:29:37.859]                 ...future.workdir <- getwd()
[01:29:37.859]             }
[01:29:37.859]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:37.859]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:37.859]         }
[01:29:37.859]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:37.859]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:37.859]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:37.859]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:37.859]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:37.859]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:37.859]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:37.859]             base::names(...future.oldOptions))
[01:29:37.859]     }
[01:29:37.859]     if (FALSE) {
[01:29:37.859]     }
[01:29:37.859]     else {
[01:29:37.859]         if (TRUE) {
[01:29:37.859]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:37.859]                 open = "w")
[01:29:37.859]         }
[01:29:37.859]         else {
[01:29:37.859]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:37.859]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:37.859]         }
[01:29:37.859]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:37.859]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:37.859]             base::sink(type = "output", split = FALSE)
[01:29:37.859]             base::close(...future.stdout)
[01:29:37.859]         }, add = TRUE)
[01:29:37.859]     }
[01:29:37.859]     ...future.frame <- base::sys.nframe()
[01:29:37.859]     ...future.conditions <- base::list()
[01:29:37.859]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:37.859]     if (FALSE) {
[01:29:37.859]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:37.859]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:37.859]     }
[01:29:37.859]     ...future.result <- base::tryCatch({
[01:29:37.859]         base::withCallingHandlers({
[01:29:37.859]             ...future.value <- base::withVisible(base::local(print(42)))
[01:29:37.859]             future::FutureResult(value = ...future.value$value, 
[01:29:37.859]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.859]                   ...future.rng), globalenv = if (FALSE) 
[01:29:37.859]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:37.859]                     ...future.globalenv.names))
[01:29:37.859]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:37.859]         }, condition = base::local({
[01:29:37.859]             c <- base::c
[01:29:37.859]             inherits <- base::inherits
[01:29:37.859]             invokeRestart <- base::invokeRestart
[01:29:37.859]             length <- base::length
[01:29:37.859]             list <- base::list
[01:29:37.859]             seq.int <- base::seq.int
[01:29:37.859]             signalCondition <- base::signalCondition
[01:29:37.859]             sys.calls <- base::sys.calls
[01:29:37.859]             `[[` <- base::`[[`
[01:29:37.859]             `+` <- base::`+`
[01:29:37.859]             `<<-` <- base::`<<-`
[01:29:37.859]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:37.859]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:37.859]                   3L)]
[01:29:37.859]             }
[01:29:37.859]             function(cond) {
[01:29:37.859]                 is_error <- inherits(cond, "error")
[01:29:37.859]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:37.859]                   NULL)
[01:29:37.859]                 if (is_error) {
[01:29:37.859]                   sessionInformation <- function() {
[01:29:37.859]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:37.859]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:37.859]                       search = base::search(), system = base::Sys.info())
[01:29:37.859]                   }
[01:29:37.859]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.859]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:37.859]                     cond$call), session = sessionInformation(), 
[01:29:37.859]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:37.859]                   signalCondition(cond)
[01:29:37.859]                 }
[01:29:37.859]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:37.859]                 "immediateCondition"))) {
[01:29:37.859]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:37.859]                   ...future.conditions[[length(...future.conditions) + 
[01:29:37.859]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:37.859]                   if (TRUE && !signal) {
[01:29:37.859]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.859]                     {
[01:29:37.859]                       inherits <- base::inherits
[01:29:37.859]                       invokeRestart <- base::invokeRestart
[01:29:37.859]                       is.null <- base::is.null
[01:29:37.859]                       muffled <- FALSE
[01:29:37.859]                       if (inherits(cond, "message")) {
[01:29:37.859]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.859]                         if (muffled) 
[01:29:37.859]                           invokeRestart("muffleMessage")
[01:29:37.859]                       }
[01:29:37.859]                       else if (inherits(cond, "warning")) {
[01:29:37.859]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.859]                         if (muffled) 
[01:29:37.859]                           invokeRestart("muffleWarning")
[01:29:37.859]                       }
[01:29:37.859]                       else if (inherits(cond, "condition")) {
[01:29:37.859]                         if (!is.null(pattern)) {
[01:29:37.859]                           computeRestarts <- base::computeRestarts
[01:29:37.859]                           grepl <- base::grepl
[01:29:37.859]                           restarts <- computeRestarts(cond)
[01:29:37.859]                           for (restart in restarts) {
[01:29:37.859]                             name <- restart$name
[01:29:37.859]                             if (is.null(name)) 
[01:29:37.859]                               next
[01:29:37.859]                             if (!grepl(pattern, name)) 
[01:29:37.859]                               next
[01:29:37.859]                             invokeRestart(restart)
[01:29:37.859]                             muffled <- TRUE
[01:29:37.859]                             break
[01:29:37.859]                           }
[01:29:37.859]                         }
[01:29:37.859]                       }
[01:29:37.859]                       invisible(muffled)
[01:29:37.859]                     }
[01:29:37.859]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.859]                   }
[01:29:37.859]                 }
[01:29:37.859]                 else {
[01:29:37.859]                   if (TRUE) {
[01:29:37.859]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:37.859]                     {
[01:29:37.859]                       inherits <- base::inherits
[01:29:37.859]                       invokeRestart <- base::invokeRestart
[01:29:37.859]                       is.null <- base::is.null
[01:29:37.859]                       muffled <- FALSE
[01:29:37.859]                       if (inherits(cond, "message")) {
[01:29:37.859]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:37.859]                         if (muffled) 
[01:29:37.859]                           invokeRestart("muffleMessage")
[01:29:37.859]                       }
[01:29:37.859]                       else if (inherits(cond, "warning")) {
[01:29:37.859]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:37.859]                         if (muffled) 
[01:29:37.859]                           invokeRestart("muffleWarning")
[01:29:37.859]                       }
[01:29:37.859]                       else if (inherits(cond, "condition")) {
[01:29:37.859]                         if (!is.null(pattern)) {
[01:29:37.859]                           computeRestarts <- base::computeRestarts
[01:29:37.859]                           grepl <- base::grepl
[01:29:37.859]                           restarts <- computeRestarts(cond)
[01:29:37.859]                           for (restart in restarts) {
[01:29:37.859]                             name <- restart$name
[01:29:37.859]                             if (is.null(name)) 
[01:29:37.859]                               next
[01:29:37.859]                             if (!grepl(pattern, name)) 
[01:29:37.859]                               next
[01:29:37.859]                             invokeRestart(restart)
[01:29:37.859]                             muffled <- TRUE
[01:29:37.859]                             break
[01:29:37.859]                           }
[01:29:37.859]                         }
[01:29:37.859]                       }
[01:29:37.859]                       invisible(muffled)
[01:29:37.859]                     }
[01:29:37.859]                     muffleCondition(cond, pattern = "^muffle")
[01:29:37.859]                   }
[01:29:37.859]                 }
[01:29:37.859]             }
[01:29:37.859]         }))
[01:29:37.859]     }, error = function(ex) {
[01:29:37.859]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:37.859]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:37.859]                 ...future.rng), started = ...future.startTime, 
[01:29:37.859]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:37.859]             version = "1.8"), class = "FutureResult")
[01:29:37.859]     }, finally = {
[01:29:37.859]         if (!identical(...future.workdir, getwd())) 
[01:29:37.859]             setwd(...future.workdir)
[01:29:37.859]         {
[01:29:37.859]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:37.859]                 ...future.oldOptions$nwarnings <- NULL
[01:29:37.859]             }
[01:29:37.859]             base::options(...future.oldOptions)
[01:29:37.859]             if (.Platform$OS.type == "windows") {
[01:29:37.859]                 old_names <- names(...future.oldEnvVars)
[01:29:37.859]                 envs <- base::Sys.getenv()
[01:29:37.859]                 names <- names(envs)
[01:29:37.859]                 common <- intersect(names, old_names)
[01:29:37.859]                 added <- setdiff(names, old_names)
[01:29:37.859]                 removed <- setdiff(old_names, names)
[01:29:37.859]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:37.859]                   envs[common]]
[01:29:37.859]                 NAMES <- toupper(changed)
[01:29:37.859]                 args <- list()
[01:29:37.859]                 for (kk in seq_along(NAMES)) {
[01:29:37.859]                   name <- changed[[kk]]
[01:29:37.859]                   NAME <- NAMES[[kk]]
[01:29:37.859]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.859]                     next
[01:29:37.859]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.859]                 }
[01:29:37.859]                 NAMES <- toupper(added)
[01:29:37.859]                 for (kk in seq_along(NAMES)) {
[01:29:37.859]                   name <- added[[kk]]
[01:29:37.859]                   NAME <- NAMES[[kk]]
[01:29:37.859]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.859]                     next
[01:29:37.859]                   args[[name]] <- ""
[01:29:37.859]                 }
[01:29:37.859]                 NAMES <- toupper(removed)
[01:29:37.859]                 for (kk in seq_along(NAMES)) {
[01:29:37.859]                   name <- removed[[kk]]
[01:29:37.859]                   NAME <- NAMES[[kk]]
[01:29:37.859]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:37.859]                     next
[01:29:37.859]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:37.859]                 }
[01:29:37.859]                 if (length(args) > 0) 
[01:29:37.859]                   base::do.call(base::Sys.setenv, args = args)
[01:29:37.859]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:37.859]             }
[01:29:37.859]             else {
[01:29:37.859]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:37.859]             }
[01:29:37.859]             {
[01:29:37.859]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:37.859]                   0L) {
[01:29:37.859]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:37.859]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:37.859]                   base::options(opts)
[01:29:37.859]                 }
[01:29:37.859]                 {
[01:29:37.859]                   {
[01:29:37.859]                     NULL
[01:29:37.859]                     RNGkind("Mersenne-Twister")
[01:29:37.859]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:29:37.859]                       inherits = FALSE)
[01:29:37.859]                   }
[01:29:37.859]                   options(future.plan = NULL)
[01:29:37.859]                   if (is.na(NA_character_)) 
[01:29:37.859]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:37.859]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:37.859]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:37.859]                   {
[01:29:37.859]                     future <- SequentialFuture(..., envir = envir)
[01:29:37.859]                     if (!future$lazy) 
[01:29:37.859]                       future <- run(future)
[01:29:37.859]                     invisible(future)
[01:29:37.859]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:37.859]                 }
[01:29:37.859]             }
[01:29:37.859]         }
[01:29:37.859]     })
[01:29:37.859]     if (TRUE) {
[01:29:37.859]         base::sink(type = "output", split = FALSE)
[01:29:37.859]         if (TRUE) {
[01:29:37.859]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:37.859]         }
[01:29:37.859]         else {
[01:29:37.859]             ...future.result["stdout"] <- base::list(NULL)
[01:29:37.859]         }
[01:29:37.859]         base::close(...future.stdout)
[01:29:37.859]         ...future.stdout <- NULL
[01:29:37.859]     }
[01:29:37.859]     ...future.result$conditions <- ...future.conditions
[01:29:37.859]     ...future.result$finished <- base::Sys.time()
[01:29:37.859]     ...future.result
[01:29:37.859] }
[01:29:37.864] plan(): Setting new future strategy stack:
[01:29:37.864] List of future strategies:
[01:29:37.864] 1. sequential:
[01:29:37.864]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.864]    - tweaked: FALSE
[01:29:37.864]    - call: NULL
[01:29:37.864] plan(): nbrOfWorkers() = 1
[01:29:37.865] plan(): Setting new future strategy stack:
[01:29:37.866] List of future strategies:
[01:29:37.866] 1. sequential:
[01:29:37.866]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:37.866]    - tweaked: FALSE
[01:29:37.866]    - call: plan(strategy)
[01:29:37.866] plan(): nbrOfWorkers() = 1
[01:29:37.867] SequentialFuture started (and completed)
[01:29:37.867] - Launch lazy future ... done
[01:29:37.867] run() for 'SequentialFuture' ... done
[1] 42
sequential ... done
Testing with 1 cores ... done
Testing with 2 cores ...
multisession ...
[01:29:37.875] plan(): Setting new future strategy stack:
[01:29:37.875] List of future strategies:
[01:29:37.875] 1. multisession:
[01:29:37.875]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:29:37.875]    - tweaked: FALSE
[01:29:37.875]    - call: plan(strategy)
[01:29:37.875] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[01:29:37.875] multisession:
[01:29:37.875] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:29:37.875] - tweaked: FALSE
[01:29:37.875] - call: plan(strategy)
[01:29:37.880] getGlobalsAndPackages() ...
[01:29:37.881] Not searching for globals
[01:29:37.881] - globals: [0] <none>
[01:29:37.881] getGlobalsAndPackages() ... DONE
[01:29:37.882] [local output] makeClusterPSOCK() ...
[01:29:37.955] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:29:37.962] [local output] Base port: 33965
[01:29:37.962] [local output] Getting setup options for 2 cluster nodes ...
[01:29:37.963] [local output]  - Node 1 of 2 ...
[01:29:37.963] [local output] localMachine=TRUE => revtunnel=FALSE

[01:29:37.965] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpQ1pRaO/worker.rank=1.parallelly.parent=6628.19e41cdd7872.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpQ1pRaO/worker.rank=1.parallelly.parent=6628.19e41cdd7872.pid\")"'
[01:29:38.410] - Possible to infer worker's PID: TRUE
[01:29:38.411] [local output] Rscript port: 33965

[01:29:38.411] [local output]  - Node 2 of 2 ...
[01:29:38.412] [local output] localMachine=TRUE => revtunnel=FALSE

[01:29:38.413] [local output] Rscript port: 33965

[01:29:38.414] [local output] Getting setup options for 2 cluster nodes ... done
[01:29:38.414] [local output]  - Parallel setup requested for some PSOCK nodes
[01:29:38.415] [local output] Setting up PSOCK nodes in parallel
[01:29:38.416] List of 36
[01:29:38.416]  $ worker          : chr "localhost"
[01:29:38.416]   ..- attr(*, "localhost")= logi TRUE
[01:29:38.416]  $ master          : chr "localhost"
[01:29:38.416]  $ port            : int 33965
[01:29:38.416]  $ connectTimeout  : num 120
[01:29:38.416]  $ timeout         : num 120
[01:29:38.416]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:29:38.416]  $ homogeneous     : logi TRUE
[01:29:38.416]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=stdout.R:6628:CRANWIN3:CRAN\" -e"| __truncated__
[01:29:38.416]  $ rscript_envs    : NULL
[01:29:38.416]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:29:38.416]  $ rscript_startup : NULL
[01:29:38.416]  $ rscript_sh      : chr "cmd"
[01:29:38.416]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:29:38.416]  $ methods         : logi TRUE
[01:29:38.416]  $ socketOptions   : chr "no-delay"
[01:29:38.416]  $ useXDR          : logi FALSE
[01:29:38.416]  $ outfile         : chr "/dev/null"
[01:29:38.416]  $ renice          : int NA
[01:29:38.416]  $ rshcmd          : NULL
[01:29:38.416]  $ user            : chr(0) 
[01:29:38.416]  $ revtunnel       : logi FALSE
[01:29:38.416]  $ rshlogfile      : NULL
[01:29:38.416]  $ rshopts         : chr(0) 
[01:29:38.416]  $ rank            : int 1
[01:29:38.416]  $ manual          : logi FALSE
[01:29:38.416]  $ dryrun          : logi FALSE
[01:29:38.416]  $ quiet           : logi FALSE
[01:29:38.416]  $ setup_strategy  : chr "parallel"
[01:29:38.416]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:29:38.416]  $ pidfile         : chr "D:/temp/RtmpQ1pRaO/worker.rank=1.parallelly.parent=6628.19e41cdd7872.pid"
[01:29:38.416]  $ rshcmd_label    : NULL
[01:29:38.416]  $ rsh_call        : NULL
[01:29:38.416]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:29:38.416]  $ localMachine    : logi TRUE
[01:29:38.416]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:29:38.416]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:29:38.416]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:29:38.416]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:29:38.416]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:29:38.416]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:29:38.416]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:29:38.416]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:29:38.416]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:29:38.416]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:29:38.416]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:29:38.416]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:29:38.416]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:29:38.416]  $ arguments       :List of 28
[01:29:38.416]   ..$ worker          : chr "localhost"
[01:29:38.416]   ..$ master          : NULL
[01:29:38.416]   ..$ port            : int 33965
[01:29:38.416]   ..$ connectTimeout  : num 120
[01:29:38.416]   ..$ timeout         : num 120
[01:29:38.416]   ..$ rscript         : NULL
[01:29:38.416]   ..$ homogeneous     : NULL
[01:29:38.416]   ..$ rscript_args    : NULL
[01:29:38.416]   ..$ rscript_envs    : NULL
[01:29:38.416]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:29:38.416]   ..$ rscript_startup : NULL
[01:29:38.416]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:29:38.416]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:29:38.416]   ..$ methods         : logi TRUE
[01:29:38.416]   ..$ socketOptions   : chr "no-delay"
[01:29:38.416]   ..$ useXDR          : logi FALSE
[01:29:38.416]   ..$ outfile         : chr "/dev/null"
[01:29:38.416]   ..$ renice          : int NA
[01:29:38.416]   ..$ rshcmd          : NULL
[01:29:38.416]   ..$ user            : NULL
[01:29:38.416]   ..$ revtunnel       : logi NA
[01:29:38.416]   ..$ rshlogfile      : NULL
[01:29:38.416]   ..$ rshopts         : NULL
[01:29:38.416]   ..$ rank            : int 1
[01:29:38.416]   ..$ manual          : logi FALSE
[01:29:38.416]   ..$ dryrun          : logi FALSE
[01:29:38.416]   ..$ quiet           : logi FALSE
[01:29:38.416]   ..$ setup_strategy  : chr "parallel"
[01:29:38.416]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:29:38.442] [local output] System call to launch all workers:
[01:29:38.442] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=stdout.R:6628:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpQ1pRaO/worker.rank=1.parallelly.parent=6628.19e41cdd7872.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=33965 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:29:38.442] [local output] Starting PSOCK main server
[01:29:38.448] [local output] Workers launched
[01:29:38.448] [local output] Waiting for workers to connect back
[01:29:38.448]  - [local output] 0 workers out of 2 ready
[01:29:38.636]  - [local output] 0 workers out of 2 ready
[01:29:38.636]  - [local output] 1 workers out of 2 ready
[01:29:38.641]  - [local output] 1 workers out of 2 ready
[01:29:38.642]  - [local output] 2 workers out of 2 ready
[01:29:38.642] [local output] Launching of workers completed
[01:29:38.642] [local output] Collecting session information from workers
[01:29:38.643] [local output]  - Worker #1 of 2
[01:29:38.644] [local output]  - Worker #2 of 2
[01:29:38.644] [local output] makeClusterPSOCK() ... done
[01:29:38.657] Packages needed by the future expression (n = 0): <none>
[01:29:38.658] Packages needed by future strategies (n = 0): <none>
[01:29:38.659] {
[01:29:38.659]     {
[01:29:38.659]         {
[01:29:38.659]             ...future.startTime <- base::Sys.time()
[01:29:38.659]             {
[01:29:38.659]                 {
[01:29:38.659]                   {
[01:29:38.659]                     {
[01:29:38.659]                       base::local({
[01:29:38.659]                         has_future <- base::requireNamespace("future", 
[01:29:38.659]                           quietly = TRUE)
[01:29:38.659]                         if (has_future) {
[01:29:38.659]                           ns <- base::getNamespace("future")
[01:29:38.659]                           version <- ns[[".package"]][["version"]]
[01:29:38.659]                           if (is.null(version)) 
[01:29:38.659]                             version <- utils::packageVersion("future")
[01:29:38.659]                         }
[01:29:38.659]                         else {
[01:29:38.659]                           version <- NULL
[01:29:38.659]                         }
[01:29:38.659]                         if (!has_future || version < "1.8.0") {
[01:29:38.659]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:38.659]                             "", base::R.version$version.string), 
[01:29:38.659]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:38.659]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:38.659]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:38.659]                               "release", "version")], collapse = " "), 
[01:29:38.659]                             hostname = base::Sys.info()[["nodename"]])
[01:29:38.659]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:38.659]                             info)
[01:29:38.659]                           info <- base::paste(info, collapse = "; ")
[01:29:38.659]                           if (!has_future) {
[01:29:38.659]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:38.659]                               info)
[01:29:38.659]                           }
[01:29:38.659]                           else {
[01:29:38.659]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:38.659]                               info, version)
[01:29:38.659]                           }
[01:29:38.659]                           base::stop(msg)
[01:29:38.659]                         }
[01:29:38.659]                       })
[01:29:38.659]                     }
[01:29:38.659]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:38.659]                     base::options(mc.cores = 1L)
[01:29:38.659]                   }
[01:29:38.659]                   options(future.plan = NULL)
[01:29:38.659]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:38.659]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:38.659]                 }
[01:29:38.659]                 ...future.workdir <- getwd()
[01:29:38.659]             }
[01:29:38.659]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:38.659]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:38.659]         }
[01:29:38.659]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:38.659]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:38.659]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:38.659]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:38.659]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:38.659]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:38.659]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:38.659]             base::names(...future.oldOptions))
[01:29:38.659]     }
[01:29:38.659]     if (FALSE) {
[01:29:38.659]     }
[01:29:38.659]     else {
[01:29:38.659]         if (TRUE) {
[01:29:38.659]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:38.659]                 open = "w")
[01:29:38.659]         }
[01:29:38.659]         else {
[01:29:38.659]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:38.659]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:38.659]         }
[01:29:38.659]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:38.659]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:38.659]             base::sink(type = "output", split = FALSE)
[01:29:38.659]             base::close(...future.stdout)
[01:29:38.659]         }, add = TRUE)
[01:29:38.659]     }
[01:29:38.659]     ...future.frame <- base::sys.nframe()
[01:29:38.659]     ...future.conditions <- base::list()
[01:29:38.659]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:38.659]     if (FALSE) {
[01:29:38.659]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:38.659]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:38.659]     }
[01:29:38.659]     ...future.result <- base::tryCatch({
[01:29:38.659]         base::withCallingHandlers({
[01:29:38.659]             ...future.value <- base::withVisible(base::local({
[01:29:38.659]                 ...future.makeSendCondition <- base::local({
[01:29:38.659]                   sendCondition <- NULL
[01:29:38.659]                   function(frame = 1L) {
[01:29:38.659]                     if (is.function(sendCondition)) 
[01:29:38.659]                       return(sendCondition)
[01:29:38.659]                     ns <- getNamespace("parallel")
[01:29:38.659]                     if (exists("sendData", mode = "function", 
[01:29:38.659]                       envir = ns)) {
[01:29:38.659]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:38.659]                         envir = ns)
[01:29:38.659]                       envir <- sys.frame(frame)
[01:29:38.659]                       master <- NULL
[01:29:38.659]                       while (!identical(envir, .GlobalEnv) && 
[01:29:38.659]                         !identical(envir, emptyenv())) {
[01:29:38.659]                         if (exists("master", mode = "list", envir = envir, 
[01:29:38.659]                           inherits = FALSE)) {
[01:29:38.659]                           master <- get("master", mode = "list", 
[01:29:38.659]                             envir = envir, inherits = FALSE)
[01:29:38.659]                           if (inherits(master, c("SOCKnode", 
[01:29:38.659]                             "SOCK0node"))) {
[01:29:38.659]                             sendCondition <<- function(cond) {
[01:29:38.659]                               data <- list(type = "VALUE", value = cond, 
[01:29:38.659]                                 success = TRUE)
[01:29:38.659]                               parallel_sendData(master, data)
[01:29:38.659]                             }
[01:29:38.659]                             return(sendCondition)
[01:29:38.659]                           }
[01:29:38.659]                         }
[01:29:38.659]                         frame <- frame + 1L
[01:29:38.659]                         envir <- sys.frame(frame)
[01:29:38.659]                       }
[01:29:38.659]                     }
[01:29:38.659]                     sendCondition <<- function(cond) NULL
[01:29:38.659]                   }
[01:29:38.659]                 })
[01:29:38.659]                 withCallingHandlers({
[01:29:38.659]                   NA
[01:29:38.659]                 }, immediateCondition = function(cond) {
[01:29:38.659]                   sendCondition <- ...future.makeSendCondition()
[01:29:38.659]                   sendCondition(cond)
[01:29:38.659]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:38.659]                   {
[01:29:38.659]                     inherits <- base::inherits
[01:29:38.659]                     invokeRestart <- base::invokeRestart
[01:29:38.659]                     is.null <- base::is.null
[01:29:38.659]                     muffled <- FALSE
[01:29:38.659]                     if (inherits(cond, "message")) {
[01:29:38.659]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:38.659]                       if (muffled) 
[01:29:38.659]                         invokeRestart("muffleMessage")
[01:29:38.659]                     }
[01:29:38.659]                     else if (inherits(cond, "warning")) {
[01:29:38.659]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:38.659]                       if (muffled) 
[01:29:38.659]                         invokeRestart("muffleWarning")
[01:29:38.659]                     }
[01:29:38.659]                     else if (inherits(cond, "condition")) {
[01:29:38.659]                       if (!is.null(pattern)) {
[01:29:38.659]                         computeRestarts <- base::computeRestarts
[01:29:38.659]                         grepl <- base::grepl
[01:29:38.659]                         restarts <- computeRestarts(cond)
[01:29:38.659]                         for (restart in restarts) {
[01:29:38.659]                           name <- restart$name
[01:29:38.659]                           if (is.null(name)) 
[01:29:38.659]                             next
[01:29:38.659]                           if (!grepl(pattern, name)) 
[01:29:38.659]                             next
[01:29:38.659]                           invokeRestart(restart)
[01:29:38.659]                           muffled <- TRUE
[01:29:38.659]                           break
[01:29:38.659]                         }
[01:29:38.659]                       }
[01:29:38.659]                     }
[01:29:38.659]                     invisible(muffled)
[01:29:38.659]                   }
[01:29:38.659]                   muffleCondition(cond)
[01:29:38.659]                 })
[01:29:38.659]             }))
[01:29:38.659]             future::FutureResult(value = ...future.value$value, 
[01:29:38.659]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:38.659]                   ...future.rng), globalenv = if (FALSE) 
[01:29:38.659]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:38.659]                     ...future.globalenv.names))
[01:29:38.659]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:38.659]         }, condition = base::local({
[01:29:38.659]             c <- base::c
[01:29:38.659]             inherits <- base::inherits
[01:29:38.659]             invokeRestart <- base::invokeRestart
[01:29:38.659]             length <- base::length
[01:29:38.659]             list <- base::list
[01:29:38.659]             seq.int <- base::seq.int
[01:29:38.659]             signalCondition <- base::signalCondition
[01:29:38.659]             sys.calls <- base::sys.calls
[01:29:38.659]             `[[` <- base::`[[`
[01:29:38.659]             `+` <- base::`+`
[01:29:38.659]             `<<-` <- base::`<<-`
[01:29:38.659]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:38.659]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:38.659]                   3L)]
[01:29:38.659]             }
[01:29:38.659]             function(cond) {
[01:29:38.659]                 is_error <- inherits(cond, "error")
[01:29:38.659]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:38.659]                   NULL)
[01:29:38.659]                 if (is_error) {
[01:29:38.659]                   sessionInformation <- function() {
[01:29:38.659]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:38.659]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:38.659]                       search = base::search(), system = base::Sys.info())
[01:29:38.659]                   }
[01:29:38.659]                   ...future.conditions[[length(...future.conditions) + 
[01:29:38.659]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:38.659]                     cond$call), session = sessionInformation(), 
[01:29:38.659]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:38.659]                   signalCondition(cond)
[01:29:38.659]                 }
[01:29:38.659]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:38.659]                 "immediateCondition"))) {
[01:29:38.659]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:38.659]                   ...future.conditions[[length(...future.conditions) + 
[01:29:38.659]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:38.659]                   if (TRUE && !signal) {
[01:29:38.659]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:38.659]                     {
[01:29:38.659]                       inherits <- base::inherits
[01:29:38.659]                       invokeRestart <- base::invokeRestart
[01:29:38.659]                       is.null <- base::is.null
[01:29:38.659]                       muffled <- FALSE
[01:29:38.659]                       if (inherits(cond, "message")) {
[01:29:38.659]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:38.659]                         if (muffled) 
[01:29:38.659]                           invokeRestart("muffleMessage")
[01:29:38.659]                       }
[01:29:38.659]                       else if (inherits(cond, "warning")) {
[01:29:38.659]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:38.659]                         if (muffled) 
[01:29:38.659]                           invokeRestart("muffleWarning")
[01:29:38.659]                       }
[01:29:38.659]                       else if (inherits(cond, "condition")) {
[01:29:38.659]                         if (!is.null(pattern)) {
[01:29:38.659]                           computeRestarts <- base::computeRestarts
[01:29:38.659]                           grepl <- base::grepl
[01:29:38.659]                           restarts <- computeRestarts(cond)
[01:29:38.659]                           for (restart in restarts) {
[01:29:38.659]                             name <- restart$name
[01:29:38.659]                             if (is.null(name)) 
[01:29:38.659]                               next
[01:29:38.659]                             if (!grepl(pattern, name)) 
[01:29:38.659]                               next
[01:29:38.659]                             invokeRestart(restart)
[01:29:38.659]                             muffled <- TRUE
[01:29:38.659]                             break
[01:29:38.659]                           }
[01:29:38.659]                         }
[01:29:38.659]                       }
[01:29:38.659]                       invisible(muffled)
[01:29:38.659]                     }
[01:29:38.659]                     muffleCondition(cond, pattern = "^muffle")
[01:29:38.659]                   }
[01:29:38.659]                 }
[01:29:38.659]                 else {
[01:29:38.659]                   if (TRUE) {
[01:29:38.659]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:38.659]                     {
[01:29:38.659]                       inherits <- base::inherits
[01:29:38.659]                       invokeRestart <- base::invokeRestart
[01:29:38.659]                       is.null <- base::is.null
[01:29:38.659]                       muffled <- FALSE
[01:29:38.659]                       if (inherits(cond, "message")) {
[01:29:38.659]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:38.659]                         if (muffled) 
[01:29:38.659]                           invokeRestart("muffleMessage")
[01:29:38.659]                       }
[01:29:38.659]                       else if (inherits(cond, "warning")) {
[01:29:38.659]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:38.659]                         if (muffled) 
[01:29:38.659]                           invokeRestart("muffleWarning")
[01:29:38.659]                       }
[01:29:38.659]                       else if (inherits(cond, "condition")) {
[01:29:38.659]                         if (!is.null(pattern)) {
[01:29:38.659]                           computeRestarts <- base::computeRestarts
[01:29:38.659]                           grepl <- base::grepl
[01:29:38.659]                           restarts <- computeRestarts(cond)
[01:29:38.659]                           for (restart in restarts) {
[01:29:38.659]                             name <- restart$name
[01:29:38.659]                             if (is.null(name)) 
[01:29:38.659]                               next
[01:29:38.659]                             if (!grepl(pattern, name)) 
[01:29:38.659]                               next
[01:29:38.659]                             invokeRestart(restart)
[01:29:38.659]                             muffled <- TRUE
[01:29:38.659]                             break
[01:29:38.659]                           }
[01:29:38.659]                         }
[01:29:38.659]                       }
[01:29:38.659]                       invisible(muffled)
[01:29:38.659]                     }
[01:29:38.659]                     muffleCondition(cond, pattern = "^muffle")
[01:29:38.659]                   }
[01:29:38.659]                 }
[01:29:38.659]             }
[01:29:38.659]         }))
[01:29:38.659]     }, error = function(ex) {
[01:29:38.659]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:38.659]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:38.659]                 ...future.rng), started = ...future.startTime, 
[01:29:38.659]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:38.659]             version = "1.8"), class = "FutureResult")
[01:29:38.659]     }, finally = {
[01:29:38.659]         if (!identical(...future.workdir, getwd())) 
[01:29:38.659]             setwd(...future.workdir)
[01:29:38.659]         {
[01:29:38.659]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:38.659]                 ...future.oldOptions$nwarnings <- NULL
[01:29:38.659]             }
[01:29:38.659]             base::options(...future.oldOptions)
[01:29:38.659]             if (.Platform$OS.type == "windows") {
[01:29:38.659]                 old_names <- names(...future.oldEnvVars)
[01:29:38.659]                 envs <- base::Sys.getenv()
[01:29:38.659]                 names <- names(envs)
[01:29:38.659]                 common <- intersect(names, old_names)
[01:29:38.659]                 added <- setdiff(names, old_names)
[01:29:38.659]                 removed <- setdiff(old_names, names)
[01:29:38.659]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:38.659]                   envs[common]]
[01:29:38.659]                 NAMES <- toupper(changed)
[01:29:38.659]                 args <- list()
[01:29:38.659]                 for (kk in seq_along(NAMES)) {
[01:29:38.659]                   name <- changed[[kk]]
[01:29:38.659]                   NAME <- NAMES[[kk]]
[01:29:38.659]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:38.659]                     next
[01:29:38.659]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:38.659]                 }
[01:29:38.659]                 NAMES <- toupper(added)
[01:29:38.659]                 for (kk in seq_along(NAMES)) {
[01:29:38.659]                   name <- added[[kk]]
[01:29:38.659]                   NAME <- NAMES[[kk]]
[01:29:38.659]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:38.659]                     next
[01:29:38.659]                   args[[name]] <- ""
[01:29:38.659]                 }
[01:29:38.659]                 NAMES <- toupper(removed)
[01:29:38.659]                 for (kk in seq_along(NAMES)) {
[01:29:38.659]                   name <- removed[[kk]]
[01:29:38.659]                   NAME <- NAMES[[kk]]
[01:29:38.659]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:38.659]                     next
[01:29:38.659]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:38.659]                 }
[01:29:38.659]                 if (length(args) > 0) 
[01:29:38.659]                   base::do.call(base::Sys.setenv, args = args)
[01:29:38.659]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:38.659]             }
[01:29:38.659]             else {
[01:29:38.659]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:38.659]             }
[01:29:38.659]             {
[01:29:38.659]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:38.659]                   0L) {
[01:29:38.659]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:38.659]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:38.659]                   base::options(opts)
[01:29:38.659]                 }
[01:29:38.659]                 {
[01:29:38.659]                   {
[01:29:38.659]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:38.659]                     NULL
[01:29:38.659]                   }
[01:29:38.659]                   options(future.plan = NULL)
[01:29:38.659]                   if (is.na(NA_character_)) 
[01:29:38.659]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:38.659]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:38.659]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:38.659]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:38.659]                     envir = parent.frame()) 
[01:29:38.659]                   {
[01:29:38.659]                     if (is.function(workers)) 
[01:29:38.659]                       workers <- workers()
[01:29:38.659]                     workers <- structure(as.integer(workers), 
[01:29:38.659]                       class = class(workers))
[01:29:38.659]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:38.659]                       workers >= 1)
[01:29:38.659]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:38.659]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:38.659]                     }
[01:29:38.659]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:38.659]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:38.659]                       envir = envir)
[01:29:38.659]                     if (!future$lazy) 
[01:29:38.659]                       future <- run(future)
[01:29:38.659]                     invisible(future)
[01:29:38.659]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:38.659]                 }
[01:29:38.659]             }
[01:29:38.659]         }
[01:29:38.659]     })
[01:29:38.659]     if (TRUE) {
[01:29:38.659]         base::sink(type = "output", split = FALSE)
[01:29:38.659]         if (TRUE) {
[01:29:38.659]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:38.659]         }
[01:29:38.659]         else {
[01:29:38.659]             ...future.result["stdout"] <- base::list(NULL)
[01:29:38.659]         }
[01:29:38.659]         base::close(...future.stdout)
[01:29:38.659]         ...future.stdout <- NULL
[01:29:38.659]     }
[01:29:38.659]     ...future.result$conditions <- ...future.conditions
[01:29:38.659]     ...future.result$finished <- base::Sys.time()
[01:29:38.659]     ...future.result
[01:29:38.659] }
[01:29:38.741] MultisessionFuture started
[01:29:38.741] result() for ClusterFuture ...
[01:29:38.742] receiveMessageFromWorker() for ClusterFuture ...
[01:29:38.742] - Validating connection of MultisessionFuture
[01:29:38.799] - received message: FutureResult
[01:29:38.800] - Received FutureResult
[01:29:38.804] - Erased future from FutureRegistry
[01:29:38.804] result() for ClusterFuture ...
[01:29:38.804] - result already collected: FutureResult
[01:29:38.804] result() for ClusterFuture ... done
[01:29:38.804] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:38.805] result() for ClusterFuture ... done
[01:29:38.805] result() for ClusterFuture ...
[01:29:38.805] - result already collected: FutureResult
[01:29:38.805] result() for ClusterFuture ... done
[01:29:38.805] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[01:29:38.808] plan(): nbrOfWorkers() = 2
- stdout = TRUE
[01:29:38.809] getGlobalsAndPackages() ...
[01:29:38.809] Searching for globals...
[01:29:38.814] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[01:29:38.814] Searching for globals ... DONE
[01:29:38.814] Resolving globals: FALSE
[01:29:38.815] 
[01:29:38.815] - packages: [1] 'utils'
[01:29:38.815] getGlobalsAndPackages() ... DONE
[01:29:38.816] run() for 'Future' ...
[01:29:38.816] - state: 'created'
[01:29:38.816] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:38.832] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:38.832] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:38.832]   - Field: 'node'
[01:29:38.832]   - Field: 'label'
[01:29:38.832]   - Field: 'local'
[01:29:38.833]   - Field: 'owner'
[01:29:38.833]   - Field: 'envir'
[01:29:38.833]   - Field: 'workers'
[01:29:38.833]   - Field: 'packages'
[01:29:38.833]   - Field: 'gc'
[01:29:38.834]   - Field: 'conditions'
[01:29:38.834]   - Field: 'persistent'
[01:29:38.834]   - Field: 'expr'
[01:29:38.834]   - Field: 'uuid'
[01:29:38.834]   - Field: 'seed'
[01:29:38.835]   - Field: 'version'
[01:29:38.835]   - Field: 'result'
[01:29:38.835]   - Field: 'asynchronous'
[01:29:38.835]   - Field: 'calls'
[01:29:38.835]   - Field: 'globals'
[01:29:38.836]   - Field: 'stdout'
[01:29:38.836]   - Field: 'earlySignal'
[01:29:38.836]   - Field: 'lazy'
[01:29:38.836]   - Field: 'state'
[01:29:38.836] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:38.837] - Launch lazy future ...
[01:29:38.837] Packages needed by the future expression (n = 1): 'utils'
[01:29:38.837] Packages needed by future strategies (n = 0): <none>
[01:29:38.838] {
[01:29:38.838]     {
[01:29:38.838]         {
[01:29:38.838]             ...future.startTime <- base::Sys.time()
[01:29:38.838]             {
[01:29:38.838]                 {
[01:29:38.838]                   {
[01:29:38.838]                     {
[01:29:38.838]                       {
[01:29:38.838]                         base::local({
[01:29:38.838]                           has_future <- base::requireNamespace("future", 
[01:29:38.838]                             quietly = TRUE)
[01:29:38.838]                           if (has_future) {
[01:29:38.838]                             ns <- base::getNamespace("future")
[01:29:38.838]                             version <- ns[[".package"]][["version"]]
[01:29:38.838]                             if (is.null(version)) 
[01:29:38.838]                               version <- utils::packageVersion("future")
[01:29:38.838]                           }
[01:29:38.838]                           else {
[01:29:38.838]                             version <- NULL
[01:29:38.838]                           }
[01:29:38.838]                           if (!has_future || version < "1.8.0") {
[01:29:38.838]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:38.838]                               "", base::R.version$version.string), 
[01:29:38.838]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:38.838]                                 base::R.version$platform, 8 * 
[01:29:38.838]                                   base::.Machine$sizeof.pointer), 
[01:29:38.838]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:38.838]                                 "release", "version")], collapse = " "), 
[01:29:38.838]                               hostname = base::Sys.info()[["nodename"]])
[01:29:38.838]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:38.838]                               info)
[01:29:38.838]                             info <- base::paste(info, collapse = "; ")
[01:29:38.838]                             if (!has_future) {
[01:29:38.838]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:38.838]                                 info)
[01:29:38.838]                             }
[01:29:38.838]                             else {
[01:29:38.838]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:38.838]                                 info, version)
[01:29:38.838]                             }
[01:29:38.838]                             base::stop(msg)
[01:29:38.838]                           }
[01:29:38.838]                         })
[01:29:38.838]                       }
[01:29:38.838]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:38.838]                       base::options(mc.cores = 1L)
[01:29:38.838]                     }
[01:29:38.838]                     base::local({
[01:29:38.838]                       for (pkg in "utils") {
[01:29:38.838]                         base::loadNamespace(pkg)
[01:29:38.838]                         base::library(pkg, character.only = TRUE)
[01:29:38.838]                       }
[01:29:38.838]                     })
[01:29:38.838]                   }
[01:29:38.838]                   options(future.plan = NULL)
[01:29:38.838]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:38.838]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:38.838]                 }
[01:29:38.838]                 ...future.workdir <- getwd()
[01:29:38.838]             }
[01:29:38.838]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:38.838]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:38.838]         }
[01:29:38.838]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:38.838]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:38.838]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:38.838]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:38.838]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:38.838]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:38.838]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:38.838]             base::names(...future.oldOptions))
[01:29:38.838]     }
[01:29:38.838]     if (FALSE) {
[01:29:38.838]     }
[01:29:38.838]     else {
[01:29:38.838]         if (TRUE) {
[01:29:38.838]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:38.838]                 open = "w")
[01:29:38.838]         }
[01:29:38.838]         else {
[01:29:38.838]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:38.838]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:38.838]         }
[01:29:38.838]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:38.838]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:38.838]             base::sink(type = "output", split = FALSE)
[01:29:38.838]             base::close(...future.stdout)
[01:29:38.838]         }, add = TRUE)
[01:29:38.838]     }
[01:29:38.838]     ...future.frame <- base::sys.nframe()
[01:29:38.838]     ...future.conditions <- base::list()
[01:29:38.838]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:38.838]     if (FALSE) {
[01:29:38.838]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:38.838]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:38.838]     }
[01:29:38.838]     ...future.result <- base::tryCatch({
[01:29:38.838]         base::withCallingHandlers({
[01:29:38.838]             ...future.value <- base::withVisible(base::local({
[01:29:38.838]                 ...future.makeSendCondition <- base::local({
[01:29:38.838]                   sendCondition <- NULL
[01:29:38.838]                   function(frame = 1L) {
[01:29:38.838]                     if (is.function(sendCondition)) 
[01:29:38.838]                       return(sendCondition)
[01:29:38.838]                     ns <- getNamespace("parallel")
[01:29:38.838]                     if (exists("sendData", mode = "function", 
[01:29:38.838]                       envir = ns)) {
[01:29:38.838]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:38.838]                         envir = ns)
[01:29:38.838]                       envir <- sys.frame(frame)
[01:29:38.838]                       master <- NULL
[01:29:38.838]                       while (!identical(envir, .GlobalEnv) && 
[01:29:38.838]                         !identical(envir, emptyenv())) {
[01:29:38.838]                         if (exists("master", mode = "list", envir = envir, 
[01:29:38.838]                           inherits = FALSE)) {
[01:29:38.838]                           master <- get("master", mode = "list", 
[01:29:38.838]                             envir = envir, inherits = FALSE)
[01:29:38.838]                           if (inherits(master, c("SOCKnode", 
[01:29:38.838]                             "SOCK0node"))) {
[01:29:38.838]                             sendCondition <<- function(cond) {
[01:29:38.838]                               data <- list(type = "VALUE", value = cond, 
[01:29:38.838]                                 success = TRUE)
[01:29:38.838]                               parallel_sendData(master, data)
[01:29:38.838]                             }
[01:29:38.838]                             return(sendCondition)
[01:29:38.838]                           }
[01:29:38.838]                         }
[01:29:38.838]                         frame <- frame + 1L
[01:29:38.838]                         envir <- sys.frame(frame)
[01:29:38.838]                       }
[01:29:38.838]                     }
[01:29:38.838]                     sendCondition <<- function(cond) NULL
[01:29:38.838]                   }
[01:29:38.838]                 })
[01:29:38.838]                 withCallingHandlers({
[01:29:38.838]                   {
[01:29:38.838]                     print(1:50)
[01:29:38.838]                     str(1:50)
[01:29:38.838]                     cat(letters, sep = "-")
[01:29:38.838]                     cat(1:6, collapse = "\n")
[01:29:38.838]                     write.table(datasets::iris[1:10, ], sep = "\t")
[01:29:38.838]                     42L
[01:29:38.838]                   }
[01:29:38.838]                 }, immediateCondition = function(cond) {
[01:29:38.838]                   sendCondition <- ...future.makeSendCondition()
[01:29:38.838]                   sendCondition(cond)
[01:29:38.838]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:38.838]                   {
[01:29:38.838]                     inherits <- base::inherits
[01:29:38.838]                     invokeRestart <- base::invokeRestart
[01:29:38.838]                     is.null <- base::is.null
[01:29:38.838]                     muffled <- FALSE
[01:29:38.838]                     if (inherits(cond, "message")) {
[01:29:38.838]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:38.838]                       if (muffled) 
[01:29:38.838]                         invokeRestart("muffleMessage")
[01:29:38.838]                     }
[01:29:38.838]                     else if (inherits(cond, "warning")) {
[01:29:38.838]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:38.838]                       if (muffled) 
[01:29:38.838]                         invokeRestart("muffleWarning")
[01:29:38.838]                     }
[01:29:38.838]                     else if (inherits(cond, "condition")) {
[01:29:38.838]                       if (!is.null(pattern)) {
[01:29:38.838]                         computeRestarts <- base::computeRestarts
[01:29:38.838]                         grepl <- base::grepl
[01:29:38.838]                         restarts <- computeRestarts(cond)
[01:29:38.838]                         for (restart in restarts) {
[01:29:38.838]                           name <- restart$name
[01:29:38.838]                           if (is.null(name)) 
[01:29:38.838]                             next
[01:29:38.838]                           if (!grepl(pattern, name)) 
[01:29:38.838]                             next
[01:29:38.838]                           invokeRestart(restart)
[01:29:38.838]                           muffled <- TRUE
[01:29:38.838]                           break
[01:29:38.838]                         }
[01:29:38.838]                       }
[01:29:38.838]                     }
[01:29:38.838]                     invisible(muffled)
[01:29:38.838]                   }
[01:29:38.838]                   muffleCondition(cond)
[01:29:38.838]                 })
[01:29:38.838]             }))
[01:29:38.838]             future::FutureResult(value = ...future.value$value, 
[01:29:38.838]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:38.838]                   ...future.rng), globalenv = if (FALSE) 
[01:29:38.838]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:38.838]                     ...future.globalenv.names))
[01:29:38.838]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:38.838]         }, condition = base::local({
[01:29:38.838]             c <- base::c
[01:29:38.838]             inherits <- base::inherits
[01:29:38.838]             invokeRestart <- base::invokeRestart
[01:29:38.838]             length <- base::length
[01:29:38.838]             list <- base::list
[01:29:38.838]             seq.int <- base::seq.int
[01:29:38.838]             signalCondition <- base::signalCondition
[01:29:38.838]             sys.calls <- base::sys.calls
[01:29:38.838]             `[[` <- base::`[[`
[01:29:38.838]             `+` <- base::`+`
[01:29:38.838]             `<<-` <- base::`<<-`
[01:29:38.838]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:38.838]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:38.838]                   3L)]
[01:29:38.838]             }
[01:29:38.838]             function(cond) {
[01:29:38.838]                 is_error <- inherits(cond, "error")
[01:29:38.838]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:38.838]                   NULL)
[01:29:38.838]                 if (is_error) {
[01:29:38.838]                   sessionInformation <- function() {
[01:29:38.838]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:38.838]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:38.838]                       search = base::search(), system = base::Sys.info())
[01:29:38.838]                   }
[01:29:38.838]                   ...future.conditions[[length(...future.conditions) + 
[01:29:38.838]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:38.838]                     cond$call), session = sessionInformation(), 
[01:29:38.838]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:38.838]                   signalCondition(cond)
[01:29:38.838]                 }
[01:29:38.838]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:38.838]                 "immediateCondition"))) {
[01:29:38.838]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:38.838]                   ...future.conditions[[length(...future.conditions) + 
[01:29:38.838]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:38.838]                   if (TRUE && !signal) {
[01:29:38.838]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:38.838]                     {
[01:29:38.838]                       inherits <- base::inherits
[01:29:38.838]                       invokeRestart <- base::invokeRestart
[01:29:38.838]                       is.null <- base::is.null
[01:29:38.838]                       muffled <- FALSE
[01:29:38.838]                       if (inherits(cond, "message")) {
[01:29:38.838]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:38.838]                         if (muffled) 
[01:29:38.838]                           invokeRestart("muffleMessage")
[01:29:38.838]                       }
[01:29:38.838]                       else if (inherits(cond, "warning")) {
[01:29:38.838]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:38.838]                         if (muffled) 
[01:29:38.838]                           invokeRestart("muffleWarning")
[01:29:38.838]                       }
[01:29:38.838]                       else if (inherits(cond, "condition")) {
[01:29:38.838]                         if (!is.null(pattern)) {
[01:29:38.838]                           computeRestarts <- base::computeRestarts
[01:29:38.838]                           grepl <- base::grepl
[01:29:38.838]                           restarts <- computeRestarts(cond)
[01:29:38.838]                           for (restart in restarts) {
[01:29:38.838]                             name <- restart$name
[01:29:38.838]                             if (is.null(name)) 
[01:29:38.838]                               next
[01:29:38.838]                             if (!grepl(pattern, name)) 
[01:29:38.838]                               next
[01:29:38.838]                             invokeRestart(restart)
[01:29:38.838]                             muffled <- TRUE
[01:29:38.838]                             break
[01:29:38.838]                           }
[01:29:38.838]                         }
[01:29:38.838]                       }
[01:29:38.838]                       invisible(muffled)
[01:29:38.838]                     }
[01:29:38.838]                     muffleCondition(cond, pattern = "^muffle")
[01:29:38.838]                   }
[01:29:38.838]                 }
[01:29:38.838]                 else {
[01:29:38.838]                   if (TRUE) {
[01:29:38.838]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:38.838]                     {
[01:29:38.838]                       inherits <- base::inherits
[01:29:38.838]                       invokeRestart <- base::invokeRestart
[01:29:38.838]                       is.null <- base::is.null
[01:29:38.838]                       muffled <- FALSE
[01:29:38.838]                       if (inherits(cond, "message")) {
[01:29:38.838]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:38.838]                         if (muffled) 
[01:29:38.838]                           invokeRestart("muffleMessage")
[01:29:38.838]                       }
[01:29:38.838]                       else if (inherits(cond, "warning")) {
[01:29:38.838]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:38.838]                         if (muffled) 
[01:29:38.838]                           invokeRestart("muffleWarning")
[01:29:38.838]                       }
[01:29:38.838]                       else if (inherits(cond, "condition")) {
[01:29:38.838]                         if (!is.null(pattern)) {
[01:29:38.838]                           computeRestarts <- base::computeRestarts
[01:29:38.838]                           grepl <- base::grepl
[01:29:38.838]                           restarts <- computeRestarts(cond)
[01:29:38.838]                           for (restart in restarts) {
[01:29:38.838]                             name <- restart$name
[01:29:38.838]                             if (is.null(name)) 
[01:29:38.838]                               next
[01:29:38.838]                             if (!grepl(pattern, name)) 
[01:29:38.838]                               next
[01:29:38.838]                             invokeRestart(restart)
[01:29:38.838]                             muffled <- TRUE
[01:29:38.838]                             break
[01:29:38.838]                           }
[01:29:38.838]                         }
[01:29:38.838]                       }
[01:29:38.838]                       invisible(muffled)
[01:29:38.838]                     }
[01:29:38.838]                     muffleCondition(cond, pattern = "^muffle")
[01:29:38.838]                   }
[01:29:38.838]                 }
[01:29:38.838]             }
[01:29:38.838]         }))
[01:29:38.838]     }, error = function(ex) {
[01:29:38.838]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:38.838]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:38.838]                 ...future.rng), started = ...future.startTime, 
[01:29:38.838]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:38.838]             version = "1.8"), class = "FutureResult")
[01:29:38.838]     }, finally = {
[01:29:38.838]         if (!identical(...future.workdir, getwd())) 
[01:29:38.838]             setwd(...future.workdir)
[01:29:38.838]         {
[01:29:38.838]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:38.838]                 ...future.oldOptions$nwarnings <- NULL
[01:29:38.838]             }
[01:29:38.838]             base::options(...future.oldOptions)
[01:29:38.838]             if (.Platform$OS.type == "windows") {
[01:29:38.838]                 old_names <- names(...future.oldEnvVars)
[01:29:38.838]                 envs <- base::Sys.getenv()
[01:29:38.838]                 names <- names(envs)
[01:29:38.838]                 common <- intersect(names, old_names)
[01:29:38.838]                 added <- setdiff(names, old_names)
[01:29:38.838]                 removed <- setdiff(old_names, names)
[01:29:38.838]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:38.838]                   envs[common]]
[01:29:38.838]                 NAMES <- toupper(changed)
[01:29:38.838]                 args <- list()
[01:29:38.838]                 for (kk in seq_along(NAMES)) {
[01:29:38.838]                   name <- changed[[kk]]
[01:29:38.838]                   NAME <- NAMES[[kk]]
[01:29:38.838]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:38.838]                     next
[01:29:38.838]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:38.838]                 }
[01:29:38.838]                 NAMES <- toupper(added)
[01:29:38.838]                 for (kk in seq_along(NAMES)) {
[01:29:38.838]                   name <- added[[kk]]
[01:29:38.838]                   NAME <- NAMES[[kk]]
[01:29:38.838]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:38.838]                     next
[01:29:38.838]                   args[[name]] <- ""
[01:29:38.838]                 }
[01:29:38.838]                 NAMES <- toupper(removed)
[01:29:38.838]                 for (kk in seq_along(NAMES)) {
[01:29:38.838]                   name <- removed[[kk]]
[01:29:38.838]                   NAME <- NAMES[[kk]]
[01:29:38.838]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:38.838]                     next
[01:29:38.838]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:38.838]                 }
[01:29:38.838]                 if (length(args) > 0) 
[01:29:38.838]                   base::do.call(base::Sys.setenv, args = args)
[01:29:38.838]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:38.838]             }
[01:29:38.838]             else {
[01:29:38.838]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:38.838]             }
[01:29:38.838]             {
[01:29:38.838]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:38.838]                   0L) {
[01:29:38.838]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:38.838]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:38.838]                   base::options(opts)
[01:29:38.838]                 }
[01:29:38.838]                 {
[01:29:38.838]                   {
[01:29:38.838]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:38.838]                     NULL
[01:29:38.838]                   }
[01:29:38.838]                   options(future.plan = NULL)
[01:29:38.838]                   if (is.na(NA_character_)) 
[01:29:38.838]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:38.838]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:38.838]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:38.838]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:38.838]                     envir = parent.frame()) 
[01:29:38.838]                   {
[01:29:38.838]                     if (is.function(workers)) 
[01:29:38.838]                       workers <- workers()
[01:29:38.838]                     workers <- structure(as.integer(workers), 
[01:29:38.838]                       class = class(workers))
[01:29:38.838]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:38.838]                       workers >= 1)
[01:29:38.838]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:38.838]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:38.838]                     }
[01:29:38.838]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:38.838]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:38.838]                       envir = envir)
[01:29:38.838]                     if (!future$lazy) 
[01:29:38.838]                       future <- run(future)
[01:29:38.838]                     invisible(future)
[01:29:38.838]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:38.838]                 }
[01:29:38.838]             }
[01:29:38.838]         }
[01:29:38.838]     })
[01:29:38.838]     if (TRUE) {
[01:29:38.838]         base::sink(type = "output", split = FALSE)
[01:29:38.838]         if (TRUE) {
[01:29:38.838]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:38.838]         }
[01:29:38.838]         else {
[01:29:38.838]             ...future.result["stdout"] <- base::list(NULL)
[01:29:38.838]         }
[01:29:38.838]         base::close(...future.stdout)
[01:29:38.838]         ...future.stdout <- NULL
[01:29:38.838]     }
[01:29:38.838]     ...future.result$conditions <- ...future.conditions
[01:29:38.838]     ...future.result$finished <- base::Sys.time()
[01:29:38.838]     ...future.result
[01:29:38.838] }
[01:29:38.844] MultisessionFuture started
[01:29:38.845] - Launch lazy future ... done
[01:29:38.845] run() for 'MultisessionFuture' ... done
[01:29:38.845] result() for ClusterFuture ...
[01:29:38.845] receiveMessageFromWorker() for ClusterFuture ...
[01:29:38.845] - Validating connection of MultisessionFuture
[01:29:38.867] - received message: FutureResult
[01:29:38.867] - Received FutureResult
[01:29:38.867] - Erased future from FutureRegistry
[01:29:38.867] result() for ClusterFuture ...
[01:29:38.867] - result already collected: FutureResult
[01:29:38.868] result() for ClusterFuture ... done
[01:29:38.868] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:38.868] result() for ClusterFuture ... done
List of 11
 $ value       : int 42
 $ visible     : logi TRUE
 $ stdout      : chr " [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 3"| __truncated__
 $ conditions  : list()
 $ rng         : logi FALSE
 $ globalenv   : NULL
 $ started     : POSIXct[1:1], format: "2023-12-22 01:29:38"
 $ finished    : POSIXct[1:1], format: "2023-12-22 01:29:38"
 $ session_uuid: chr "05f91763-b12d-ded6-9d80-c3ce459b1113"
  ..- attr(*, "source")=List of 5
  .. ..$ host  : Named chr "CRANWIN3"
  .. .. ..- attr(*, "names")= chr "COMPUTERNAME"
  .. ..$ info  : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...
  .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...
  .. ..$ pid   : int 3264
  .. ..$ time  : POSIXct[1:1], format: "2023-12-22 01:29:38"
  .. ..$ random: int 2147483647
 $ r_info      :List of 4
  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1
  .. ..$ : int [1:3] 4 4 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[01:29:38.880] result() for ClusterFuture ...
[01:29:38.880] - result already collected: FutureResult
[01:29:38.880] result() for ClusterFuture ... done
[01:29:38.880] result() for ClusterFuture ...
[01:29:38.880] - result already collected: FutureResult
[01:29:38.880] result() for ClusterFuture ... done
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
 int [1:50] 1 2 3 4 5 6 7 8 9 10 ...
a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 
"Sepal.Length"	"Sepal.Width"	"Petal.Length"	"Petal.Width"	"Species"
"1"	5.1	3.5	1.4	0.2	"setosa"
"2"	4.9	3	1.4	0.2	"setosa"
"3"	4.7	3.2	1.3	0.2	"setosa"
"4"	4.6	3.1	1.5	0.2	"setosa"
"5"	5	3.6	1.4	0.2	"setosa"
"6"	5.4	3.9	1.7	0.4	"setosa"
"7"	4.6	3.4	1.4	0.3	"setosa"
"8"	5	3.4	1.5	0.2	"setosa"
"9"	4.4	2.9	1.4	0.2	"setosa"
"10"	4.9	3.1	1.5	0.1	"setosa"
FutureResult:
value: 'integer'
visible: TRUE
stdout: character
conditions: [n = 0] 
RNG used: FALSE
duration: 0.02191997 secs (started 2023-12-22 01:29:38.84487)
version: 1.8
[01:29:38.881] getGlobalsAndPackages() ...
[01:29:38.882] Searching for globals...
[01:29:38.886] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[01:29:38.887] Searching for globals ... DONE
[01:29:38.887] Resolving globals: FALSE
[01:29:38.887] 
[01:29:38.888] - packages: [1] 'utils'
[01:29:38.888] getGlobalsAndPackages() ... DONE
[01:29:38.888] run() for 'Future' ...
[01:29:38.889] - state: 'created'
[01:29:38.889] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:38.904] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:38.905] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:38.905]   - Field: 'node'
[01:29:38.905]   - Field: 'label'
[01:29:38.905]   - Field: 'local'
[01:29:38.906]   - Field: 'owner'
[01:29:38.906]   - Field: 'envir'
[01:29:38.906]   - Field: 'workers'
[01:29:38.906]   - Field: 'packages'
[01:29:38.906]   - Field: 'gc'
[01:29:38.907]   - Field: 'conditions'
[01:29:38.907]   - Field: 'persistent'
[01:29:38.907]   - Field: 'expr'
[01:29:38.907]   - Field: 'uuid'
[01:29:38.907]   - Field: 'seed'
[01:29:38.908]   - Field: 'version'
[01:29:38.908]   - Field: 'result'
[01:29:38.908]   - Field: 'asynchronous'
[01:29:38.908]   - Field: 'calls'
[01:29:38.909]   - Field: 'globals'
[01:29:38.909]   - Field: 'stdout'
[01:29:38.909]   - Field: 'earlySignal'
[01:29:38.909]   - Field: 'lazy'
[01:29:38.910]   - Field: 'state'
[01:29:38.910] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:38.910] - Launch lazy future ...
[01:29:38.911] Packages needed by the future expression (n = 1): 'utils'
[01:29:38.911] Packages needed by future strategies (n = 0): <none>
[01:29:38.912] {
[01:29:38.912]     {
[01:29:38.912]         {
[01:29:38.912]             ...future.startTime <- base::Sys.time()
[01:29:38.912]             {
[01:29:38.912]                 {
[01:29:38.912]                   {
[01:29:38.912]                     {
[01:29:38.912]                       {
[01:29:38.912]                         base::local({
[01:29:38.912]                           has_future <- base::requireNamespace("future", 
[01:29:38.912]                             quietly = TRUE)
[01:29:38.912]                           if (has_future) {
[01:29:38.912]                             ns <- base::getNamespace("future")
[01:29:38.912]                             version <- ns[[".package"]][["version"]]
[01:29:38.912]                             if (is.null(version)) 
[01:29:38.912]                               version <- utils::packageVersion("future")
[01:29:38.912]                           }
[01:29:38.912]                           else {
[01:29:38.912]                             version <- NULL
[01:29:38.912]                           }
[01:29:38.912]                           if (!has_future || version < "1.8.0") {
[01:29:38.912]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:38.912]                               "", base::R.version$version.string), 
[01:29:38.912]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:38.912]                                 base::R.version$platform, 8 * 
[01:29:38.912]                                   base::.Machine$sizeof.pointer), 
[01:29:38.912]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:38.912]                                 "release", "version")], collapse = " "), 
[01:29:38.912]                               hostname = base::Sys.info()[["nodename"]])
[01:29:38.912]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:38.912]                               info)
[01:29:38.912]                             info <- base::paste(info, collapse = "; ")
[01:29:38.912]                             if (!has_future) {
[01:29:38.912]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:38.912]                                 info)
[01:29:38.912]                             }
[01:29:38.912]                             else {
[01:29:38.912]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:38.912]                                 info, version)
[01:29:38.912]                             }
[01:29:38.912]                             base::stop(msg)
[01:29:38.912]                           }
[01:29:38.912]                         })
[01:29:38.912]                       }
[01:29:38.912]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:38.912]                       base::options(mc.cores = 1L)
[01:29:38.912]                     }
[01:29:38.912]                     base::local({
[01:29:38.912]                       for (pkg in "utils") {
[01:29:38.912]                         base::loadNamespace(pkg)
[01:29:38.912]                         base::library(pkg, character.only = TRUE)
[01:29:38.912]                       }
[01:29:38.912]                     })
[01:29:38.912]                   }
[01:29:38.912]                   options(future.plan = NULL)
[01:29:38.912]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:38.912]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:38.912]                 }
[01:29:38.912]                 ...future.workdir <- getwd()
[01:29:38.912]             }
[01:29:38.912]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:38.912]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:38.912]         }
[01:29:38.912]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:38.912]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:38.912]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:38.912]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:38.912]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:38.912]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:38.912]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:38.912]             base::names(...future.oldOptions))
[01:29:38.912]     }
[01:29:38.912]     if (FALSE) {
[01:29:38.912]     }
[01:29:38.912]     else {
[01:29:38.912]         if (TRUE) {
[01:29:38.912]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:38.912]                 open = "w")
[01:29:38.912]         }
[01:29:38.912]         else {
[01:29:38.912]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:38.912]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:38.912]         }
[01:29:38.912]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:38.912]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:38.912]             base::sink(type = "output", split = FALSE)
[01:29:38.912]             base::close(...future.stdout)
[01:29:38.912]         }, add = TRUE)
[01:29:38.912]     }
[01:29:38.912]     ...future.frame <- base::sys.nframe()
[01:29:38.912]     ...future.conditions <- base::list()
[01:29:38.912]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:38.912]     if (FALSE) {
[01:29:38.912]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:38.912]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:38.912]     }
[01:29:38.912]     ...future.result <- base::tryCatch({
[01:29:38.912]         base::withCallingHandlers({
[01:29:38.912]             ...future.value <- base::withVisible(base::local({
[01:29:38.912]                 ...future.makeSendCondition <- base::local({
[01:29:38.912]                   sendCondition <- NULL
[01:29:38.912]                   function(frame = 1L) {
[01:29:38.912]                     if (is.function(sendCondition)) 
[01:29:38.912]                       return(sendCondition)
[01:29:38.912]                     ns <- getNamespace("parallel")
[01:29:38.912]                     if (exists("sendData", mode = "function", 
[01:29:38.912]                       envir = ns)) {
[01:29:38.912]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:38.912]                         envir = ns)
[01:29:38.912]                       envir <- sys.frame(frame)
[01:29:38.912]                       master <- NULL
[01:29:38.912]                       while (!identical(envir, .GlobalEnv) && 
[01:29:38.912]                         !identical(envir, emptyenv())) {
[01:29:38.912]                         if (exists("master", mode = "list", envir = envir, 
[01:29:38.912]                           inherits = FALSE)) {
[01:29:38.912]                           master <- get("master", mode = "list", 
[01:29:38.912]                             envir = envir, inherits = FALSE)
[01:29:38.912]                           if (inherits(master, c("SOCKnode", 
[01:29:38.912]                             "SOCK0node"))) {
[01:29:38.912]                             sendCondition <<- function(cond) {
[01:29:38.912]                               data <- list(type = "VALUE", value = cond, 
[01:29:38.912]                                 success = TRUE)
[01:29:38.912]                               parallel_sendData(master, data)
[01:29:38.912]                             }
[01:29:38.912]                             return(sendCondition)
[01:29:38.912]                           }
[01:29:38.912]                         }
[01:29:38.912]                         frame <- frame + 1L
[01:29:38.912]                         envir <- sys.frame(frame)
[01:29:38.912]                       }
[01:29:38.912]                     }
[01:29:38.912]                     sendCondition <<- function(cond) NULL
[01:29:38.912]                   }
[01:29:38.912]                 })
[01:29:38.912]                 withCallingHandlers({
[01:29:38.912]                   {
[01:29:38.912]                     print(1:50)
[01:29:38.912]                     str(1:50)
[01:29:38.912]                     cat(letters, sep = "-")
[01:29:38.912]                     cat(1:6, collapse = "\n")
[01:29:38.912]                     write.table(datasets::iris[1:10, ], sep = "\t")
[01:29:38.912]                     42L
[01:29:38.912]                   }
[01:29:38.912]                 }, immediateCondition = function(cond) {
[01:29:38.912]                   sendCondition <- ...future.makeSendCondition()
[01:29:38.912]                   sendCondition(cond)
[01:29:38.912]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:38.912]                   {
[01:29:38.912]                     inherits <- base::inherits
[01:29:38.912]                     invokeRestart <- base::invokeRestart
[01:29:38.912]                     is.null <- base::is.null
[01:29:38.912]                     muffled <- FALSE
[01:29:38.912]                     if (inherits(cond, "message")) {
[01:29:38.912]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:38.912]                       if (muffled) 
[01:29:38.912]                         invokeRestart("muffleMessage")
[01:29:38.912]                     }
[01:29:38.912]                     else if (inherits(cond, "warning")) {
[01:29:38.912]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:38.912]                       if (muffled) 
[01:29:38.912]                         invokeRestart("muffleWarning")
[01:29:38.912]                     }
[01:29:38.912]                     else if (inherits(cond, "condition")) {
[01:29:38.912]                       if (!is.null(pattern)) {
[01:29:38.912]                         computeRestarts <- base::computeRestarts
[01:29:38.912]                         grepl <- base::grepl
[01:29:38.912]                         restarts <- computeRestarts(cond)
[01:29:38.912]                         for (restart in restarts) {
[01:29:38.912]                           name <- restart$name
[01:29:38.912]                           if (is.null(name)) 
[01:29:38.912]                             next
[01:29:38.912]                           if (!grepl(pattern, name)) 
[01:29:38.912]                             next
[01:29:38.912]                           invokeRestart(restart)
[01:29:38.912]                           muffled <- TRUE
[01:29:38.912]                           break
[01:29:38.912]                         }
[01:29:38.912]                       }
[01:29:38.912]                     }
[01:29:38.912]                     invisible(muffled)
[01:29:38.912]                   }
[01:29:38.912]                   muffleCondition(cond)
[01:29:38.912]                 })
[01:29:38.912]             }))
[01:29:38.912]             future::FutureResult(value = ...future.value$value, 
[01:29:38.912]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:38.912]                   ...future.rng), globalenv = if (FALSE) 
[01:29:38.912]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:38.912]                     ...future.globalenv.names))
[01:29:38.912]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:38.912]         }, condition = base::local({
[01:29:38.912]             c <- base::c
[01:29:38.912]             inherits <- base::inherits
[01:29:38.912]             invokeRestart <- base::invokeRestart
[01:29:38.912]             length <- base::length
[01:29:38.912]             list <- base::list
[01:29:38.912]             seq.int <- base::seq.int
[01:29:38.912]             signalCondition <- base::signalCondition
[01:29:38.912]             sys.calls <- base::sys.calls
[01:29:38.912]             `[[` <- base::`[[`
[01:29:38.912]             `+` <- base::`+`
[01:29:38.912]             `<<-` <- base::`<<-`
[01:29:38.912]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:38.912]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:38.912]                   3L)]
[01:29:38.912]             }
[01:29:38.912]             function(cond) {
[01:29:38.912]                 is_error <- inherits(cond, "error")
[01:29:38.912]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:38.912]                   NULL)
[01:29:38.912]                 if (is_error) {
[01:29:38.912]                   sessionInformation <- function() {
[01:29:38.912]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:38.912]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:38.912]                       search = base::search(), system = base::Sys.info())
[01:29:38.912]                   }
[01:29:38.912]                   ...future.conditions[[length(...future.conditions) + 
[01:29:38.912]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:38.912]                     cond$call), session = sessionInformation(), 
[01:29:38.912]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:38.912]                   signalCondition(cond)
[01:29:38.912]                 }
[01:29:38.912]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:38.912]                 "immediateCondition"))) {
[01:29:38.912]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:38.912]                   ...future.conditions[[length(...future.conditions) + 
[01:29:38.912]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:38.912]                   if (TRUE && !signal) {
[01:29:38.912]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:38.912]                     {
[01:29:38.912]                       inherits <- base::inherits
[01:29:38.912]                       invokeRestart <- base::invokeRestart
[01:29:38.912]                       is.null <- base::is.null
[01:29:38.912]                       muffled <- FALSE
[01:29:38.912]                       if (inherits(cond, "message")) {
[01:29:38.912]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:38.912]                         if (muffled) 
[01:29:38.912]                           invokeRestart("muffleMessage")
[01:29:38.912]                       }
[01:29:38.912]                       else if (inherits(cond, "warning")) {
[01:29:38.912]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:38.912]                         if (muffled) 
[01:29:38.912]                           invokeRestart("muffleWarning")
[01:29:38.912]                       }
[01:29:38.912]                       else if (inherits(cond, "condition")) {
[01:29:38.912]                         if (!is.null(pattern)) {
[01:29:38.912]                           computeRestarts <- base::computeRestarts
[01:29:38.912]                           grepl <- base::grepl
[01:29:38.912]                           restarts <- computeRestarts(cond)
[01:29:38.912]                           for (restart in restarts) {
[01:29:38.912]                             name <- restart$name
[01:29:38.912]                             if (is.null(name)) 
[01:29:38.912]                               next
[01:29:38.912]                             if (!grepl(pattern, name)) 
[01:29:38.912]                               next
[01:29:38.912]                             invokeRestart(restart)
[01:29:38.912]                             muffled <- TRUE
[01:29:38.912]                             break
[01:29:38.912]                           }
[01:29:38.912]                         }
[01:29:38.912]                       }
[01:29:38.912]                       invisible(muffled)
[01:29:38.912]                     }
[01:29:38.912]                     muffleCondition(cond, pattern = "^muffle")
[01:29:38.912]                   }
[01:29:38.912]                 }
[01:29:38.912]                 else {
[01:29:38.912]                   if (TRUE) {
[01:29:38.912]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:38.912]                     {
[01:29:38.912]                       inherits <- base::inherits
[01:29:38.912]                       invokeRestart <- base::invokeRestart
[01:29:38.912]                       is.null <- base::is.null
[01:29:38.912]                       muffled <- FALSE
[01:29:38.912]                       if (inherits(cond, "message")) {
[01:29:38.912]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:38.912]                         if (muffled) 
[01:29:38.912]                           invokeRestart("muffleMessage")
[01:29:38.912]                       }
[01:29:38.912]                       else if (inherits(cond, "warning")) {
[01:29:38.912]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:38.912]                         if (muffled) 
[01:29:38.912]                           invokeRestart("muffleWarning")
[01:29:38.912]                       }
[01:29:38.912]                       else if (inherits(cond, "condition")) {
[01:29:38.912]                         if (!is.null(pattern)) {
[01:29:38.912]                           computeRestarts <- base::computeRestarts
[01:29:38.912]                           grepl <- base::grepl
[01:29:38.912]                           restarts <- computeRestarts(cond)
[01:29:38.912]                           for (restart in restarts) {
[01:29:38.912]                             name <- restart$name
[01:29:38.912]                             if (is.null(name)) 
[01:29:38.912]                               next
[01:29:38.912]                             if (!grepl(pattern, name)) 
[01:29:38.912]                               next
[01:29:38.912]                             invokeRestart(restart)
[01:29:38.912]                             muffled <- TRUE
[01:29:38.912]                             break
[01:29:38.912]                           }
[01:29:38.912]                         }
[01:29:38.912]                       }
[01:29:38.912]                       invisible(muffled)
[01:29:38.912]                     }
[01:29:38.912]                     muffleCondition(cond, pattern = "^muffle")
[01:29:38.912]                   }
[01:29:38.912]                 }
[01:29:38.912]             }
[01:29:38.912]         }))
[01:29:38.912]     }, error = function(ex) {
[01:29:38.912]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:38.912]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:38.912]                 ...future.rng), started = ...future.startTime, 
[01:29:38.912]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:38.912]             version = "1.8"), class = "FutureResult")
[01:29:38.912]     }, finally = {
[01:29:38.912]         if (!identical(...future.workdir, getwd())) 
[01:29:38.912]             setwd(...future.workdir)
[01:29:38.912]         {
[01:29:38.912]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:38.912]                 ...future.oldOptions$nwarnings <- NULL
[01:29:38.912]             }
[01:29:38.912]             base::options(...future.oldOptions)
[01:29:38.912]             if (.Platform$OS.type == "windows") {
[01:29:38.912]                 old_names <- names(...future.oldEnvVars)
[01:29:38.912]                 envs <- base::Sys.getenv()
[01:29:38.912]                 names <- names(envs)
[01:29:38.912]                 common <- intersect(names, old_names)
[01:29:38.912]                 added <- setdiff(names, old_names)
[01:29:38.912]                 removed <- setdiff(old_names, names)
[01:29:38.912]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:38.912]                   envs[common]]
[01:29:38.912]                 NAMES <- toupper(changed)
[01:29:38.912]                 args <- list()
[01:29:38.912]                 for (kk in seq_along(NAMES)) {
[01:29:38.912]                   name <- changed[[kk]]
[01:29:38.912]                   NAME <- NAMES[[kk]]
[01:29:38.912]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:38.912]                     next
[01:29:38.912]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:38.912]                 }
[01:29:38.912]                 NAMES <- toupper(added)
[01:29:38.912]                 for (kk in seq_along(NAMES)) {
[01:29:38.912]                   name <- added[[kk]]
[01:29:38.912]                   NAME <- NAMES[[kk]]
[01:29:38.912]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:38.912]                     next
[01:29:38.912]                   args[[name]] <- ""
[01:29:38.912]                 }
[01:29:38.912]                 NAMES <- toupper(removed)
[01:29:38.912]                 for (kk in seq_along(NAMES)) {
[01:29:38.912]                   name <- removed[[kk]]
[01:29:38.912]                   NAME <- NAMES[[kk]]
[01:29:38.912]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:38.912]                     next
[01:29:38.912]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:38.912]                 }
[01:29:38.912]                 if (length(args) > 0) 
[01:29:38.912]                   base::do.call(base::Sys.setenv, args = args)
[01:29:38.912]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:38.912]             }
[01:29:38.912]             else {
[01:29:38.912]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:38.912]             }
[01:29:38.912]             {
[01:29:38.912]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:38.912]                   0L) {
[01:29:38.912]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:38.912]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:38.912]                   base::options(opts)
[01:29:38.912]                 }
[01:29:38.912]                 {
[01:29:38.912]                   {
[01:29:38.912]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:38.912]                     NULL
[01:29:38.912]                   }
[01:29:38.912]                   options(future.plan = NULL)
[01:29:38.912]                   if (is.na(NA_character_)) 
[01:29:38.912]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:38.912]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:38.912]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:38.912]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:38.912]                     envir = parent.frame()) 
[01:29:38.912]                   {
[01:29:38.912]                     if (is.function(workers)) 
[01:29:38.912]                       workers <- workers()
[01:29:38.912]                     workers <- structure(as.integer(workers), 
[01:29:38.912]                       class = class(workers))
[01:29:38.912]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:38.912]                       workers >= 1)
[01:29:38.912]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:38.912]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:38.912]                     }
[01:29:38.912]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:38.912]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:38.912]                       envir = envir)
[01:29:38.912]                     if (!future$lazy) 
[01:29:38.912]                       future <- run(future)
[01:29:38.912]                     invisible(future)
[01:29:38.912]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:38.912]                 }
[01:29:38.912]             }
[01:29:38.912]         }
[01:29:38.912]     })
[01:29:38.912]     if (TRUE) {
[01:29:38.912]         base::sink(type = "output", split = FALSE)
[01:29:38.912]         if (TRUE) {
[01:29:38.912]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:38.912]         }
[01:29:38.912]         else {
[01:29:38.912]             ...future.result["stdout"] <- base::list(NULL)
[01:29:38.912]         }
[01:29:38.912]         base::close(...future.stdout)
[01:29:38.912]         ...future.stdout <- NULL
[01:29:38.912]     }
[01:29:38.912]     ...future.result$conditions <- ...future.conditions
[01:29:38.912]     ...future.result$finished <- base::Sys.time()
[01:29:38.912]     ...future.result
[01:29:38.912] }
[01:29:38.921] MultisessionFuture started
[01:29:38.921] - Launch lazy future ... done
[01:29:38.921] run() for 'MultisessionFuture' ... done
[01:29:38.921] result() for ClusterFuture ...
[01:29:38.922] receiveMessageFromWorker() for ClusterFuture ...
[01:29:38.922] - Validating connection of MultisessionFuture
[01:29:38.938] - received message: FutureResult
[01:29:38.938] - Received FutureResult
[01:29:38.938] - Erased future from FutureRegistry
[01:29:38.939] result() for ClusterFuture ...
[01:29:38.939] - result already collected: FutureResult
[01:29:38.939] result() for ClusterFuture ... done
[01:29:38.939] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:38.939] result() for ClusterFuture ... done
[01:29:38.939] result() for ClusterFuture ...
[01:29:38.940] - result already collected: FutureResult
[01:29:38.940] result() for ClusterFuture ... done
 [1] " [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25"  
 [2] "[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50"  
 [3] " int [1:50] 1 2 3 4 5 6 7 8 9 10 ..."                                             
 [4] "a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 "                  
 [5] "\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\""
 [6] "\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\""                                            
 [7] "\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\""                                              
 [8] "\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\""                                            
 [9] "\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\""                                            
[10] "\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\""                                              
[11] "\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\""                                            
[12] "\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\""                                            
[13] "\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\""                                              
[14] "\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\""                                            
[15] "\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\""                                           
- stdout = structure(TRUE, drop = TRUE)
[01:29:38.940] getGlobalsAndPackages() ...
[01:29:38.941] Searching for globals...
[01:29:38.941] - globals found: [1] 'print'
[01:29:38.942] Searching for globals ... DONE
[01:29:38.942] Resolving globals: FALSE
[01:29:38.942] 
[01:29:38.942] 
[01:29:38.943] getGlobalsAndPackages() ... DONE
[01:29:38.943] run() for 'Future' ...
[01:29:38.943] - state: 'created'
[01:29:38.943] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:38.958] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:38.958] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:38.958]   - Field: 'node'
[01:29:38.958]   - Field: 'label'
[01:29:38.959]   - Field: 'local'
[01:29:38.959]   - Field: 'owner'
[01:29:38.959]   - Field: 'envir'
[01:29:38.960]   - Field: 'workers'
[01:29:38.960]   - Field: 'packages'
[01:29:38.960]   - Field: 'gc'
[01:29:38.960]   - Field: 'conditions'
[01:29:38.961]   - Field: 'persistent'
[01:29:38.961]   - Field: 'expr'
[01:29:38.961]   - Field: 'uuid'
[01:29:38.962]   - Field: 'seed'
[01:29:38.962]   - Field: 'version'
[01:29:38.962]   - Field: 'result'
[01:29:38.962]   - Field: 'asynchronous'
[01:29:38.963]   - Field: 'calls'
[01:29:38.963]   - Field: 'globals'
[01:29:38.963]   - Field: 'stdout'
[01:29:38.964]   - Field: 'earlySignal'
[01:29:38.964]   - Field: 'lazy'
[01:29:38.964]   - Field: 'state'
[01:29:38.964] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:38.965] - Launch lazy future ...
[01:29:38.965] Packages needed by the future expression (n = 0): <none>
[01:29:38.965] Packages needed by future strategies (n = 0): <none>
[01:29:38.966] {
[01:29:38.966]     {
[01:29:38.966]         {
[01:29:38.966]             ...future.startTime <- base::Sys.time()
[01:29:38.966]             {
[01:29:38.966]                 {
[01:29:38.966]                   {
[01:29:38.966]                     {
[01:29:38.966]                       base::local({
[01:29:38.966]                         has_future <- base::requireNamespace("future", 
[01:29:38.966]                           quietly = TRUE)
[01:29:38.966]                         if (has_future) {
[01:29:38.966]                           ns <- base::getNamespace("future")
[01:29:38.966]                           version <- ns[[".package"]][["version"]]
[01:29:38.966]                           if (is.null(version)) 
[01:29:38.966]                             version <- utils::packageVersion("future")
[01:29:38.966]                         }
[01:29:38.966]                         else {
[01:29:38.966]                           version <- NULL
[01:29:38.966]                         }
[01:29:38.966]                         if (!has_future || version < "1.8.0") {
[01:29:38.966]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:38.966]                             "", base::R.version$version.string), 
[01:29:38.966]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:38.966]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:38.966]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:38.966]                               "release", "version")], collapse = " "), 
[01:29:38.966]                             hostname = base::Sys.info()[["nodename"]])
[01:29:38.966]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:38.966]                             info)
[01:29:38.966]                           info <- base::paste(info, collapse = "; ")
[01:29:38.966]                           if (!has_future) {
[01:29:38.966]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:38.966]                               info)
[01:29:38.966]                           }
[01:29:38.966]                           else {
[01:29:38.966]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:38.966]                               info, version)
[01:29:38.966]                           }
[01:29:38.966]                           base::stop(msg)
[01:29:38.966]                         }
[01:29:38.966]                       })
[01:29:38.966]                     }
[01:29:38.966]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:38.966]                     base::options(mc.cores = 1L)
[01:29:38.966]                   }
[01:29:38.966]                   options(future.plan = NULL)
[01:29:38.966]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:38.966]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:38.966]                 }
[01:29:38.966]                 ...future.workdir <- getwd()
[01:29:38.966]             }
[01:29:38.966]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:38.966]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:38.966]         }
[01:29:38.966]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:38.966]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:38.966]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:38.966]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:38.966]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:38.966]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:38.966]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:38.966]             base::names(...future.oldOptions))
[01:29:38.966]     }
[01:29:38.966]     if (FALSE) {
[01:29:38.966]     }
[01:29:38.966]     else {
[01:29:38.966]         if (TRUE) {
[01:29:38.966]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:38.966]                 open = "w")
[01:29:38.966]         }
[01:29:38.966]         else {
[01:29:38.966]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:38.966]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:38.966]         }
[01:29:38.966]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:38.966]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:38.966]             base::sink(type = "output", split = FALSE)
[01:29:38.966]             base::close(...future.stdout)
[01:29:38.966]         }, add = TRUE)
[01:29:38.966]     }
[01:29:38.966]     ...future.frame <- base::sys.nframe()
[01:29:38.966]     ...future.conditions <- base::list()
[01:29:38.966]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:38.966]     if (FALSE) {
[01:29:38.966]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:38.966]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:38.966]     }
[01:29:38.966]     ...future.result <- base::tryCatch({
[01:29:38.966]         base::withCallingHandlers({
[01:29:38.966]             ...future.value <- base::withVisible(base::local({
[01:29:38.966]                 ...future.makeSendCondition <- base::local({
[01:29:38.966]                   sendCondition <- NULL
[01:29:38.966]                   function(frame = 1L) {
[01:29:38.966]                     if (is.function(sendCondition)) 
[01:29:38.966]                       return(sendCondition)
[01:29:38.966]                     ns <- getNamespace("parallel")
[01:29:38.966]                     if (exists("sendData", mode = "function", 
[01:29:38.966]                       envir = ns)) {
[01:29:38.966]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:38.966]                         envir = ns)
[01:29:38.966]                       envir <- sys.frame(frame)
[01:29:38.966]                       master <- NULL
[01:29:38.966]                       while (!identical(envir, .GlobalEnv) && 
[01:29:38.966]                         !identical(envir, emptyenv())) {
[01:29:38.966]                         if (exists("master", mode = "list", envir = envir, 
[01:29:38.966]                           inherits = FALSE)) {
[01:29:38.966]                           master <- get("master", mode = "list", 
[01:29:38.966]                             envir = envir, inherits = FALSE)
[01:29:38.966]                           if (inherits(master, c("SOCKnode", 
[01:29:38.966]                             "SOCK0node"))) {
[01:29:38.966]                             sendCondition <<- function(cond) {
[01:29:38.966]                               data <- list(type = "VALUE", value = cond, 
[01:29:38.966]                                 success = TRUE)
[01:29:38.966]                               parallel_sendData(master, data)
[01:29:38.966]                             }
[01:29:38.966]                             return(sendCondition)
[01:29:38.966]                           }
[01:29:38.966]                         }
[01:29:38.966]                         frame <- frame + 1L
[01:29:38.966]                         envir <- sys.frame(frame)
[01:29:38.966]                       }
[01:29:38.966]                     }
[01:29:38.966]                     sendCondition <<- function(cond) NULL
[01:29:38.966]                   }
[01:29:38.966]                 })
[01:29:38.966]                 withCallingHandlers({
[01:29:38.966]                   print(42)
[01:29:38.966]                 }, immediateCondition = function(cond) {
[01:29:38.966]                   sendCondition <- ...future.makeSendCondition()
[01:29:38.966]                   sendCondition(cond)
[01:29:38.966]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:38.966]                   {
[01:29:38.966]                     inherits <- base::inherits
[01:29:38.966]                     invokeRestart <- base::invokeRestart
[01:29:38.966]                     is.null <- base::is.null
[01:29:38.966]                     muffled <- FALSE
[01:29:38.966]                     if (inherits(cond, "message")) {
[01:29:38.966]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:38.966]                       if (muffled) 
[01:29:38.966]                         invokeRestart("muffleMessage")
[01:29:38.966]                     }
[01:29:38.966]                     else if (inherits(cond, "warning")) {
[01:29:38.966]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:38.966]                       if (muffled) 
[01:29:38.966]                         invokeRestart("muffleWarning")
[01:29:38.966]                     }
[01:29:38.966]                     else if (inherits(cond, "condition")) {
[01:29:38.966]                       if (!is.null(pattern)) {
[01:29:38.966]                         computeRestarts <- base::computeRestarts
[01:29:38.966]                         grepl <- base::grepl
[01:29:38.966]                         restarts <- computeRestarts(cond)
[01:29:38.966]                         for (restart in restarts) {
[01:29:38.966]                           name <- restart$name
[01:29:38.966]                           if (is.null(name)) 
[01:29:38.966]                             next
[01:29:38.966]                           if (!grepl(pattern, name)) 
[01:29:38.966]                             next
[01:29:38.966]                           invokeRestart(restart)
[01:29:38.966]                           muffled <- TRUE
[01:29:38.966]                           break
[01:29:38.966]                         }
[01:29:38.966]                       }
[01:29:38.966]                     }
[01:29:38.966]                     invisible(muffled)
[01:29:38.966]                   }
[01:29:38.966]                   muffleCondition(cond)
[01:29:38.966]                 })
[01:29:38.966]             }))
[01:29:38.966]             future::FutureResult(value = ...future.value$value, 
[01:29:38.966]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:38.966]                   ...future.rng), globalenv = if (FALSE) 
[01:29:38.966]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:38.966]                     ...future.globalenv.names))
[01:29:38.966]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:38.966]         }, condition = base::local({
[01:29:38.966]             c <- base::c
[01:29:38.966]             inherits <- base::inherits
[01:29:38.966]             invokeRestart <- base::invokeRestart
[01:29:38.966]             length <- base::length
[01:29:38.966]             list <- base::list
[01:29:38.966]             seq.int <- base::seq.int
[01:29:38.966]             signalCondition <- base::signalCondition
[01:29:38.966]             sys.calls <- base::sys.calls
[01:29:38.966]             `[[` <- base::`[[`
[01:29:38.966]             `+` <- base::`+`
[01:29:38.966]             `<<-` <- base::`<<-`
[01:29:38.966]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:38.966]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:38.966]                   3L)]
[01:29:38.966]             }
[01:29:38.966]             function(cond) {
[01:29:38.966]                 is_error <- inherits(cond, "error")
[01:29:38.966]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:38.966]                   NULL)
[01:29:38.966]                 if (is_error) {
[01:29:38.966]                   sessionInformation <- function() {
[01:29:38.966]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:38.966]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:38.966]                       search = base::search(), system = base::Sys.info())
[01:29:38.966]                   }
[01:29:38.966]                   ...future.conditions[[length(...future.conditions) + 
[01:29:38.966]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:38.966]                     cond$call), session = sessionInformation(), 
[01:29:38.966]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:38.966]                   signalCondition(cond)
[01:29:38.966]                 }
[01:29:38.966]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:38.966]                 "immediateCondition"))) {
[01:29:38.966]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:38.966]                   ...future.conditions[[length(...future.conditions) + 
[01:29:38.966]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:38.966]                   if (TRUE && !signal) {
[01:29:38.966]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:38.966]                     {
[01:29:38.966]                       inherits <- base::inherits
[01:29:38.966]                       invokeRestart <- base::invokeRestart
[01:29:38.966]                       is.null <- base::is.null
[01:29:38.966]                       muffled <- FALSE
[01:29:38.966]                       if (inherits(cond, "message")) {
[01:29:38.966]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:38.966]                         if (muffled) 
[01:29:38.966]                           invokeRestart("muffleMessage")
[01:29:38.966]                       }
[01:29:38.966]                       else if (inherits(cond, "warning")) {
[01:29:38.966]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:38.966]                         if (muffled) 
[01:29:38.966]                           invokeRestart("muffleWarning")
[01:29:38.966]                       }
[01:29:38.966]                       else if (inherits(cond, "condition")) {
[01:29:38.966]                         if (!is.null(pattern)) {
[01:29:38.966]                           computeRestarts <- base::computeRestarts
[01:29:38.966]                           grepl <- base::grepl
[01:29:38.966]                           restarts <- computeRestarts(cond)
[01:29:38.966]                           for (restart in restarts) {
[01:29:38.966]                             name <- restart$name
[01:29:38.966]                             if (is.null(name)) 
[01:29:38.966]                               next
[01:29:38.966]                             if (!grepl(pattern, name)) 
[01:29:38.966]                               next
[01:29:38.966]                             invokeRestart(restart)
[01:29:38.966]                             muffled <- TRUE
[01:29:38.966]                             break
[01:29:38.966]                           }
[01:29:38.966]                         }
[01:29:38.966]                       }
[01:29:38.966]                       invisible(muffled)
[01:29:38.966]                     }
[01:29:38.966]                     muffleCondition(cond, pattern = "^muffle")
[01:29:38.966]                   }
[01:29:38.966]                 }
[01:29:38.966]                 else {
[01:29:38.966]                   if (TRUE) {
[01:29:38.966]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:38.966]                     {
[01:29:38.966]                       inherits <- base::inherits
[01:29:38.966]                       invokeRestart <- base::invokeRestart
[01:29:38.966]                       is.null <- base::is.null
[01:29:38.966]                       muffled <- FALSE
[01:29:38.966]                       if (inherits(cond, "message")) {
[01:29:38.966]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:38.966]                         if (muffled) 
[01:29:38.966]                           invokeRestart("muffleMessage")
[01:29:38.966]                       }
[01:29:38.966]                       else if (inherits(cond, "warning")) {
[01:29:38.966]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:38.966]                         if (muffled) 
[01:29:38.966]                           invokeRestart("muffleWarning")
[01:29:38.966]                       }
[01:29:38.966]                       else if (inherits(cond, "condition")) {
[01:29:38.966]                         if (!is.null(pattern)) {
[01:29:38.966]                           computeRestarts <- base::computeRestarts
[01:29:38.966]                           grepl <- base::grepl
[01:29:38.966]                           restarts <- computeRestarts(cond)
[01:29:38.966]                           for (restart in restarts) {
[01:29:38.966]                             name <- restart$name
[01:29:38.966]                             if (is.null(name)) 
[01:29:38.966]                               next
[01:29:38.966]                             if (!grepl(pattern, name)) 
[01:29:38.966]                               next
[01:29:38.966]                             invokeRestart(restart)
[01:29:38.966]                             muffled <- TRUE
[01:29:38.966]                             break
[01:29:38.966]                           }
[01:29:38.966]                         }
[01:29:38.966]                       }
[01:29:38.966]                       invisible(muffled)
[01:29:38.966]                     }
[01:29:38.966]                     muffleCondition(cond, pattern = "^muffle")
[01:29:38.966]                   }
[01:29:38.966]                 }
[01:29:38.966]             }
[01:29:38.966]         }))
[01:29:38.966]     }, error = function(ex) {
[01:29:38.966]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:38.966]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:38.966]                 ...future.rng), started = ...future.startTime, 
[01:29:38.966]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:38.966]             version = "1.8"), class = "FutureResult")
[01:29:38.966]     }, finally = {
[01:29:38.966]         if (!identical(...future.workdir, getwd())) 
[01:29:38.966]             setwd(...future.workdir)
[01:29:38.966]         {
[01:29:38.966]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:38.966]                 ...future.oldOptions$nwarnings <- NULL
[01:29:38.966]             }
[01:29:38.966]             base::options(...future.oldOptions)
[01:29:38.966]             if (.Platform$OS.type == "windows") {
[01:29:38.966]                 old_names <- names(...future.oldEnvVars)
[01:29:38.966]                 envs <- base::Sys.getenv()
[01:29:38.966]                 names <- names(envs)
[01:29:38.966]                 common <- intersect(names, old_names)
[01:29:38.966]                 added <- setdiff(names, old_names)
[01:29:38.966]                 removed <- setdiff(old_names, names)
[01:29:38.966]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:38.966]                   envs[common]]
[01:29:38.966]                 NAMES <- toupper(changed)
[01:29:38.966]                 args <- list()
[01:29:38.966]                 for (kk in seq_along(NAMES)) {
[01:29:38.966]                   name <- changed[[kk]]
[01:29:38.966]                   NAME <- NAMES[[kk]]
[01:29:38.966]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:38.966]                     next
[01:29:38.966]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:38.966]                 }
[01:29:38.966]                 NAMES <- toupper(added)
[01:29:38.966]                 for (kk in seq_along(NAMES)) {
[01:29:38.966]                   name <- added[[kk]]
[01:29:38.966]                   NAME <- NAMES[[kk]]
[01:29:38.966]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:38.966]                     next
[01:29:38.966]                   args[[name]] <- ""
[01:29:38.966]                 }
[01:29:38.966]                 NAMES <- toupper(removed)
[01:29:38.966]                 for (kk in seq_along(NAMES)) {
[01:29:38.966]                   name <- removed[[kk]]
[01:29:38.966]                   NAME <- NAMES[[kk]]
[01:29:38.966]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:38.966]                     next
[01:29:38.966]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:38.966]                 }
[01:29:38.966]                 if (length(args) > 0) 
[01:29:38.966]                   base::do.call(base::Sys.setenv, args = args)
[01:29:38.966]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:38.966]             }
[01:29:38.966]             else {
[01:29:38.966]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:38.966]             }
[01:29:38.966]             {
[01:29:38.966]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:38.966]                   0L) {
[01:29:38.966]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:38.966]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:38.966]                   base::options(opts)
[01:29:38.966]                 }
[01:29:38.966]                 {
[01:29:38.966]                   {
[01:29:38.966]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:38.966]                     NULL
[01:29:38.966]                   }
[01:29:38.966]                   options(future.plan = NULL)
[01:29:38.966]                   if (is.na(NA_character_)) 
[01:29:38.966]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:38.966]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:38.966]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:38.966]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:38.966]                     envir = parent.frame()) 
[01:29:38.966]                   {
[01:29:38.966]                     if (is.function(workers)) 
[01:29:38.966]                       workers <- workers()
[01:29:38.966]                     workers <- structure(as.integer(workers), 
[01:29:38.966]                       class = class(workers))
[01:29:38.966]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:38.966]                       workers >= 1)
[01:29:38.966]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:38.966]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:38.966]                     }
[01:29:38.966]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:38.966]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:38.966]                       envir = envir)
[01:29:38.966]                     if (!future$lazy) 
[01:29:38.966]                       future <- run(future)
[01:29:38.966]                     invisible(future)
[01:29:38.966]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:38.966]                 }
[01:29:38.966]             }
[01:29:38.966]         }
[01:29:38.966]     })
[01:29:38.966]     if (TRUE) {
[01:29:38.966]         base::sink(type = "output", split = FALSE)
[01:29:38.966]         if (TRUE) {
[01:29:38.966]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:38.966]         }
[01:29:38.966]         else {
[01:29:38.966]             ...future.result["stdout"] <- base::list(NULL)
[01:29:38.966]         }
[01:29:38.966]         base::close(...future.stdout)
[01:29:38.966]         ...future.stdout <- NULL
[01:29:38.966]     }
[01:29:38.966]     ...future.result$conditions <- ...future.conditions
[01:29:38.966]     ...future.result$finished <- base::Sys.time()
[01:29:38.966]     ...future.result
[01:29:38.966] }
[01:29:38.975] MultisessionFuture started
[01:29:38.976] - Launch lazy future ... done
[01:29:38.976] run() for 'MultisessionFuture' ... done
[01:29:38.976] result() for ClusterFuture ...
[01:29:38.976] receiveMessageFromWorker() for ClusterFuture ...
[01:29:38.976] - Validating connection of MultisessionFuture
[01:29:38.992] - received message: FutureResult
[01:29:38.992] - Received FutureResult
[01:29:38.992] - Erased future from FutureRegistry
[01:29:38.992] result() for ClusterFuture ...
[01:29:38.993] - result already collected: FutureResult
[01:29:38.993] result() for ClusterFuture ... done
[01:29:38.993] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:38.993] result() for ClusterFuture ... done
[01:29:38.994] result() for ClusterFuture ...
[01:29:38.994] - result already collected: FutureResult
[01:29:38.994] result() for ClusterFuture ... done
[01:29:38.994] result() for ClusterFuture ...
[01:29:38.994] - result already collected: FutureResult
[01:29:38.995] result() for ClusterFuture ... done
[1] 42
[01:29:38.995] result() for ClusterFuture ...
[01:29:38.995] - result already collected: FutureResult
[01:29:38.995] result() for ClusterFuture ... done
- stdout = FALSE
[01:29:38.996] getGlobalsAndPackages() ...
[01:29:38.996] Searching for globals...
[01:29:39.001] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[01:29:39.001] Searching for globals ... DONE
[01:29:39.001] Resolving globals: FALSE
[01:29:39.002] 
[01:29:39.002] - packages: [1] 'utils'
[01:29:39.003] getGlobalsAndPackages() ... DONE
[01:29:39.003] run() for 'Future' ...
[01:29:39.004] - state: 'created'
[01:29:39.004] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:39.019] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:39.020] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:39.020]   - Field: 'node'
[01:29:39.020]   - Field: 'label'
[01:29:39.020]   - Field: 'local'
[01:29:39.020]   - Field: 'owner'
[01:29:39.021]   - Field: 'envir'
[01:29:39.021]   - Field: 'workers'
[01:29:39.021]   - Field: 'packages'
[01:29:39.021]   - Field: 'gc'
[01:29:39.021]   - Field: 'conditions'
[01:29:39.021]   - Field: 'persistent'
[01:29:39.022]   - Field: 'expr'
[01:29:39.022]   - Field: 'uuid'
[01:29:39.022]   - Field: 'seed'
[01:29:39.022]   - Field: 'version'
[01:29:39.022]   - Field: 'result'
[01:29:39.023]   - Field: 'asynchronous'
[01:29:39.023]   - Field: 'calls'
[01:29:39.023]   - Field: 'globals'
[01:29:39.023]   - Field: 'stdout'
[01:29:39.023]   - Field: 'earlySignal'
[01:29:39.023]   - Field: 'lazy'
[01:29:39.024]   - Field: 'state'
[01:29:39.024] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:39.024] - Launch lazy future ...
[01:29:39.024] Packages needed by the future expression (n = 1): 'utils'
[01:29:39.025] Packages needed by future strategies (n = 0): <none>
[01:29:39.025] {
[01:29:39.025]     {
[01:29:39.025]         {
[01:29:39.025]             ...future.startTime <- base::Sys.time()
[01:29:39.025]             {
[01:29:39.025]                 {
[01:29:39.025]                   {
[01:29:39.025]                     {
[01:29:39.025]                       {
[01:29:39.025]                         base::local({
[01:29:39.025]                           has_future <- base::requireNamespace("future", 
[01:29:39.025]                             quietly = TRUE)
[01:29:39.025]                           if (has_future) {
[01:29:39.025]                             ns <- base::getNamespace("future")
[01:29:39.025]                             version <- ns[[".package"]][["version"]]
[01:29:39.025]                             if (is.null(version)) 
[01:29:39.025]                               version <- utils::packageVersion("future")
[01:29:39.025]                           }
[01:29:39.025]                           else {
[01:29:39.025]                             version <- NULL
[01:29:39.025]                           }
[01:29:39.025]                           if (!has_future || version < "1.8.0") {
[01:29:39.025]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:39.025]                               "", base::R.version$version.string), 
[01:29:39.025]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:39.025]                                 base::R.version$platform, 8 * 
[01:29:39.025]                                   base::.Machine$sizeof.pointer), 
[01:29:39.025]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:39.025]                                 "release", "version")], collapse = " "), 
[01:29:39.025]                               hostname = base::Sys.info()[["nodename"]])
[01:29:39.025]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:39.025]                               info)
[01:29:39.025]                             info <- base::paste(info, collapse = "; ")
[01:29:39.025]                             if (!has_future) {
[01:29:39.025]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:39.025]                                 info)
[01:29:39.025]                             }
[01:29:39.025]                             else {
[01:29:39.025]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:39.025]                                 info, version)
[01:29:39.025]                             }
[01:29:39.025]                             base::stop(msg)
[01:29:39.025]                           }
[01:29:39.025]                         })
[01:29:39.025]                       }
[01:29:39.025]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:39.025]                       base::options(mc.cores = 1L)
[01:29:39.025]                     }
[01:29:39.025]                     base::local({
[01:29:39.025]                       for (pkg in "utils") {
[01:29:39.025]                         base::loadNamespace(pkg)
[01:29:39.025]                         base::library(pkg, character.only = TRUE)
[01:29:39.025]                       }
[01:29:39.025]                     })
[01:29:39.025]                   }
[01:29:39.025]                   options(future.plan = NULL)
[01:29:39.025]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:39.025]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:39.025]                 }
[01:29:39.025]                 ...future.workdir <- getwd()
[01:29:39.025]             }
[01:29:39.025]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:39.025]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:39.025]         }
[01:29:39.025]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:39.025]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:39.025]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:39.025]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:39.025]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:39.025]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:39.025]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:39.025]             base::names(...future.oldOptions))
[01:29:39.025]     }
[01:29:39.025]     if (FALSE) {
[01:29:39.025]     }
[01:29:39.025]     else {
[01:29:39.025]         if (FALSE) {
[01:29:39.025]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:39.025]                 open = "w")
[01:29:39.025]         }
[01:29:39.025]         else {
[01:29:39.025]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:39.025]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:39.025]         }
[01:29:39.025]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:39.025]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:39.025]             base::sink(type = "output", split = FALSE)
[01:29:39.025]             base::close(...future.stdout)
[01:29:39.025]         }, add = TRUE)
[01:29:39.025]     }
[01:29:39.025]     ...future.frame <- base::sys.nframe()
[01:29:39.025]     ...future.conditions <- base::list()
[01:29:39.025]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:39.025]     if (FALSE) {
[01:29:39.025]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:39.025]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:39.025]     }
[01:29:39.025]     ...future.result <- base::tryCatch({
[01:29:39.025]         base::withCallingHandlers({
[01:29:39.025]             ...future.value <- base::withVisible(base::local({
[01:29:39.025]                 ...future.makeSendCondition <- base::local({
[01:29:39.025]                   sendCondition <- NULL
[01:29:39.025]                   function(frame = 1L) {
[01:29:39.025]                     if (is.function(sendCondition)) 
[01:29:39.025]                       return(sendCondition)
[01:29:39.025]                     ns <- getNamespace("parallel")
[01:29:39.025]                     if (exists("sendData", mode = "function", 
[01:29:39.025]                       envir = ns)) {
[01:29:39.025]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:39.025]                         envir = ns)
[01:29:39.025]                       envir <- sys.frame(frame)
[01:29:39.025]                       master <- NULL
[01:29:39.025]                       while (!identical(envir, .GlobalEnv) && 
[01:29:39.025]                         !identical(envir, emptyenv())) {
[01:29:39.025]                         if (exists("master", mode = "list", envir = envir, 
[01:29:39.025]                           inherits = FALSE)) {
[01:29:39.025]                           master <- get("master", mode = "list", 
[01:29:39.025]                             envir = envir, inherits = FALSE)
[01:29:39.025]                           if (inherits(master, c("SOCKnode", 
[01:29:39.025]                             "SOCK0node"))) {
[01:29:39.025]                             sendCondition <<- function(cond) {
[01:29:39.025]                               data <- list(type = "VALUE", value = cond, 
[01:29:39.025]                                 success = TRUE)
[01:29:39.025]                               parallel_sendData(master, data)
[01:29:39.025]                             }
[01:29:39.025]                             return(sendCondition)
[01:29:39.025]                           }
[01:29:39.025]                         }
[01:29:39.025]                         frame <- frame + 1L
[01:29:39.025]                         envir <- sys.frame(frame)
[01:29:39.025]                       }
[01:29:39.025]                     }
[01:29:39.025]                     sendCondition <<- function(cond) NULL
[01:29:39.025]                   }
[01:29:39.025]                 })
[01:29:39.025]                 withCallingHandlers({
[01:29:39.025]                   {
[01:29:39.025]                     print(1:50)
[01:29:39.025]                     str(1:50)
[01:29:39.025]                     cat(letters, sep = "-")
[01:29:39.025]                     cat(1:6, collapse = "\n")
[01:29:39.025]                     write.table(datasets::iris[1:10, ], sep = "\t")
[01:29:39.025]                     42L
[01:29:39.025]                   }
[01:29:39.025]                 }, immediateCondition = function(cond) {
[01:29:39.025]                   sendCondition <- ...future.makeSendCondition()
[01:29:39.025]                   sendCondition(cond)
[01:29:39.025]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.025]                   {
[01:29:39.025]                     inherits <- base::inherits
[01:29:39.025]                     invokeRestart <- base::invokeRestart
[01:29:39.025]                     is.null <- base::is.null
[01:29:39.025]                     muffled <- FALSE
[01:29:39.025]                     if (inherits(cond, "message")) {
[01:29:39.025]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:39.025]                       if (muffled) 
[01:29:39.025]                         invokeRestart("muffleMessage")
[01:29:39.025]                     }
[01:29:39.025]                     else if (inherits(cond, "warning")) {
[01:29:39.025]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:39.025]                       if (muffled) 
[01:29:39.025]                         invokeRestart("muffleWarning")
[01:29:39.025]                     }
[01:29:39.025]                     else if (inherits(cond, "condition")) {
[01:29:39.025]                       if (!is.null(pattern)) {
[01:29:39.025]                         computeRestarts <- base::computeRestarts
[01:29:39.025]                         grepl <- base::grepl
[01:29:39.025]                         restarts <- computeRestarts(cond)
[01:29:39.025]                         for (restart in restarts) {
[01:29:39.025]                           name <- restart$name
[01:29:39.025]                           if (is.null(name)) 
[01:29:39.025]                             next
[01:29:39.025]                           if (!grepl(pattern, name)) 
[01:29:39.025]                             next
[01:29:39.025]                           invokeRestart(restart)
[01:29:39.025]                           muffled <- TRUE
[01:29:39.025]                           break
[01:29:39.025]                         }
[01:29:39.025]                       }
[01:29:39.025]                     }
[01:29:39.025]                     invisible(muffled)
[01:29:39.025]                   }
[01:29:39.025]                   muffleCondition(cond)
[01:29:39.025]                 })
[01:29:39.025]             }))
[01:29:39.025]             future::FutureResult(value = ...future.value$value, 
[01:29:39.025]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:39.025]                   ...future.rng), globalenv = if (FALSE) 
[01:29:39.025]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:39.025]                     ...future.globalenv.names))
[01:29:39.025]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:39.025]         }, condition = base::local({
[01:29:39.025]             c <- base::c
[01:29:39.025]             inherits <- base::inherits
[01:29:39.025]             invokeRestart <- base::invokeRestart
[01:29:39.025]             length <- base::length
[01:29:39.025]             list <- base::list
[01:29:39.025]             seq.int <- base::seq.int
[01:29:39.025]             signalCondition <- base::signalCondition
[01:29:39.025]             sys.calls <- base::sys.calls
[01:29:39.025]             `[[` <- base::`[[`
[01:29:39.025]             `+` <- base::`+`
[01:29:39.025]             `<<-` <- base::`<<-`
[01:29:39.025]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:39.025]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:39.025]                   3L)]
[01:29:39.025]             }
[01:29:39.025]             function(cond) {
[01:29:39.025]                 is_error <- inherits(cond, "error")
[01:29:39.025]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:39.025]                   NULL)
[01:29:39.025]                 if (is_error) {
[01:29:39.025]                   sessionInformation <- function() {
[01:29:39.025]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:39.025]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:39.025]                       search = base::search(), system = base::Sys.info())
[01:29:39.025]                   }
[01:29:39.025]                   ...future.conditions[[length(...future.conditions) + 
[01:29:39.025]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:39.025]                     cond$call), session = sessionInformation(), 
[01:29:39.025]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:39.025]                   signalCondition(cond)
[01:29:39.025]                 }
[01:29:39.025]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:39.025]                 "immediateCondition"))) {
[01:29:39.025]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:39.025]                   ...future.conditions[[length(...future.conditions) + 
[01:29:39.025]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:39.025]                   if (TRUE && !signal) {
[01:29:39.025]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.025]                     {
[01:29:39.025]                       inherits <- base::inherits
[01:29:39.025]                       invokeRestart <- base::invokeRestart
[01:29:39.025]                       is.null <- base::is.null
[01:29:39.025]                       muffled <- FALSE
[01:29:39.025]                       if (inherits(cond, "message")) {
[01:29:39.025]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:39.025]                         if (muffled) 
[01:29:39.025]                           invokeRestart("muffleMessage")
[01:29:39.025]                       }
[01:29:39.025]                       else if (inherits(cond, "warning")) {
[01:29:39.025]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:39.025]                         if (muffled) 
[01:29:39.025]                           invokeRestart("muffleWarning")
[01:29:39.025]                       }
[01:29:39.025]                       else if (inherits(cond, "condition")) {
[01:29:39.025]                         if (!is.null(pattern)) {
[01:29:39.025]                           computeRestarts <- base::computeRestarts
[01:29:39.025]                           grepl <- base::grepl
[01:29:39.025]                           restarts <- computeRestarts(cond)
[01:29:39.025]                           for (restart in restarts) {
[01:29:39.025]                             name <- restart$name
[01:29:39.025]                             if (is.null(name)) 
[01:29:39.025]                               next
[01:29:39.025]                             if (!grepl(pattern, name)) 
[01:29:39.025]                               next
[01:29:39.025]                             invokeRestart(restart)
[01:29:39.025]                             muffled <- TRUE
[01:29:39.025]                             break
[01:29:39.025]                           }
[01:29:39.025]                         }
[01:29:39.025]                       }
[01:29:39.025]                       invisible(muffled)
[01:29:39.025]                     }
[01:29:39.025]                     muffleCondition(cond, pattern = "^muffle")
[01:29:39.025]                   }
[01:29:39.025]                 }
[01:29:39.025]                 else {
[01:29:39.025]                   if (TRUE) {
[01:29:39.025]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.025]                     {
[01:29:39.025]                       inherits <- base::inherits
[01:29:39.025]                       invokeRestart <- base::invokeRestart
[01:29:39.025]                       is.null <- base::is.null
[01:29:39.025]                       muffled <- FALSE
[01:29:39.025]                       if (inherits(cond, "message")) {
[01:29:39.025]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:39.025]                         if (muffled) 
[01:29:39.025]                           invokeRestart("muffleMessage")
[01:29:39.025]                       }
[01:29:39.025]                       else if (inherits(cond, "warning")) {
[01:29:39.025]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:39.025]                         if (muffled) 
[01:29:39.025]                           invokeRestart("muffleWarning")
[01:29:39.025]                       }
[01:29:39.025]                       else if (inherits(cond, "condition")) {
[01:29:39.025]                         if (!is.null(pattern)) {
[01:29:39.025]                           computeRestarts <- base::computeRestarts
[01:29:39.025]                           grepl <- base::grepl
[01:29:39.025]                           restarts <- computeRestarts(cond)
[01:29:39.025]                           for (restart in restarts) {
[01:29:39.025]                             name <- restart$name
[01:29:39.025]                             if (is.null(name)) 
[01:29:39.025]                               next
[01:29:39.025]                             if (!grepl(pattern, name)) 
[01:29:39.025]                               next
[01:29:39.025]                             invokeRestart(restart)
[01:29:39.025]                             muffled <- TRUE
[01:29:39.025]                             break
[01:29:39.025]                           }
[01:29:39.025]                         }
[01:29:39.025]                       }
[01:29:39.025]                       invisible(muffled)
[01:29:39.025]                     }
[01:29:39.025]                     muffleCondition(cond, pattern = "^muffle")
[01:29:39.025]                   }
[01:29:39.025]                 }
[01:29:39.025]             }
[01:29:39.025]         }))
[01:29:39.025]     }, error = function(ex) {
[01:29:39.025]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:39.025]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:39.025]                 ...future.rng), started = ...future.startTime, 
[01:29:39.025]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:39.025]             version = "1.8"), class = "FutureResult")
[01:29:39.025]     }, finally = {
[01:29:39.025]         if (!identical(...future.workdir, getwd())) 
[01:29:39.025]             setwd(...future.workdir)
[01:29:39.025]         {
[01:29:39.025]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:39.025]                 ...future.oldOptions$nwarnings <- NULL
[01:29:39.025]             }
[01:29:39.025]             base::options(...future.oldOptions)
[01:29:39.025]             if (.Platform$OS.type == "windows") {
[01:29:39.025]                 old_names <- names(...future.oldEnvVars)
[01:29:39.025]                 envs <- base::Sys.getenv()
[01:29:39.025]                 names <- names(envs)
[01:29:39.025]                 common <- intersect(names, old_names)
[01:29:39.025]                 added <- setdiff(names, old_names)
[01:29:39.025]                 removed <- setdiff(old_names, names)
[01:29:39.025]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:39.025]                   envs[common]]
[01:29:39.025]                 NAMES <- toupper(changed)
[01:29:39.025]                 args <- list()
[01:29:39.025]                 for (kk in seq_along(NAMES)) {
[01:29:39.025]                   name <- changed[[kk]]
[01:29:39.025]                   NAME <- NAMES[[kk]]
[01:29:39.025]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.025]                     next
[01:29:39.025]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:39.025]                 }
[01:29:39.025]                 NAMES <- toupper(added)
[01:29:39.025]                 for (kk in seq_along(NAMES)) {
[01:29:39.025]                   name <- added[[kk]]
[01:29:39.025]                   NAME <- NAMES[[kk]]
[01:29:39.025]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.025]                     next
[01:29:39.025]                   args[[name]] <- ""
[01:29:39.025]                 }
[01:29:39.025]                 NAMES <- toupper(removed)
[01:29:39.025]                 for (kk in seq_along(NAMES)) {
[01:29:39.025]                   name <- removed[[kk]]
[01:29:39.025]                   NAME <- NAMES[[kk]]
[01:29:39.025]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.025]                     next
[01:29:39.025]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:39.025]                 }
[01:29:39.025]                 if (length(args) > 0) 
[01:29:39.025]                   base::do.call(base::Sys.setenv, args = args)
[01:29:39.025]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:39.025]             }
[01:29:39.025]             else {
[01:29:39.025]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:39.025]             }
[01:29:39.025]             {
[01:29:39.025]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:39.025]                   0L) {
[01:29:39.025]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:39.025]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:39.025]                   base::options(opts)
[01:29:39.025]                 }
[01:29:39.025]                 {
[01:29:39.025]                   {
[01:29:39.025]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:39.025]                     NULL
[01:29:39.025]                   }
[01:29:39.025]                   options(future.plan = NULL)
[01:29:39.025]                   if (is.na(NA_character_)) 
[01:29:39.025]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:39.025]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:39.025]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:39.025]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:39.025]                     envir = parent.frame()) 
[01:29:39.025]                   {
[01:29:39.025]                     if (is.function(workers)) 
[01:29:39.025]                       workers <- workers()
[01:29:39.025]                     workers <- structure(as.integer(workers), 
[01:29:39.025]                       class = class(workers))
[01:29:39.025]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:39.025]                       workers >= 1)
[01:29:39.025]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:39.025]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:39.025]                     }
[01:29:39.025]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:39.025]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:39.025]                       envir = envir)
[01:29:39.025]                     if (!future$lazy) 
[01:29:39.025]                       future <- run(future)
[01:29:39.025]                     invisible(future)
[01:29:39.025]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:39.025]                 }
[01:29:39.025]             }
[01:29:39.025]         }
[01:29:39.025]     })
[01:29:39.025]     if (TRUE) {
[01:29:39.025]         base::sink(type = "output", split = FALSE)
[01:29:39.025]         if (FALSE) {
[01:29:39.025]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:39.025]         }
[01:29:39.025]         else {
[01:29:39.025]             ...future.result["stdout"] <- base::list(NULL)
[01:29:39.025]         }
[01:29:39.025]         base::close(...future.stdout)
[01:29:39.025]         ...future.stdout <- NULL
[01:29:39.025]     }
[01:29:39.025]     ...future.result$conditions <- ...future.conditions
[01:29:39.025]     ...future.result$finished <- base::Sys.time()
[01:29:39.025]     ...future.result
[01:29:39.025] }
[01:29:39.031] MultisessionFuture started
[01:29:39.031] - Launch lazy future ... done
[01:29:39.032] run() for 'MultisessionFuture' ... done
[01:29:39.032] result() for ClusterFuture ...
[01:29:39.032] receiveMessageFromWorker() for ClusterFuture ...
[01:29:39.032] - Validating connection of MultisessionFuture
[01:29:39.052] - received message: FutureResult
[01:29:39.053] - Received FutureResult
[01:29:39.053] - Erased future from FutureRegistry
[01:29:39.053] result() for ClusterFuture ...
[01:29:39.053] - result already collected: FutureResult
[01:29:39.053] result() for ClusterFuture ... done
[01:29:39.053] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:39.054] result() for ClusterFuture ... done
List of 11
 $ value       : int 42
 $ visible     : logi TRUE
 $ stdout      : NULL
 $ conditions  : list()
 $ rng         : logi FALSE
 $ globalenv   : NULL
 $ started     : POSIXct[1:1], format: "2023-12-22 01:29:39"
 $ finished    : POSIXct[1:1], format: "2023-12-22 01:29:39"
 $ session_uuid: chr "05f91763-b12d-ded6-9d80-c3ce459b1113"
  ..- attr(*, "source")=List of 5
  .. ..$ host  : Named chr "CRANWIN3"
  .. .. ..- attr(*, "names")= chr "COMPUTERNAME"
  .. ..$ info  : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...
  .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...
  .. ..$ pid   : int 3264
  .. ..$ time  : POSIXct[1:1], format: "2023-12-22 01:29:38"
  .. ..$ random: int 2147483647
 $ r_info      :List of 4
  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1
  .. ..$ : int [1:3] 4 4 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[01:29:39.063] result() for ClusterFuture ...
[01:29:39.063] - result already collected: FutureResult
[01:29:39.064] result() for ClusterFuture ... done
[01:29:39.064] result() for ClusterFuture ...
[01:29:39.064] - result already collected: FutureResult
[01:29:39.064] result() for ClusterFuture ... done
[01:29:39.065] getGlobalsAndPackages() ...
[01:29:39.065] Searching for globals...
[01:29:39.068] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[01:29:39.069] Searching for globals ... DONE
[01:29:39.069] Resolving globals: FALSE
[01:29:39.069] 
[01:29:39.070] - packages: [1] 'utils'
[01:29:39.070] getGlobalsAndPackages() ... DONE
[01:29:39.070] run() for 'Future' ...
[01:29:39.070] - state: 'created'
[01:29:39.071] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:39.085] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:39.085] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:39.086]   - Field: 'node'
[01:29:39.086]   - Field: 'label'
[01:29:39.086]   - Field: 'local'
[01:29:39.086]   - Field: 'owner'
[01:29:39.086]   - Field: 'envir'
[01:29:39.086]   - Field: 'workers'
[01:29:39.087]   - Field: 'packages'
[01:29:39.087]   - Field: 'gc'
[01:29:39.087]   - Field: 'conditions'
[01:29:39.087]   - Field: 'persistent'
[01:29:39.087]   - Field: 'expr'
[01:29:39.088]   - Field: 'uuid'
[01:29:39.088]   - Field: 'seed'
[01:29:39.088]   - Field: 'version'
[01:29:39.088]   - Field: 'result'
[01:29:39.088]   - Field: 'asynchronous'
[01:29:39.088]   - Field: 'calls'
[01:29:39.089]   - Field: 'globals'
[01:29:39.089]   - Field: 'stdout'
[01:29:39.089]   - Field: 'earlySignal'
[01:29:39.089]   - Field: 'lazy'
[01:29:39.089]   - Field: 'state'
[01:29:39.089] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:39.090] - Launch lazy future ...
[01:29:39.090] Packages needed by the future expression (n = 1): 'utils'
[01:29:39.090] Packages needed by future strategies (n = 0): <none>
[01:29:39.091] {
[01:29:39.091]     {
[01:29:39.091]         {
[01:29:39.091]             ...future.startTime <- base::Sys.time()
[01:29:39.091]             {
[01:29:39.091]                 {
[01:29:39.091]                   {
[01:29:39.091]                     {
[01:29:39.091]                       {
[01:29:39.091]                         base::local({
[01:29:39.091]                           has_future <- base::requireNamespace("future", 
[01:29:39.091]                             quietly = TRUE)
[01:29:39.091]                           if (has_future) {
[01:29:39.091]                             ns <- base::getNamespace("future")
[01:29:39.091]                             version <- ns[[".package"]][["version"]]
[01:29:39.091]                             if (is.null(version)) 
[01:29:39.091]                               version <- utils::packageVersion("future")
[01:29:39.091]                           }
[01:29:39.091]                           else {
[01:29:39.091]                             version <- NULL
[01:29:39.091]                           }
[01:29:39.091]                           if (!has_future || version < "1.8.0") {
[01:29:39.091]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:39.091]                               "", base::R.version$version.string), 
[01:29:39.091]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:39.091]                                 base::R.version$platform, 8 * 
[01:29:39.091]                                   base::.Machine$sizeof.pointer), 
[01:29:39.091]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:39.091]                                 "release", "version")], collapse = " "), 
[01:29:39.091]                               hostname = base::Sys.info()[["nodename"]])
[01:29:39.091]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:39.091]                               info)
[01:29:39.091]                             info <- base::paste(info, collapse = "; ")
[01:29:39.091]                             if (!has_future) {
[01:29:39.091]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:39.091]                                 info)
[01:29:39.091]                             }
[01:29:39.091]                             else {
[01:29:39.091]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:39.091]                                 info, version)
[01:29:39.091]                             }
[01:29:39.091]                             base::stop(msg)
[01:29:39.091]                           }
[01:29:39.091]                         })
[01:29:39.091]                       }
[01:29:39.091]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:39.091]                       base::options(mc.cores = 1L)
[01:29:39.091]                     }
[01:29:39.091]                     base::local({
[01:29:39.091]                       for (pkg in "utils") {
[01:29:39.091]                         base::loadNamespace(pkg)
[01:29:39.091]                         base::library(pkg, character.only = TRUE)
[01:29:39.091]                       }
[01:29:39.091]                     })
[01:29:39.091]                   }
[01:29:39.091]                   options(future.plan = NULL)
[01:29:39.091]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:39.091]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:39.091]                 }
[01:29:39.091]                 ...future.workdir <- getwd()
[01:29:39.091]             }
[01:29:39.091]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:39.091]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:39.091]         }
[01:29:39.091]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:39.091]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:39.091]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:39.091]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:39.091]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:39.091]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:39.091]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:39.091]             base::names(...future.oldOptions))
[01:29:39.091]     }
[01:29:39.091]     if (FALSE) {
[01:29:39.091]     }
[01:29:39.091]     else {
[01:29:39.091]         if (FALSE) {
[01:29:39.091]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:39.091]                 open = "w")
[01:29:39.091]         }
[01:29:39.091]         else {
[01:29:39.091]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:39.091]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:39.091]         }
[01:29:39.091]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:39.091]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:39.091]             base::sink(type = "output", split = FALSE)
[01:29:39.091]             base::close(...future.stdout)
[01:29:39.091]         }, add = TRUE)
[01:29:39.091]     }
[01:29:39.091]     ...future.frame <- base::sys.nframe()
[01:29:39.091]     ...future.conditions <- base::list()
[01:29:39.091]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:39.091]     if (FALSE) {
[01:29:39.091]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:39.091]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:39.091]     }
[01:29:39.091]     ...future.result <- base::tryCatch({
[01:29:39.091]         base::withCallingHandlers({
[01:29:39.091]             ...future.value <- base::withVisible(base::local({
[01:29:39.091]                 ...future.makeSendCondition <- base::local({
[01:29:39.091]                   sendCondition <- NULL
[01:29:39.091]                   function(frame = 1L) {
[01:29:39.091]                     if (is.function(sendCondition)) 
[01:29:39.091]                       return(sendCondition)
[01:29:39.091]                     ns <- getNamespace("parallel")
[01:29:39.091]                     if (exists("sendData", mode = "function", 
[01:29:39.091]                       envir = ns)) {
[01:29:39.091]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:39.091]                         envir = ns)
[01:29:39.091]                       envir <- sys.frame(frame)
[01:29:39.091]                       master <- NULL
[01:29:39.091]                       while (!identical(envir, .GlobalEnv) && 
[01:29:39.091]                         !identical(envir, emptyenv())) {
[01:29:39.091]                         if (exists("master", mode = "list", envir = envir, 
[01:29:39.091]                           inherits = FALSE)) {
[01:29:39.091]                           master <- get("master", mode = "list", 
[01:29:39.091]                             envir = envir, inherits = FALSE)
[01:29:39.091]                           if (inherits(master, c("SOCKnode", 
[01:29:39.091]                             "SOCK0node"))) {
[01:29:39.091]                             sendCondition <<- function(cond) {
[01:29:39.091]                               data <- list(type = "VALUE", value = cond, 
[01:29:39.091]                                 success = TRUE)
[01:29:39.091]                               parallel_sendData(master, data)
[01:29:39.091]                             }
[01:29:39.091]                             return(sendCondition)
[01:29:39.091]                           }
[01:29:39.091]                         }
[01:29:39.091]                         frame <- frame + 1L
[01:29:39.091]                         envir <- sys.frame(frame)
[01:29:39.091]                       }
[01:29:39.091]                     }
[01:29:39.091]                     sendCondition <<- function(cond) NULL
[01:29:39.091]                   }
[01:29:39.091]                 })
[01:29:39.091]                 withCallingHandlers({
[01:29:39.091]                   {
[01:29:39.091]                     print(1:50)
[01:29:39.091]                     str(1:50)
[01:29:39.091]                     cat(letters, sep = "-")
[01:29:39.091]                     cat(1:6, collapse = "\n")
[01:29:39.091]                     write.table(datasets::iris[1:10, ], sep = "\t")
[01:29:39.091]                     42L
[01:29:39.091]                   }
[01:29:39.091]                 }, immediateCondition = function(cond) {
[01:29:39.091]                   sendCondition <- ...future.makeSendCondition()
[01:29:39.091]                   sendCondition(cond)
[01:29:39.091]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.091]                   {
[01:29:39.091]                     inherits <- base::inherits
[01:29:39.091]                     invokeRestart <- base::invokeRestart
[01:29:39.091]                     is.null <- base::is.null
[01:29:39.091]                     muffled <- FALSE
[01:29:39.091]                     if (inherits(cond, "message")) {
[01:29:39.091]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:39.091]                       if (muffled) 
[01:29:39.091]                         invokeRestart("muffleMessage")
[01:29:39.091]                     }
[01:29:39.091]                     else if (inherits(cond, "warning")) {
[01:29:39.091]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:39.091]                       if (muffled) 
[01:29:39.091]                         invokeRestart("muffleWarning")
[01:29:39.091]                     }
[01:29:39.091]                     else if (inherits(cond, "condition")) {
[01:29:39.091]                       if (!is.null(pattern)) {
[01:29:39.091]                         computeRestarts <- base::computeRestarts
[01:29:39.091]                         grepl <- base::grepl
[01:29:39.091]                         restarts <- computeRestarts(cond)
[01:29:39.091]                         for (restart in restarts) {
[01:29:39.091]                           name <- restart$name
[01:29:39.091]                           if (is.null(name)) 
[01:29:39.091]                             next
[01:29:39.091]                           if (!grepl(pattern, name)) 
[01:29:39.091]                             next
[01:29:39.091]                           invokeRestart(restart)
[01:29:39.091]                           muffled <- TRUE
[01:29:39.091]                           break
[01:29:39.091]                         }
[01:29:39.091]                       }
[01:29:39.091]                     }
[01:29:39.091]                     invisible(muffled)
[01:29:39.091]                   }
[01:29:39.091]                   muffleCondition(cond)
[01:29:39.091]                 })
[01:29:39.091]             }))
[01:29:39.091]             future::FutureResult(value = ...future.value$value, 
[01:29:39.091]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:39.091]                   ...future.rng), globalenv = if (FALSE) 
[01:29:39.091]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:39.091]                     ...future.globalenv.names))
[01:29:39.091]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:39.091]         }, condition = base::local({
[01:29:39.091]             c <- base::c
[01:29:39.091]             inherits <- base::inherits
[01:29:39.091]             invokeRestart <- base::invokeRestart
[01:29:39.091]             length <- base::length
[01:29:39.091]             list <- base::list
[01:29:39.091]             seq.int <- base::seq.int
[01:29:39.091]             signalCondition <- base::signalCondition
[01:29:39.091]             sys.calls <- base::sys.calls
[01:29:39.091]             `[[` <- base::`[[`
[01:29:39.091]             `+` <- base::`+`
[01:29:39.091]             `<<-` <- base::`<<-`
[01:29:39.091]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:39.091]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:39.091]                   3L)]
[01:29:39.091]             }
[01:29:39.091]             function(cond) {
[01:29:39.091]                 is_error <- inherits(cond, "error")
[01:29:39.091]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:39.091]                   NULL)
[01:29:39.091]                 if (is_error) {
[01:29:39.091]                   sessionInformation <- function() {
[01:29:39.091]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:39.091]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:39.091]                       search = base::search(), system = base::Sys.info())
[01:29:39.091]                   }
[01:29:39.091]                   ...future.conditions[[length(...future.conditions) + 
[01:29:39.091]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:39.091]                     cond$call), session = sessionInformation(), 
[01:29:39.091]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:39.091]                   signalCondition(cond)
[01:29:39.091]                 }
[01:29:39.091]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:39.091]                 "immediateCondition"))) {
[01:29:39.091]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:39.091]                   ...future.conditions[[length(...future.conditions) + 
[01:29:39.091]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:39.091]                   if (TRUE && !signal) {
[01:29:39.091]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.091]                     {
[01:29:39.091]                       inherits <- base::inherits
[01:29:39.091]                       invokeRestart <- base::invokeRestart
[01:29:39.091]                       is.null <- base::is.null
[01:29:39.091]                       muffled <- FALSE
[01:29:39.091]                       if (inherits(cond, "message")) {
[01:29:39.091]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:39.091]                         if (muffled) 
[01:29:39.091]                           invokeRestart("muffleMessage")
[01:29:39.091]                       }
[01:29:39.091]                       else if (inherits(cond, "warning")) {
[01:29:39.091]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:39.091]                         if (muffled) 
[01:29:39.091]                           invokeRestart("muffleWarning")
[01:29:39.091]                       }
[01:29:39.091]                       else if (inherits(cond, "condition")) {
[01:29:39.091]                         if (!is.null(pattern)) {
[01:29:39.091]                           computeRestarts <- base::computeRestarts
[01:29:39.091]                           grepl <- base::grepl
[01:29:39.091]                           restarts <- computeRestarts(cond)
[01:29:39.091]                           for (restart in restarts) {
[01:29:39.091]                             name <- restart$name
[01:29:39.091]                             if (is.null(name)) 
[01:29:39.091]                               next
[01:29:39.091]                             if (!grepl(pattern, name)) 
[01:29:39.091]                               next
[01:29:39.091]                             invokeRestart(restart)
[01:29:39.091]                             muffled <- TRUE
[01:29:39.091]                             break
[01:29:39.091]                           }
[01:29:39.091]                         }
[01:29:39.091]                       }
[01:29:39.091]                       invisible(muffled)
[01:29:39.091]                     }
[01:29:39.091]                     muffleCondition(cond, pattern = "^muffle")
[01:29:39.091]                   }
[01:29:39.091]                 }
[01:29:39.091]                 else {
[01:29:39.091]                   if (TRUE) {
[01:29:39.091]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.091]                     {
[01:29:39.091]                       inherits <- base::inherits
[01:29:39.091]                       invokeRestart <- base::invokeRestart
[01:29:39.091]                       is.null <- base::is.null
[01:29:39.091]                       muffled <- FALSE
[01:29:39.091]                       if (inherits(cond, "message")) {
[01:29:39.091]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:39.091]                         if (muffled) 
[01:29:39.091]                           invokeRestart("muffleMessage")
[01:29:39.091]                       }
[01:29:39.091]                       else if (inherits(cond, "warning")) {
[01:29:39.091]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:39.091]                         if (muffled) 
[01:29:39.091]                           invokeRestart("muffleWarning")
[01:29:39.091]                       }
[01:29:39.091]                       else if (inherits(cond, "condition")) {
[01:29:39.091]                         if (!is.null(pattern)) {
[01:29:39.091]                           computeRestarts <- base::computeRestarts
[01:29:39.091]                           grepl <- base::grepl
[01:29:39.091]                           restarts <- computeRestarts(cond)
[01:29:39.091]                           for (restart in restarts) {
[01:29:39.091]                             name <- restart$name
[01:29:39.091]                             if (is.null(name)) 
[01:29:39.091]                               next
[01:29:39.091]                             if (!grepl(pattern, name)) 
[01:29:39.091]                               next
[01:29:39.091]                             invokeRestart(restart)
[01:29:39.091]                             muffled <- TRUE
[01:29:39.091]                             break
[01:29:39.091]                           }
[01:29:39.091]                         }
[01:29:39.091]                       }
[01:29:39.091]                       invisible(muffled)
[01:29:39.091]                     }
[01:29:39.091]                     muffleCondition(cond, pattern = "^muffle")
[01:29:39.091]                   }
[01:29:39.091]                 }
[01:29:39.091]             }
[01:29:39.091]         }))
[01:29:39.091]     }, error = function(ex) {
[01:29:39.091]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:39.091]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:39.091]                 ...future.rng), started = ...future.startTime, 
[01:29:39.091]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:39.091]             version = "1.8"), class = "FutureResult")
[01:29:39.091]     }, finally = {
[01:29:39.091]         if (!identical(...future.workdir, getwd())) 
[01:29:39.091]             setwd(...future.workdir)
[01:29:39.091]         {
[01:29:39.091]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:39.091]                 ...future.oldOptions$nwarnings <- NULL
[01:29:39.091]             }
[01:29:39.091]             base::options(...future.oldOptions)
[01:29:39.091]             if (.Platform$OS.type == "windows") {
[01:29:39.091]                 old_names <- names(...future.oldEnvVars)
[01:29:39.091]                 envs <- base::Sys.getenv()
[01:29:39.091]                 names <- names(envs)
[01:29:39.091]                 common <- intersect(names, old_names)
[01:29:39.091]                 added <- setdiff(names, old_names)
[01:29:39.091]                 removed <- setdiff(old_names, names)
[01:29:39.091]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:39.091]                   envs[common]]
[01:29:39.091]                 NAMES <- toupper(changed)
[01:29:39.091]                 args <- list()
[01:29:39.091]                 for (kk in seq_along(NAMES)) {
[01:29:39.091]                   name <- changed[[kk]]
[01:29:39.091]                   NAME <- NAMES[[kk]]
[01:29:39.091]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.091]                     next
[01:29:39.091]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:39.091]                 }
[01:29:39.091]                 NAMES <- toupper(added)
[01:29:39.091]                 for (kk in seq_along(NAMES)) {
[01:29:39.091]                   name <- added[[kk]]
[01:29:39.091]                   NAME <- NAMES[[kk]]
[01:29:39.091]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.091]                     next
[01:29:39.091]                   args[[name]] <- ""
[01:29:39.091]                 }
[01:29:39.091]                 NAMES <- toupper(removed)
[01:29:39.091]                 for (kk in seq_along(NAMES)) {
[01:29:39.091]                   name <- removed[[kk]]
[01:29:39.091]                   NAME <- NAMES[[kk]]
[01:29:39.091]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.091]                     next
[01:29:39.091]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:39.091]                 }
[01:29:39.091]                 if (length(args) > 0) 
[01:29:39.091]                   base::do.call(base::Sys.setenv, args = args)
[01:29:39.091]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:39.091]             }
[01:29:39.091]             else {
[01:29:39.091]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:39.091]             }
[01:29:39.091]             {
[01:29:39.091]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:39.091]                   0L) {
[01:29:39.091]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:39.091]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:39.091]                   base::options(opts)
[01:29:39.091]                 }
[01:29:39.091]                 {
[01:29:39.091]                   {
[01:29:39.091]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:39.091]                     NULL
[01:29:39.091]                   }
[01:29:39.091]                   options(future.plan = NULL)
[01:29:39.091]                   if (is.na(NA_character_)) 
[01:29:39.091]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:39.091]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:39.091]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:39.091]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:39.091]                     envir = parent.frame()) 
[01:29:39.091]                   {
[01:29:39.091]                     if (is.function(workers)) 
[01:29:39.091]                       workers <- workers()
[01:29:39.091]                     workers <- structure(as.integer(workers), 
[01:29:39.091]                       class = class(workers))
[01:29:39.091]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:39.091]                       workers >= 1)
[01:29:39.091]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:39.091]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:39.091]                     }
[01:29:39.091]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:39.091]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:39.091]                       envir = envir)
[01:29:39.091]                     if (!future$lazy) 
[01:29:39.091]                       future <- run(future)
[01:29:39.091]                     invisible(future)
[01:29:39.091]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:39.091]                 }
[01:29:39.091]             }
[01:29:39.091]         }
[01:29:39.091]     })
[01:29:39.091]     if (TRUE) {
[01:29:39.091]         base::sink(type = "output", split = FALSE)
[01:29:39.091]         if (FALSE) {
[01:29:39.091]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:39.091]         }
[01:29:39.091]         else {
[01:29:39.091]             ...future.result["stdout"] <- base::list(NULL)
[01:29:39.091]         }
[01:29:39.091]         base::close(...future.stdout)
[01:29:39.091]         ...future.stdout <- NULL
[01:29:39.091]     }
[01:29:39.091]     ...future.result$conditions <- ...future.conditions
[01:29:39.091]     ...future.result$finished <- base::Sys.time()
[01:29:39.091]     ...future.result
[01:29:39.091] }
[01:29:39.097] MultisessionFuture started
[01:29:39.097] - Launch lazy future ... done
[01:29:39.098] run() for 'MultisessionFuture' ... done
[01:29:39.098] result() for ClusterFuture ...
[01:29:39.098] receiveMessageFromWorker() for ClusterFuture ...
[01:29:39.098] - Validating connection of MultisessionFuture
[01:29:39.117] - received message: FutureResult
[01:29:39.117] - Received FutureResult
[01:29:39.117] - Erased future from FutureRegistry
[01:29:39.117] result() for ClusterFuture ...
[01:29:39.117] - result already collected: FutureResult
[01:29:39.118] result() for ClusterFuture ... done
[01:29:39.118] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:39.118] result() for ClusterFuture ... done
[01:29:39.118] result() for ClusterFuture ...
[01:29:39.118] - result already collected: FutureResult
[01:29:39.118] result() for ClusterFuture ... done
- stdout = structure(TRUE, drop = TRUE)
[01:29:39.119] getGlobalsAndPackages() ...
[01:29:39.119] Searching for globals...
[01:29:39.119] - globals found: [1] 'print'
[01:29:39.120] Searching for globals ... DONE
[01:29:39.120] Resolving globals: FALSE
[01:29:39.120] 
[01:29:39.120] 
[01:29:39.121] getGlobalsAndPackages() ... DONE
[01:29:39.121] run() for 'Future' ...
[01:29:39.121] - state: 'created'
[01:29:39.121] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:39.136] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:39.136] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:39.136]   - Field: 'node'
[01:29:39.136]   - Field: 'label'
[01:29:39.136]   - Field: 'local'
[01:29:39.137]   - Field: 'owner'
[01:29:39.137]   - Field: 'envir'
[01:29:39.137]   - Field: 'workers'
[01:29:39.137]   - Field: 'packages'
[01:29:39.137]   - Field: 'gc'
[01:29:39.138]   - Field: 'conditions'
[01:29:39.138]   - Field: 'persistent'
[01:29:39.138]   - Field: 'expr'
[01:29:39.138]   - Field: 'uuid'
[01:29:39.138]   - Field: 'seed'
[01:29:39.138]   - Field: 'version'
[01:29:39.139]   - Field: 'result'
[01:29:39.139]   - Field: 'asynchronous'
[01:29:39.139]   - Field: 'calls'
[01:29:39.139]   - Field: 'globals'
[01:29:39.139]   - Field: 'stdout'
[01:29:39.139]   - Field: 'earlySignal'
[01:29:39.140]   - Field: 'lazy'
[01:29:39.140]   - Field: 'state'
[01:29:39.140] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:39.140] - Launch lazy future ...
[01:29:39.141] Packages needed by the future expression (n = 0): <none>
[01:29:39.141] Packages needed by future strategies (n = 0): <none>
[01:29:39.141] {
[01:29:39.141]     {
[01:29:39.141]         {
[01:29:39.141]             ...future.startTime <- base::Sys.time()
[01:29:39.141]             {
[01:29:39.141]                 {
[01:29:39.141]                   {
[01:29:39.141]                     {
[01:29:39.141]                       base::local({
[01:29:39.141]                         has_future <- base::requireNamespace("future", 
[01:29:39.141]                           quietly = TRUE)
[01:29:39.141]                         if (has_future) {
[01:29:39.141]                           ns <- base::getNamespace("future")
[01:29:39.141]                           version <- ns[[".package"]][["version"]]
[01:29:39.141]                           if (is.null(version)) 
[01:29:39.141]                             version <- utils::packageVersion("future")
[01:29:39.141]                         }
[01:29:39.141]                         else {
[01:29:39.141]                           version <- NULL
[01:29:39.141]                         }
[01:29:39.141]                         if (!has_future || version < "1.8.0") {
[01:29:39.141]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:39.141]                             "", base::R.version$version.string), 
[01:29:39.141]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:39.141]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:39.141]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:39.141]                               "release", "version")], collapse = " "), 
[01:29:39.141]                             hostname = base::Sys.info()[["nodename"]])
[01:29:39.141]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:39.141]                             info)
[01:29:39.141]                           info <- base::paste(info, collapse = "; ")
[01:29:39.141]                           if (!has_future) {
[01:29:39.141]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:39.141]                               info)
[01:29:39.141]                           }
[01:29:39.141]                           else {
[01:29:39.141]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:39.141]                               info, version)
[01:29:39.141]                           }
[01:29:39.141]                           base::stop(msg)
[01:29:39.141]                         }
[01:29:39.141]                       })
[01:29:39.141]                     }
[01:29:39.141]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:39.141]                     base::options(mc.cores = 1L)
[01:29:39.141]                   }
[01:29:39.141]                   options(future.plan = NULL)
[01:29:39.141]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:39.141]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:39.141]                 }
[01:29:39.141]                 ...future.workdir <- getwd()
[01:29:39.141]             }
[01:29:39.141]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:39.141]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:39.141]         }
[01:29:39.141]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:39.141]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:39.141]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:39.141]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:39.141]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:39.141]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:39.141]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:39.141]             base::names(...future.oldOptions))
[01:29:39.141]     }
[01:29:39.141]     if (FALSE) {
[01:29:39.141]     }
[01:29:39.141]     else {
[01:29:39.141]         if (TRUE) {
[01:29:39.141]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:39.141]                 open = "w")
[01:29:39.141]         }
[01:29:39.141]         else {
[01:29:39.141]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:39.141]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:39.141]         }
[01:29:39.141]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:39.141]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:39.141]             base::sink(type = "output", split = FALSE)
[01:29:39.141]             base::close(...future.stdout)
[01:29:39.141]         }, add = TRUE)
[01:29:39.141]     }
[01:29:39.141]     ...future.frame <- base::sys.nframe()
[01:29:39.141]     ...future.conditions <- base::list()
[01:29:39.141]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:39.141]     if (FALSE) {
[01:29:39.141]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:39.141]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:39.141]     }
[01:29:39.141]     ...future.result <- base::tryCatch({
[01:29:39.141]         base::withCallingHandlers({
[01:29:39.141]             ...future.value <- base::withVisible(base::local({
[01:29:39.141]                 ...future.makeSendCondition <- base::local({
[01:29:39.141]                   sendCondition <- NULL
[01:29:39.141]                   function(frame = 1L) {
[01:29:39.141]                     if (is.function(sendCondition)) 
[01:29:39.141]                       return(sendCondition)
[01:29:39.141]                     ns <- getNamespace("parallel")
[01:29:39.141]                     if (exists("sendData", mode = "function", 
[01:29:39.141]                       envir = ns)) {
[01:29:39.141]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:39.141]                         envir = ns)
[01:29:39.141]                       envir <- sys.frame(frame)
[01:29:39.141]                       master <- NULL
[01:29:39.141]                       while (!identical(envir, .GlobalEnv) && 
[01:29:39.141]                         !identical(envir, emptyenv())) {
[01:29:39.141]                         if (exists("master", mode = "list", envir = envir, 
[01:29:39.141]                           inherits = FALSE)) {
[01:29:39.141]                           master <- get("master", mode = "list", 
[01:29:39.141]                             envir = envir, inherits = FALSE)
[01:29:39.141]                           if (inherits(master, c("SOCKnode", 
[01:29:39.141]                             "SOCK0node"))) {
[01:29:39.141]                             sendCondition <<- function(cond) {
[01:29:39.141]                               data <- list(type = "VALUE", value = cond, 
[01:29:39.141]                                 success = TRUE)
[01:29:39.141]                               parallel_sendData(master, data)
[01:29:39.141]                             }
[01:29:39.141]                             return(sendCondition)
[01:29:39.141]                           }
[01:29:39.141]                         }
[01:29:39.141]                         frame <- frame + 1L
[01:29:39.141]                         envir <- sys.frame(frame)
[01:29:39.141]                       }
[01:29:39.141]                     }
[01:29:39.141]                     sendCondition <<- function(cond) NULL
[01:29:39.141]                   }
[01:29:39.141]                 })
[01:29:39.141]                 withCallingHandlers({
[01:29:39.141]                   print(42)
[01:29:39.141]                 }, immediateCondition = function(cond) {
[01:29:39.141]                   sendCondition <- ...future.makeSendCondition()
[01:29:39.141]                   sendCondition(cond)
[01:29:39.141]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.141]                   {
[01:29:39.141]                     inherits <- base::inherits
[01:29:39.141]                     invokeRestart <- base::invokeRestart
[01:29:39.141]                     is.null <- base::is.null
[01:29:39.141]                     muffled <- FALSE
[01:29:39.141]                     if (inherits(cond, "message")) {
[01:29:39.141]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:39.141]                       if (muffled) 
[01:29:39.141]                         invokeRestart("muffleMessage")
[01:29:39.141]                     }
[01:29:39.141]                     else if (inherits(cond, "warning")) {
[01:29:39.141]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:39.141]                       if (muffled) 
[01:29:39.141]                         invokeRestart("muffleWarning")
[01:29:39.141]                     }
[01:29:39.141]                     else if (inherits(cond, "condition")) {
[01:29:39.141]                       if (!is.null(pattern)) {
[01:29:39.141]                         computeRestarts <- base::computeRestarts
[01:29:39.141]                         grepl <- base::grepl
[01:29:39.141]                         restarts <- computeRestarts(cond)
[01:29:39.141]                         for (restart in restarts) {
[01:29:39.141]                           name <- restart$name
[01:29:39.141]                           if (is.null(name)) 
[01:29:39.141]                             next
[01:29:39.141]                           if (!grepl(pattern, name)) 
[01:29:39.141]                             next
[01:29:39.141]                           invokeRestart(restart)
[01:29:39.141]                           muffled <- TRUE
[01:29:39.141]                           break
[01:29:39.141]                         }
[01:29:39.141]                       }
[01:29:39.141]                     }
[01:29:39.141]                     invisible(muffled)
[01:29:39.141]                   }
[01:29:39.141]                   muffleCondition(cond)
[01:29:39.141]                 })
[01:29:39.141]             }))
[01:29:39.141]             future::FutureResult(value = ...future.value$value, 
[01:29:39.141]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:39.141]                   ...future.rng), globalenv = if (FALSE) 
[01:29:39.141]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:39.141]                     ...future.globalenv.names))
[01:29:39.141]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:39.141]         }, condition = base::local({
[01:29:39.141]             c <- base::c
[01:29:39.141]             inherits <- base::inherits
[01:29:39.141]             invokeRestart <- base::invokeRestart
[01:29:39.141]             length <- base::length
[01:29:39.141]             list <- base::list
[01:29:39.141]             seq.int <- base::seq.int
[01:29:39.141]             signalCondition <- base::signalCondition
[01:29:39.141]             sys.calls <- base::sys.calls
[01:29:39.141]             `[[` <- base::`[[`
[01:29:39.141]             `+` <- base::`+`
[01:29:39.141]             `<<-` <- base::`<<-`
[01:29:39.141]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:39.141]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:39.141]                   3L)]
[01:29:39.141]             }
[01:29:39.141]             function(cond) {
[01:29:39.141]                 is_error <- inherits(cond, "error")
[01:29:39.141]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:39.141]                   NULL)
[01:29:39.141]                 if (is_error) {
[01:29:39.141]                   sessionInformation <- function() {
[01:29:39.141]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:39.141]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:39.141]                       search = base::search(), system = base::Sys.info())
[01:29:39.141]                   }
[01:29:39.141]                   ...future.conditions[[length(...future.conditions) + 
[01:29:39.141]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:39.141]                     cond$call), session = sessionInformation(), 
[01:29:39.141]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:39.141]                   signalCondition(cond)
[01:29:39.141]                 }
[01:29:39.141]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:39.141]                 "immediateCondition"))) {
[01:29:39.141]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:39.141]                   ...future.conditions[[length(...future.conditions) + 
[01:29:39.141]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:39.141]                   if (TRUE && !signal) {
[01:29:39.141]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.141]                     {
[01:29:39.141]                       inherits <- base::inherits
[01:29:39.141]                       invokeRestart <- base::invokeRestart
[01:29:39.141]                       is.null <- base::is.null
[01:29:39.141]                       muffled <- FALSE
[01:29:39.141]                       if (inherits(cond, "message")) {
[01:29:39.141]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:39.141]                         if (muffled) 
[01:29:39.141]                           invokeRestart("muffleMessage")
[01:29:39.141]                       }
[01:29:39.141]                       else if (inherits(cond, "warning")) {
[01:29:39.141]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:39.141]                         if (muffled) 
[01:29:39.141]                           invokeRestart("muffleWarning")
[01:29:39.141]                       }
[01:29:39.141]                       else if (inherits(cond, "condition")) {
[01:29:39.141]                         if (!is.null(pattern)) {
[01:29:39.141]                           computeRestarts <- base::computeRestarts
[01:29:39.141]                           grepl <- base::grepl
[01:29:39.141]                           restarts <- computeRestarts(cond)
[01:29:39.141]                           for (restart in restarts) {
[01:29:39.141]                             name <- restart$name
[01:29:39.141]                             if (is.null(name)) 
[01:29:39.141]                               next
[01:29:39.141]                             if (!grepl(pattern, name)) 
[01:29:39.141]                               next
[01:29:39.141]                             invokeRestart(restart)
[01:29:39.141]                             muffled <- TRUE
[01:29:39.141]                             break
[01:29:39.141]                           }
[01:29:39.141]                         }
[01:29:39.141]                       }
[01:29:39.141]                       invisible(muffled)
[01:29:39.141]                     }
[01:29:39.141]                     muffleCondition(cond, pattern = "^muffle")
[01:29:39.141]                   }
[01:29:39.141]                 }
[01:29:39.141]                 else {
[01:29:39.141]                   if (TRUE) {
[01:29:39.141]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.141]                     {
[01:29:39.141]                       inherits <- base::inherits
[01:29:39.141]                       invokeRestart <- base::invokeRestart
[01:29:39.141]                       is.null <- base::is.null
[01:29:39.141]                       muffled <- FALSE
[01:29:39.141]                       if (inherits(cond, "message")) {
[01:29:39.141]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:39.141]                         if (muffled) 
[01:29:39.141]                           invokeRestart("muffleMessage")
[01:29:39.141]                       }
[01:29:39.141]                       else if (inherits(cond, "warning")) {
[01:29:39.141]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:39.141]                         if (muffled) 
[01:29:39.141]                           invokeRestart("muffleWarning")
[01:29:39.141]                       }
[01:29:39.141]                       else if (inherits(cond, "condition")) {
[01:29:39.141]                         if (!is.null(pattern)) {
[01:29:39.141]                           computeRestarts <- base::computeRestarts
[01:29:39.141]                           grepl <- base::grepl
[01:29:39.141]                           restarts <- computeRestarts(cond)
[01:29:39.141]                           for (restart in restarts) {
[01:29:39.141]                             name <- restart$name
[01:29:39.141]                             if (is.null(name)) 
[01:29:39.141]                               next
[01:29:39.141]                             if (!grepl(pattern, name)) 
[01:29:39.141]                               next
[01:29:39.141]                             invokeRestart(restart)
[01:29:39.141]                             muffled <- TRUE
[01:29:39.141]                             break
[01:29:39.141]                           }
[01:29:39.141]                         }
[01:29:39.141]                       }
[01:29:39.141]                       invisible(muffled)
[01:29:39.141]                     }
[01:29:39.141]                     muffleCondition(cond, pattern = "^muffle")
[01:29:39.141]                   }
[01:29:39.141]                 }
[01:29:39.141]             }
[01:29:39.141]         }))
[01:29:39.141]     }, error = function(ex) {
[01:29:39.141]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:39.141]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:39.141]                 ...future.rng), started = ...future.startTime, 
[01:29:39.141]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:39.141]             version = "1.8"), class = "FutureResult")
[01:29:39.141]     }, finally = {
[01:29:39.141]         if (!identical(...future.workdir, getwd())) 
[01:29:39.141]             setwd(...future.workdir)
[01:29:39.141]         {
[01:29:39.141]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:39.141]                 ...future.oldOptions$nwarnings <- NULL
[01:29:39.141]             }
[01:29:39.141]             base::options(...future.oldOptions)
[01:29:39.141]             if (.Platform$OS.type == "windows") {
[01:29:39.141]                 old_names <- names(...future.oldEnvVars)
[01:29:39.141]                 envs <- base::Sys.getenv()
[01:29:39.141]                 names <- names(envs)
[01:29:39.141]                 common <- intersect(names, old_names)
[01:29:39.141]                 added <- setdiff(names, old_names)
[01:29:39.141]                 removed <- setdiff(old_names, names)
[01:29:39.141]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:39.141]                   envs[common]]
[01:29:39.141]                 NAMES <- toupper(changed)
[01:29:39.141]                 args <- list()
[01:29:39.141]                 for (kk in seq_along(NAMES)) {
[01:29:39.141]                   name <- changed[[kk]]
[01:29:39.141]                   NAME <- NAMES[[kk]]
[01:29:39.141]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.141]                     next
[01:29:39.141]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:39.141]                 }
[01:29:39.141]                 NAMES <- toupper(added)
[01:29:39.141]                 for (kk in seq_along(NAMES)) {
[01:29:39.141]                   name <- added[[kk]]
[01:29:39.141]                   NAME <- NAMES[[kk]]
[01:29:39.141]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.141]                     next
[01:29:39.141]                   args[[name]] <- ""
[01:29:39.141]                 }
[01:29:39.141]                 NAMES <- toupper(removed)
[01:29:39.141]                 for (kk in seq_along(NAMES)) {
[01:29:39.141]                   name <- removed[[kk]]
[01:29:39.141]                   NAME <- NAMES[[kk]]
[01:29:39.141]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.141]                     next
[01:29:39.141]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:39.141]                 }
[01:29:39.141]                 if (length(args) > 0) 
[01:29:39.141]                   base::do.call(base::Sys.setenv, args = args)
[01:29:39.141]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:39.141]             }
[01:29:39.141]             else {
[01:29:39.141]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:39.141]             }
[01:29:39.141]             {
[01:29:39.141]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:39.141]                   0L) {
[01:29:39.141]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:39.141]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:39.141]                   base::options(opts)
[01:29:39.141]                 }
[01:29:39.141]                 {
[01:29:39.141]                   {
[01:29:39.141]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:39.141]                     NULL
[01:29:39.141]                   }
[01:29:39.141]                   options(future.plan = NULL)
[01:29:39.141]                   if (is.na(NA_character_)) 
[01:29:39.141]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:39.141]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:39.141]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:39.141]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:39.141]                     envir = parent.frame()) 
[01:29:39.141]                   {
[01:29:39.141]                     if (is.function(workers)) 
[01:29:39.141]                       workers <- workers()
[01:29:39.141]                     workers <- structure(as.integer(workers), 
[01:29:39.141]                       class = class(workers))
[01:29:39.141]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:39.141]                       workers >= 1)
[01:29:39.141]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:39.141]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:39.141]                     }
[01:29:39.141]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:39.141]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:39.141]                       envir = envir)
[01:29:39.141]                     if (!future$lazy) 
[01:29:39.141]                       future <- run(future)
[01:29:39.141]                     invisible(future)
[01:29:39.141]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:39.141]                 }
[01:29:39.141]             }
[01:29:39.141]         }
[01:29:39.141]     })
[01:29:39.141]     if (TRUE) {
[01:29:39.141]         base::sink(type = "output", split = FALSE)
[01:29:39.141]         if (TRUE) {
[01:29:39.141]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:39.141]         }
[01:29:39.141]         else {
[01:29:39.141]             ...future.result["stdout"] <- base::list(NULL)
[01:29:39.141]         }
[01:29:39.141]         base::close(...future.stdout)
[01:29:39.141]         ...future.stdout <- NULL
[01:29:39.141]     }
[01:29:39.141]     ...future.result$conditions <- ...future.conditions
[01:29:39.141]     ...future.result$finished <- base::Sys.time()
[01:29:39.141]     ...future.result
[01:29:39.141] }
[01:29:39.147] MultisessionFuture started
[01:29:39.147] - Launch lazy future ... done
[01:29:39.148] run() for 'MultisessionFuture' ... done
[01:29:39.148] result() for ClusterFuture ...
[01:29:39.148] receiveMessageFromWorker() for ClusterFuture ...
[01:29:39.148] - Validating connection of MultisessionFuture
[01:29:39.165] - received message: FutureResult
[01:29:39.165] - Received FutureResult
[01:29:39.165] - Erased future from FutureRegistry
[01:29:39.165] result() for ClusterFuture ...
[01:29:39.165] - result already collected: FutureResult
[01:29:39.165] result() for ClusterFuture ... done
[01:29:39.166] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:39.166] result() for ClusterFuture ... done
[01:29:39.166] result() for ClusterFuture ...
[01:29:39.166] - result already collected: FutureResult
[01:29:39.166] result() for ClusterFuture ... done
[01:29:39.166] result() for ClusterFuture ...
[01:29:39.167] - result already collected: FutureResult
[01:29:39.167] result() for ClusterFuture ... done
[1] 42
[01:29:39.167] result() for ClusterFuture ...
[01:29:39.167] - result already collected: FutureResult
[01:29:39.167] result() for ClusterFuture ... done
- stdout = NA
[01:29:39.168] getGlobalsAndPackages() ...
[01:29:39.168] Searching for globals...
[01:29:39.171] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[01:29:39.172] Searching for globals ... DONE
[01:29:39.172] Resolving globals: FALSE
[01:29:39.172] 
[01:29:39.173] - packages: [1] 'utils'
[01:29:39.173] getGlobalsAndPackages() ... DONE
[01:29:39.173] run() for 'Future' ...
[01:29:39.173] - state: 'created'
[01:29:39.174] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:39.188] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:39.188] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:39.188]   - Field: 'node'
[01:29:39.189]   - Field: 'label'
[01:29:39.189]   - Field: 'local'
[01:29:39.189]   - Field: 'owner'
[01:29:39.189]   - Field: 'envir'
[01:29:39.189]   - Field: 'workers'
[01:29:39.189]   - Field: 'packages'
[01:29:39.190]   - Field: 'gc'
[01:29:39.190]   - Field: 'conditions'
[01:29:39.190]   - Field: 'persistent'
[01:29:39.190]   - Field: 'expr'
[01:29:39.190]   - Field: 'uuid'
[01:29:39.191]   - Field: 'seed'
[01:29:39.191]   - Field: 'version'
[01:29:39.191]   - Field: 'result'
[01:29:39.191]   - Field: 'asynchronous'
[01:29:39.194]   - Field: 'calls'
[01:29:39.194]   - Field: 'globals'
[01:29:39.194]   - Field: 'stdout'
[01:29:39.194]   - Field: 'earlySignal'
[01:29:39.195]   - Field: 'lazy'
[01:29:39.195]   - Field: 'state'
[01:29:39.195] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:39.195] - Launch lazy future ...
[01:29:39.195] Packages needed by the future expression (n = 1): 'utils'
[01:29:39.196] Packages needed by future strategies (n = 0): <none>
[01:29:39.196] {
[01:29:39.196]     {
[01:29:39.196]         {
[01:29:39.196]             ...future.startTime <- base::Sys.time()
[01:29:39.196]             {
[01:29:39.196]                 {
[01:29:39.196]                   {
[01:29:39.196]                     {
[01:29:39.196]                       {
[01:29:39.196]                         base::local({
[01:29:39.196]                           has_future <- base::requireNamespace("future", 
[01:29:39.196]                             quietly = TRUE)
[01:29:39.196]                           if (has_future) {
[01:29:39.196]                             ns <- base::getNamespace("future")
[01:29:39.196]                             version <- ns[[".package"]][["version"]]
[01:29:39.196]                             if (is.null(version)) 
[01:29:39.196]                               version <- utils::packageVersion("future")
[01:29:39.196]                           }
[01:29:39.196]                           else {
[01:29:39.196]                             version <- NULL
[01:29:39.196]                           }
[01:29:39.196]                           if (!has_future || version < "1.8.0") {
[01:29:39.196]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:39.196]                               "", base::R.version$version.string), 
[01:29:39.196]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:39.196]                                 base::R.version$platform, 8 * 
[01:29:39.196]                                   base::.Machine$sizeof.pointer), 
[01:29:39.196]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:39.196]                                 "release", "version")], collapse = " "), 
[01:29:39.196]                               hostname = base::Sys.info()[["nodename"]])
[01:29:39.196]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:39.196]                               info)
[01:29:39.196]                             info <- base::paste(info, collapse = "; ")
[01:29:39.196]                             if (!has_future) {
[01:29:39.196]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:39.196]                                 info)
[01:29:39.196]                             }
[01:29:39.196]                             else {
[01:29:39.196]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:39.196]                                 info, version)
[01:29:39.196]                             }
[01:29:39.196]                             base::stop(msg)
[01:29:39.196]                           }
[01:29:39.196]                         })
[01:29:39.196]                       }
[01:29:39.196]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:39.196]                       base::options(mc.cores = 1L)
[01:29:39.196]                     }
[01:29:39.196]                     base::local({
[01:29:39.196]                       for (pkg in "utils") {
[01:29:39.196]                         base::loadNamespace(pkg)
[01:29:39.196]                         base::library(pkg, character.only = TRUE)
[01:29:39.196]                       }
[01:29:39.196]                     })
[01:29:39.196]                   }
[01:29:39.196]                   options(future.plan = NULL)
[01:29:39.196]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:39.196]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:39.196]                 }
[01:29:39.196]                 ...future.workdir <- getwd()
[01:29:39.196]             }
[01:29:39.196]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:39.196]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:39.196]         }
[01:29:39.196]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:39.196]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:39.196]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:39.196]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:39.196]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:39.196]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:39.196]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:39.196]             base::names(...future.oldOptions))
[01:29:39.196]     }
[01:29:39.196]     if (TRUE) {
[01:29:39.196]     }
[01:29:39.196]     else {
[01:29:39.196]         if (NA) {
[01:29:39.196]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:39.196]                 open = "w")
[01:29:39.196]         }
[01:29:39.196]         else {
[01:29:39.196]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:39.196]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:39.196]         }
[01:29:39.196]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:39.196]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:39.196]             base::sink(type = "output", split = FALSE)
[01:29:39.196]             base::close(...future.stdout)
[01:29:39.196]         }, add = TRUE)
[01:29:39.196]     }
[01:29:39.196]     ...future.frame <- base::sys.nframe()
[01:29:39.196]     ...future.conditions <- base::list()
[01:29:39.196]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:39.196]     if (FALSE) {
[01:29:39.196]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:39.196]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:39.196]     }
[01:29:39.196]     ...future.result <- base::tryCatch({
[01:29:39.196]         base::withCallingHandlers({
[01:29:39.196]             ...future.value <- base::withVisible(base::local({
[01:29:39.196]                 ...future.makeSendCondition <- base::local({
[01:29:39.196]                   sendCondition <- NULL
[01:29:39.196]                   function(frame = 1L) {
[01:29:39.196]                     if (is.function(sendCondition)) 
[01:29:39.196]                       return(sendCondition)
[01:29:39.196]                     ns <- getNamespace("parallel")
[01:29:39.196]                     if (exists("sendData", mode = "function", 
[01:29:39.196]                       envir = ns)) {
[01:29:39.196]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:39.196]                         envir = ns)
[01:29:39.196]                       envir <- sys.frame(frame)
[01:29:39.196]                       master <- NULL
[01:29:39.196]                       while (!identical(envir, .GlobalEnv) && 
[01:29:39.196]                         !identical(envir, emptyenv())) {
[01:29:39.196]                         if (exists("master", mode = "list", envir = envir, 
[01:29:39.196]                           inherits = FALSE)) {
[01:29:39.196]                           master <- get("master", mode = "list", 
[01:29:39.196]                             envir = envir, inherits = FALSE)
[01:29:39.196]                           if (inherits(master, c("SOCKnode", 
[01:29:39.196]                             "SOCK0node"))) {
[01:29:39.196]                             sendCondition <<- function(cond) {
[01:29:39.196]                               data <- list(type = "VALUE", value = cond, 
[01:29:39.196]                                 success = TRUE)
[01:29:39.196]                               parallel_sendData(master, data)
[01:29:39.196]                             }
[01:29:39.196]                             return(sendCondition)
[01:29:39.196]                           }
[01:29:39.196]                         }
[01:29:39.196]                         frame <- frame + 1L
[01:29:39.196]                         envir <- sys.frame(frame)
[01:29:39.196]                       }
[01:29:39.196]                     }
[01:29:39.196]                     sendCondition <<- function(cond) NULL
[01:29:39.196]                   }
[01:29:39.196]                 })
[01:29:39.196]                 withCallingHandlers({
[01:29:39.196]                   {
[01:29:39.196]                     print(1:50)
[01:29:39.196]                     str(1:50)
[01:29:39.196]                     cat(letters, sep = "-")
[01:29:39.196]                     cat(1:6, collapse = "\n")
[01:29:39.196]                     write.table(datasets::iris[1:10, ], sep = "\t")
[01:29:39.196]                     42L
[01:29:39.196]                   }
[01:29:39.196]                 }, immediateCondition = function(cond) {
[01:29:39.196]                   sendCondition <- ...future.makeSendCondition()
[01:29:39.196]                   sendCondition(cond)
[01:29:39.196]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.196]                   {
[01:29:39.196]                     inherits <- base::inherits
[01:29:39.196]                     invokeRestart <- base::invokeRestart
[01:29:39.196]                     is.null <- base::is.null
[01:29:39.196]                     muffled <- FALSE
[01:29:39.196]                     if (inherits(cond, "message")) {
[01:29:39.196]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:39.196]                       if (muffled) 
[01:29:39.196]                         invokeRestart("muffleMessage")
[01:29:39.196]                     }
[01:29:39.196]                     else if (inherits(cond, "warning")) {
[01:29:39.196]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:39.196]                       if (muffled) 
[01:29:39.196]                         invokeRestart("muffleWarning")
[01:29:39.196]                     }
[01:29:39.196]                     else if (inherits(cond, "condition")) {
[01:29:39.196]                       if (!is.null(pattern)) {
[01:29:39.196]                         computeRestarts <- base::computeRestarts
[01:29:39.196]                         grepl <- base::grepl
[01:29:39.196]                         restarts <- computeRestarts(cond)
[01:29:39.196]                         for (restart in restarts) {
[01:29:39.196]                           name <- restart$name
[01:29:39.196]                           if (is.null(name)) 
[01:29:39.196]                             next
[01:29:39.196]                           if (!grepl(pattern, name)) 
[01:29:39.196]                             next
[01:29:39.196]                           invokeRestart(restart)
[01:29:39.196]                           muffled <- TRUE
[01:29:39.196]                           break
[01:29:39.196]                         }
[01:29:39.196]                       }
[01:29:39.196]                     }
[01:29:39.196]                     invisible(muffled)
[01:29:39.196]                   }
[01:29:39.196]                   muffleCondition(cond)
[01:29:39.196]                 })
[01:29:39.196]             }))
[01:29:39.196]             future::FutureResult(value = ...future.value$value, 
[01:29:39.196]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:39.196]                   ...future.rng), globalenv = if (FALSE) 
[01:29:39.196]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:39.196]                     ...future.globalenv.names))
[01:29:39.196]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:39.196]         }, condition = base::local({
[01:29:39.196]             c <- base::c
[01:29:39.196]             inherits <- base::inherits
[01:29:39.196]             invokeRestart <- base::invokeRestart
[01:29:39.196]             length <- base::length
[01:29:39.196]             list <- base::list
[01:29:39.196]             seq.int <- base::seq.int
[01:29:39.196]             signalCondition <- base::signalCondition
[01:29:39.196]             sys.calls <- base::sys.calls
[01:29:39.196]             `[[` <- base::`[[`
[01:29:39.196]             `+` <- base::`+`
[01:29:39.196]             `<<-` <- base::`<<-`
[01:29:39.196]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:39.196]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:39.196]                   3L)]
[01:29:39.196]             }
[01:29:39.196]             function(cond) {
[01:29:39.196]                 is_error <- inherits(cond, "error")
[01:29:39.196]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:39.196]                   NULL)
[01:29:39.196]                 if (is_error) {
[01:29:39.196]                   sessionInformation <- function() {
[01:29:39.196]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:39.196]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:39.196]                       search = base::search(), system = base::Sys.info())
[01:29:39.196]                   }
[01:29:39.196]                   ...future.conditions[[length(...future.conditions) + 
[01:29:39.196]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:39.196]                     cond$call), session = sessionInformation(), 
[01:29:39.196]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:39.196]                   signalCondition(cond)
[01:29:39.196]                 }
[01:29:39.196]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:39.196]                 "immediateCondition"))) {
[01:29:39.196]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:39.196]                   ...future.conditions[[length(...future.conditions) + 
[01:29:39.196]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:39.196]                   if (TRUE && !signal) {
[01:29:39.196]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.196]                     {
[01:29:39.196]                       inherits <- base::inherits
[01:29:39.196]                       invokeRestart <- base::invokeRestart
[01:29:39.196]                       is.null <- base::is.null
[01:29:39.196]                       muffled <- FALSE
[01:29:39.196]                       if (inherits(cond, "message")) {
[01:29:39.196]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:39.196]                         if (muffled) 
[01:29:39.196]                           invokeRestart("muffleMessage")
[01:29:39.196]                       }
[01:29:39.196]                       else if (inherits(cond, "warning")) {
[01:29:39.196]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:39.196]                         if (muffled) 
[01:29:39.196]                           invokeRestart("muffleWarning")
[01:29:39.196]                       }
[01:29:39.196]                       else if (inherits(cond, "condition")) {
[01:29:39.196]                         if (!is.null(pattern)) {
[01:29:39.196]                           computeRestarts <- base::computeRestarts
[01:29:39.196]                           grepl <- base::grepl
[01:29:39.196]                           restarts <- computeRestarts(cond)
[01:29:39.196]                           for (restart in restarts) {
[01:29:39.196]                             name <- restart$name
[01:29:39.196]                             if (is.null(name)) 
[01:29:39.196]                               next
[01:29:39.196]                             if (!grepl(pattern, name)) 
[01:29:39.196]                               next
[01:29:39.196]                             invokeRestart(restart)
[01:29:39.196]                             muffled <- TRUE
[01:29:39.196]                             break
[01:29:39.196]                           }
[01:29:39.196]                         }
[01:29:39.196]                       }
[01:29:39.196]                       invisible(muffled)
[01:29:39.196]                     }
[01:29:39.196]                     muffleCondition(cond, pattern = "^muffle")
[01:29:39.196]                   }
[01:29:39.196]                 }
[01:29:39.196]                 else {
[01:29:39.196]                   if (TRUE) {
[01:29:39.196]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.196]                     {
[01:29:39.196]                       inherits <- base::inherits
[01:29:39.196]                       invokeRestart <- base::invokeRestart
[01:29:39.196]                       is.null <- base::is.null
[01:29:39.196]                       muffled <- FALSE
[01:29:39.196]                       if (inherits(cond, "message")) {
[01:29:39.196]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:39.196]                         if (muffled) 
[01:29:39.196]                           invokeRestart("muffleMessage")
[01:29:39.196]                       }
[01:29:39.196]                       else if (inherits(cond, "warning")) {
[01:29:39.196]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:39.196]                         if (muffled) 
[01:29:39.196]                           invokeRestart("muffleWarning")
[01:29:39.196]                       }
[01:29:39.196]                       else if (inherits(cond, "condition")) {
[01:29:39.196]                         if (!is.null(pattern)) {
[01:29:39.196]                           computeRestarts <- base::computeRestarts
[01:29:39.196]                           grepl <- base::grepl
[01:29:39.196]                           restarts <- computeRestarts(cond)
[01:29:39.196]                           for (restart in restarts) {
[01:29:39.196]                             name <- restart$name
[01:29:39.196]                             if (is.null(name)) 
[01:29:39.196]                               next
[01:29:39.196]                             if (!grepl(pattern, name)) 
[01:29:39.196]                               next
[01:29:39.196]                             invokeRestart(restart)
[01:29:39.196]                             muffled <- TRUE
[01:29:39.196]                             break
[01:29:39.196]                           }
[01:29:39.196]                         }
[01:29:39.196]                       }
[01:29:39.196]                       invisible(muffled)
[01:29:39.196]                     }
[01:29:39.196]                     muffleCondition(cond, pattern = "^muffle")
[01:29:39.196]                   }
[01:29:39.196]                 }
[01:29:39.196]             }
[01:29:39.196]         }))
[01:29:39.196]     }, error = function(ex) {
[01:29:39.196]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:39.196]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:39.196]                 ...future.rng), started = ...future.startTime, 
[01:29:39.196]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:39.196]             version = "1.8"), class = "FutureResult")
[01:29:39.196]     }, finally = {
[01:29:39.196]         if (!identical(...future.workdir, getwd())) 
[01:29:39.196]             setwd(...future.workdir)
[01:29:39.196]         {
[01:29:39.196]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:39.196]                 ...future.oldOptions$nwarnings <- NULL
[01:29:39.196]             }
[01:29:39.196]             base::options(...future.oldOptions)
[01:29:39.196]             if (.Platform$OS.type == "windows") {
[01:29:39.196]                 old_names <- names(...future.oldEnvVars)
[01:29:39.196]                 envs <- base::Sys.getenv()
[01:29:39.196]                 names <- names(envs)
[01:29:39.196]                 common <- intersect(names, old_names)
[01:29:39.196]                 added <- setdiff(names, old_names)
[01:29:39.196]                 removed <- setdiff(old_names, names)
[01:29:39.196]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:39.196]                   envs[common]]
[01:29:39.196]                 NAMES <- toupper(changed)
[01:29:39.196]                 args <- list()
[01:29:39.196]                 for (kk in seq_along(NAMES)) {
[01:29:39.196]                   name <- changed[[kk]]
[01:29:39.196]                   NAME <- NAMES[[kk]]
[01:29:39.196]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.196]                     next
[01:29:39.196]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:39.196]                 }
[01:29:39.196]                 NAMES <- toupper(added)
[01:29:39.196]                 for (kk in seq_along(NAMES)) {
[01:29:39.196]                   name <- added[[kk]]
[01:29:39.196]                   NAME <- NAMES[[kk]]
[01:29:39.196]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.196]                     next
[01:29:39.196]                   args[[name]] <- ""
[01:29:39.196]                 }
[01:29:39.196]                 NAMES <- toupper(removed)
[01:29:39.196]                 for (kk in seq_along(NAMES)) {
[01:29:39.196]                   name <- removed[[kk]]
[01:29:39.196]                   NAME <- NAMES[[kk]]
[01:29:39.196]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.196]                     next
[01:29:39.196]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:39.196]                 }
[01:29:39.196]                 if (length(args) > 0) 
[01:29:39.196]                   base::do.call(base::Sys.setenv, args = args)
[01:29:39.196]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:39.196]             }
[01:29:39.196]             else {
[01:29:39.196]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:39.196]             }
[01:29:39.196]             {
[01:29:39.196]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:39.196]                   0L) {
[01:29:39.196]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:39.196]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:39.196]                   base::options(opts)
[01:29:39.196]                 }
[01:29:39.196]                 {
[01:29:39.196]                   {
[01:29:39.196]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:39.196]                     NULL
[01:29:39.196]                   }
[01:29:39.196]                   options(future.plan = NULL)
[01:29:39.196]                   if (is.na(NA_character_)) 
[01:29:39.196]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:39.196]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:39.196]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:39.196]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:39.196]                     envir = parent.frame()) 
[01:29:39.196]                   {
[01:29:39.196]                     if (is.function(workers)) 
[01:29:39.196]                       workers <- workers()
[01:29:39.196]                     workers <- structure(as.integer(workers), 
[01:29:39.196]                       class = class(workers))
[01:29:39.196]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:39.196]                       workers >= 1)
[01:29:39.196]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:39.196]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:39.196]                     }
[01:29:39.196]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:39.196]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:39.196]                       envir = envir)
[01:29:39.196]                     if (!future$lazy) 
[01:29:39.196]                       future <- run(future)
[01:29:39.196]                     invisible(future)
[01:29:39.196]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:39.196]                 }
[01:29:39.196]             }
[01:29:39.196]         }
[01:29:39.196]     })
[01:29:39.196]     if (FALSE) {
[01:29:39.196]         base::sink(type = "output", split = FALSE)
[01:29:39.196]         if (NA) {
[01:29:39.196]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:39.196]         }
[01:29:39.196]         else {
[01:29:39.196]             ...future.result["stdout"] <- base::list(NULL)
[01:29:39.196]         }
[01:29:39.196]         base::close(...future.stdout)
[01:29:39.196]         ...future.stdout <- NULL
[01:29:39.196]     }
[01:29:39.196]     ...future.result$conditions <- ...future.conditions
[01:29:39.196]     ...future.result$finished <- base::Sys.time()
[01:29:39.196]     ...future.result
[01:29:39.196] }
[01:29:39.202] MultisessionFuture started
[01:29:39.202] - Launch lazy future ... done
[01:29:39.203] run() for 'MultisessionFuture' ... done
[01:29:39.203] result() for ClusterFuture ...
[01:29:39.203] receiveMessageFromWorker() for ClusterFuture ...
[01:29:39.203] - Validating connection of MultisessionFuture
[01:29:39.220] - received message: FutureResult
[01:29:39.221] - Received FutureResult
[01:29:39.221] - Erased future from FutureRegistry
[01:29:39.221] result() for ClusterFuture ...
[01:29:39.221] - result already collected: FutureResult
[01:29:39.221] result() for ClusterFuture ... done
[01:29:39.222] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:39.222] result() for ClusterFuture ... done
List of 11
 $ value       : int 42
 $ visible     : logi TRUE
 $ stdout      : NULL
 $ conditions  : list()
 $ rng         : logi FALSE
 $ globalenv   : NULL
 $ started     : POSIXct[1:1], format: "2023-12-22 01:29:39"
 $ finished    : POSIXct[1:1], format: "2023-12-22 01:29:39"
 $ session_uuid: chr "05f91763-b12d-ded6-9d80-c3ce459b1113"
  ..- attr(*, "source")=List of 5
  .. ..$ host  : Named chr "CRANWIN3"
  .. .. ..- attr(*, "names")= chr "COMPUTERNAME"
  .. ..$ info  : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...
  .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...
  .. ..$ pid   : int 3264
  .. ..$ time  : POSIXct[1:1], format: "2023-12-22 01:29:38"
  .. ..$ random: int 2147483647
 $ r_info      :List of 4
  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1
  .. ..$ : int [1:3] 4 4 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[01:29:39.231] result() for ClusterFuture ...
[01:29:39.231] - result already collected: FutureResult
[01:29:39.231] result() for ClusterFuture ... done
[01:29:39.232] result() for ClusterFuture ...
[01:29:39.232] - result already collected: FutureResult
[01:29:39.232] result() for ClusterFuture ... done
[01:29:39.232] getGlobalsAndPackages() ...
[01:29:39.232] Searching for globals...
[01:29:39.236] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[01:29:39.236] Searching for globals ... DONE
[01:29:39.236] Resolving globals: FALSE
[01:29:39.237] 
[01:29:39.237] - packages: [1] 'utils'
[01:29:39.237] getGlobalsAndPackages() ... DONE
[01:29:39.238] run() for 'Future' ...
[01:29:39.238] - state: 'created'
[01:29:39.238] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:39.253] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:39.253] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:39.254]   - Field: 'node'
[01:29:39.254]   - Field: 'label'
[01:29:39.254]   - Field: 'local'
[01:29:39.254]   - Field: 'owner'
[01:29:39.254]   - Field: 'envir'
[01:29:39.255]   - Field: 'workers'
[01:29:39.255]   - Field: 'packages'
[01:29:39.255]   - Field: 'gc'
[01:29:39.255]   - Field: 'conditions'
[01:29:39.255]   - Field: 'persistent'
[01:29:39.256]   - Field: 'expr'
[01:29:39.256]   - Field: 'uuid'
[01:29:39.256]   - Field: 'seed'
[01:29:39.256]   - Field: 'version'
[01:29:39.256]   - Field: 'result'
[01:29:39.257]   - Field: 'asynchronous'
[01:29:39.257]   - Field: 'calls'
[01:29:39.257]   - Field: 'globals'
[01:29:39.257]   - Field: 'stdout'
[01:29:39.257]   - Field: 'earlySignal'
[01:29:39.257]   - Field: 'lazy'
[01:29:39.258]   - Field: 'state'
[01:29:39.258] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:39.258] - Launch lazy future ...
[01:29:39.258] Packages needed by the future expression (n = 1): 'utils'
[01:29:39.259] Packages needed by future strategies (n = 0): <none>
[01:29:39.259] {
[01:29:39.259]     {
[01:29:39.259]         {
[01:29:39.259]             ...future.startTime <- base::Sys.time()
[01:29:39.259]             {
[01:29:39.259]                 {
[01:29:39.259]                   {
[01:29:39.259]                     {
[01:29:39.259]                       {
[01:29:39.259]                         base::local({
[01:29:39.259]                           has_future <- base::requireNamespace("future", 
[01:29:39.259]                             quietly = TRUE)
[01:29:39.259]                           if (has_future) {
[01:29:39.259]                             ns <- base::getNamespace("future")
[01:29:39.259]                             version <- ns[[".package"]][["version"]]
[01:29:39.259]                             if (is.null(version)) 
[01:29:39.259]                               version <- utils::packageVersion("future")
[01:29:39.259]                           }
[01:29:39.259]                           else {
[01:29:39.259]                             version <- NULL
[01:29:39.259]                           }
[01:29:39.259]                           if (!has_future || version < "1.8.0") {
[01:29:39.259]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:39.259]                               "", base::R.version$version.string), 
[01:29:39.259]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:39.259]                                 base::R.version$platform, 8 * 
[01:29:39.259]                                   base::.Machine$sizeof.pointer), 
[01:29:39.259]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:39.259]                                 "release", "version")], collapse = " "), 
[01:29:39.259]                               hostname = base::Sys.info()[["nodename"]])
[01:29:39.259]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:39.259]                               info)
[01:29:39.259]                             info <- base::paste(info, collapse = "; ")
[01:29:39.259]                             if (!has_future) {
[01:29:39.259]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:39.259]                                 info)
[01:29:39.259]                             }
[01:29:39.259]                             else {
[01:29:39.259]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:39.259]                                 info, version)
[01:29:39.259]                             }
[01:29:39.259]                             base::stop(msg)
[01:29:39.259]                           }
[01:29:39.259]                         })
[01:29:39.259]                       }
[01:29:39.259]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:39.259]                       base::options(mc.cores = 1L)
[01:29:39.259]                     }
[01:29:39.259]                     base::local({
[01:29:39.259]                       for (pkg in "utils") {
[01:29:39.259]                         base::loadNamespace(pkg)
[01:29:39.259]                         base::library(pkg, character.only = TRUE)
[01:29:39.259]                       }
[01:29:39.259]                     })
[01:29:39.259]                   }
[01:29:39.259]                   options(future.plan = NULL)
[01:29:39.259]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:39.259]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:39.259]                 }
[01:29:39.259]                 ...future.workdir <- getwd()
[01:29:39.259]             }
[01:29:39.259]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:39.259]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:39.259]         }
[01:29:39.259]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:39.259]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:39.259]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:39.259]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:39.259]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:39.259]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:39.259]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:39.259]             base::names(...future.oldOptions))
[01:29:39.259]     }
[01:29:39.259]     if (TRUE) {
[01:29:39.259]     }
[01:29:39.259]     else {
[01:29:39.259]         if (NA) {
[01:29:39.259]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:39.259]                 open = "w")
[01:29:39.259]         }
[01:29:39.259]         else {
[01:29:39.259]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:39.259]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:39.259]         }
[01:29:39.259]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:39.259]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:39.259]             base::sink(type = "output", split = FALSE)
[01:29:39.259]             base::close(...future.stdout)
[01:29:39.259]         }, add = TRUE)
[01:29:39.259]     }
[01:29:39.259]     ...future.frame <- base::sys.nframe()
[01:29:39.259]     ...future.conditions <- base::list()
[01:29:39.259]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:39.259]     if (FALSE) {
[01:29:39.259]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:39.259]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:39.259]     }
[01:29:39.259]     ...future.result <- base::tryCatch({
[01:29:39.259]         base::withCallingHandlers({
[01:29:39.259]             ...future.value <- base::withVisible(base::local({
[01:29:39.259]                 ...future.makeSendCondition <- base::local({
[01:29:39.259]                   sendCondition <- NULL
[01:29:39.259]                   function(frame = 1L) {
[01:29:39.259]                     if (is.function(sendCondition)) 
[01:29:39.259]                       return(sendCondition)
[01:29:39.259]                     ns <- getNamespace("parallel")
[01:29:39.259]                     if (exists("sendData", mode = "function", 
[01:29:39.259]                       envir = ns)) {
[01:29:39.259]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:39.259]                         envir = ns)
[01:29:39.259]                       envir <- sys.frame(frame)
[01:29:39.259]                       master <- NULL
[01:29:39.259]                       while (!identical(envir, .GlobalEnv) && 
[01:29:39.259]                         !identical(envir, emptyenv())) {
[01:29:39.259]                         if (exists("master", mode = "list", envir = envir, 
[01:29:39.259]                           inherits = FALSE)) {
[01:29:39.259]                           master <- get("master", mode = "list", 
[01:29:39.259]                             envir = envir, inherits = FALSE)
[01:29:39.259]                           if (inherits(master, c("SOCKnode", 
[01:29:39.259]                             "SOCK0node"))) {
[01:29:39.259]                             sendCondition <<- function(cond) {
[01:29:39.259]                               data <- list(type = "VALUE", value = cond, 
[01:29:39.259]                                 success = TRUE)
[01:29:39.259]                               parallel_sendData(master, data)
[01:29:39.259]                             }
[01:29:39.259]                             return(sendCondition)
[01:29:39.259]                           }
[01:29:39.259]                         }
[01:29:39.259]                         frame <- frame + 1L
[01:29:39.259]                         envir <- sys.frame(frame)
[01:29:39.259]                       }
[01:29:39.259]                     }
[01:29:39.259]                     sendCondition <<- function(cond) NULL
[01:29:39.259]                   }
[01:29:39.259]                 })
[01:29:39.259]                 withCallingHandlers({
[01:29:39.259]                   {
[01:29:39.259]                     print(1:50)
[01:29:39.259]                     str(1:50)
[01:29:39.259]                     cat(letters, sep = "-")
[01:29:39.259]                     cat(1:6, collapse = "\n")
[01:29:39.259]                     write.table(datasets::iris[1:10, ], sep = "\t")
[01:29:39.259]                     42L
[01:29:39.259]                   }
[01:29:39.259]                 }, immediateCondition = function(cond) {
[01:29:39.259]                   sendCondition <- ...future.makeSendCondition()
[01:29:39.259]                   sendCondition(cond)
[01:29:39.259]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.259]                   {
[01:29:39.259]                     inherits <- base::inherits
[01:29:39.259]                     invokeRestart <- base::invokeRestart
[01:29:39.259]                     is.null <- base::is.null
[01:29:39.259]                     muffled <- FALSE
[01:29:39.259]                     if (inherits(cond, "message")) {
[01:29:39.259]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:39.259]                       if (muffled) 
[01:29:39.259]                         invokeRestart("muffleMessage")
[01:29:39.259]                     }
[01:29:39.259]                     else if (inherits(cond, "warning")) {
[01:29:39.259]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:39.259]                       if (muffled) 
[01:29:39.259]                         invokeRestart("muffleWarning")
[01:29:39.259]                     }
[01:29:39.259]                     else if (inherits(cond, "condition")) {
[01:29:39.259]                       if (!is.null(pattern)) {
[01:29:39.259]                         computeRestarts <- base::computeRestarts
[01:29:39.259]                         grepl <- base::grepl
[01:29:39.259]                         restarts <- computeRestarts(cond)
[01:29:39.259]                         for (restart in restarts) {
[01:29:39.259]                           name <- restart$name
[01:29:39.259]                           if (is.null(name)) 
[01:29:39.259]                             next
[01:29:39.259]                           if (!grepl(pattern, name)) 
[01:29:39.259]                             next
[01:29:39.259]                           invokeRestart(restart)
[01:29:39.259]                           muffled <- TRUE
[01:29:39.259]                           break
[01:29:39.259]                         }
[01:29:39.259]                       }
[01:29:39.259]                     }
[01:29:39.259]                     invisible(muffled)
[01:29:39.259]                   }
[01:29:39.259]                   muffleCondition(cond)
[01:29:39.259]                 })
[01:29:39.259]             }))
[01:29:39.259]             future::FutureResult(value = ...future.value$value, 
[01:29:39.259]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:39.259]                   ...future.rng), globalenv = if (FALSE) 
[01:29:39.259]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:39.259]                     ...future.globalenv.names))
[01:29:39.259]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:39.259]         }, condition = base::local({
[01:29:39.259]             c <- base::c
[01:29:39.259]             inherits <- base::inherits
[01:29:39.259]             invokeRestart <- base::invokeRestart
[01:29:39.259]             length <- base::length
[01:29:39.259]             list <- base::list
[01:29:39.259]             seq.int <- base::seq.int
[01:29:39.259]             signalCondition <- base::signalCondition
[01:29:39.259]             sys.calls <- base::sys.calls
[01:29:39.259]             `[[` <- base::`[[`
[01:29:39.259]             `+` <- base::`+`
[01:29:39.259]             `<<-` <- base::`<<-`
[01:29:39.259]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:39.259]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:39.259]                   3L)]
[01:29:39.259]             }
[01:29:39.259]             function(cond) {
[01:29:39.259]                 is_error <- inherits(cond, "error")
[01:29:39.259]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:39.259]                   NULL)
[01:29:39.259]                 if (is_error) {
[01:29:39.259]                   sessionInformation <- function() {
[01:29:39.259]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:39.259]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:39.259]                       search = base::search(), system = base::Sys.info())
[01:29:39.259]                   }
[01:29:39.259]                   ...future.conditions[[length(...future.conditions) + 
[01:29:39.259]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:39.259]                     cond$call), session = sessionInformation(), 
[01:29:39.259]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:39.259]                   signalCondition(cond)
[01:29:39.259]                 }
[01:29:39.259]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:39.259]                 "immediateCondition"))) {
[01:29:39.259]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:39.259]                   ...future.conditions[[length(...future.conditions) + 
[01:29:39.259]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:39.259]                   if (TRUE && !signal) {
[01:29:39.259]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.259]                     {
[01:29:39.259]                       inherits <- base::inherits
[01:29:39.259]                       invokeRestart <- base::invokeRestart
[01:29:39.259]                       is.null <- base::is.null
[01:29:39.259]                       muffled <- FALSE
[01:29:39.259]                       if (inherits(cond, "message")) {
[01:29:39.259]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:39.259]                         if (muffled) 
[01:29:39.259]                           invokeRestart("muffleMessage")
[01:29:39.259]                       }
[01:29:39.259]                       else if (inherits(cond, "warning")) {
[01:29:39.259]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:39.259]                         if (muffled) 
[01:29:39.259]                           invokeRestart("muffleWarning")
[01:29:39.259]                       }
[01:29:39.259]                       else if (inherits(cond, "condition")) {
[01:29:39.259]                         if (!is.null(pattern)) {
[01:29:39.259]                           computeRestarts <- base::computeRestarts
[01:29:39.259]                           grepl <- base::grepl
[01:29:39.259]                           restarts <- computeRestarts(cond)
[01:29:39.259]                           for (restart in restarts) {
[01:29:39.259]                             name <- restart$name
[01:29:39.259]                             if (is.null(name)) 
[01:29:39.259]                               next
[01:29:39.259]                             if (!grepl(pattern, name)) 
[01:29:39.259]                               next
[01:29:39.259]                             invokeRestart(restart)
[01:29:39.259]                             muffled <- TRUE
[01:29:39.259]                             break
[01:29:39.259]                           }
[01:29:39.259]                         }
[01:29:39.259]                       }
[01:29:39.259]                       invisible(muffled)
[01:29:39.259]                     }
[01:29:39.259]                     muffleCondition(cond, pattern = "^muffle")
[01:29:39.259]                   }
[01:29:39.259]                 }
[01:29:39.259]                 else {
[01:29:39.259]                   if (TRUE) {
[01:29:39.259]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.259]                     {
[01:29:39.259]                       inherits <- base::inherits
[01:29:39.259]                       invokeRestart <- base::invokeRestart
[01:29:39.259]                       is.null <- base::is.null
[01:29:39.259]                       muffled <- FALSE
[01:29:39.259]                       if (inherits(cond, "message")) {
[01:29:39.259]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:39.259]                         if (muffled) 
[01:29:39.259]                           invokeRestart("muffleMessage")
[01:29:39.259]                       }
[01:29:39.259]                       else if (inherits(cond, "warning")) {
[01:29:39.259]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:39.259]                         if (muffled) 
[01:29:39.259]                           invokeRestart("muffleWarning")
[01:29:39.259]                       }
[01:29:39.259]                       else if (inherits(cond, "condition")) {
[01:29:39.259]                         if (!is.null(pattern)) {
[01:29:39.259]                           computeRestarts <- base::computeRestarts
[01:29:39.259]                           grepl <- base::grepl
[01:29:39.259]                           restarts <- computeRestarts(cond)
[01:29:39.259]                           for (restart in restarts) {
[01:29:39.259]                             name <- restart$name
[01:29:39.259]                             if (is.null(name)) 
[01:29:39.259]                               next
[01:29:39.259]                             if (!grepl(pattern, name)) 
[01:29:39.259]                               next
[01:29:39.259]                             invokeRestart(restart)
[01:29:39.259]                             muffled <- TRUE
[01:29:39.259]                             break
[01:29:39.259]                           }
[01:29:39.259]                         }
[01:29:39.259]                       }
[01:29:39.259]                       invisible(muffled)
[01:29:39.259]                     }
[01:29:39.259]                     muffleCondition(cond, pattern = "^muffle")
[01:29:39.259]                   }
[01:29:39.259]                 }
[01:29:39.259]             }
[01:29:39.259]         }))
[01:29:39.259]     }, error = function(ex) {
[01:29:39.259]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:39.259]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:39.259]                 ...future.rng), started = ...future.startTime, 
[01:29:39.259]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:39.259]             version = "1.8"), class = "FutureResult")
[01:29:39.259]     }, finally = {
[01:29:39.259]         if (!identical(...future.workdir, getwd())) 
[01:29:39.259]             setwd(...future.workdir)
[01:29:39.259]         {
[01:29:39.259]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:39.259]                 ...future.oldOptions$nwarnings <- NULL
[01:29:39.259]             }
[01:29:39.259]             base::options(...future.oldOptions)
[01:29:39.259]             if (.Platform$OS.type == "windows") {
[01:29:39.259]                 old_names <- names(...future.oldEnvVars)
[01:29:39.259]                 envs <- base::Sys.getenv()
[01:29:39.259]                 names <- names(envs)
[01:29:39.259]                 common <- intersect(names, old_names)
[01:29:39.259]                 added <- setdiff(names, old_names)
[01:29:39.259]                 removed <- setdiff(old_names, names)
[01:29:39.259]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:39.259]                   envs[common]]
[01:29:39.259]                 NAMES <- toupper(changed)
[01:29:39.259]                 args <- list()
[01:29:39.259]                 for (kk in seq_along(NAMES)) {
[01:29:39.259]                   name <- changed[[kk]]
[01:29:39.259]                   NAME <- NAMES[[kk]]
[01:29:39.259]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.259]                     next
[01:29:39.259]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:39.259]                 }
[01:29:39.259]                 NAMES <- toupper(added)
[01:29:39.259]                 for (kk in seq_along(NAMES)) {
[01:29:39.259]                   name <- added[[kk]]
[01:29:39.259]                   NAME <- NAMES[[kk]]
[01:29:39.259]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.259]                     next
[01:29:39.259]                   args[[name]] <- ""
[01:29:39.259]                 }
[01:29:39.259]                 NAMES <- toupper(removed)
[01:29:39.259]                 for (kk in seq_along(NAMES)) {
[01:29:39.259]                   name <- removed[[kk]]
[01:29:39.259]                   NAME <- NAMES[[kk]]
[01:29:39.259]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.259]                     next
[01:29:39.259]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:39.259]                 }
[01:29:39.259]                 if (length(args) > 0) 
[01:29:39.259]                   base::do.call(base::Sys.setenv, args = args)
[01:29:39.259]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:39.259]             }
[01:29:39.259]             else {
[01:29:39.259]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:39.259]             }
[01:29:39.259]             {
[01:29:39.259]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:39.259]                   0L) {
[01:29:39.259]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:39.259]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:39.259]                   base::options(opts)
[01:29:39.259]                 }
[01:29:39.259]                 {
[01:29:39.259]                   {
[01:29:39.259]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:39.259]                     NULL
[01:29:39.259]                   }
[01:29:39.259]                   options(future.plan = NULL)
[01:29:39.259]                   if (is.na(NA_character_)) 
[01:29:39.259]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:39.259]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:39.259]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:39.259]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:39.259]                     envir = parent.frame()) 
[01:29:39.259]                   {
[01:29:39.259]                     if (is.function(workers)) 
[01:29:39.259]                       workers <- workers()
[01:29:39.259]                     workers <- structure(as.integer(workers), 
[01:29:39.259]                       class = class(workers))
[01:29:39.259]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:39.259]                       workers >= 1)
[01:29:39.259]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:39.259]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:39.259]                     }
[01:29:39.259]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:39.259]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:39.259]                       envir = envir)
[01:29:39.259]                     if (!future$lazy) 
[01:29:39.259]                       future <- run(future)
[01:29:39.259]                     invisible(future)
[01:29:39.259]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:39.259]                 }
[01:29:39.259]             }
[01:29:39.259]         }
[01:29:39.259]     })
[01:29:39.259]     if (FALSE) {
[01:29:39.259]         base::sink(type = "output", split = FALSE)
[01:29:39.259]         if (NA) {
[01:29:39.259]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:39.259]         }
[01:29:39.259]         else {
[01:29:39.259]             ...future.result["stdout"] <- base::list(NULL)
[01:29:39.259]         }
[01:29:39.259]         base::close(...future.stdout)
[01:29:39.259]         ...future.stdout <- NULL
[01:29:39.259]     }
[01:29:39.259]     ...future.result$conditions <- ...future.conditions
[01:29:39.259]     ...future.result$finished <- base::Sys.time()
[01:29:39.259]     ...future.result
[01:29:39.259] }
[01:29:39.265] MultisessionFuture started
[01:29:39.265] - Launch lazy future ... done
[01:29:39.266] run() for 'MultisessionFuture' ... done
[01:29:39.266] result() for ClusterFuture ...
[01:29:39.266] receiveMessageFromWorker() for ClusterFuture ...
[01:29:39.266] - Validating connection of MultisessionFuture
[01:29:39.283] - received message: FutureResult
[01:29:39.283] - Received FutureResult
[01:29:39.283] - Erased future from FutureRegistry
[01:29:39.283] result() for ClusterFuture ...
[01:29:39.283] - result already collected: FutureResult
[01:29:39.284] result() for ClusterFuture ... done
[01:29:39.284] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:39.284] result() for ClusterFuture ... done
[01:29:39.284] result() for ClusterFuture ...
[01:29:39.284] - result already collected: FutureResult
[01:29:39.284] result() for ClusterFuture ... done
- stdout = structure(TRUE, drop = TRUE)
[01:29:39.285] getGlobalsAndPackages() ...
[01:29:39.286] Searching for globals...
[01:29:39.287] - globals found: [1] 'print'
[01:29:39.287] Searching for globals ... DONE
[01:29:39.288] Resolving globals: FALSE
[01:29:39.288] 
[01:29:39.288] 
[01:29:39.288] getGlobalsAndPackages() ... DONE
[01:29:39.289] run() for 'Future' ...
[01:29:39.289] - state: 'created'
[01:29:39.290] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:39.307] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:39.307] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:39.307]   - Field: 'node'
[01:29:39.308]   - Field: 'label'
[01:29:39.308]   - Field: 'local'
[01:29:39.308]   - Field: 'owner'
[01:29:39.308]   - Field: 'envir'
[01:29:39.308]   - Field: 'workers'
[01:29:39.309]   - Field: 'packages'
[01:29:39.309]   - Field: 'gc'
[01:29:39.309]   - Field: 'conditions'
[01:29:39.309]   - Field: 'persistent'
[01:29:39.309]   - Field: 'expr'
[01:29:39.310]   - Field: 'uuid'
[01:29:39.310]   - Field: 'seed'
[01:29:39.310]   - Field: 'version'
[01:29:39.310]   - Field: 'result'
[01:29:39.310]   - Field: 'asynchronous'
[01:29:39.311]   - Field: 'calls'
[01:29:39.311]   - Field: 'globals'
[01:29:39.311]   - Field: 'stdout'
[01:29:39.311]   - Field: 'earlySignal'
[01:29:39.311]   - Field: 'lazy'
[01:29:39.312]   - Field: 'state'
[01:29:39.312] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:39.312] - Launch lazy future ...
[01:29:39.313] Packages needed by the future expression (n = 0): <none>
[01:29:39.313] Packages needed by future strategies (n = 0): <none>
[01:29:39.314] {
[01:29:39.314]     {
[01:29:39.314]         {
[01:29:39.314]             ...future.startTime <- base::Sys.time()
[01:29:39.314]             {
[01:29:39.314]                 {
[01:29:39.314]                   {
[01:29:39.314]                     {
[01:29:39.314]                       base::local({
[01:29:39.314]                         has_future <- base::requireNamespace("future", 
[01:29:39.314]                           quietly = TRUE)
[01:29:39.314]                         if (has_future) {
[01:29:39.314]                           ns <- base::getNamespace("future")
[01:29:39.314]                           version <- ns[[".package"]][["version"]]
[01:29:39.314]                           if (is.null(version)) 
[01:29:39.314]                             version <- utils::packageVersion("future")
[01:29:39.314]                         }
[01:29:39.314]                         else {
[01:29:39.314]                           version <- NULL
[01:29:39.314]                         }
[01:29:39.314]                         if (!has_future || version < "1.8.0") {
[01:29:39.314]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:39.314]                             "", base::R.version$version.string), 
[01:29:39.314]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:39.314]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:39.314]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:39.314]                               "release", "version")], collapse = " "), 
[01:29:39.314]                             hostname = base::Sys.info()[["nodename"]])
[01:29:39.314]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:39.314]                             info)
[01:29:39.314]                           info <- base::paste(info, collapse = "; ")
[01:29:39.314]                           if (!has_future) {
[01:29:39.314]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:39.314]                               info)
[01:29:39.314]                           }
[01:29:39.314]                           else {
[01:29:39.314]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:39.314]                               info, version)
[01:29:39.314]                           }
[01:29:39.314]                           base::stop(msg)
[01:29:39.314]                         }
[01:29:39.314]                       })
[01:29:39.314]                     }
[01:29:39.314]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:39.314]                     base::options(mc.cores = 1L)
[01:29:39.314]                   }
[01:29:39.314]                   options(future.plan = NULL)
[01:29:39.314]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:39.314]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:39.314]                 }
[01:29:39.314]                 ...future.workdir <- getwd()
[01:29:39.314]             }
[01:29:39.314]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:39.314]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:39.314]         }
[01:29:39.314]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:39.314]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:39.314]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:39.314]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:39.314]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:39.314]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:39.314]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:39.314]             base::names(...future.oldOptions))
[01:29:39.314]     }
[01:29:39.314]     if (FALSE) {
[01:29:39.314]     }
[01:29:39.314]     else {
[01:29:39.314]         if (TRUE) {
[01:29:39.314]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:39.314]                 open = "w")
[01:29:39.314]         }
[01:29:39.314]         else {
[01:29:39.314]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:39.314]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:39.314]         }
[01:29:39.314]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:39.314]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:39.314]             base::sink(type = "output", split = FALSE)
[01:29:39.314]             base::close(...future.stdout)
[01:29:39.314]         }, add = TRUE)
[01:29:39.314]     }
[01:29:39.314]     ...future.frame <- base::sys.nframe()
[01:29:39.314]     ...future.conditions <- base::list()
[01:29:39.314]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:39.314]     if (FALSE) {
[01:29:39.314]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:39.314]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:39.314]     }
[01:29:39.314]     ...future.result <- base::tryCatch({
[01:29:39.314]         base::withCallingHandlers({
[01:29:39.314]             ...future.value <- base::withVisible(base::local({
[01:29:39.314]                 ...future.makeSendCondition <- base::local({
[01:29:39.314]                   sendCondition <- NULL
[01:29:39.314]                   function(frame = 1L) {
[01:29:39.314]                     if (is.function(sendCondition)) 
[01:29:39.314]                       return(sendCondition)
[01:29:39.314]                     ns <- getNamespace("parallel")
[01:29:39.314]                     if (exists("sendData", mode = "function", 
[01:29:39.314]                       envir = ns)) {
[01:29:39.314]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:39.314]                         envir = ns)
[01:29:39.314]                       envir <- sys.frame(frame)
[01:29:39.314]                       master <- NULL
[01:29:39.314]                       while (!identical(envir, .GlobalEnv) && 
[01:29:39.314]                         !identical(envir, emptyenv())) {
[01:29:39.314]                         if (exists("master", mode = "list", envir = envir, 
[01:29:39.314]                           inherits = FALSE)) {
[01:29:39.314]                           master <- get("master", mode = "list", 
[01:29:39.314]                             envir = envir, inherits = FALSE)
[01:29:39.314]                           if (inherits(master, c("SOCKnode", 
[01:29:39.314]                             "SOCK0node"))) {
[01:29:39.314]                             sendCondition <<- function(cond) {
[01:29:39.314]                               data <- list(type = "VALUE", value = cond, 
[01:29:39.314]                                 success = TRUE)
[01:29:39.314]                               parallel_sendData(master, data)
[01:29:39.314]                             }
[01:29:39.314]                             return(sendCondition)
[01:29:39.314]                           }
[01:29:39.314]                         }
[01:29:39.314]                         frame <- frame + 1L
[01:29:39.314]                         envir <- sys.frame(frame)
[01:29:39.314]                       }
[01:29:39.314]                     }
[01:29:39.314]                     sendCondition <<- function(cond) NULL
[01:29:39.314]                   }
[01:29:39.314]                 })
[01:29:39.314]                 withCallingHandlers({
[01:29:39.314]                   print(42)
[01:29:39.314]                 }, immediateCondition = function(cond) {
[01:29:39.314]                   sendCondition <- ...future.makeSendCondition()
[01:29:39.314]                   sendCondition(cond)
[01:29:39.314]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.314]                   {
[01:29:39.314]                     inherits <- base::inherits
[01:29:39.314]                     invokeRestart <- base::invokeRestart
[01:29:39.314]                     is.null <- base::is.null
[01:29:39.314]                     muffled <- FALSE
[01:29:39.314]                     if (inherits(cond, "message")) {
[01:29:39.314]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:39.314]                       if (muffled) 
[01:29:39.314]                         invokeRestart("muffleMessage")
[01:29:39.314]                     }
[01:29:39.314]                     else if (inherits(cond, "warning")) {
[01:29:39.314]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:39.314]                       if (muffled) 
[01:29:39.314]                         invokeRestart("muffleWarning")
[01:29:39.314]                     }
[01:29:39.314]                     else if (inherits(cond, "condition")) {
[01:29:39.314]                       if (!is.null(pattern)) {
[01:29:39.314]                         computeRestarts <- base::computeRestarts
[01:29:39.314]                         grepl <- base::grepl
[01:29:39.314]                         restarts <- computeRestarts(cond)
[01:29:39.314]                         for (restart in restarts) {
[01:29:39.314]                           name <- restart$name
[01:29:39.314]                           if (is.null(name)) 
[01:29:39.314]                             next
[01:29:39.314]                           if (!grepl(pattern, name)) 
[01:29:39.314]                             next
[01:29:39.314]                           invokeRestart(restart)
[01:29:39.314]                           muffled <- TRUE
[01:29:39.314]                           break
[01:29:39.314]                         }
[01:29:39.314]                       }
[01:29:39.314]                     }
[01:29:39.314]                     invisible(muffled)
[01:29:39.314]                   }
[01:29:39.314]                   muffleCondition(cond)
[01:29:39.314]                 })
[01:29:39.314]             }))
[01:29:39.314]             future::FutureResult(value = ...future.value$value, 
[01:29:39.314]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:39.314]                   ...future.rng), globalenv = if (FALSE) 
[01:29:39.314]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:39.314]                     ...future.globalenv.names))
[01:29:39.314]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:39.314]         }, condition = base::local({
[01:29:39.314]             c <- base::c
[01:29:39.314]             inherits <- base::inherits
[01:29:39.314]             invokeRestart <- base::invokeRestart
[01:29:39.314]             length <- base::length
[01:29:39.314]             list <- base::list
[01:29:39.314]             seq.int <- base::seq.int
[01:29:39.314]             signalCondition <- base::signalCondition
[01:29:39.314]             sys.calls <- base::sys.calls
[01:29:39.314]             `[[` <- base::`[[`
[01:29:39.314]             `+` <- base::`+`
[01:29:39.314]             `<<-` <- base::`<<-`
[01:29:39.314]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:39.314]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:39.314]                   3L)]
[01:29:39.314]             }
[01:29:39.314]             function(cond) {
[01:29:39.314]                 is_error <- inherits(cond, "error")
[01:29:39.314]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:39.314]                   NULL)
[01:29:39.314]                 if (is_error) {
[01:29:39.314]                   sessionInformation <- function() {
[01:29:39.314]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:39.314]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:39.314]                       search = base::search(), system = base::Sys.info())
[01:29:39.314]                   }
[01:29:39.314]                   ...future.conditions[[length(...future.conditions) + 
[01:29:39.314]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:39.314]                     cond$call), session = sessionInformation(), 
[01:29:39.314]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:39.314]                   signalCondition(cond)
[01:29:39.314]                 }
[01:29:39.314]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:39.314]                 "immediateCondition"))) {
[01:29:39.314]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:39.314]                   ...future.conditions[[length(...future.conditions) + 
[01:29:39.314]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:39.314]                   if (TRUE && !signal) {
[01:29:39.314]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.314]                     {
[01:29:39.314]                       inherits <- base::inherits
[01:29:39.314]                       invokeRestart <- base::invokeRestart
[01:29:39.314]                       is.null <- base::is.null
[01:29:39.314]                       muffled <- FALSE
[01:29:39.314]                       if (inherits(cond, "message")) {
[01:29:39.314]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:39.314]                         if (muffled) 
[01:29:39.314]                           invokeRestart("muffleMessage")
[01:29:39.314]                       }
[01:29:39.314]                       else if (inherits(cond, "warning")) {
[01:29:39.314]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:39.314]                         if (muffled) 
[01:29:39.314]                           invokeRestart("muffleWarning")
[01:29:39.314]                       }
[01:29:39.314]                       else if (inherits(cond, "condition")) {
[01:29:39.314]                         if (!is.null(pattern)) {
[01:29:39.314]                           computeRestarts <- base::computeRestarts
[01:29:39.314]                           grepl <- base::grepl
[01:29:39.314]                           restarts <- computeRestarts(cond)
[01:29:39.314]                           for (restart in restarts) {
[01:29:39.314]                             name <- restart$name
[01:29:39.314]                             if (is.null(name)) 
[01:29:39.314]                               next
[01:29:39.314]                             if (!grepl(pattern, name)) 
[01:29:39.314]                               next
[01:29:39.314]                             invokeRestart(restart)
[01:29:39.314]                             muffled <- TRUE
[01:29:39.314]                             break
[01:29:39.314]                           }
[01:29:39.314]                         }
[01:29:39.314]                       }
[01:29:39.314]                       invisible(muffled)
[01:29:39.314]                     }
[01:29:39.314]                     muffleCondition(cond, pattern = "^muffle")
[01:29:39.314]                   }
[01:29:39.314]                 }
[01:29:39.314]                 else {
[01:29:39.314]                   if (TRUE) {
[01:29:39.314]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:39.314]                     {
[01:29:39.314]                       inherits <- base::inherits
[01:29:39.314]                       invokeRestart <- base::invokeRestart
[01:29:39.314]                       is.null <- base::is.null
[01:29:39.314]                       muffled <- FALSE
[01:29:39.314]                       if (inherits(cond, "message")) {
[01:29:39.314]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:39.314]                         if (muffled) 
[01:29:39.314]                           invokeRestart("muffleMessage")
[01:29:39.314]                       }
[01:29:39.314]                       else if (inherits(cond, "warning")) {
[01:29:39.314]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:39.314]                         if (muffled) 
[01:29:39.314]                           invokeRestart("muffleWarning")
[01:29:39.314]                       }
[01:29:39.314]                       else if (inherits(cond, "condition")) {
[01:29:39.314]                         if (!is.null(pattern)) {
[01:29:39.314]                           computeRestarts <- base::computeRestarts
[01:29:39.314]                           grepl <- base::grepl
[01:29:39.314]                           restarts <- computeRestarts(cond)
[01:29:39.314]                           for (restart in restarts) {
[01:29:39.314]                             name <- restart$name
[01:29:39.314]                             if (is.null(name)) 
[01:29:39.314]                               next
[01:29:39.314]                             if (!grepl(pattern, name)) 
[01:29:39.314]                               next
[01:29:39.314]                             invokeRestart(restart)
[01:29:39.314]                             muffled <- TRUE
[01:29:39.314]                             break
[01:29:39.314]                           }
[01:29:39.314]                         }
[01:29:39.314]                       }
[01:29:39.314]                       invisible(muffled)
[01:29:39.314]                     }
[01:29:39.314]                     muffleCondition(cond, pattern = "^muffle")
[01:29:39.314]                   }
[01:29:39.314]                 }
[01:29:39.314]             }
[01:29:39.314]         }))
[01:29:39.314]     }, error = function(ex) {
[01:29:39.314]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:39.314]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:39.314]                 ...future.rng), started = ...future.startTime, 
[01:29:39.314]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:39.314]             version = "1.8"), class = "FutureResult")
[01:29:39.314]     }, finally = {
[01:29:39.314]         if (!identical(...future.workdir, getwd())) 
[01:29:39.314]             setwd(...future.workdir)
[01:29:39.314]         {
[01:29:39.314]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:39.314]                 ...future.oldOptions$nwarnings <- NULL
[01:29:39.314]             }
[01:29:39.314]             base::options(...future.oldOptions)
[01:29:39.314]             if (.Platform$OS.type == "windows") {
[01:29:39.314]                 old_names <- names(...future.oldEnvVars)
[01:29:39.314]                 envs <- base::Sys.getenv()
[01:29:39.314]                 names <- names(envs)
[01:29:39.314]                 common <- intersect(names, old_names)
[01:29:39.314]                 added <- setdiff(names, old_names)
[01:29:39.314]                 removed <- setdiff(old_names, names)
[01:29:39.314]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:39.314]                   envs[common]]
[01:29:39.314]                 NAMES <- toupper(changed)
[01:29:39.314]                 args <- list()
[01:29:39.314]                 for (kk in seq_along(NAMES)) {
[01:29:39.314]                   name <- changed[[kk]]
[01:29:39.314]                   NAME <- NAMES[[kk]]
[01:29:39.314]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.314]                     next
[01:29:39.314]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:39.314]                 }
[01:29:39.314]                 NAMES <- toupper(added)
[01:29:39.314]                 for (kk in seq_along(NAMES)) {
[01:29:39.314]                   name <- added[[kk]]
[01:29:39.314]                   NAME <- NAMES[[kk]]
[01:29:39.314]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.314]                     next
[01:29:39.314]                   args[[name]] <- ""
[01:29:39.314]                 }
[01:29:39.314]                 NAMES <- toupper(removed)
[01:29:39.314]                 for (kk in seq_along(NAMES)) {
[01:29:39.314]                   name <- removed[[kk]]
[01:29:39.314]                   NAME <- NAMES[[kk]]
[01:29:39.314]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:39.314]                     next
[01:29:39.314]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:39.314]                 }
[01:29:39.314]                 if (length(args) > 0) 
[01:29:39.314]                   base::do.call(base::Sys.setenv, args = args)
[01:29:39.314]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:39.314]             }
[01:29:39.314]             else {
[01:29:39.314]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:39.314]             }
[01:29:39.314]             {
[01:29:39.314]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:39.314]                   0L) {
[01:29:39.314]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:39.314]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:39.314]                   base::options(opts)
[01:29:39.314]                 }
[01:29:39.314]                 {
[01:29:39.314]                   {
[01:29:39.314]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:39.314]                     NULL
[01:29:39.314]                   }
[01:29:39.314]                   options(future.plan = NULL)
[01:29:39.314]                   if (is.na(NA_character_)) 
[01:29:39.314]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:39.314]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:39.314]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:39.314]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:39.314]                     envir = parent.frame()) 
[01:29:39.314]                   {
[01:29:39.314]                     if (is.function(workers)) 
[01:29:39.314]                       workers <- workers()
[01:29:39.314]                     workers <- structure(as.integer(workers), 
[01:29:39.314]                       class = class(workers))
[01:29:39.314]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:39.314]                       workers >= 1)
[01:29:39.314]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:39.314]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:39.314]                     }
[01:29:39.314]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:39.314]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:39.314]                       envir = envir)
[01:29:39.314]                     if (!future$lazy) 
[01:29:39.314]                       future <- run(future)
[01:29:39.314]                     invisible(future)
[01:29:39.314]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:39.314]                 }
[01:29:39.314]             }
[01:29:39.314]         }
[01:29:39.314]     })
[01:29:39.314]     if (TRUE) {
[01:29:39.314]         base::sink(type = "output", split = FALSE)
[01:29:39.314]         if (TRUE) {
[01:29:39.314]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:39.314]         }
[01:29:39.314]         else {
[01:29:39.314]             ...future.result["stdout"] <- base::list(NULL)
[01:29:39.314]         }
[01:29:39.314]         base::close(...future.stdout)
[01:29:39.314]         ...future.stdout <- NULL
[01:29:39.314]     }
[01:29:39.314]     ...future.result$conditions <- ...future.conditions
[01:29:39.314]     ...future.result$finished <- base::Sys.time()
[01:29:39.314]     ...future.result
[01:29:39.314] }
[01:29:39.321] MultisessionFuture started
[01:29:39.321] - Launch lazy future ... done
[01:29:39.322] run() for 'MultisessionFuture' ... done
[01:29:39.322] result() for ClusterFuture ...
[01:29:39.322] receiveMessageFromWorker() for ClusterFuture ...
[01:29:39.322] - Validating connection of MultisessionFuture
[01:29:39.338] - received message: FutureResult
[01:29:39.338] - Received FutureResult
[01:29:39.338] - Erased future from FutureRegistry
[01:29:39.339] result() for ClusterFuture ...
[01:29:39.339] - result already collected: FutureResult
[01:29:39.339] result() for ClusterFuture ... done
[01:29:39.339] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:39.339] result() for ClusterFuture ... done
[01:29:39.339] result() for ClusterFuture ...
[01:29:39.340] - result already collected: FutureResult
[01:29:39.340] result() for ClusterFuture ... done
[01:29:39.340] result() for ClusterFuture ...
[01:29:39.340] - result already collected: FutureResult
[01:29:39.340] result() for ClusterFuture ... done
[1] 42
[01:29:39.341] result() for ClusterFuture ...
[01:29:39.341] - result already collected: FutureResult
[01:29:39.341] result() for ClusterFuture ... done
multisession ... done
Testing with 2 cores ... done
> 
> message("*** Standard output ... DONE")
*** Standard output ... DONE
> 
> source("incl/end.R")
[01:29:39.342] plan(): Setting new future strategy stack:
[01:29:39.342] List of future strategies:
[01:29:39.342] 1. FutureStrategy:
[01:29:39.342]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:39.342]    - tweaked: FALSE
[01:29:39.342]    - call: future::plan(oplan)
[01:29:39.344] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=204] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS43_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUBDIRS_STRICT_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_INSTALL_TIME_PATCHES_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   1.09    0.09    2.12