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

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

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

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

> source("incl/start.R")
[17:29:54.888] plan(): Setting new future strategy stack:
[17:29:54.890] List of future strategies:
[17:29:54.890] 1. sequential:
[17:29:54.890]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:54.890]    - tweaked: FALSE
[17:29:54.890]    - call: future::plan("sequential")
[17:29:54.917] 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 ...
[17:29:55.027] plan(): Setting new future strategy stack:
[17:29:55.028] List of future strategies:
[17:29:55.028] 1. sequential:
[17:29:55.028]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.028]    - tweaked: FALSE
[17:29:55.028]    - call: plan(strategy)
[17:29:55.052] plan(): nbrOfWorkers() = 1
- stdout = TRUE
[17:29:55.053] getGlobalsAndPackages() ...
[17:29:55.054] Searching for globals...
[17:29:55.073] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:29:55.074] Searching for globals ... DONE
[17:29:55.074] Resolving globals: FALSE
[17:29:55.076] 
[17:29:55.076] - packages: [1] 'utils'
[17:29:55.076] getGlobalsAndPackages() ... DONE
[17:29:55.078] run() for 'Future' ...
[17:29:55.078] - state: 'created'
[17:29:55.078] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:55.079] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:55.079] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:55.080]   - Field: 'label'
[17:29:55.080]   - Field: 'local'
[17:29:55.080]   - Field: 'owner'
[17:29:55.080]   - Field: 'envir'
[17:29:55.080]   - Field: 'packages'
[17:29:55.081]   - Field: 'gc'
[17:29:55.081]   - Field: 'conditions'
[17:29:55.081]   - Field: 'expr'
[17:29:55.081]   - Field: 'uuid'
[17:29:55.081]   - Field: 'seed'
[17:29:55.082]   - Field: 'version'
[17:29:55.082]   - Field: 'result'
[17:29:55.082]   - Field: 'asynchronous'
[17:29:55.083]   - Field: 'calls'
[17:29:55.083]   - Field: 'globals'
[17:29:55.083]   - Field: 'stdout'
[17:29:55.084]   - Field: 'earlySignal'
[17:29:55.084]   - Field: 'lazy'
[17:29:55.084]   - Field: 'state'
[17:29:55.085] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:55.085] - Launch lazy future ...
[17:29:55.086] Packages needed by the future expression (n = 1): 'utils'
[17:29:55.086] Packages needed by future strategies (n = 0): <none>
[17:29:55.088] {
[17:29:55.088]     {
[17:29:55.088]         {
[17:29:55.088]             ...future.startTime <- base::Sys.time()
[17:29:55.088]             {
[17:29:55.088]                 {
[17:29:55.088]                   {
[17:29:55.088]                     {
[17:29:55.088]                       base::local({
[17:29:55.088]                         has_future <- base::requireNamespace("future", 
[17:29:55.088]                           quietly = TRUE)
[17:29:55.088]                         if (has_future) {
[17:29:55.088]                           ns <- base::getNamespace("future")
[17:29:55.088]                           version <- ns[[".package"]][["version"]]
[17:29:55.088]                           if (is.null(version)) 
[17:29:55.088]                             version <- utils::packageVersion("future")
[17:29:55.088]                         }
[17:29:55.088]                         else {
[17:29:55.088]                           version <- NULL
[17:29:55.088]                         }
[17:29:55.088]                         if (!has_future || version < "1.8.0") {
[17:29:55.088]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:55.088]                             "", base::R.version$version.string), 
[17:29:55.088]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:55.088]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:55.088]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:55.088]                               "release", "version")], collapse = " "), 
[17:29:55.088]                             hostname = base::Sys.info()[["nodename"]])
[17:29:55.088]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:55.088]                             info)
[17:29:55.088]                           info <- base::paste(info, collapse = "; ")
[17:29:55.088]                           if (!has_future) {
[17:29:55.088]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:55.088]                               info)
[17:29:55.088]                           }
[17:29:55.088]                           else {
[17:29:55.088]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:55.088]                               info, version)
[17:29:55.088]                           }
[17:29:55.088]                           base::stop(msg)
[17:29:55.088]                         }
[17:29:55.088]                       })
[17:29:55.088]                     }
[17:29:55.088]                     base::local({
[17:29:55.088]                       for (pkg in "utils") {
[17:29:55.088]                         base::loadNamespace(pkg)
[17:29:55.088]                         base::library(pkg, character.only = TRUE)
[17:29:55.088]                       }
[17:29:55.088]                     })
[17:29:55.088]                   }
[17:29:55.088]                   ...future.strategy.old <- future::plan("list")
[17:29:55.088]                   options(future.plan = NULL)
[17:29:55.088]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.088]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:55.088]                 }
[17:29:55.088]                 ...future.workdir <- getwd()
[17:29:55.088]             }
[17:29:55.088]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:55.088]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:55.088]         }
[17:29:55.088]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:55.088]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:55.088]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:55.088]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:55.088]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:55.088]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:55.088]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:55.088]             base::names(...future.oldOptions))
[17:29:55.088]     }
[17:29:55.088]     if (FALSE) {
[17:29:55.088]     }
[17:29:55.088]     else {
[17:29:55.088]         if (TRUE) {
[17:29:55.088]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:55.088]                 open = "w")
[17:29:55.088]         }
[17:29:55.088]         else {
[17:29:55.088]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:55.088]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:55.088]         }
[17:29:55.088]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:55.088]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:55.088]             base::sink(type = "output", split = FALSE)
[17:29:55.088]             base::close(...future.stdout)
[17:29:55.088]         }, add = TRUE)
[17:29:55.088]     }
[17:29:55.088]     ...future.frame <- base::sys.nframe()
[17:29:55.088]     ...future.conditions <- base::list()
[17:29:55.088]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:55.088]     if (FALSE) {
[17:29:55.088]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:55.088]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:55.088]     }
[17:29:55.088]     ...future.result <- base::tryCatch({
[17:29:55.088]         base::withCallingHandlers({
[17:29:55.088]             ...future.value <- base::withVisible(base::local({
[17:29:55.088]                 print(1:50)
[17:29:55.088]                 str(1:50)
[17:29:55.088]                 cat(letters, sep = "-")
[17:29:55.088]                 cat(1:6, collapse = "\n")
[17:29:55.088]                 write.table(datasets::iris[1:10, ], sep = "\t")
[17:29:55.088]                 42L
[17:29:55.088]             }))
[17:29:55.088]             future::FutureResult(value = ...future.value$value, 
[17:29:55.088]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.088]                   ...future.rng), globalenv = if (FALSE) 
[17:29:55.088]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:55.088]                     ...future.globalenv.names))
[17:29:55.088]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:55.088]         }, condition = base::local({
[17:29:55.088]             c <- base::c
[17:29:55.088]             inherits <- base::inherits
[17:29:55.088]             invokeRestart <- base::invokeRestart
[17:29:55.088]             length <- base::length
[17:29:55.088]             list <- base::list
[17:29:55.088]             seq.int <- base::seq.int
[17:29:55.088]             signalCondition <- base::signalCondition
[17:29:55.088]             sys.calls <- base::sys.calls
[17:29:55.088]             `[[` <- base::`[[`
[17:29:55.088]             `+` <- base::`+`
[17:29:55.088]             `<<-` <- base::`<<-`
[17:29:55.088]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:55.088]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:55.088]                   3L)]
[17:29:55.088]             }
[17:29:55.088]             function(cond) {
[17:29:55.088]                 is_error <- inherits(cond, "error")
[17:29:55.088]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:55.088]                   NULL)
[17:29:55.088]                 if (is_error) {
[17:29:55.088]                   sessionInformation <- function() {
[17:29:55.088]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:55.088]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:55.088]                       search = base::search(), system = base::Sys.info())
[17:29:55.088]                   }
[17:29:55.088]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.088]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:55.088]                     cond$call), session = sessionInformation(), 
[17:29:55.088]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:55.088]                   signalCondition(cond)
[17:29:55.088]                 }
[17:29:55.088]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:55.088]                 "immediateCondition"))) {
[17:29:55.088]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:55.088]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.088]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:55.088]                   if (TRUE && !signal) {
[17:29:55.088]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.088]                     {
[17:29:55.088]                       inherits <- base::inherits
[17:29:55.088]                       invokeRestart <- base::invokeRestart
[17:29:55.088]                       is.null <- base::is.null
[17:29:55.088]                       muffled <- FALSE
[17:29:55.088]                       if (inherits(cond, "message")) {
[17:29:55.088]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.088]                         if (muffled) 
[17:29:55.088]                           invokeRestart("muffleMessage")
[17:29:55.088]                       }
[17:29:55.088]                       else if (inherits(cond, "warning")) {
[17:29:55.088]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.088]                         if (muffled) 
[17:29:55.088]                           invokeRestart("muffleWarning")
[17:29:55.088]                       }
[17:29:55.088]                       else if (inherits(cond, "condition")) {
[17:29:55.088]                         if (!is.null(pattern)) {
[17:29:55.088]                           computeRestarts <- base::computeRestarts
[17:29:55.088]                           grepl <- base::grepl
[17:29:55.088]                           restarts <- computeRestarts(cond)
[17:29:55.088]                           for (restart in restarts) {
[17:29:55.088]                             name <- restart$name
[17:29:55.088]                             if (is.null(name)) 
[17:29:55.088]                               next
[17:29:55.088]                             if (!grepl(pattern, name)) 
[17:29:55.088]                               next
[17:29:55.088]                             invokeRestart(restart)
[17:29:55.088]                             muffled <- TRUE
[17:29:55.088]                             break
[17:29:55.088]                           }
[17:29:55.088]                         }
[17:29:55.088]                       }
[17:29:55.088]                       invisible(muffled)
[17:29:55.088]                     }
[17:29:55.088]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.088]                   }
[17:29:55.088]                 }
[17:29:55.088]                 else {
[17:29:55.088]                   if (TRUE) {
[17:29:55.088]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.088]                     {
[17:29:55.088]                       inherits <- base::inherits
[17:29:55.088]                       invokeRestart <- base::invokeRestart
[17:29:55.088]                       is.null <- base::is.null
[17:29:55.088]                       muffled <- FALSE
[17:29:55.088]                       if (inherits(cond, "message")) {
[17:29:55.088]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.088]                         if (muffled) 
[17:29:55.088]                           invokeRestart("muffleMessage")
[17:29:55.088]                       }
[17:29:55.088]                       else if (inherits(cond, "warning")) {
[17:29:55.088]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.088]                         if (muffled) 
[17:29:55.088]                           invokeRestart("muffleWarning")
[17:29:55.088]                       }
[17:29:55.088]                       else if (inherits(cond, "condition")) {
[17:29:55.088]                         if (!is.null(pattern)) {
[17:29:55.088]                           computeRestarts <- base::computeRestarts
[17:29:55.088]                           grepl <- base::grepl
[17:29:55.088]                           restarts <- computeRestarts(cond)
[17:29:55.088]                           for (restart in restarts) {
[17:29:55.088]                             name <- restart$name
[17:29:55.088]                             if (is.null(name)) 
[17:29:55.088]                               next
[17:29:55.088]                             if (!grepl(pattern, name)) 
[17:29:55.088]                               next
[17:29:55.088]                             invokeRestart(restart)
[17:29:55.088]                             muffled <- TRUE
[17:29:55.088]                             break
[17:29:55.088]                           }
[17:29:55.088]                         }
[17:29:55.088]                       }
[17:29:55.088]                       invisible(muffled)
[17:29:55.088]                     }
[17:29:55.088]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.088]                   }
[17:29:55.088]                 }
[17:29:55.088]             }
[17:29:55.088]         }))
[17:29:55.088]     }, error = function(ex) {
[17:29:55.088]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:55.088]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.088]                 ...future.rng), started = ...future.startTime, 
[17:29:55.088]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:55.088]             version = "1.8"), class = "FutureResult")
[17:29:55.088]     }, finally = {
[17:29:55.088]         if (!identical(...future.workdir, getwd())) 
[17:29:55.088]             setwd(...future.workdir)
[17:29:55.088]         {
[17:29:55.088]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:55.088]                 ...future.oldOptions$nwarnings <- NULL
[17:29:55.088]             }
[17:29:55.088]             base::options(...future.oldOptions)
[17:29:55.088]             if (.Platform$OS.type == "windows") {
[17:29:55.088]                 old_names <- names(...future.oldEnvVars)
[17:29:55.088]                 envs <- base::Sys.getenv()
[17:29:55.088]                 names <- names(envs)
[17:29:55.088]                 common <- intersect(names, old_names)
[17:29:55.088]                 added <- setdiff(names, old_names)
[17:29:55.088]                 removed <- setdiff(old_names, names)
[17:29:55.088]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:55.088]                   envs[common]]
[17:29:55.088]                 NAMES <- toupper(changed)
[17:29:55.088]                 args <- list()
[17:29:55.088]                 for (kk in seq_along(NAMES)) {
[17:29:55.088]                   name <- changed[[kk]]
[17:29:55.088]                   NAME <- NAMES[[kk]]
[17:29:55.088]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.088]                     next
[17:29:55.088]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.088]                 }
[17:29:55.088]                 NAMES <- toupper(added)
[17:29:55.088]                 for (kk in seq_along(NAMES)) {
[17:29:55.088]                   name <- added[[kk]]
[17:29:55.088]                   NAME <- NAMES[[kk]]
[17:29:55.088]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.088]                     next
[17:29:55.088]                   args[[name]] <- ""
[17:29:55.088]                 }
[17:29:55.088]                 NAMES <- toupper(removed)
[17:29:55.088]                 for (kk in seq_along(NAMES)) {
[17:29:55.088]                   name <- removed[[kk]]
[17:29:55.088]                   NAME <- NAMES[[kk]]
[17:29:55.088]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.088]                     next
[17:29:55.088]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.088]                 }
[17:29:55.088]                 if (length(args) > 0) 
[17:29:55.088]                   base::do.call(base::Sys.setenv, args = args)
[17:29:55.088]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:55.088]             }
[17:29:55.088]             else {
[17:29:55.088]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:55.088]             }
[17:29:55.088]             {
[17:29:55.088]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:55.088]                   0L) {
[17:29:55.088]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:55.088]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:55.088]                   base::options(opts)
[17:29:55.088]                 }
[17:29:55.088]                 {
[17:29:55.088]                   {
[17:29:55.088]                     NULL
[17:29:55.088]                     RNGkind("Mersenne-Twister")
[17:29:55.088]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:55.088]                       inherits = FALSE)
[17:29:55.088]                   }
[17:29:55.088]                   options(future.plan = NULL)
[17:29:55.088]                   if (is.na(NA_character_)) 
[17:29:55.088]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.088]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:55.088]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:55.088]                     .init = FALSE)
[17:29:55.088]                 }
[17:29:55.088]             }
[17:29:55.088]         }
[17:29:55.088]     })
[17:29:55.088]     if (TRUE) {
[17:29:55.088]         base::sink(type = "output", split = FALSE)
[17:29:55.088]         if (TRUE) {
[17:29:55.088]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:55.088]         }
[17:29:55.088]         else {
[17:29:55.088]             ...future.result["stdout"] <- base::list(NULL)
[17:29:55.088]         }
[17:29:55.088]         base::close(...future.stdout)
[17:29:55.088]         ...future.stdout <- NULL
[17:29:55.088]     }
[17:29:55.088]     ...future.result$conditions <- ...future.conditions
[17:29:55.088]     ...future.result$finished <- base::Sys.time()
[17:29:55.088]     ...future.result
[17:29:55.088] }
[17:29:55.097] plan(): Setting new future strategy stack:
[17:29:55.097] List of future strategies:
[17:29:55.097] 1. sequential:
[17:29:55.097]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.097]    - tweaked: FALSE
[17:29:55.097]    - call: NULL
[17:29:55.099] plan(): nbrOfWorkers() = 1
[17:29:55.105] plan(): Setting new future strategy stack:
[17:29:55.105] List of future strategies:
[17:29:55.105] 1. sequential:
[17:29:55.105]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.105]    - tweaked: FALSE
[17:29:55.105]    - call: plan(strategy)
[17:29:55.107] plan(): nbrOfWorkers() = 1
[17:29:55.107] SequentialFuture started (and completed)
[17:29:55.108] - Launch lazy future ... done
[17:29:55.109] 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: "2024-07-29 17:29:55"
 $ finished    : POSIXct[1:1], format: "2024-07-29 17:29:55"
 $ session_uuid: chr "be0736ef-3a70-9a22-50bb-ae47450014f2"
  ..- 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 189084
  .. ..$ time  : POSIXct[1:1], format: "2024-07-29 17:29:54"
  .. ..$ 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 5 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.01148701 secs (started 2024-07-29 17:29:55.096021)
version: 1.8
[17:29:55.138] getGlobalsAndPackages() ...
[17:29:55.138] Searching for globals...
[17:29:55.146] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:29:55.147] Searching for globals ... DONE
[17:29:55.147] Resolving globals: FALSE
[17:29:55.148] 
[17:29:55.148] - packages: [1] 'utils'
[17:29:55.149] getGlobalsAndPackages() ... DONE
[17:29:55.150] run() for 'Future' ...
[17:29:55.150] - state: 'created'
[17:29:55.150] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:55.151] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:55.152] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:55.152]   - Field: 'label'
[17:29:55.152]   - Field: 'local'
[17:29:55.153]   - Field: 'owner'
[17:29:55.153]   - Field: 'envir'
[17:29:55.153]   - Field: 'packages'
[17:29:55.154]   - Field: 'gc'
[17:29:55.154]   - Field: 'conditions'
[17:29:55.154]   - Field: 'expr'
[17:29:55.155]   - Field: 'uuid'
[17:29:55.155]   - Field: 'seed'
[17:29:55.156]   - Field: 'version'
[17:29:55.156]   - Field: 'result'
[17:29:55.156]   - Field: 'asynchronous'
[17:29:55.157]   - Field: 'calls'
[17:29:55.157]   - Field: 'globals'
[17:29:55.157]   - Field: 'stdout'
[17:29:55.158]   - Field: 'earlySignal'
[17:29:55.158]   - Field: 'lazy'
[17:29:55.159]   - Field: 'state'
[17:29:55.159] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:55.159] - Launch lazy future ...
[17:29:55.160] Packages needed by the future expression (n = 1): 'utils'
[17:29:55.160] Packages needed by future strategies (n = 0): <none>
[17:29:55.161] {
[17:29:55.161]     {
[17:29:55.161]         {
[17:29:55.161]             ...future.startTime <- base::Sys.time()
[17:29:55.161]             {
[17:29:55.161]                 {
[17:29:55.161]                   {
[17:29:55.161]                     {
[17:29:55.161]                       base::local({
[17:29:55.161]                         has_future <- base::requireNamespace("future", 
[17:29:55.161]                           quietly = TRUE)
[17:29:55.161]                         if (has_future) {
[17:29:55.161]                           ns <- base::getNamespace("future")
[17:29:55.161]                           version <- ns[[".package"]][["version"]]
[17:29:55.161]                           if (is.null(version)) 
[17:29:55.161]                             version <- utils::packageVersion("future")
[17:29:55.161]                         }
[17:29:55.161]                         else {
[17:29:55.161]                           version <- NULL
[17:29:55.161]                         }
[17:29:55.161]                         if (!has_future || version < "1.8.0") {
[17:29:55.161]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:55.161]                             "", base::R.version$version.string), 
[17:29:55.161]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:55.161]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:55.161]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:55.161]                               "release", "version")], collapse = " "), 
[17:29:55.161]                             hostname = base::Sys.info()[["nodename"]])
[17:29:55.161]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:55.161]                             info)
[17:29:55.161]                           info <- base::paste(info, collapse = "; ")
[17:29:55.161]                           if (!has_future) {
[17:29:55.161]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:55.161]                               info)
[17:29:55.161]                           }
[17:29:55.161]                           else {
[17:29:55.161]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:55.161]                               info, version)
[17:29:55.161]                           }
[17:29:55.161]                           base::stop(msg)
[17:29:55.161]                         }
[17:29:55.161]                       })
[17:29:55.161]                     }
[17:29:55.161]                     base::local({
[17:29:55.161]                       for (pkg in "utils") {
[17:29:55.161]                         base::loadNamespace(pkg)
[17:29:55.161]                         base::library(pkg, character.only = TRUE)
[17:29:55.161]                       }
[17:29:55.161]                     })
[17:29:55.161]                   }
[17:29:55.161]                   ...future.strategy.old <- future::plan("list")
[17:29:55.161]                   options(future.plan = NULL)
[17:29:55.161]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.161]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:55.161]                 }
[17:29:55.161]                 ...future.workdir <- getwd()
[17:29:55.161]             }
[17:29:55.161]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:55.161]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:55.161]         }
[17:29:55.161]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:55.161]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:55.161]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:55.161]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:55.161]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:55.161]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:55.161]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:55.161]             base::names(...future.oldOptions))
[17:29:55.161]     }
[17:29:55.161]     if (FALSE) {
[17:29:55.161]     }
[17:29:55.161]     else {
[17:29:55.161]         if (TRUE) {
[17:29:55.161]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:55.161]                 open = "w")
[17:29:55.161]         }
[17:29:55.161]         else {
[17:29:55.161]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:55.161]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:55.161]         }
[17:29:55.161]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:55.161]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:55.161]             base::sink(type = "output", split = FALSE)
[17:29:55.161]             base::close(...future.stdout)
[17:29:55.161]         }, add = TRUE)
[17:29:55.161]     }
[17:29:55.161]     ...future.frame <- base::sys.nframe()
[17:29:55.161]     ...future.conditions <- base::list()
[17:29:55.161]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:55.161]     if (FALSE) {
[17:29:55.161]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:55.161]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:55.161]     }
[17:29:55.161]     ...future.result <- base::tryCatch({
[17:29:55.161]         base::withCallingHandlers({
[17:29:55.161]             ...future.value <- base::withVisible(base::local({
[17:29:55.161]                 print(1:50)
[17:29:55.161]                 str(1:50)
[17:29:55.161]                 cat(letters, sep = "-")
[17:29:55.161]                 cat(1:6, collapse = "\n")
[17:29:55.161]                 write.table(datasets::iris[1:10, ], sep = "\t")
[17:29:55.161]                 42L
[17:29:55.161]             }))
[17:29:55.161]             future::FutureResult(value = ...future.value$value, 
[17:29:55.161]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.161]                   ...future.rng), globalenv = if (FALSE) 
[17:29:55.161]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:55.161]                     ...future.globalenv.names))
[17:29:55.161]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:55.161]         }, condition = base::local({
[17:29:55.161]             c <- base::c
[17:29:55.161]             inherits <- base::inherits
[17:29:55.161]             invokeRestart <- base::invokeRestart
[17:29:55.161]             length <- base::length
[17:29:55.161]             list <- base::list
[17:29:55.161]             seq.int <- base::seq.int
[17:29:55.161]             signalCondition <- base::signalCondition
[17:29:55.161]             sys.calls <- base::sys.calls
[17:29:55.161]             `[[` <- base::`[[`
[17:29:55.161]             `+` <- base::`+`
[17:29:55.161]             `<<-` <- base::`<<-`
[17:29:55.161]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:55.161]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:55.161]                   3L)]
[17:29:55.161]             }
[17:29:55.161]             function(cond) {
[17:29:55.161]                 is_error <- inherits(cond, "error")
[17:29:55.161]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:55.161]                   NULL)
[17:29:55.161]                 if (is_error) {
[17:29:55.161]                   sessionInformation <- function() {
[17:29:55.161]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:55.161]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:55.161]                       search = base::search(), system = base::Sys.info())
[17:29:55.161]                   }
[17:29:55.161]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.161]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:55.161]                     cond$call), session = sessionInformation(), 
[17:29:55.161]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:55.161]                   signalCondition(cond)
[17:29:55.161]                 }
[17:29:55.161]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:55.161]                 "immediateCondition"))) {
[17:29:55.161]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:55.161]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.161]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:55.161]                   if (TRUE && !signal) {
[17:29:55.161]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.161]                     {
[17:29:55.161]                       inherits <- base::inherits
[17:29:55.161]                       invokeRestart <- base::invokeRestart
[17:29:55.161]                       is.null <- base::is.null
[17:29:55.161]                       muffled <- FALSE
[17:29:55.161]                       if (inherits(cond, "message")) {
[17:29:55.161]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.161]                         if (muffled) 
[17:29:55.161]                           invokeRestart("muffleMessage")
[17:29:55.161]                       }
[17:29:55.161]                       else if (inherits(cond, "warning")) {
[17:29:55.161]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.161]                         if (muffled) 
[17:29:55.161]                           invokeRestart("muffleWarning")
[17:29:55.161]                       }
[17:29:55.161]                       else if (inherits(cond, "condition")) {
[17:29:55.161]                         if (!is.null(pattern)) {
[17:29:55.161]                           computeRestarts <- base::computeRestarts
[17:29:55.161]                           grepl <- base::grepl
[17:29:55.161]                           restarts <- computeRestarts(cond)
[17:29:55.161]                           for (restart in restarts) {
[17:29:55.161]                             name <- restart$name
[17:29:55.161]                             if (is.null(name)) 
[17:29:55.161]                               next
[17:29:55.161]                             if (!grepl(pattern, name)) 
[17:29:55.161]                               next
[17:29:55.161]                             invokeRestart(restart)
[17:29:55.161]                             muffled <- TRUE
[17:29:55.161]                             break
[17:29:55.161]                           }
[17:29:55.161]                         }
[17:29:55.161]                       }
[17:29:55.161]                       invisible(muffled)
[17:29:55.161]                     }
[17:29:55.161]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.161]                   }
[17:29:55.161]                 }
[17:29:55.161]                 else {
[17:29:55.161]                   if (TRUE) {
[17:29:55.161]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.161]                     {
[17:29:55.161]                       inherits <- base::inherits
[17:29:55.161]                       invokeRestart <- base::invokeRestart
[17:29:55.161]                       is.null <- base::is.null
[17:29:55.161]                       muffled <- FALSE
[17:29:55.161]                       if (inherits(cond, "message")) {
[17:29:55.161]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.161]                         if (muffled) 
[17:29:55.161]                           invokeRestart("muffleMessage")
[17:29:55.161]                       }
[17:29:55.161]                       else if (inherits(cond, "warning")) {
[17:29:55.161]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.161]                         if (muffled) 
[17:29:55.161]                           invokeRestart("muffleWarning")
[17:29:55.161]                       }
[17:29:55.161]                       else if (inherits(cond, "condition")) {
[17:29:55.161]                         if (!is.null(pattern)) {
[17:29:55.161]                           computeRestarts <- base::computeRestarts
[17:29:55.161]                           grepl <- base::grepl
[17:29:55.161]                           restarts <- computeRestarts(cond)
[17:29:55.161]                           for (restart in restarts) {
[17:29:55.161]                             name <- restart$name
[17:29:55.161]                             if (is.null(name)) 
[17:29:55.161]                               next
[17:29:55.161]                             if (!grepl(pattern, name)) 
[17:29:55.161]                               next
[17:29:55.161]                             invokeRestart(restart)
[17:29:55.161]                             muffled <- TRUE
[17:29:55.161]                             break
[17:29:55.161]                           }
[17:29:55.161]                         }
[17:29:55.161]                       }
[17:29:55.161]                       invisible(muffled)
[17:29:55.161]                     }
[17:29:55.161]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.161]                   }
[17:29:55.161]                 }
[17:29:55.161]             }
[17:29:55.161]         }))
[17:29:55.161]     }, error = function(ex) {
[17:29:55.161]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:55.161]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.161]                 ...future.rng), started = ...future.startTime, 
[17:29:55.161]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:55.161]             version = "1.8"), class = "FutureResult")
[17:29:55.161]     }, finally = {
[17:29:55.161]         if (!identical(...future.workdir, getwd())) 
[17:29:55.161]             setwd(...future.workdir)
[17:29:55.161]         {
[17:29:55.161]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:55.161]                 ...future.oldOptions$nwarnings <- NULL
[17:29:55.161]             }
[17:29:55.161]             base::options(...future.oldOptions)
[17:29:55.161]             if (.Platform$OS.type == "windows") {
[17:29:55.161]                 old_names <- names(...future.oldEnvVars)
[17:29:55.161]                 envs <- base::Sys.getenv()
[17:29:55.161]                 names <- names(envs)
[17:29:55.161]                 common <- intersect(names, old_names)
[17:29:55.161]                 added <- setdiff(names, old_names)
[17:29:55.161]                 removed <- setdiff(old_names, names)
[17:29:55.161]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:55.161]                   envs[common]]
[17:29:55.161]                 NAMES <- toupper(changed)
[17:29:55.161]                 args <- list()
[17:29:55.161]                 for (kk in seq_along(NAMES)) {
[17:29:55.161]                   name <- changed[[kk]]
[17:29:55.161]                   NAME <- NAMES[[kk]]
[17:29:55.161]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.161]                     next
[17:29:55.161]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.161]                 }
[17:29:55.161]                 NAMES <- toupper(added)
[17:29:55.161]                 for (kk in seq_along(NAMES)) {
[17:29:55.161]                   name <- added[[kk]]
[17:29:55.161]                   NAME <- NAMES[[kk]]
[17:29:55.161]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.161]                     next
[17:29:55.161]                   args[[name]] <- ""
[17:29:55.161]                 }
[17:29:55.161]                 NAMES <- toupper(removed)
[17:29:55.161]                 for (kk in seq_along(NAMES)) {
[17:29:55.161]                   name <- removed[[kk]]
[17:29:55.161]                   NAME <- NAMES[[kk]]
[17:29:55.161]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.161]                     next
[17:29:55.161]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.161]                 }
[17:29:55.161]                 if (length(args) > 0) 
[17:29:55.161]                   base::do.call(base::Sys.setenv, args = args)
[17:29:55.161]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:55.161]             }
[17:29:55.161]             else {
[17:29:55.161]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:55.161]             }
[17:29:55.161]             {
[17:29:55.161]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:55.161]                   0L) {
[17:29:55.161]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:55.161]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:55.161]                   base::options(opts)
[17:29:55.161]                 }
[17:29:55.161]                 {
[17:29:55.161]                   {
[17:29:55.161]                     NULL
[17:29:55.161]                     RNGkind("Mersenne-Twister")
[17:29:55.161]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:55.161]                       inherits = FALSE)
[17:29:55.161]                   }
[17:29:55.161]                   options(future.plan = NULL)
[17:29:55.161]                   if (is.na(NA_character_)) 
[17:29:55.161]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.161]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:55.161]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:55.161]                     .init = FALSE)
[17:29:55.161]                 }
[17:29:55.161]             }
[17:29:55.161]         }
[17:29:55.161]     })
[17:29:55.161]     if (TRUE) {
[17:29:55.161]         base::sink(type = "output", split = FALSE)
[17:29:55.161]         if (TRUE) {
[17:29:55.161]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:55.161]         }
[17:29:55.161]         else {
[17:29:55.161]             ...future.result["stdout"] <- base::list(NULL)
[17:29:55.161]         }
[17:29:55.161]         base::close(...future.stdout)
[17:29:55.161]         ...future.stdout <- NULL
[17:29:55.161]     }
[17:29:55.161]     ...future.result$conditions <- ...future.conditions
[17:29:55.161]     ...future.result$finished <- base::Sys.time()
[17:29:55.161]     ...future.result
[17:29:55.161] }
[17:29:55.171] plan(): Setting new future strategy stack:
[17:29:55.171] List of future strategies:
[17:29:55.171] 1. sequential:
[17:29:55.171]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.171]    - tweaked: FALSE
[17:29:55.171]    - call: NULL
[17:29:55.172] plan(): nbrOfWorkers() = 1
[17:29:55.177] plan(): Setting new future strategy stack:
[17:29:55.177] List of future strategies:
[17:29:55.177] 1. sequential:
[17:29:55.177]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.177]    - tweaked: FALSE
[17:29:55.177]    - call: plan(strategy)
[17:29:55.178] plan(): nbrOfWorkers() = 1
[17:29:55.179] SequentialFuture started (and completed)
[17:29:55.179] - Launch lazy future ... done
[17:29:55.180] 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)
[17:29:55.182] getGlobalsAndPackages() ...
[17:29:55.182] Searching for globals...
[17:29:55.183] - globals found: [1] 'print'
[17:29:55.184] Searching for globals ... DONE
[17:29:55.184] Resolving globals: FALSE
[17:29:55.185] 
[17:29:55.185] 
[17:29:55.186] getGlobalsAndPackages() ... DONE
[17:29:55.186] run() for 'Future' ...
[17:29:55.187] - state: 'created'
[17:29:55.187] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:55.188] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:55.189] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:55.189]   - Field: 'label'
[17:29:55.189]   - Field: 'local'
[17:29:55.190]   - Field: 'owner'
[17:29:55.190]   - Field: 'envir'
[17:29:55.191]   - Field: 'packages'
[17:29:55.191]   - Field: 'gc'
[17:29:55.192]   - Field: 'conditions'
[17:29:55.192]   - Field: 'expr'
[17:29:55.192]   - Field: 'uuid'
[17:29:55.193]   - Field: 'seed'
[17:29:55.193]   - Field: 'version'
[17:29:55.194]   - Field: 'result'
[17:29:55.194]   - Field: 'asynchronous'
[17:29:55.194]   - Field: 'calls'
[17:29:55.195]   - Field: 'globals'
[17:29:55.198]   - Field: 'stdout'
[17:29:55.199]   - Field: 'earlySignal'
[17:29:55.199]   - Field: 'lazy'
[17:29:55.199]   - Field: 'state'
[17:29:55.200] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:55.200] - Launch lazy future ...
[17:29:55.201] Packages needed by the future expression (n = 0): <none>
[17:29:55.201] Packages needed by future strategies (n = 0): <none>
[17:29:55.202] {
[17:29:55.202]     {
[17:29:55.202]         {
[17:29:55.202]             ...future.startTime <- base::Sys.time()
[17:29:55.202]             {
[17:29:55.202]                 {
[17:29:55.202]                   {
[17:29:55.202]                     base::local({
[17:29:55.202]                       has_future <- base::requireNamespace("future", 
[17:29:55.202]                         quietly = TRUE)
[17:29:55.202]                       if (has_future) {
[17:29:55.202]                         ns <- base::getNamespace("future")
[17:29:55.202]                         version <- ns[[".package"]][["version"]]
[17:29:55.202]                         if (is.null(version)) 
[17:29:55.202]                           version <- utils::packageVersion("future")
[17:29:55.202]                       }
[17:29:55.202]                       else {
[17:29:55.202]                         version <- NULL
[17:29:55.202]                       }
[17:29:55.202]                       if (!has_future || version < "1.8.0") {
[17:29:55.202]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:55.202]                           "", base::R.version$version.string), 
[17:29:55.202]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:55.202]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:55.202]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:55.202]                             "release", "version")], collapse = " "), 
[17:29:55.202]                           hostname = base::Sys.info()[["nodename"]])
[17:29:55.202]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:55.202]                           info)
[17:29:55.202]                         info <- base::paste(info, collapse = "; ")
[17:29:55.202]                         if (!has_future) {
[17:29:55.202]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:55.202]                             info)
[17:29:55.202]                         }
[17:29:55.202]                         else {
[17:29:55.202]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:55.202]                             info, version)
[17:29:55.202]                         }
[17:29:55.202]                         base::stop(msg)
[17:29:55.202]                       }
[17:29:55.202]                     })
[17:29:55.202]                   }
[17:29:55.202]                   ...future.strategy.old <- future::plan("list")
[17:29:55.202]                   options(future.plan = NULL)
[17:29:55.202]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.202]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:55.202]                 }
[17:29:55.202]                 ...future.workdir <- getwd()
[17:29:55.202]             }
[17:29:55.202]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:55.202]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:55.202]         }
[17:29:55.202]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:55.202]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:55.202]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:55.202]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:55.202]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:55.202]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:55.202]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:55.202]             base::names(...future.oldOptions))
[17:29:55.202]     }
[17:29:55.202]     if (FALSE) {
[17:29:55.202]     }
[17:29:55.202]     else {
[17:29:55.202]         if (TRUE) {
[17:29:55.202]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:55.202]                 open = "w")
[17:29:55.202]         }
[17:29:55.202]         else {
[17:29:55.202]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:55.202]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:55.202]         }
[17:29:55.202]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:55.202]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:55.202]             base::sink(type = "output", split = FALSE)
[17:29:55.202]             base::close(...future.stdout)
[17:29:55.202]         }, add = TRUE)
[17:29:55.202]     }
[17:29:55.202]     ...future.frame <- base::sys.nframe()
[17:29:55.202]     ...future.conditions <- base::list()
[17:29:55.202]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:55.202]     if (FALSE) {
[17:29:55.202]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:55.202]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:55.202]     }
[17:29:55.202]     ...future.result <- base::tryCatch({
[17:29:55.202]         base::withCallingHandlers({
[17:29:55.202]             ...future.value <- base::withVisible(base::local(print(42)))
[17:29:55.202]             future::FutureResult(value = ...future.value$value, 
[17:29:55.202]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.202]                   ...future.rng), globalenv = if (FALSE) 
[17:29:55.202]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:55.202]                     ...future.globalenv.names))
[17:29:55.202]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:55.202]         }, condition = base::local({
[17:29:55.202]             c <- base::c
[17:29:55.202]             inherits <- base::inherits
[17:29:55.202]             invokeRestart <- base::invokeRestart
[17:29:55.202]             length <- base::length
[17:29:55.202]             list <- base::list
[17:29:55.202]             seq.int <- base::seq.int
[17:29:55.202]             signalCondition <- base::signalCondition
[17:29:55.202]             sys.calls <- base::sys.calls
[17:29:55.202]             `[[` <- base::`[[`
[17:29:55.202]             `+` <- base::`+`
[17:29:55.202]             `<<-` <- base::`<<-`
[17:29:55.202]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:55.202]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:55.202]                   3L)]
[17:29:55.202]             }
[17:29:55.202]             function(cond) {
[17:29:55.202]                 is_error <- inherits(cond, "error")
[17:29:55.202]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:55.202]                   NULL)
[17:29:55.202]                 if (is_error) {
[17:29:55.202]                   sessionInformation <- function() {
[17:29:55.202]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:55.202]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:55.202]                       search = base::search(), system = base::Sys.info())
[17:29:55.202]                   }
[17:29:55.202]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.202]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:55.202]                     cond$call), session = sessionInformation(), 
[17:29:55.202]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:55.202]                   signalCondition(cond)
[17:29:55.202]                 }
[17:29:55.202]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:55.202]                 "immediateCondition"))) {
[17:29:55.202]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:55.202]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.202]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:55.202]                   if (TRUE && !signal) {
[17:29:55.202]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.202]                     {
[17:29:55.202]                       inherits <- base::inherits
[17:29:55.202]                       invokeRestart <- base::invokeRestart
[17:29:55.202]                       is.null <- base::is.null
[17:29:55.202]                       muffled <- FALSE
[17:29:55.202]                       if (inherits(cond, "message")) {
[17:29:55.202]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.202]                         if (muffled) 
[17:29:55.202]                           invokeRestart("muffleMessage")
[17:29:55.202]                       }
[17:29:55.202]                       else if (inherits(cond, "warning")) {
[17:29:55.202]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.202]                         if (muffled) 
[17:29:55.202]                           invokeRestart("muffleWarning")
[17:29:55.202]                       }
[17:29:55.202]                       else if (inherits(cond, "condition")) {
[17:29:55.202]                         if (!is.null(pattern)) {
[17:29:55.202]                           computeRestarts <- base::computeRestarts
[17:29:55.202]                           grepl <- base::grepl
[17:29:55.202]                           restarts <- computeRestarts(cond)
[17:29:55.202]                           for (restart in restarts) {
[17:29:55.202]                             name <- restart$name
[17:29:55.202]                             if (is.null(name)) 
[17:29:55.202]                               next
[17:29:55.202]                             if (!grepl(pattern, name)) 
[17:29:55.202]                               next
[17:29:55.202]                             invokeRestart(restart)
[17:29:55.202]                             muffled <- TRUE
[17:29:55.202]                             break
[17:29:55.202]                           }
[17:29:55.202]                         }
[17:29:55.202]                       }
[17:29:55.202]                       invisible(muffled)
[17:29:55.202]                     }
[17:29:55.202]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.202]                   }
[17:29:55.202]                 }
[17:29:55.202]                 else {
[17:29:55.202]                   if (TRUE) {
[17:29:55.202]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.202]                     {
[17:29:55.202]                       inherits <- base::inherits
[17:29:55.202]                       invokeRestart <- base::invokeRestart
[17:29:55.202]                       is.null <- base::is.null
[17:29:55.202]                       muffled <- FALSE
[17:29:55.202]                       if (inherits(cond, "message")) {
[17:29:55.202]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.202]                         if (muffled) 
[17:29:55.202]                           invokeRestart("muffleMessage")
[17:29:55.202]                       }
[17:29:55.202]                       else if (inherits(cond, "warning")) {
[17:29:55.202]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.202]                         if (muffled) 
[17:29:55.202]                           invokeRestart("muffleWarning")
[17:29:55.202]                       }
[17:29:55.202]                       else if (inherits(cond, "condition")) {
[17:29:55.202]                         if (!is.null(pattern)) {
[17:29:55.202]                           computeRestarts <- base::computeRestarts
[17:29:55.202]                           grepl <- base::grepl
[17:29:55.202]                           restarts <- computeRestarts(cond)
[17:29:55.202]                           for (restart in restarts) {
[17:29:55.202]                             name <- restart$name
[17:29:55.202]                             if (is.null(name)) 
[17:29:55.202]                               next
[17:29:55.202]                             if (!grepl(pattern, name)) 
[17:29:55.202]                               next
[17:29:55.202]                             invokeRestart(restart)
[17:29:55.202]                             muffled <- TRUE
[17:29:55.202]                             break
[17:29:55.202]                           }
[17:29:55.202]                         }
[17:29:55.202]                       }
[17:29:55.202]                       invisible(muffled)
[17:29:55.202]                     }
[17:29:55.202]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.202]                   }
[17:29:55.202]                 }
[17:29:55.202]             }
[17:29:55.202]         }))
[17:29:55.202]     }, error = function(ex) {
[17:29:55.202]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:55.202]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.202]                 ...future.rng), started = ...future.startTime, 
[17:29:55.202]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:55.202]             version = "1.8"), class = "FutureResult")
[17:29:55.202]     }, finally = {
[17:29:55.202]         if (!identical(...future.workdir, getwd())) 
[17:29:55.202]             setwd(...future.workdir)
[17:29:55.202]         {
[17:29:55.202]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:55.202]                 ...future.oldOptions$nwarnings <- NULL
[17:29:55.202]             }
[17:29:55.202]             base::options(...future.oldOptions)
[17:29:55.202]             if (.Platform$OS.type == "windows") {
[17:29:55.202]                 old_names <- names(...future.oldEnvVars)
[17:29:55.202]                 envs <- base::Sys.getenv()
[17:29:55.202]                 names <- names(envs)
[17:29:55.202]                 common <- intersect(names, old_names)
[17:29:55.202]                 added <- setdiff(names, old_names)
[17:29:55.202]                 removed <- setdiff(old_names, names)
[17:29:55.202]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:55.202]                   envs[common]]
[17:29:55.202]                 NAMES <- toupper(changed)
[17:29:55.202]                 args <- list()
[17:29:55.202]                 for (kk in seq_along(NAMES)) {
[17:29:55.202]                   name <- changed[[kk]]
[17:29:55.202]                   NAME <- NAMES[[kk]]
[17:29:55.202]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.202]                     next
[17:29:55.202]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.202]                 }
[17:29:55.202]                 NAMES <- toupper(added)
[17:29:55.202]                 for (kk in seq_along(NAMES)) {
[17:29:55.202]                   name <- added[[kk]]
[17:29:55.202]                   NAME <- NAMES[[kk]]
[17:29:55.202]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.202]                     next
[17:29:55.202]                   args[[name]] <- ""
[17:29:55.202]                 }
[17:29:55.202]                 NAMES <- toupper(removed)
[17:29:55.202]                 for (kk in seq_along(NAMES)) {
[17:29:55.202]                   name <- removed[[kk]]
[17:29:55.202]                   NAME <- NAMES[[kk]]
[17:29:55.202]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.202]                     next
[17:29:55.202]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.202]                 }
[17:29:55.202]                 if (length(args) > 0) 
[17:29:55.202]                   base::do.call(base::Sys.setenv, args = args)
[17:29:55.202]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:55.202]             }
[17:29:55.202]             else {
[17:29:55.202]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:55.202]             }
[17:29:55.202]             {
[17:29:55.202]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:55.202]                   0L) {
[17:29:55.202]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:55.202]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:55.202]                   base::options(opts)
[17:29:55.202]                 }
[17:29:55.202]                 {
[17:29:55.202]                   {
[17:29:55.202]                     NULL
[17:29:55.202]                     RNGkind("Mersenne-Twister")
[17:29:55.202]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:55.202]                       inherits = FALSE)
[17:29:55.202]                   }
[17:29:55.202]                   options(future.plan = NULL)
[17:29:55.202]                   if (is.na(NA_character_)) 
[17:29:55.202]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.202]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:55.202]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:55.202]                     .init = FALSE)
[17:29:55.202]                 }
[17:29:55.202]             }
[17:29:55.202]         }
[17:29:55.202]     })
[17:29:55.202]     if (TRUE) {
[17:29:55.202]         base::sink(type = "output", split = FALSE)
[17:29:55.202]         if (TRUE) {
[17:29:55.202]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:55.202]         }
[17:29:55.202]         else {
[17:29:55.202]             ...future.result["stdout"] <- base::list(NULL)
[17:29:55.202]         }
[17:29:55.202]         base::close(...future.stdout)
[17:29:55.202]         ...future.stdout <- NULL
[17:29:55.202]     }
[17:29:55.202]     ...future.result$conditions <- ...future.conditions
[17:29:55.202]     ...future.result$finished <- base::Sys.time()
[17:29:55.202]     ...future.result
[17:29:55.202] }
[17:29:55.211] plan(): Setting new future strategy stack:
[17:29:55.211] List of future strategies:
[17:29:55.211] 1. sequential:
[17:29:55.211]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.211]    - tweaked: FALSE
[17:29:55.211]    - call: NULL
[17:29:55.212] plan(): nbrOfWorkers() = 1
[17:29:55.215] plan(): Setting new future strategy stack:
[17:29:55.215] List of future strategies:
[17:29:55.215] 1. sequential:
[17:29:55.215]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.215]    - tweaked: FALSE
[17:29:55.215]    - call: plan(strategy)
[17:29:55.217] plan(): nbrOfWorkers() = 1
[17:29:55.217] SequentialFuture started (and completed)
[17:29:55.217] - Launch lazy future ... done
[17:29:55.218] run() for 'SequentialFuture' ... done
[1] 42
- stdout = FALSE
[17:29:55.219] getGlobalsAndPackages() ...
[17:29:55.219] Searching for globals...
[17:29:55.227] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:29:55.228] Searching for globals ... DONE
[17:29:55.228] Resolving globals: FALSE
[17:29:55.229] 
[17:29:55.230] - packages: [1] 'utils'
[17:29:55.230] getGlobalsAndPackages() ... DONE
[17:29:55.231] run() for 'Future' ...
[17:29:55.231] - state: 'created'
[17:29:55.232] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:55.233] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:55.233] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:55.233]   - Field: 'label'
[17:29:55.234]   - Field: 'local'
[17:29:55.234]   - Field: 'owner'
[17:29:55.235]   - Field: 'envir'
[17:29:55.235]   - Field: 'packages'
[17:29:55.235]   - Field: 'gc'
[17:29:55.236]   - Field: 'conditions'
[17:29:55.236]   - Field: 'expr'
[17:29:55.237]   - Field: 'uuid'
[17:29:55.237]   - Field: 'seed'
[17:29:55.237]   - Field: 'version'
[17:29:55.238]   - Field: 'result'
[17:29:55.238]   - Field: 'asynchronous'
[17:29:55.239]   - Field: 'calls'
[17:29:55.239]   - Field: 'globals'
[17:29:55.239]   - Field: 'stdout'
[17:29:55.240]   - Field: 'earlySignal'
[17:29:55.240]   - Field: 'lazy'
[17:29:55.241]   - Field: 'state'
[17:29:55.241] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:55.241] - Launch lazy future ...
[17:29:55.242] Packages needed by the future expression (n = 1): 'utils'
[17:29:55.242] Packages needed by future strategies (n = 0): <none>
[17:29:55.244] {
[17:29:55.244]     {
[17:29:55.244]         {
[17:29:55.244]             ...future.startTime <- base::Sys.time()
[17:29:55.244]             {
[17:29:55.244]                 {
[17:29:55.244]                   {
[17:29:55.244]                     {
[17:29:55.244]                       base::local({
[17:29:55.244]                         has_future <- base::requireNamespace("future", 
[17:29:55.244]                           quietly = TRUE)
[17:29:55.244]                         if (has_future) {
[17:29:55.244]                           ns <- base::getNamespace("future")
[17:29:55.244]                           version <- ns[[".package"]][["version"]]
[17:29:55.244]                           if (is.null(version)) 
[17:29:55.244]                             version <- utils::packageVersion("future")
[17:29:55.244]                         }
[17:29:55.244]                         else {
[17:29:55.244]                           version <- NULL
[17:29:55.244]                         }
[17:29:55.244]                         if (!has_future || version < "1.8.0") {
[17:29:55.244]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:55.244]                             "", base::R.version$version.string), 
[17:29:55.244]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:55.244]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:55.244]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:55.244]                               "release", "version")], collapse = " "), 
[17:29:55.244]                             hostname = base::Sys.info()[["nodename"]])
[17:29:55.244]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:55.244]                             info)
[17:29:55.244]                           info <- base::paste(info, collapse = "; ")
[17:29:55.244]                           if (!has_future) {
[17:29:55.244]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:55.244]                               info)
[17:29:55.244]                           }
[17:29:55.244]                           else {
[17:29:55.244]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:55.244]                               info, version)
[17:29:55.244]                           }
[17:29:55.244]                           base::stop(msg)
[17:29:55.244]                         }
[17:29:55.244]                       })
[17:29:55.244]                     }
[17:29:55.244]                     base::local({
[17:29:55.244]                       for (pkg in "utils") {
[17:29:55.244]                         base::loadNamespace(pkg)
[17:29:55.244]                         base::library(pkg, character.only = TRUE)
[17:29:55.244]                       }
[17:29:55.244]                     })
[17:29:55.244]                   }
[17:29:55.244]                   ...future.strategy.old <- future::plan("list")
[17:29:55.244]                   options(future.plan = NULL)
[17:29:55.244]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.244]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:55.244]                 }
[17:29:55.244]                 ...future.workdir <- getwd()
[17:29:55.244]             }
[17:29:55.244]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:55.244]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:55.244]         }
[17:29:55.244]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:55.244]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:55.244]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:55.244]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:55.244]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:55.244]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:55.244]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:55.244]             base::names(...future.oldOptions))
[17:29:55.244]     }
[17:29:55.244]     if (FALSE) {
[17:29:55.244]     }
[17:29:55.244]     else {
[17:29:55.244]         if (FALSE) {
[17:29:55.244]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:55.244]                 open = "w")
[17:29:55.244]         }
[17:29:55.244]         else {
[17:29:55.244]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:55.244]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:55.244]         }
[17:29:55.244]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:55.244]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:55.244]             base::sink(type = "output", split = FALSE)
[17:29:55.244]             base::close(...future.stdout)
[17:29:55.244]         }, add = TRUE)
[17:29:55.244]     }
[17:29:55.244]     ...future.frame <- base::sys.nframe()
[17:29:55.244]     ...future.conditions <- base::list()
[17:29:55.244]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:55.244]     if (FALSE) {
[17:29:55.244]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:55.244]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:55.244]     }
[17:29:55.244]     ...future.result <- base::tryCatch({
[17:29:55.244]         base::withCallingHandlers({
[17:29:55.244]             ...future.value <- base::withVisible(base::local({
[17:29:55.244]                 print(1:50)
[17:29:55.244]                 str(1:50)
[17:29:55.244]                 cat(letters, sep = "-")
[17:29:55.244]                 cat(1:6, collapse = "\n")
[17:29:55.244]                 write.table(datasets::iris[1:10, ], sep = "\t")
[17:29:55.244]                 42L
[17:29:55.244]             }))
[17:29:55.244]             future::FutureResult(value = ...future.value$value, 
[17:29:55.244]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.244]                   ...future.rng), globalenv = if (FALSE) 
[17:29:55.244]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:55.244]                     ...future.globalenv.names))
[17:29:55.244]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:55.244]         }, condition = base::local({
[17:29:55.244]             c <- base::c
[17:29:55.244]             inherits <- base::inherits
[17:29:55.244]             invokeRestart <- base::invokeRestart
[17:29:55.244]             length <- base::length
[17:29:55.244]             list <- base::list
[17:29:55.244]             seq.int <- base::seq.int
[17:29:55.244]             signalCondition <- base::signalCondition
[17:29:55.244]             sys.calls <- base::sys.calls
[17:29:55.244]             `[[` <- base::`[[`
[17:29:55.244]             `+` <- base::`+`
[17:29:55.244]             `<<-` <- base::`<<-`
[17:29:55.244]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:55.244]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:55.244]                   3L)]
[17:29:55.244]             }
[17:29:55.244]             function(cond) {
[17:29:55.244]                 is_error <- inherits(cond, "error")
[17:29:55.244]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:55.244]                   NULL)
[17:29:55.244]                 if (is_error) {
[17:29:55.244]                   sessionInformation <- function() {
[17:29:55.244]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:55.244]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:55.244]                       search = base::search(), system = base::Sys.info())
[17:29:55.244]                   }
[17:29:55.244]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.244]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:55.244]                     cond$call), session = sessionInformation(), 
[17:29:55.244]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:55.244]                   signalCondition(cond)
[17:29:55.244]                 }
[17:29:55.244]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:55.244]                 "immediateCondition"))) {
[17:29:55.244]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:55.244]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.244]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:55.244]                   if (TRUE && !signal) {
[17:29:55.244]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.244]                     {
[17:29:55.244]                       inherits <- base::inherits
[17:29:55.244]                       invokeRestart <- base::invokeRestart
[17:29:55.244]                       is.null <- base::is.null
[17:29:55.244]                       muffled <- FALSE
[17:29:55.244]                       if (inherits(cond, "message")) {
[17:29:55.244]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.244]                         if (muffled) 
[17:29:55.244]                           invokeRestart("muffleMessage")
[17:29:55.244]                       }
[17:29:55.244]                       else if (inherits(cond, "warning")) {
[17:29:55.244]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.244]                         if (muffled) 
[17:29:55.244]                           invokeRestart("muffleWarning")
[17:29:55.244]                       }
[17:29:55.244]                       else if (inherits(cond, "condition")) {
[17:29:55.244]                         if (!is.null(pattern)) {
[17:29:55.244]                           computeRestarts <- base::computeRestarts
[17:29:55.244]                           grepl <- base::grepl
[17:29:55.244]                           restarts <- computeRestarts(cond)
[17:29:55.244]                           for (restart in restarts) {
[17:29:55.244]                             name <- restart$name
[17:29:55.244]                             if (is.null(name)) 
[17:29:55.244]                               next
[17:29:55.244]                             if (!grepl(pattern, name)) 
[17:29:55.244]                               next
[17:29:55.244]                             invokeRestart(restart)
[17:29:55.244]                             muffled <- TRUE
[17:29:55.244]                             break
[17:29:55.244]                           }
[17:29:55.244]                         }
[17:29:55.244]                       }
[17:29:55.244]                       invisible(muffled)
[17:29:55.244]                     }
[17:29:55.244]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.244]                   }
[17:29:55.244]                 }
[17:29:55.244]                 else {
[17:29:55.244]                   if (TRUE) {
[17:29:55.244]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.244]                     {
[17:29:55.244]                       inherits <- base::inherits
[17:29:55.244]                       invokeRestart <- base::invokeRestart
[17:29:55.244]                       is.null <- base::is.null
[17:29:55.244]                       muffled <- FALSE
[17:29:55.244]                       if (inherits(cond, "message")) {
[17:29:55.244]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.244]                         if (muffled) 
[17:29:55.244]                           invokeRestart("muffleMessage")
[17:29:55.244]                       }
[17:29:55.244]                       else if (inherits(cond, "warning")) {
[17:29:55.244]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.244]                         if (muffled) 
[17:29:55.244]                           invokeRestart("muffleWarning")
[17:29:55.244]                       }
[17:29:55.244]                       else if (inherits(cond, "condition")) {
[17:29:55.244]                         if (!is.null(pattern)) {
[17:29:55.244]                           computeRestarts <- base::computeRestarts
[17:29:55.244]                           grepl <- base::grepl
[17:29:55.244]                           restarts <- computeRestarts(cond)
[17:29:55.244]                           for (restart in restarts) {
[17:29:55.244]                             name <- restart$name
[17:29:55.244]                             if (is.null(name)) 
[17:29:55.244]                               next
[17:29:55.244]                             if (!grepl(pattern, name)) 
[17:29:55.244]                               next
[17:29:55.244]                             invokeRestart(restart)
[17:29:55.244]                             muffled <- TRUE
[17:29:55.244]                             break
[17:29:55.244]                           }
[17:29:55.244]                         }
[17:29:55.244]                       }
[17:29:55.244]                       invisible(muffled)
[17:29:55.244]                     }
[17:29:55.244]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.244]                   }
[17:29:55.244]                 }
[17:29:55.244]             }
[17:29:55.244]         }))
[17:29:55.244]     }, error = function(ex) {
[17:29:55.244]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:55.244]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.244]                 ...future.rng), started = ...future.startTime, 
[17:29:55.244]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:55.244]             version = "1.8"), class = "FutureResult")
[17:29:55.244]     }, finally = {
[17:29:55.244]         if (!identical(...future.workdir, getwd())) 
[17:29:55.244]             setwd(...future.workdir)
[17:29:55.244]         {
[17:29:55.244]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:55.244]                 ...future.oldOptions$nwarnings <- NULL
[17:29:55.244]             }
[17:29:55.244]             base::options(...future.oldOptions)
[17:29:55.244]             if (.Platform$OS.type == "windows") {
[17:29:55.244]                 old_names <- names(...future.oldEnvVars)
[17:29:55.244]                 envs <- base::Sys.getenv()
[17:29:55.244]                 names <- names(envs)
[17:29:55.244]                 common <- intersect(names, old_names)
[17:29:55.244]                 added <- setdiff(names, old_names)
[17:29:55.244]                 removed <- setdiff(old_names, names)
[17:29:55.244]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:55.244]                   envs[common]]
[17:29:55.244]                 NAMES <- toupper(changed)
[17:29:55.244]                 args <- list()
[17:29:55.244]                 for (kk in seq_along(NAMES)) {
[17:29:55.244]                   name <- changed[[kk]]
[17:29:55.244]                   NAME <- NAMES[[kk]]
[17:29:55.244]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.244]                     next
[17:29:55.244]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.244]                 }
[17:29:55.244]                 NAMES <- toupper(added)
[17:29:55.244]                 for (kk in seq_along(NAMES)) {
[17:29:55.244]                   name <- added[[kk]]
[17:29:55.244]                   NAME <- NAMES[[kk]]
[17:29:55.244]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.244]                     next
[17:29:55.244]                   args[[name]] <- ""
[17:29:55.244]                 }
[17:29:55.244]                 NAMES <- toupper(removed)
[17:29:55.244]                 for (kk in seq_along(NAMES)) {
[17:29:55.244]                   name <- removed[[kk]]
[17:29:55.244]                   NAME <- NAMES[[kk]]
[17:29:55.244]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.244]                     next
[17:29:55.244]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.244]                 }
[17:29:55.244]                 if (length(args) > 0) 
[17:29:55.244]                   base::do.call(base::Sys.setenv, args = args)
[17:29:55.244]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:55.244]             }
[17:29:55.244]             else {
[17:29:55.244]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:55.244]             }
[17:29:55.244]             {
[17:29:55.244]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:55.244]                   0L) {
[17:29:55.244]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:55.244]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:55.244]                   base::options(opts)
[17:29:55.244]                 }
[17:29:55.244]                 {
[17:29:55.244]                   {
[17:29:55.244]                     NULL
[17:29:55.244]                     RNGkind("Mersenne-Twister")
[17:29:55.244]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:55.244]                       inherits = FALSE)
[17:29:55.244]                   }
[17:29:55.244]                   options(future.plan = NULL)
[17:29:55.244]                   if (is.na(NA_character_)) 
[17:29:55.244]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.244]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:55.244]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:55.244]                     .init = FALSE)
[17:29:55.244]                 }
[17:29:55.244]             }
[17:29:55.244]         }
[17:29:55.244]     })
[17:29:55.244]     if (TRUE) {
[17:29:55.244]         base::sink(type = "output", split = FALSE)
[17:29:55.244]         if (FALSE) {
[17:29:55.244]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:55.244]         }
[17:29:55.244]         else {
[17:29:55.244]             ...future.result["stdout"] <- base::list(NULL)
[17:29:55.244]         }
[17:29:55.244]         base::close(...future.stdout)
[17:29:55.244]         ...future.stdout <- NULL
[17:29:55.244]     }
[17:29:55.244]     ...future.result$conditions <- ...future.conditions
[17:29:55.244]     ...future.result$finished <- base::Sys.time()
[17:29:55.244]     ...future.result
[17:29:55.244] }
[17:29:55.253] plan(): Setting new future strategy stack:
[17:29:55.253] List of future strategies:
[17:29:55.253] 1. sequential:
[17:29:55.253]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.253]    - tweaked: FALSE
[17:29:55.253]    - call: NULL
[17:29:55.255] plan(): nbrOfWorkers() = 1
[17:29:55.260] plan(): Setting new future strategy stack:
[17:29:55.260] List of future strategies:
[17:29:55.260] 1. sequential:
[17:29:55.260]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.260]    - tweaked: FALSE
[17:29:55.260]    - call: plan(strategy)
[17:29:55.261] plan(): nbrOfWorkers() = 1
[17:29:55.262] SequentialFuture started (and completed)
[17:29:55.262] - Launch lazy future ... done
[17:29:55.263] 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: "2024-07-29 17:29:55"
 $ finished    : POSIXct[1:1], format: "2024-07-29 17:29:55"
 $ session_uuid: chr "be0736ef-3a70-9a22-50bb-ae47450014f2"
  ..- 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 189084
  .. ..$ time  : POSIXct[1:1], format: "2024-07-29 17:29:54"
  .. ..$ 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 5 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[17:29:55.281] getGlobalsAndPackages() ...
[17:29:55.281] Searching for globals...
[17:29:55.288] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:29:55.288] Searching for globals ... DONE
[17:29:55.288] Resolving globals: FALSE
[17:29:55.289] 
[17:29:55.289] - packages: [1] 'utils'
[17:29:55.290] getGlobalsAndPackages() ... DONE
[17:29:55.290] run() for 'Future' ...
[17:29:55.290] - state: 'created'
[17:29:55.291] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:55.291] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:55.291] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:55.292]   - Field: 'label'
[17:29:55.292]   - Field: 'local'
[17:29:55.292]   - Field: 'owner'
[17:29:55.292]   - Field: 'envir'
[17:29:55.292]   - Field: 'packages'
[17:29:55.293]   - Field: 'gc'
[17:29:55.293]   - Field: 'conditions'
[17:29:55.293]   - Field: 'expr'
[17:29:55.293]   - Field: 'uuid'
[17:29:55.293]   - Field: 'seed'
[17:29:55.294]   - Field: 'version'
[17:29:55.294]   - Field: 'result'
[17:29:55.294]   - Field: 'asynchronous'
[17:29:55.294]   - Field: 'calls'
[17:29:55.294]   - Field: 'globals'
[17:29:55.295]   - Field: 'stdout'
[17:29:55.295]   - Field: 'earlySignal'
[17:29:55.295]   - Field: 'lazy'
[17:29:55.295]   - Field: 'state'
[17:29:55.296] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:55.296] - Launch lazy future ...
[17:29:55.296] Packages needed by the future expression (n = 1): 'utils'
[17:29:55.296] Packages needed by future strategies (n = 0): <none>
[17:29:55.297] {
[17:29:55.297]     {
[17:29:55.297]         {
[17:29:55.297]             ...future.startTime <- base::Sys.time()
[17:29:55.297]             {
[17:29:55.297]                 {
[17:29:55.297]                   {
[17:29:55.297]                     {
[17:29:55.297]                       base::local({
[17:29:55.297]                         has_future <- base::requireNamespace("future", 
[17:29:55.297]                           quietly = TRUE)
[17:29:55.297]                         if (has_future) {
[17:29:55.297]                           ns <- base::getNamespace("future")
[17:29:55.297]                           version <- ns[[".package"]][["version"]]
[17:29:55.297]                           if (is.null(version)) 
[17:29:55.297]                             version <- utils::packageVersion("future")
[17:29:55.297]                         }
[17:29:55.297]                         else {
[17:29:55.297]                           version <- NULL
[17:29:55.297]                         }
[17:29:55.297]                         if (!has_future || version < "1.8.0") {
[17:29:55.297]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:55.297]                             "", base::R.version$version.string), 
[17:29:55.297]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:55.297]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:55.297]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:55.297]                               "release", "version")], collapse = " "), 
[17:29:55.297]                             hostname = base::Sys.info()[["nodename"]])
[17:29:55.297]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:55.297]                             info)
[17:29:55.297]                           info <- base::paste(info, collapse = "; ")
[17:29:55.297]                           if (!has_future) {
[17:29:55.297]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:55.297]                               info)
[17:29:55.297]                           }
[17:29:55.297]                           else {
[17:29:55.297]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:55.297]                               info, version)
[17:29:55.297]                           }
[17:29:55.297]                           base::stop(msg)
[17:29:55.297]                         }
[17:29:55.297]                       })
[17:29:55.297]                     }
[17:29:55.297]                     base::local({
[17:29:55.297]                       for (pkg in "utils") {
[17:29:55.297]                         base::loadNamespace(pkg)
[17:29:55.297]                         base::library(pkg, character.only = TRUE)
[17:29:55.297]                       }
[17:29:55.297]                     })
[17:29:55.297]                   }
[17:29:55.297]                   ...future.strategy.old <- future::plan("list")
[17:29:55.297]                   options(future.plan = NULL)
[17:29:55.297]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.297]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:55.297]                 }
[17:29:55.297]                 ...future.workdir <- getwd()
[17:29:55.297]             }
[17:29:55.297]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:55.297]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:55.297]         }
[17:29:55.297]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:55.297]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:55.297]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:55.297]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:55.297]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:55.297]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:55.297]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:55.297]             base::names(...future.oldOptions))
[17:29:55.297]     }
[17:29:55.297]     if (FALSE) {
[17:29:55.297]     }
[17:29:55.297]     else {
[17:29:55.297]         if (FALSE) {
[17:29:55.297]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:55.297]                 open = "w")
[17:29:55.297]         }
[17:29:55.297]         else {
[17:29:55.297]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:55.297]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:55.297]         }
[17:29:55.297]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:55.297]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:55.297]             base::sink(type = "output", split = FALSE)
[17:29:55.297]             base::close(...future.stdout)
[17:29:55.297]         }, add = TRUE)
[17:29:55.297]     }
[17:29:55.297]     ...future.frame <- base::sys.nframe()
[17:29:55.297]     ...future.conditions <- base::list()
[17:29:55.297]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:55.297]     if (FALSE) {
[17:29:55.297]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:55.297]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:55.297]     }
[17:29:55.297]     ...future.result <- base::tryCatch({
[17:29:55.297]         base::withCallingHandlers({
[17:29:55.297]             ...future.value <- base::withVisible(base::local({
[17:29:55.297]                 print(1:50)
[17:29:55.297]                 str(1:50)
[17:29:55.297]                 cat(letters, sep = "-")
[17:29:55.297]                 cat(1:6, collapse = "\n")
[17:29:55.297]                 write.table(datasets::iris[1:10, ], sep = "\t")
[17:29:55.297]                 42L
[17:29:55.297]             }))
[17:29:55.297]             future::FutureResult(value = ...future.value$value, 
[17:29:55.297]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.297]                   ...future.rng), globalenv = if (FALSE) 
[17:29:55.297]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:55.297]                     ...future.globalenv.names))
[17:29:55.297]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:55.297]         }, condition = base::local({
[17:29:55.297]             c <- base::c
[17:29:55.297]             inherits <- base::inherits
[17:29:55.297]             invokeRestart <- base::invokeRestart
[17:29:55.297]             length <- base::length
[17:29:55.297]             list <- base::list
[17:29:55.297]             seq.int <- base::seq.int
[17:29:55.297]             signalCondition <- base::signalCondition
[17:29:55.297]             sys.calls <- base::sys.calls
[17:29:55.297]             `[[` <- base::`[[`
[17:29:55.297]             `+` <- base::`+`
[17:29:55.297]             `<<-` <- base::`<<-`
[17:29:55.297]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:55.297]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:55.297]                   3L)]
[17:29:55.297]             }
[17:29:55.297]             function(cond) {
[17:29:55.297]                 is_error <- inherits(cond, "error")
[17:29:55.297]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:55.297]                   NULL)
[17:29:55.297]                 if (is_error) {
[17:29:55.297]                   sessionInformation <- function() {
[17:29:55.297]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:55.297]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:55.297]                       search = base::search(), system = base::Sys.info())
[17:29:55.297]                   }
[17:29:55.297]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.297]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:55.297]                     cond$call), session = sessionInformation(), 
[17:29:55.297]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:55.297]                   signalCondition(cond)
[17:29:55.297]                 }
[17:29:55.297]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:55.297]                 "immediateCondition"))) {
[17:29:55.297]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:55.297]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.297]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:55.297]                   if (TRUE && !signal) {
[17:29:55.297]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.297]                     {
[17:29:55.297]                       inherits <- base::inherits
[17:29:55.297]                       invokeRestart <- base::invokeRestart
[17:29:55.297]                       is.null <- base::is.null
[17:29:55.297]                       muffled <- FALSE
[17:29:55.297]                       if (inherits(cond, "message")) {
[17:29:55.297]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.297]                         if (muffled) 
[17:29:55.297]                           invokeRestart("muffleMessage")
[17:29:55.297]                       }
[17:29:55.297]                       else if (inherits(cond, "warning")) {
[17:29:55.297]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.297]                         if (muffled) 
[17:29:55.297]                           invokeRestart("muffleWarning")
[17:29:55.297]                       }
[17:29:55.297]                       else if (inherits(cond, "condition")) {
[17:29:55.297]                         if (!is.null(pattern)) {
[17:29:55.297]                           computeRestarts <- base::computeRestarts
[17:29:55.297]                           grepl <- base::grepl
[17:29:55.297]                           restarts <- computeRestarts(cond)
[17:29:55.297]                           for (restart in restarts) {
[17:29:55.297]                             name <- restart$name
[17:29:55.297]                             if (is.null(name)) 
[17:29:55.297]                               next
[17:29:55.297]                             if (!grepl(pattern, name)) 
[17:29:55.297]                               next
[17:29:55.297]                             invokeRestart(restart)
[17:29:55.297]                             muffled <- TRUE
[17:29:55.297]                             break
[17:29:55.297]                           }
[17:29:55.297]                         }
[17:29:55.297]                       }
[17:29:55.297]                       invisible(muffled)
[17:29:55.297]                     }
[17:29:55.297]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.297]                   }
[17:29:55.297]                 }
[17:29:55.297]                 else {
[17:29:55.297]                   if (TRUE) {
[17:29:55.297]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.297]                     {
[17:29:55.297]                       inherits <- base::inherits
[17:29:55.297]                       invokeRestart <- base::invokeRestart
[17:29:55.297]                       is.null <- base::is.null
[17:29:55.297]                       muffled <- FALSE
[17:29:55.297]                       if (inherits(cond, "message")) {
[17:29:55.297]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.297]                         if (muffled) 
[17:29:55.297]                           invokeRestart("muffleMessage")
[17:29:55.297]                       }
[17:29:55.297]                       else if (inherits(cond, "warning")) {
[17:29:55.297]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.297]                         if (muffled) 
[17:29:55.297]                           invokeRestart("muffleWarning")
[17:29:55.297]                       }
[17:29:55.297]                       else if (inherits(cond, "condition")) {
[17:29:55.297]                         if (!is.null(pattern)) {
[17:29:55.297]                           computeRestarts <- base::computeRestarts
[17:29:55.297]                           grepl <- base::grepl
[17:29:55.297]                           restarts <- computeRestarts(cond)
[17:29:55.297]                           for (restart in restarts) {
[17:29:55.297]                             name <- restart$name
[17:29:55.297]                             if (is.null(name)) 
[17:29:55.297]                               next
[17:29:55.297]                             if (!grepl(pattern, name)) 
[17:29:55.297]                               next
[17:29:55.297]                             invokeRestart(restart)
[17:29:55.297]                             muffled <- TRUE
[17:29:55.297]                             break
[17:29:55.297]                           }
[17:29:55.297]                         }
[17:29:55.297]                       }
[17:29:55.297]                       invisible(muffled)
[17:29:55.297]                     }
[17:29:55.297]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.297]                   }
[17:29:55.297]                 }
[17:29:55.297]             }
[17:29:55.297]         }))
[17:29:55.297]     }, error = function(ex) {
[17:29:55.297]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:55.297]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.297]                 ...future.rng), started = ...future.startTime, 
[17:29:55.297]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:55.297]             version = "1.8"), class = "FutureResult")
[17:29:55.297]     }, finally = {
[17:29:55.297]         if (!identical(...future.workdir, getwd())) 
[17:29:55.297]             setwd(...future.workdir)
[17:29:55.297]         {
[17:29:55.297]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:55.297]                 ...future.oldOptions$nwarnings <- NULL
[17:29:55.297]             }
[17:29:55.297]             base::options(...future.oldOptions)
[17:29:55.297]             if (.Platform$OS.type == "windows") {
[17:29:55.297]                 old_names <- names(...future.oldEnvVars)
[17:29:55.297]                 envs <- base::Sys.getenv()
[17:29:55.297]                 names <- names(envs)
[17:29:55.297]                 common <- intersect(names, old_names)
[17:29:55.297]                 added <- setdiff(names, old_names)
[17:29:55.297]                 removed <- setdiff(old_names, names)
[17:29:55.297]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:55.297]                   envs[common]]
[17:29:55.297]                 NAMES <- toupper(changed)
[17:29:55.297]                 args <- list()
[17:29:55.297]                 for (kk in seq_along(NAMES)) {
[17:29:55.297]                   name <- changed[[kk]]
[17:29:55.297]                   NAME <- NAMES[[kk]]
[17:29:55.297]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.297]                     next
[17:29:55.297]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.297]                 }
[17:29:55.297]                 NAMES <- toupper(added)
[17:29:55.297]                 for (kk in seq_along(NAMES)) {
[17:29:55.297]                   name <- added[[kk]]
[17:29:55.297]                   NAME <- NAMES[[kk]]
[17:29:55.297]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.297]                     next
[17:29:55.297]                   args[[name]] <- ""
[17:29:55.297]                 }
[17:29:55.297]                 NAMES <- toupper(removed)
[17:29:55.297]                 for (kk in seq_along(NAMES)) {
[17:29:55.297]                   name <- removed[[kk]]
[17:29:55.297]                   NAME <- NAMES[[kk]]
[17:29:55.297]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.297]                     next
[17:29:55.297]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.297]                 }
[17:29:55.297]                 if (length(args) > 0) 
[17:29:55.297]                   base::do.call(base::Sys.setenv, args = args)
[17:29:55.297]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:55.297]             }
[17:29:55.297]             else {
[17:29:55.297]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:55.297]             }
[17:29:55.297]             {
[17:29:55.297]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:55.297]                   0L) {
[17:29:55.297]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:55.297]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:55.297]                   base::options(opts)
[17:29:55.297]                 }
[17:29:55.297]                 {
[17:29:55.297]                   {
[17:29:55.297]                     NULL
[17:29:55.297]                     RNGkind("Mersenne-Twister")
[17:29:55.297]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:55.297]                       inherits = FALSE)
[17:29:55.297]                   }
[17:29:55.297]                   options(future.plan = NULL)
[17:29:55.297]                   if (is.na(NA_character_)) 
[17:29:55.297]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.297]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:55.297]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:55.297]                     .init = FALSE)
[17:29:55.297]                 }
[17:29:55.297]             }
[17:29:55.297]         }
[17:29:55.297]     })
[17:29:55.297]     if (TRUE) {
[17:29:55.297]         base::sink(type = "output", split = FALSE)
[17:29:55.297]         if (FALSE) {
[17:29:55.297]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:55.297]         }
[17:29:55.297]         else {
[17:29:55.297]             ...future.result["stdout"] <- base::list(NULL)
[17:29:55.297]         }
[17:29:55.297]         base::close(...future.stdout)
[17:29:55.297]         ...future.stdout <- NULL
[17:29:55.297]     }
[17:29:55.297]     ...future.result$conditions <- ...future.conditions
[17:29:55.297]     ...future.result$finished <- base::Sys.time()
[17:29:55.297]     ...future.result
[17:29:55.297] }
[17:29:55.304] plan(): Setting new future strategy stack:
[17:29:55.304] List of future strategies:
[17:29:55.304] 1. sequential:
[17:29:55.304]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.304]    - tweaked: FALSE
[17:29:55.304]    - call: NULL
[17:29:55.306] plan(): nbrOfWorkers() = 1
[17:29:55.310] plan(): Setting new future strategy stack:
[17:29:55.311] List of future strategies:
[17:29:55.311] 1. sequential:
[17:29:55.311]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.311]    - tweaked: FALSE
[17:29:55.311]    - call: plan(strategy)
[17:29:55.312] plan(): nbrOfWorkers() = 1
[17:29:55.312] SequentialFuture started (and completed)
[17:29:55.312] - Launch lazy future ... done
[17:29:55.313] run() for 'SequentialFuture' ... done
- stdout = structure(TRUE, drop = TRUE)
[17:29:55.314] getGlobalsAndPackages() ...
[17:29:55.314] Searching for globals...
[17:29:55.320] - globals found: [1] 'print'
[17:29:55.320] Searching for globals ... DONE
[17:29:55.320] Resolving globals: FALSE
[17:29:55.321] 
[17:29:55.321] 
[17:29:55.321] getGlobalsAndPackages() ... DONE
[17:29:55.322] run() for 'Future' ...
[17:29:55.322] - state: 'created'
[17:29:55.323] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:55.323] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:55.324] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:55.324]   - Field: 'label'
[17:29:55.324]   - Field: 'local'
[17:29:55.325]   - Field: 'owner'
[17:29:55.325]   - Field: 'envir'
[17:29:55.325]   - Field: 'packages'
[17:29:55.326]   - Field: 'gc'
[17:29:55.326]   - Field: 'conditions'
[17:29:55.326]   - Field: 'expr'
[17:29:55.327]   - Field: 'uuid'
[17:29:55.327]   - Field: 'seed'
[17:29:55.327]   - Field: 'version'
[17:29:55.328]   - Field: 'result'
[17:29:55.328]   - Field: 'asynchronous'
[17:29:55.328]   - Field: 'calls'
[17:29:55.329]   - Field: 'globals'
[17:29:55.329]   - Field: 'stdout'
[17:29:55.329]   - Field: 'earlySignal'
[17:29:55.330]   - Field: 'lazy'
[17:29:55.330]   - Field: 'state'
[17:29:55.330] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:55.331] - Launch lazy future ...
[17:29:55.331] Packages needed by the future expression (n = 0): <none>
[17:29:55.332] Packages needed by future strategies (n = 0): <none>
[17:29:55.333] {
[17:29:55.333]     {
[17:29:55.333]         {
[17:29:55.333]             ...future.startTime <- base::Sys.time()
[17:29:55.333]             {
[17:29:55.333]                 {
[17:29:55.333]                   {
[17:29:55.333]                     base::local({
[17:29:55.333]                       has_future <- base::requireNamespace("future", 
[17:29:55.333]                         quietly = TRUE)
[17:29:55.333]                       if (has_future) {
[17:29:55.333]                         ns <- base::getNamespace("future")
[17:29:55.333]                         version <- ns[[".package"]][["version"]]
[17:29:55.333]                         if (is.null(version)) 
[17:29:55.333]                           version <- utils::packageVersion("future")
[17:29:55.333]                       }
[17:29:55.333]                       else {
[17:29:55.333]                         version <- NULL
[17:29:55.333]                       }
[17:29:55.333]                       if (!has_future || version < "1.8.0") {
[17:29:55.333]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:55.333]                           "", base::R.version$version.string), 
[17:29:55.333]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:55.333]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:55.333]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:55.333]                             "release", "version")], collapse = " "), 
[17:29:55.333]                           hostname = base::Sys.info()[["nodename"]])
[17:29:55.333]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:55.333]                           info)
[17:29:55.333]                         info <- base::paste(info, collapse = "; ")
[17:29:55.333]                         if (!has_future) {
[17:29:55.333]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:55.333]                             info)
[17:29:55.333]                         }
[17:29:55.333]                         else {
[17:29:55.333]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:55.333]                             info, version)
[17:29:55.333]                         }
[17:29:55.333]                         base::stop(msg)
[17:29:55.333]                       }
[17:29:55.333]                     })
[17:29:55.333]                   }
[17:29:55.333]                   ...future.strategy.old <- future::plan("list")
[17:29:55.333]                   options(future.plan = NULL)
[17:29:55.333]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.333]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:55.333]                 }
[17:29:55.333]                 ...future.workdir <- getwd()
[17:29:55.333]             }
[17:29:55.333]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:55.333]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:55.333]         }
[17:29:55.333]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:55.333]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:55.333]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:55.333]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:55.333]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:55.333]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:55.333]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:55.333]             base::names(...future.oldOptions))
[17:29:55.333]     }
[17:29:55.333]     if (FALSE) {
[17:29:55.333]     }
[17:29:55.333]     else {
[17:29:55.333]         if (TRUE) {
[17:29:55.333]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:55.333]                 open = "w")
[17:29:55.333]         }
[17:29:55.333]         else {
[17:29:55.333]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:55.333]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:55.333]         }
[17:29:55.333]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:55.333]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:55.333]             base::sink(type = "output", split = FALSE)
[17:29:55.333]             base::close(...future.stdout)
[17:29:55.333]         }, add = TRUE)
[17:29:55.333]     }
[17:29:55.333]     ...future.frame <- base::sys.nframe()
[17:29:55.333]     ...future.conditions <- base::list()
[17:29:55.333]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:55.333]     if (FALSE) {
[17:29:55.333]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:55.333]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:55.333]     }
[17:29:55.333]     ...future.result <- base::tryCatch({
[17:29:55.333]         base::withCallingHandlers({
[17:29:55.333]             ...future.value <- base::withVisible(base::local(print(42)))
[17:29:55.333]             future::FutureResult(value = ...future.value$value, 
[17:29:55.333]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.333]                   ...future.rng), globalenv = if (FALSE) 
[17:29:55.333]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:55.333]                     ...future.globalenv.names))
[17:29:55.333]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:55.333]         }, condition = base::local({
[17:29:55.333]             c <- base::c
[17:29:55.333]             inherits <- base::inherits
[17:29:55.333]             invokeRestart <- base::invokeRestart
[17:29:55.333]             length <- base::length
[17:29:55.333]             list <- base::list
[17:29:55.333]             seq.int <- base::seq.int
[17:29:55.333]             signalCondition <- base::signalCondition
[17:29:55.333]             sys.calls <- base::sys.calls
[17:29:55.333]             `[[` <- base::`[[`
[17:29:55.333]             `+` <- base::`+`
[17:29:55.333]             `<<-` <- base::`<<-`
[17:29:55.333]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:55.333]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:55.333]                   3L)]
[17:29:55.333]             }
[17:29:55.333]             function(cond) {
[17:29:55.333]                 is_error <- inherits(cond, "error")
[17:29:55.333]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:55.333]                   NULL)
[17:29:55.333]                 if (is_error) {
[17:29:55.333]                   sessionInformation <- function() {
[17:29:55.333]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:55.333]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:55.333]                       search = base::search(), system = base::Sys.info())
[17:29:55.333]                   }
[17:29:55.333]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.333]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:55.333]                     cond$call), session = sessionInformation(), 
[17:29:55.333]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:55.333]                   signalCondition(cond)
[17:29:55.333]                 }
[17:29:55.333]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:55.333]                 "immediateCondition"))) {
[17:29:55.333]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:55.333]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.333]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:55.333]                   if (TRUE && !signal) {
[17:29:55.333]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.333]                     {
[17:29:55.333]                       inherits <- base::inherits
[17:29:55.333]                       invokeRestart <- base::invokeRestart
[17:29:55.333]                       is.null <- base::is.null
[17:29:55.333]                       muffled <- FALSE
[17:29:55.333]                       if (inherits(cond, "message")) {
[17:29:55.333]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.333]                         if (muffled) 
[17:29:55.333]                           invokeRestart("muffleMessage")
[17:29:55.333]                       }
[17:29:55.333]                       else if (inherits(cond, "warning")) {
[17:29:55.333]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.333]                         if (muffled) 
[17:29:55.333]                           invokeRestart("muffleWarning")
[17:29:55.333]                       }
[17:29:55.333]                       else if (inherits(cond, "condition")) {
[17:29:55.333]                         if (!is.null(pattern)) {
[17:29:55.333]                           computeRestarts <- base::computeRestarts
[17:29:55.333]                           grepl <- base::grepl
[17:29:55.333]                           restarts <- computeRestarts(cond)
[17:29:55.333]                           for (restart in restarts) {
[17:29:55.333]                             name <- restart$name
[17:29:55.333]                             if (is.null(name)) 
[17:29:55.333]                               next
[17:29:55.333]                             if (!grepl(pattern, name)) 
[17:29:55.333]                               next
[17:29:55.333]                             invokeRestart(restart)
[17:29:55.333]                             muffled <- TRUE
[17:29:55.333]                             break
[17:29:55.333]                           }
[17:29:55.333]                         }
[17:29:55.333]                       }
[17:29:55.333]                       invisible(muffled)
[17:29:55.333]                     }
[17:29:55.333]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.333]                   }
[17:29:55.333]                 }
[17:29:55.333]                 else {
[17:29:55.333]                   if (TRUE) {
[17:29:55.333]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.333]                     {
[17:29:55.333]                       inherits <- base::inherits
[17:29:55.333]                       invokeRestart <- base::invokeRestart
[17:29:55.333]                       is.null <- base::is.null
[17:29:55.333]                       muffled <- FALSE
[17:29:55.333]                       if (inherits(cond, "message")) {
[17:29:55.333]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.333]                         if (muffled) 
[17:29:55.333]                           invokeRestart("muffleMessage")
[17:29:55.333]                       }
[17:29:55.333]                       else if (inherits(cond, "warning")) {
[17:29:55.333]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.333]                         if (muffled) 
[17:29:55.333]                           invokeRestart("muffleWarning")
[17:29:55.333]                       }
[17:29:55.333]                       else if (inherits(cond, "condition")) {
[17:29:55.333]                         if (!is.null(pattern)) {
[17:29:55.333]                           computeRestarts <- base::computeRestarts
[17:29:55.333]                           grepl <- base::grepl
[17:29:55.333]                           restarts <- computeRestarts(cond)
[17:29:55.333]                           for (restart in restarts) {
[17:29:55.333]                             name <- restart$name
[17:29:55.333]                             if (is.null(name)) 
[17:29:55.333]                               next
[17:29:55.333]                             if (!grepl(pattern, name)) 
[17:29:55.333]                               next
[17:29:55.333]                             invokeRestart(restart)
[17:29:55.333]                             muffled <- TRUE
[17:29:55.333]                             break
[17:29:55.333]                           }
[17:29:55.333]                         }
[17:29:55.333]                       }
[17:29:55.333]                       invisible(muffled)
[17:29:55.333]                     }
[17:29:55.333]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.333]                   }
[17:29:55.333]                 }
[17:29:55.333]             }
[17:29:55.333]         }))
[17:29:55.333]     }, error = function(ex) {
[17:29:55.333]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:55.333]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.333]                 ...future.rng), started = ...future.startTime, 
[17:29:55.333]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:55.333]             version = "1.8"), class = "FutureResult")
[17:29:55.333]     }, finally = {
[17:29:55.333]         if (!identical(...future.workdir, getwd())) 
[17:29:55.333]             setwd(...future.workdir)
[17:29:55.333]         {
[17:29:55.333]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:55.333]                 ...future.oldOptions$nwarnings <- NULL
[17:29:55.333]             }
[17:29:55.333]             base::options(...future.oldOptions)
[17:29:55.333]             if (.Platform$OS.type == "windows") {
[17:29:55.333]                 old_names <- names(...future.oldEnvVars)
[17:29:55.333]                 envs <- base::Sys.getenv()
[17:29:55.333]                 names <- names(envs)
[17:29:55.333]                 common <- intersect(names, old_names)
[17:29:55.333]                 added <- setdiff(names, old_names)
[17:29:55.333]                 removed <- setdiff(old_names, names)
[17:29:55.333]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:55.333]                   envs[common]]
[17:29:55.333]                 NAMES <- toupper(changed)
[17:29:55.333]                 args <- list()
[17:29:55.333]                 for (kk in seq_along(NAMES)) {
[17:29:55.333]                   name <- changed[[kk]]
[17:29:55.333]                   NAME <- NAMES[[kk]]
[17:29:55.333]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.333]                     next
[17:29:55.333]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.333]                 }
[17:29:55.333]                 NAMES <- toupper(added)
[17:29:55.333]                 for (kk in seq_along(NAMES)) {
[17:29:55.333]                   name <- added[[kk]]
[17:29:55.333]                   NAME <- NAMES[[kk]]
[17:29:55.333]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.333]                     next
[17:29:55.333]                   args[[name]] <- ""
[17:29:55.333]                 }
[17:29:55.333]                 NAMES <- toupper(removed)
[17:29:55.333]                 for (kk in seq_along(NAMES)) {
[17:29:55.333]                   name <- removed[[kk]]
[17:29:55.333]                   NAME <- NAMES[[kk]]
[17:29:55.333]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.333]                     next
[17:29:55.333]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.333]                 }
[17:29:55.333]                 if (length(args) > 0) 
[17:29:55.333]                   base::do.call(base::Sys.setenv, args = args)
[17:29:55.333]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:55.333]             }
[17:29:55.333]             else {
[17:29:55.333]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:55.333]             }
[17:29:55.333]             {
[17:29:55.333]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:55.333]                   0L) {
[17:29:55.333]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:55.333]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:55.333]                   base::options(opts)
[17:29:55.333]                 }
[17:29:55.333]                 {
[17:29:55.333]                   {
[17:29:55.333]                     NULL
[17:29:55.333]                     RNGkind("Mersenne-Twister")
[17:29:55.333]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:55.333]                       inherits = FALSE)
[17:29:55.333]                   }
[17:29:55.333]                   options(future.plan = NULL)
[17:29:55.333]                   if (is.na(NA_character_)) 
[17:29:55.333]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.333]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:55.333]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:55.333]                     .init = FALSE)
[17:29:55.333]                 }
[17:29:55.333]             }
[17:29:55.333]         }
[17:29:55.333]     })
[17:29:55.333]     if (TRUE) {
[17:29:55.333]         base::sink(type = "output", split = FALSE)
[17:29:55.333]         if (TRUE) {
[17:29:55.333]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:55.333]         }
[17:29:55.333]         else {
[17:29:55.333]             ...future.result["stdout"] <- base::list(NULL)
[17:29:55.333]         }
[17:29:55.333]         base::close(...future.stdout)
[17:29:55.333]         ...future.stdout <- NULL
[17:29:55.333]     }
[17:29:55.333]     ...future.result$conditions <- ...future.conditions
[17:29:55.333]     ...future.result$finished <- base::Sys.time()
[17:29:55.333]     ...future.result
[17:29:55.333] }
[17:29:55.339] plan(): Setting new future strategy stack:
[17:29:55.339] List of future strategies:
[17:29:55.339] 1. sequential:
[17:29:55.339]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.339]    - tweaked: FALSE
[17:29:55.339]    - call: NULL
[17:29:55.340] plan(): nbrOfWorkers() = 1
[17:29:55.342] plan(): Setting new future strategy stack:
[17:29:55.343] List of future strategies:
[17:29:55.343] 1. sequential:
[17:29:55.343]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.343]    - tweaked: FALSE
[17:29:55.343]    - call: plan(strategy)
[17:29:55.344] plan(): nbrOfWorkers() = 1
[17:29:55.344] SequentialFuture started (and completed)
[17:29:55.344] - Launch lazy future ... done
[17:29:55.345] run() for 'SequentialFuture' ... done
[1] 42
- stdout = NA
[17:29:55.346] getGlobalsAndPackages() ...
[17:29:55.346] Searching for globals...
[17:29:55.350] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:29:55.351] Searching for globals ... DONE
[17:29:55.351] Resolving globals: FALSE
[17:29:55.351] 
[17:29:55.352] - packages: [1] 'utils'
[17:29:55.352] getGlobalsAndPackages() ... DONE
[17:29:55.352] run() for 'Future' ...
[17:29:55.352] - state: 'created'
[17:29:55.353] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:55.353] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:55.353] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:55.353]   - Field: 'label'
[17:29:55.354]   - Field: 'local'
[17:29:55.354]   - Field: 'owner'
[17:29:55.354]   - Field: 'envir'
[17:29:55.354]   - Field: 'packages'
[17:29:55.354]   - Field: 'gc'
[17:29:55.354]   - Field: 'conditions'
[17:29:55.355]   - Field: 'expr'
[17:29:55.355]   - Field: 'uuid'
[17:29:55.355]   - Field: 'seed'
[17:29:55.355]   - Field: 'version'
[17:29:55.355]   - Field: 'result'
[17:29:55.355]   - Field: 'asynchronous'
[17:29:55.356]   - Field: 'calls'
[17:29:55.356]   - Field: 'globals'
[17:29:55.356]   - Field: 'stdout'
[17:29:55.356]   - Field: 'earlySignal'
[17:29:55.356]   - Field: 'lazy'
[17:29:55.356]   - Field: 'state'
[17:29:55.357] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:55.357] - Launch lazy future ...
[17:29:55.357] Packages needed by the future expression (n = 1): 'utils'
[17:29:55.357] Packages needed by future strategies (n = 0): <none>
[17:29:55.359] {
[17:29:55.359]     {
[17:29:55.359]         {
[17:29:55.359]             ...future.startTime <- base::Sys.time()
[17:29:55.359]             {
[17:29:55.359]                 {
[17:29:55.359]                   {
[17:29:55.359]                     {
[17:29:55.359]                       base::local({
[17:29:55.359]                         has_future <- base::requireNamespace("future", 
[17:29:55.359]                           quietly = TRUE)
[17:29:55.359]                         if (has_future) {
[17:29:55.359]                           ns <- base::getNamespace("future")
[17:29:55.359]                           version <- ns[[".package"]][["version"]]
[17:29:55.359]                           if (is.null(version)) 
[17:29:55.359]                             version <- utils::packageVersion("future")
[17:29:55.359]                         }
[17:29:55.359]                         else {
[17:29:55.359]                           version <- NULL
[17:29:55.359]                         }
[17:29:55.359]                         if (!has_future || version < "1.8.0") {
[17:29:55.359]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:55.359]                             "", base::R.version$version.string), 
[17:29:55.359]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:55.359]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:55.359]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:55.359]                               "release", "version")], collapse = " "), 
[17:29:55.359]                             hostname = base::Sys.info()[["nodename"]])
[17:29:55.359]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:55.359]                             info)
[17:29:55.359]                           info <- base::paste(info, collapse = "; ")
[17:29:55.359]                           if (!has_future) {
[17:29:55.359]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:55.359]                               info)
[17:29:55.359]                           }
[17:29:55.359]                           else {
[17:29:55.359]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:55.359]                               info, version)
[17:29:55.359]                           }
[17:29:55.359]                           base::stop(msg)
[17:29:55.359]                         }
[17:29:55.359]                       })
[17:29:55.359]                     }
[17:29:55.359]                     base::local({
[17:29:55.359]                       for (pkg in "utils") {
[17:29:55.359]                         base::loadNamespace(pkg)
[17:29:55.359]                         base::library(pkg, character.only = TRUE)
[17:29:55.359]                       }
[17:29:55.359]                     })
[17:29:55.359]                   }
[17:29:55.359]                   ...future.strategy.old <- future::plan("list")
[17:29:55.359]                   options(future.plan = NULL)
[17:29:55.359]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.359]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:55.359]                 }
[17:29:55.359]                 ...future.workdir <- getwd()
[17:29:55.359]             }
[17:29:55.359]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:55.359]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:55.359]         }
[17:29:55.359]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:55.359]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:55.359]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:55.359]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:55.359]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:55.359]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:55.359]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:55.359]             base::names(...future.oldOptions))
[17:29:55.359]     }
[17:29:55.359]     if (TRUE) {
[17:29:55.359]     }
[17:29:55.359]     else {
[17:29:55.359]         if (NA) {
[17:29:55.359]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:55.359]                 open = "w")
[17:29:55.359]         }
[17:29:55.359]         else {
[17:29:55.359]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:55.359]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:55.359]         }
[17:29:55.359]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:55.359]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:55.359]             base::sink(type = "output", split = FALSE)
[17:29:55.359]             base::close(...future.stdout)
[17:29:55.359]         }, add = TRUE)
[17:29:55.359]     }
[17:29:55.359]     ...future.frame <- base::sys.nframe()
[17:29:55.359]     ...future.conditions <- base::list()
[17:29:55.359]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:55.359]     if (FALSE) {
[17:29:55.359]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:55.359]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:55.359]     }
[17:29:55.359]     ...future.result <- base::tryCatch({
[17:29:55.359]         base::withCallingHandlers({
[17:29:55.359]             ...future.value <- base::withVisible(base::local({
[17:29:55.359]                 print(1:50)
[17:29:55.359]                 str(1:50)
[17:29:55.359]                 cat(letters, sep = "-")
[17:29:55.359]                 cat(1:6, collapse = "\n")
[17:29:55.359]                 write.table(datasets::iris[1:10, ], sep = "\t")
[17:29:55.359]                 42L
[17:29:55.359]             }))
[17:29:55.359]             future::FutureResult(value = ...future.value$value, 
[17:29:55.359]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.359]                   ...future.rng), globalenv = if (FALSE) 
[17:29:55.359]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:55.359]                     ...future.globalenv.names))
[17:29:55.359]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:55.359]         }, condition = base::local({
[17:29:55.359]             c <- base::c
[17:29:55.359]             inherits <- base::inherits
[17:29:55.359]             invokeRestart <- base::invokeRestart
[17:29:55.359]             length <- base::length
[17:29:55.359]             list <- base::list
[17:29:55.359]             seq.int <- base::seq.int
[17:29:55.359]             signalCondition <- base::signalCondition
[17:29:55.359]             sys.calls <- base::sys.calls
[17:29:55.359]             `[[` <- base::`[[`
[17:29:55.359]             `+` <- base::`+`
[17:29:55.359]             `<<-` <- base::`<<-`
[17:29:55.359]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:55.359]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:55.359]                   3L)]
[17:29:55.359]             }
[17:29:55.359]             function(cond) {
[17:29:55.359]                 is_error <- inherits(cond, "error")
[17:29:55.359]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:55.359]                   NULL)
[17:29:55.359]                 if (is_error) {
[17:29:55.359]                   sessionInformation <- function() {
[17:29:55.359]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:55.359]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:55.359]                       search = base::search(), system = base::Sys.info())
[17:29:55.359]                   }
[17:29:55.359]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.359]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:55.359]                     cond$call), session = sessionInformation(), 
[17:29:55.359]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:55.359]                   signalCondition(cond)
[17:29:55.359]                 }
[17:29:55.359]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:55.359]                 "immediateCondition"))) {
[17:29:55.359]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:55.359]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.359]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:55.359]                   if (TRUE && !signal) {
[17:29:55.359]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.359]                     {
[17:29:55.359]                       inherits <- base::inherits
[17:29:55.359]                       invokeRestart <- base::invokeRestart
[17:29:55.359]                       is.null <- base::is.null
[17:29:55.359]                       muffled <- FALSE
[17:29:55.359]                       if (inherits(cond, "message")) {
[17:29:55.359]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.359]                         if (muffled) 
[17:29:55.359]                           invokeRestart("muffleMessage")
[17:29:55.359]                       }
[17:29:55.359]                       else if (inherits(cond, "warning")) {
[17:29:55.359]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.359]                         if (muffled) 
[17:29:55.359]                           invokeRestart("muffleWarning")
[17:29:55.359]                       }
[17:29:55.359]                       else if (inherits(cond, "condition")) {
[17:29:55.359]                         if (!is.null(pattern)) {
[17:29:55.359]                           computeRestarts <- base::computeRestarts
[17:29:55.359]                           grepl <- base::grepl
[17:29:55.359]                           restarts <- computeRestarts(cond)
[17:29:55.359]                           for (restart in restarts) {
[17:29:55.359]                             name <- restart$name
[17:29:55.359]                             if (is.null(name)) 
[17:29:55.359]                               next
[17:29:55.359]                             if (!grepl(pattern, name)) 
[17:29:55.359]                               next
[17:29:55.359]                             invokeRestart(restart)
[17:29:55.359]                             muffled <- TRUE
[17:29:55.359]                             break
[17:29:55.359]                           }
[17:29:55.359]                         }
[17:29:55.359]                       }
[17:29:55.359]                       invisible(muffled)
[17:29:55.359]                     }
[17:29:55.359]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.359]                   }
[17:29:55.359]                 }
[17:29:55.359]                 else {
[17:29:55.359]                   if (TRUE) {
[17:29:55.359]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.359]                     {
[17:29:55.359]                       inherits <- base::inherits
[17:29:55.359]                       invokeRestart <- base::invokeRestart
[17:29:55.359]                       is.null <- base::is.null
[17:29:55.359]                       muffled <- FALSE
[17:29:55.359]                       if (inherits(cond, "message")) {
[17:29:55.359]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.359]                         if (muffled) 
[17:29:55.359]                           invokeRestart("muffleMessage")
[17:29:55.359]                       }
[17:29:55.359]                       else if (inherits(cond, "warning")) {
[17:29:55.359]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.359]                         if (muffled) 
[17:29:55.359]                           invokeRestart("muffleWarning")
[17:29:55.359]                       }
[17:29:55.359]                       else if (inherits(cond, "condition")) {
[17:29:55.359]                         if (!is.null(pattern)) {
[17:29:55.359]                           computeRestarts <- base::computeRestarts
[17:29:55.359]                           grepl <- base::grepl
[17:29:55.359]                           restarts <- computeRestarts(cond)
[17:29:55.359]                           for (restart in restarts) {
[17:29:55.359]                             name <- restart$name
[17:29:55.359]                             if (is.null(name)) 
[17:29:55.359]                               next
[17:29:55.359]                             if (!grepl(pattern, name)) 
[17:29:55.359]                               next
[17:29:55.359]                             invokeRestart(restart)
[17:29:55.359]                             muffled <- TRUE
[17:29:55.359]                             break
[17:29:55.359]                           }
[17:29:55.359]                         }
[17:29:55.359]                       }
[17:29:55.359]                       invisible(muffled)
[17:29:55.359]                     }
[17:29:55.359]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.359]                   }
[17:29:55.359]                 }
[17:29:55.359]             }
[17:29:55.359]         }))
[17:29:55.359]     }, error = function(ex) {
[17:29:55.359]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:55.359]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.359]                 ...future.rng), started = ...future.startTime, 
[17:29:55.359]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:55.359]             version = "1.8"), class = "FutureResult")
[17:29:55.359]     }, finally = {
[17:29:55.359]         if (!identical(...future.workdir, getwd())) 
[17:29:55.359]             setwd(...future.workdir)
[17:29:55.359]         {
[17:29:55.359]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:55.359]                 ...future.oldOptions$nwarnings <- NULL
[17:29:55.359]             }
[17:29:55.359]             base::options(...future.oldOptions)
[17:29:55.359]             if (.Platform$OS.type == "windows") {
[17:29:55.359]                 old_names <- names(...future.oldEnvVars)
[17:29:55.359]                 envs <- base::Sys.getenv()
[17:29:55.359]                 names <- names(envs)
[17:29:55.359]                 common <- intersect(names, old_names)
[17:29:55.359]                 added <- setdiff(names, old_names)
[17:29:55.359]                 removed <- setdiff(old_names, names)
[17:29:55.359]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:55.359]                   envs[common]]
[17:29:55.359]                 NAMES <- toupper(changed)
[17:29:55.359]                 args <- list()
[17:29:55.359]                 for (kk in seq_along(NAMES)) {
[17:29:55.359]                   name <- changed[[kk]]
[17:29:55.359]                   NAME <- NAMES[[kk]]
[17:29:55.359]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.359]                     next
[17:29:55.359]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.359]                 }
[17:29:55.359]                 NAMES <- toupper(added)
[17:29:55.359]                 for (kk in seq_along(NAMES)) {
[17:29:55.359]                   name <- added[[kk]]
[17:29:55.359]                   NAME <- NAMES[[kk]]
[17:29:55.359]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.359]                     next
[17:29:55.359]                   args[[name]] <- ""
[17:29:55.359]                 }
[17:29:55.359]                 NAMES <- toupper(removed)
[17:29:55.359]                 for (kk in seq_along(NAMES)) {
[17:29:55.359]                   name <- removed[[kk]]
[17:29:55.359]                   NAME <- NAMES[[kk]]
[17:29:55.359]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.359]                     next
[17:29:55.359]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.359]                 }
[17:29:55.359]                 if (length(args) > 0) 
[17:29:55.359]                   base::do.call(base::Sys.setenv, args = args)
[17:29:55.359]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:55.359]             }
[17:29:55.359]             else {
[17:29:55.359]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:55.359]             }
[17:29:55.359]             {
[17:29:55.359]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:55.359]                   0L) {
[17:29:55.359]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:55.359]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:55.359]                   base::options(opts)
[17:29:55.359]                 }
[17:29:55.359]                 {
[17:29:55.359]                   {
[17:29:55.359]                     NULL
[17:29:55.359]                     RNGkind("Mersenne-Twister")
[17:29:55.359]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:55.359]                       inherits = FALSE)
[17:29:55.359]                   }
[17:29:55.359]                   options(future.plan = NULL)
[17:29:55.359]                   if (is.na(NA_character_)) 
[17:29:55.359]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.359]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:55.359]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:55.359]                     .init = FALSE)
[17:29:55.359]                 }
[17:29:55.359]             }
[17:29:55.359]         }
[17:29:55.359]     })
[17:29:55.359]     if (FALSE) {
[17:29:55.359]         base::sink(type = "output", split = FALSE)
[17:29:55.359]         if (NA) {
[17:29:55.359]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:55.359]         }
[17:29:55.359]         else {
[17:29:55.359]             ...future.result["stdout"] <- base::list(NULL)
[17:29:55.359]         }
[17:29:55.359]         base::close(...future.stdout)
[17:29:55.359]         ...future.stdout <- NULL
[17:29:55.359]     }
[17:29:55.359]     ...future.result$conditions <- ...future.conditions
[17:29:55.359]     ...future.result$finished <- base::Sys.time()
[17:29:55.359]     ...future.result
[17:29:55.359] }
[17:29:55.366] plan(): Setting new future strategy stack:
[17:29:55.366] List of future strategies:
[17:29:55.366] 1. sequential:
[17:29:55.366]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.366]    - tweaked: FALSE
[17:29:55.366]    - call: NULL
[17:29:55.367] 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"
[17:29:55.376] plan(): Setting new future strategy stack:
[17:29:55.376] List of future strategies:
[17:29:55.376] 1. sequential:
[17:29:55.376]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.376]    - tweaked: FALSE
[17:29:55.376]    - call: plan(strategy)
[17:29:55.378] plan(): nbrOfWorkers() = 1
[17:29:55.378] SequentialFuture started (and completed)
[17:29:55.379] - Launch lazy future ... done
[17:29:55.379] 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: "2024-07-29 17:29:55"
 $ finished    : POSIXct[1:1], format: "2024-07-29 17:29:55"
 $ session_uuid: chr "be0736ef-3a70-9a22-50bb-ae47450014f2"
  ..- 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 189084
  .. ..$ time  : POSIXct[1:1], format: "2024-07-29 17:29:54"
  .. ..$ 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 5 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[17:29:55.398] getGlobalsAndPackages() ...
[17:29:55.399] Searching for globals...
[17:29:55.406] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:29:55.406] Searching for globals ... DONE
[17:29:55.406] Resolving globals: FALSE
[17:29:55.407] 
[17:29:55.408] - packages: [1] 'utils'
[17:29:55.408] getGlobalsAndPackages() ... DONE
[17:29:55.409] run() for 'Future' ...
[17:29:55.409] - state: 'created'
[17:29:55.410] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:55.410] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:55.411] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:55.411]   - Field: 'label'
[17:29:55.411]   - Field: 'local'
[17:29:55.412]   - Field: 'owner'
[17:29:55.412]   - Field: 'envir'
[17:29:55.412]   - Field: 'packages'
[17:29:55.413]   - Field: 'gc'
[17:29:55.413]   - Field: 'conditions'
[17:29:55.413]   - Field: 'expr'
[17:29:55.414]   - Field: 'uuid'
[17:29:55.414]   - Field: 'seed'
[17:29:55.414]   - Field: 'version'
[17:29:55.415]   - Field: 'result'
[17:29:55.415]   - Field: 'asynchronous'
[17:29:55.415]   - Field: 'calls'
[17:29:55.416]   - Field: 'globals'
[17:29:55.416]   - Field: 'stdout'
[17:29:55.417]   - Field: 'earlySignal'
[17:29:55.417]   - Field: 'lazy'
[17:29:55.417]   - Field: 'state'
[17:29:55.418] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:55.418] - Launch lazy future ...
[17:29:55.418] Packages needed by the future expression (n = 1): 'utils'
[17:29:55.419] Packages needed by future strategies (n = 0): <none>
[17:29:55.423] {
[17:29:55.423]     {
[17:29:55.423]         {
[17:29:55.423]             ...future.startTime <- base::Sys.time()
[17:29:55.423]             {
[17:29:55.423]                 {
[17:29:55.423]                   {
[17:29:55.423]                     {
[17:29:55.423]                       base::local({
[17:29:55.423]                         has_future <- base::requireNamespace("future", 
[17:29:55.423]                           quietly = TRUE)
[17:29:55.423]                         if (has_future) {
[17:29:55.423]                           ns <- base::getNamespace("future")
[17:29:55.423]                           version <- ns[[".package"]][["version"]]
[17:29:55.423]                           if (is.null(version)) 
[17:29:55.423]                             version <- utils::packageVersion("future")
[17:29:55.423]                         }
[17:29:55.423]                         else {
[17:29:55.423]                           version <- NULL
[17:29:55.423]                         }
[17:29:55.423]                         if (!has_future || version < "1.8.0") {
[17:29:55.423]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:55.423]                             "", base::R.version$version.string), 
[17:29:55.423]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:55.423]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:55.423]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:55.423]                               "release", "version")], collapse = " "), 
[17:29:55.423]                             hostname = base::Sys.info()[["nodename"]])
[17:29:55.423]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:55.423]                             info)
[17:29:55.423]                           info <- base::paste(info, collapse = "; ")
[17:29:55.423]                           if (!has_future) {
[17:29:55.423]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:55.423]                               info)
[17:29:55.423]                           }
[17:29:55.423]                           else {
[17:29:55.423]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:55.423]                               info, version)
[17:29:55.423]                           }
[17:29:55.423]                           base::stop(msg)
[17:29:55.423]                         }
[17:29:55.423]                       })
[17:29:55.423]                     }
[17:29:55.423]                     base::local({
[17:29:55.423]                       for (pkg in "utils") {
[17:29:55.423]                         base::loadNamespace(pkg)
[17:29:55.423]                         base::library(pkg, character.only = TRUE)
[17:29:55.423]                       }
[17:29:55.423]                     })
[17:29:55.423]                   }
[17:29:55.423]                   ...future.strategy.old <- future::plan("list")
[17:29:55.423]                   options(future.plan = NULL)
[17:29:55.423]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.423]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:55.423]                 }
[17:29:55.423]                 ...future.workdir <- getwd()
[17:29:55.423]             }
[17:29:55.423]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:55.423]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:55.423]         }
[17:29:55.423]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:55.423]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:55.423]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:55.423]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:55.423]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:55.423]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:55.423]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:55.423]             base::names(...future.oldOptions))
[17:29:55.423]     }
[17:29:55.423]     if (TRUE) {
[17:29:55.423]     }
[17:29:55.423]     else {
[17:29:55.423]         if (NA) {
[17:29:55.423]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:55.423]                 open = "w")
[17:29:55.423]         }
[17:29:55.423]         else {
[17:29:55.423]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:55.423]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:55.423]         }
[17:29:55.423]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:55.423]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:55.423]             base::sink(type = "output", split = FALSE)
[17:29:55.423]             base::close(...future.stdout)
[17:29:55.423]         }, add = TRUE)
[17:29:55.423]     }
[17:29:55.423]     ...future.frame <- base::sys.nframe()
[17:29:55.423]     ...future.conditions <- base::list()
[17:29:55.423]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:55.423]     if (FALSE) {
[17:29:55.423]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:55.423]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:55.423]     }
[17:29:55.423]     ...future.result <- base::tryCatch({
[17:29:55.423]         base::withCallingHandlers({
[17:29:55.423]             ...future.value <- base::withVisible(base::local({
[17:29:55.423]                 print(1:50)
[17:29:55.423]                 str(1:50)
[17:29:55.423]                 cat(letters, sep = "-")
[17:29:55.423]                 cat(1:6, collapse = "\n")
[17:29:55.423]                 write.table(datasets::iris[1:10, ], sep = "\t")
[17:29:55.423]                 42L
[17:29:55.423]             }))
[17:29:55.423]             future::FutureResult(value = ...future.value$value, 
[17:29:55.423]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.423]                   ...future.rng), globalenv = if (FALSE) 
[17:29:55.423]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:55.423]                     ...future.globalenv.names))
[17:29:55.423]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:55.423]         }, condition = base::local({
[17:29:55.423]             c <- base::c
[17:29:55.423]             inherits <- base::inherits
[17:29:55.423]             invokeRestart <- base::invokeRestart
[17:29:55.423]             length <- base::length
[17:29:55.423]             list <- base::list
[17:29:55.423]             seq.int <- base::seq.int
[17:29:55.423]             signalCondition <- base::signalCondition
[17:29:55.423]             sys.calls <- base::sys.calls
[17:29:55.423]             `[[` <- base::`[[`
[17:29:55.423]             `+` <- base::`+`
[17:29:55.423]             `<<-` <- base::`<<-`
[17:29:55.423]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:55.423]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:55.423]                   3L)]
[17:29:55.423]             }
[17:29:55.423]             function(cond) {
[17:29:55.423]                 is_error <- inherits(cond, "error")
[17:29:55.423]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:55.423]                   NULL)
[17:29:55.423]                 if (is_error) {
[17:29:55.423]                   sessionInformation <- function() {
[17:29:55.423]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:55.423]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:55.423]                       search = base::search(), system = base::Sys.info())
[17:29:55.423]                   }
[17:29:55.423]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.423]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:55.423]                     cond$call), session = sessionInformation(), 
[17:29:55.423]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:55.423]                   signalCondition(cond)
[17:29:55.423]                 }
[17:29:55.423]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:55.423]                 "immediateCondition"))) {
[17:29:55.423]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:55.423]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.423]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:55.423]                   if (TRUE && !signal) {
[17:29:55.423]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.423]                     {
[17:29:55.423]                       inherits <- base::inherits
[17:29:55.423]                       invokeRestart <- base::invokeRestart
[17:29:55.423]                       is.null <- base::is.null
[17:29:55.423]                       muffled <- FALSE
[17:29:55.423]                       if (inherits(cond, "message")) {
[17:29:55.423]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.423]                         if (muffled) 
[17:29:55.423]                           invokeRestart("muffleMessage")
[17:29:55.423]                       }
[17:29:55.423]                       else if (inherits(cond, "warning")) {
[17:29:55.423]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.423]                         if (muffled) 
[17:29:55.423]                           invokeRestart("muffleWarning")
[17:29:55.423]                       }
[17:29:55.423]                       else if (inherits(cond, "condition")) {
[17:29:55.423]                         if (!is.null(pattern)) {
[17:29:55.423]                           computeRestarts <- base::computeRestarts
[17:29:55.423]                           grepl <- base::grepl
[17:29:55.423]                           restarts <- computeRestarts(cond)
[17:29:55.423]                           for (restart in restarts) {
[17:29:55.423]                             name <- restart$name
[17:29:55.423]                             if (is.null(name)) 
[17:29:55.423]                               next
[17:29:55.423]                             if (!grepl(pattern, name)) 
[17:29:55.423]                               next
[17:29:55.423]                             invokeRestart(restart)
[17:29:55.423]                             muffled <- TRUE
[17:29:55.423]                             break
[17:29:55.423]                           }
[17:29:55.423]                         }
[17:29:55.423]                       }
[17:29:55.423]                       invisible(muffled)
[17:29:55.423]                     }
[17:29:55.423]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.423]                   }
[17:29:55.423]                 }
[17:29:55.423]                 else {
[17:29:55.423]                   if (TRUE) {
[17:29:55.423]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.423]                     {
[17:29:55.423]                       inherits <- base::inherits
[17:29:55.423]                       invokeRestart <- base::invokeRestart
[17:29:55.423]                       is.null <- base::is.null
[17:29:55.423]                       muffled <- FALSE
[17:29:55.423]                       if (inherits(cond, "message")) {
[17:29:55.423]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.423]                         if (muffled) 
[17:29:55.423]                           invokeRestart("muffleMessage")
[17:29:55.423]                       }
[17:29:55.423]                       else if (inherits(cond, "warning")) {
[17:29:55.423]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.423]                         if (muffled) 
[17:29:55.423]                           invokeRestart("muffleWarning")
[17:29:55.423]                       }
[17:29:55.423]                       else if (inherits(cond, "condition")) {
[17:29:55.423]                         if (!is.null(pattern)) {
[17:29:55.423]                           computeRestarts <- base::computeRestarts
[17:29:55.423]                           grepl <- base::grepl
[17:29:55.423]                           restarts <- computeRestarts(cond)
[17:29:55.423]                           for (restart in restarts) {
[17:29:55.423]                             name <- restart$name
[17:29:55.423]                             if (is.null(name)) 
[17:29:55.423]                               next
[17:29:55.423]                             if (!grepl(pattern, name)) 
[17:29:55.423]                               next
[17:29:55.423]                             invokeRestart(restart)
[17:29:55.423]                             muffled <- TRUE
[17:29:55.423]                             break
[17:29:55.423]                           }
[17:29:55.423]                         }
[17:29:55.423]                       }
[17:29:55.423]                       invisible(muffled)
[17:29:55.423]                     }
[17:29:55.423]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.423]                   }
[17:29:55.423]                 }
[17:29:55.423]             }
[17:29:55.423]         }))
[17:29:55.423]     }, error = function(ex) {
[17:29:55.423]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:55.423]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.423]                 ...future.rng), started = ...future.startTime, 
[17:29:55.423]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:55.423]             version = "1.8"), class = "FutureResult")
[17:29:55.423]     }, finally = {
[17:29:55.423]         if (!identical(...future.workdir, getwd())) 
[17:29:55.423]             setwd(...future.workdir)
[17:29:55.423]         {
[17:29:55.423]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:55.423]                 ...future.oldOptions$nwarnings <- NULL
[17:29:55.423]             }
[17:29:55.423]             base::options(...future.oldOptions)
[17:29:55.423]             if (.Platform$OS.type == "windows") {
[17:29:55.423]                 old_names <- names(...future.oldEnvVars)
[17:29:55.423]                 envs <- base::Sys.getenv()
[17:29:55.423]                 names <- names(envs)
[17:29:55.423]                 common <- intersect(names, old_names)
[17:29:55.423]                 added <- setdiff(names, old_names)
[17:29:55.423]                 removed <- setdiff(old_names, names)
[17:29:55.423]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:55.423]                   envs[common]]
[17:29:55.423]                 NAMES <- toupper(changed)
[17:29:55.423]                 args <- list()
[17:29:55.423]                 for (kk in seq_along(NAMES)) {
[17:29:55.423]                   name <- changed[[kk]]
[17:29:55.423]                   NAME <- NAMES[[kk]]
[17:29:55.423]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.423]                     next
[17:29:55.423]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.423]                 }
[17:29:55.423]                 NAMES <- toupper(added)
[17:29:55.423]                 for (kk in seq_along(NAMES)) {
[17:29:55.423]                   name <- added[[kk]]
[17:29:55.423]                   NAME <- NAMES[[kk]]
[17:29:55.423]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.423]                     next
[17:29:55.423]                   args[[name]] <- ""
[17:29:55.423]                 }
[17:29:55.423]                 NAMES <- toupper(removed)
[17:29:55.423]                 for (kk in seq_along(NAMES)) {
[17:29:55.423]                   name <- removed[[kk]]
[17:29:55.423]                   NAME <- NAMES[[kk]]
[17:29:55.423]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.423]                     next
[17:29:55.423]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.423]                 }
[17:29:55.423]                 if (length(args) > 0) 
[17:29:55.423]                   base::do.call(base::Sys.setenv, args = args)
[17:29:55.423]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:55.423]             }
[17:29:55.423]             else {
[17:29:55.423]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:55.423]             }
[17:29:55.423]             {
[17:29:55.423]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:55.423]                   0L) {
[17:29:55.423]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:55.423]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:55.423]                   base::options(opts)
[17:29:55.423]                 }
[17:29:55.423]                 {
[17:29:55.423]                   {
[17:29:55.423]                     NULL
[17:29:55.423]                     RNGkind("Mersenne-Twister")
[17:29:55.423]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:55.423]                       inherits = FALSE)
[17:29:55.423]                   }
[17:29:55.423]                   options(future.plan = NULL)
[17:29:55.423]                   if (is.na(NA_character_)) 
[17:29:55.423]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.423]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:55.423]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:55.423]                     .init = FALSE)
[17:29:55.423]                 }
[17:29:55.423]             }
[17:29:55.423]         }
[17:29:55.423]     })
[17:29:55.423]     if (FALSE) {
[17:29:55.423]         base::sink(type = "output", split = FALSE)
[17:29:55.423]         if (NA) {
[17:29:55.423]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:55.423]         }
[17:29:55.423]         else {
[17:29:55.423]             ...future.result["stdout"] <- base::list(NULL)
[17:29:55.423]         }
[17:29:55.423]         base::close(...future.stdout)
[17:29:55.423]         ...future.stdout <- NULL
[17:29:55.423]     }
[17:29:55.423]     ...future.result$conditions <- ...future.conditions
[17:29:55.423]     ...future.result$finished <- base::Sys.time()
[17:29:55.423]     ...future.result
[17:29:55.423] }
[17:29:55.430] plan(): Setting new future strategy stack:
[17:29:55.430] List of future strategies:
[17:29:55.430] 1. sequential:
[17:29:55.430]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.430]    - tweaked: FALSE
[17:29:55.430]    - call: NULL
[17:29:55.431] 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"
[17:29:55.434] plan(): Setting new future strategy stack:
[17:29:55.434] List of future strategies:
[17:29:55.434] 1. sequential:
[17:29:55.434]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.434]    - tweaked: FALSE
[17:29:55.434]    - call: plan(strategy)
[17:29:55.435] plan(): nbrOfWorkers() = 1
[17:29:55.435] SequentialFuture started (and completed)
[17:29:55.435] - Launch lazy future ... done
[17:29:55.435] run() for 'SequentialFuture' ... done
- stdout = structure(TRUE, drop = TRUE)
[17:29:55.436] getGlobalsAndPackages() ...
[17:29:55.436] Searching for globals...
[17:29:55.437] - globals found: [1] 'print'
[17:29:55.437] Searching for globals ... DONE
[17:29:55.437] Resolving globals: FALSE
[17:29:55.437] 
[17:29:55.438] 
[17:29:55.438] getGlobalsAndPackages() ... DONE
[17:29:55.438] run() for 'Future' ...
[17:29:55.438] - state: 'created'
[17:29:55.439] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:55.439] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:55.439] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:55.439]   - Field: 'label'
[17:29:55.440]   - Field: 'local'
[17:29:55.440]   - Field: 'owner'
[17:29:55.440]   - Field: 'envir'
[17:29:55.440]   - Field: 'packages'
[17:29:55.440]   - Field: 'gc'
[17:29:55.441]   - Field: 'conditions'
[17:29:55.441]   - Field: 'expr'
[17:29:55.441]   - Field: 'uuid'
[17:29:55.441]   - Field: 'seed'
[17:29:55.442]   - Field: 'version'
[17:29:55.442]   - Field: 'result'
[17:29:55.443]   - Field: 'asynchronous'
[17:29:55.443]   - Field: 'calls'
[17:29:55.443]   - Field: 'globals'
[17:29:55.444]   - Field: 'stdout'
[17:29:55.444]   - Field: 'earlySignal'
[17:29:55.444]   - Field: 'lazy'
[17:29:55.445]   - Field: 'state'
[17:29:55.445] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:55.445] - Launch lazy future ...
[17:29:55.446] Packages needed by the future expression (n = 0): <none>
[17:29:55.446] Packages needed by future strategies (n = 0): <none>
[17:29:55.447] {
[17:29:55.447]     {
[17:29:55.447]         {
[17:29:55.447]             ...future.startTime <- base::Sys.time()
[17:29:55.447]             {
[17:29:55.447]                 {
[17:29:55.447]                   {
[17:29:55.447]                     base::local({
[17:29:55.447]                       has_future <- base::requireNamespace("future", 
[17:29:55.447]                         quietly = TRUE)
[17:29:55.447]                       if (has_future) {
[17:29:55.447]                         ns <- base::getNamespace("future")
[17:29:55.447]                         version <- ns[[".package"]][["version"]]
[17:29:55.447]                         if (is.null(version)) 
[17:29:55.447]                           version <- utils::packageVersion("future")
[17:29:55.447]                       }
[17:29:55.447]                       else {
[17:29:55.447]                         version <- NULL
[17:29:55.447]                       }
[17:29:55.447]                       if (!has_future || version < "1.8.0") {
[17:29:55.447]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:55.447]                           "", base::R.version$version.string), 
[17:29:55.447]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:55.447]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:55.447]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:55.447]                             "release", "version")], collapse = " "), 
[17:29:55.447]                           hostname = base::Sys.info()[["nodename"]])
[17:29:55.447]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:55.447]                           info)
[17:29:55.447]                         info <- base::paste(info, collapse = "; ")
[17:29:55.447]                         if (!has_future) {
[17:29:55.447]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:55.447]                             info)
[17:29:55.447]                         }
[17:29:55.447]                         else {
[17:29:55.447]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:55.447]                             info, version)
[17:29:55.447]                         }
[17:29:55.447]                         base::stop(msg)
[17:29:55.447]                       }
[17:29:55.447]                     })
[17:29:55.447]                   }
[17:29:55.447]                   ...future.strategy.old <- future::plan("list")
[17:29:55.447]                   options(future.plan = NULL)
[17:29:55.447]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.447]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:55.447]                 }
[17:29:55.447]                 ...future.workdir <- getwd()
[17:29:55.447]             }
[17:29:55.447]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:55.447]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:55.447]         }
[17:29:55.447]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:55.447]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:55.447]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:55.447]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:55.447]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:55.447]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:55.447]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:55.447]             base::names(...future.oldOptions))
[17:29:55.447]     }
[17:29:55.447]     if (FALSE) {
[17:29:55.447]     }
[17:29:55.447]     else {
[17:29:55.447]         if (TRUE) {
[17:29:55.447]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:55.447]                 open = "w")
[17:29:55.447]         }
[17:29:55.447]         else {
[17:29:55.447]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:55.447]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:55.447]         }
[17:29:55.447]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:55.447]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:55.447]             base::sink(type = "output", split = FALSE)
[17:29:55.447]             base::close(...future.stdout)
[17:29:55.447]         }, add = TRUE)
[17:29:55.447]     }
[17:29:55.447]     ...future.frame <- base::sys.nframe()
[17:29:55.447]     ...future.conditions <- base::list()
[17:29:55.447]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:55.447]     if (FALSE) {
[17:29:55.447]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:55.447]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:55.447]     }
[17:29:55.447]     ...future.result <- base::tryCatch({
[17:29:55.447]         base::withCallingHandlers({
[17:29:55.447]             ...future.value <- base::withVisible(base::local(print(42)))
[17:29:55.447]             future::FutureResult(value = ...future.value$value, 
[17:29:55.447]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.447]                   ...future.rng), globalenv = if (FALSE) 
[17:29:55.447]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:55.447]                     ...future.globalenv.names))
[17:29:55.447]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:55.447]         }, condition = base::local({
[17:29:55.447]             c <- base::c
[17:29:55.447]             inherits <- base::inherits
[17:29:55.447]             invokeRestart <- base::invokeRestart
[17:29:55.447]             length <- base::length
[17:29:55.447]             list <- base::list
[17:29:55.447]             seq.int <- base::seq.int
[17:29:55.447]             signalCondition <- base::signalCondition
[17:29:55.447]             sys.calls <- base::sys.calls
[17:29:55.447]             `[[` <- base::`[[`
[17:29:55.447]             `+` <- base::`+`
[17:29:55.447]             `<<-` <- base::`<<-`
[17:29:55.447]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:55.447]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:55.447]                   3L)]
[17:29:55.447]             }
[17:29:55.447]             function(cond) {
[17:29:55.447]                 is_error <- inherits(cond, "error")
[17:29:55.447]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:55.447]                   NULL)
[17:29:55.447]                 if (is_error) {
[17:29:55.447]                   sessionInformation <- function() {
[17:29:55.447]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:55.447]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:55.447]                       search = base::search(), system = base::Sys.info())
[17:29:55.447]                   }
[17:29:55.447]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.447]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:55.447]                     cond$call), session = sessionInformation(), 
[17:29:55.447]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:55.447]                   signalCondition(cond)
[17:29:55.447]                 }
[17:29:55.447]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:55.447]                 "immediateCondition"))) {
[17:29:55.447]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:55.447]                   ...future.conditions[[length(...future.conditions) + 
[17:29:55.447]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:55.447]                   if (TRUE && !signal) {
[17:29:55.447]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.447]                     {
[17:29:55.447]                       inherits <- base::inherits
[17:29:55.447]                       invokeRestart <- base::invokeRestart
[17:29:55.447]                       is.null <- base::is.null
[17:29:55.447]                       muffled <- FALSE
[17:29:55.447]                       if (inherits(cond, "message")) {
[17:29:55.447]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.447]                         if (muffled) 
[17:29:55.447]                           invokeRestart("muffleMessage")
[17:29:55.447]                       }
[17:29:55.447]                       else if (inherits(cond, "warning")) {
[17:29:55.447]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.447]                         if (muffled) 
[17:29:55.447]                           invokeRestart("muffleWarning")
[17:29:55.447]                       }
[17:29:55.447]                       else if (inherits(cond, "condition")) {
[17:29:55.447]                         if (!is.null(pattern)) {
[17:29:55.447]                           computeRestarts <- base::computeRestarts
[17:29:55.447]                           grepl <- base::grepl
[17:29:55.447]                           restarts <- computeRestarts(cond)
[17:29:55.447]                           for (restart in restarts) {
[17:29:55.447]                             name <- restart$name
[17:29:55.447]                             if (is.null(name)) 
[17:29:55.447]                               next
[17:29:55.447]                             if (!grepl(pattern, name)) 
[17:29:55.447]                               next
[17:29:55.447]                             invokeRestart(restart)
[17:29:55.447]                             muffled <- TRUE
[17:29:55.447]                             break
[17:29:55.447]                           }
[17:29:55.447]                         }
[17:29:55.447]                       }
[17:29:55.447]                       invisible(muffled)
[17:29:55.447]                     }
[17:29:55.447]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.447]                   }
[17:29:55.447]                 }
[17:29:55.447]                 else {
[17:29:55.447]                   if (TRUE) {
[17:29:55.447]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:55.447]                     {
[17:29:55.447]                       inherits <- base::inherits
[17:29:55.447]                       invokeRestart <- base::invokeRestart
[17:29:55.447]                       is.null <- base::is.null
[17:29:55.447]                       muffled <- FALSE
[17:29:55.447]                       if (inherits(cond, "message")) {
[17:29:55.447]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:55.447]                         if (muffled) 
[17:29:55.447]                           invokeRestart("muffleMessage")
[17:29:55.447]                       }
[17:29:55.447]                       else if (inherits(cond, "warning")) {
[17:29:55.447]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:55.447]                         if (muffled) 
[17:29:55.447]                           invokeRestart("muffleWarning")
[17:29:55.447]                       }
[17:29:55.447]                       else if (inherits(cond, "condition")) {
[17:29:55.447]                         if (!is.null(pattern)) {
[17:29:55.447]                           computeRestarts <- base::computeRestarts
[17:29:55.447]                           grepl <- base::grepl
[17:29:55.447]                           restarts <- computeRestarts(cond)
[17:29:55.447]                           for (restart in restarts) {
[17:29:55.447]                             name <- restart$name
[17:29:55.447]                             if (is.null(name)) 
[17:29:55.447]                               next
[17:29:55.447]                             if (!grepl(pattern, name)) 
[17:29:55.447]                               next
[17:29:55.447]                             invokeRestart(restart)
[17:29:55.447]                             muffled <- TRUE
[17:29:55.447]                             break
[17:29:55.447]                           }
[17:29:55.447]                         }
[17:29:55.447]                       }
[17:29:55.447]                       invisible(muffled)
[17:29:55.447]                     }
[17:29:55.447]                     muffleCondition(cond, pattern = "^muffle")
[17:29:55.447]                   }
[17:29:55.447]                 }
[17:29:55.447]             }
[17:29:55.447]         }))
[17:29:55.447]     }, error = function(ex) {
[17:29:55.447]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:55.447]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:55.447]                 ...future.rng), started = ...future.startTime, 
[17:29:55.447]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:55.447]             version = "1.8"), class = "FutureResult")
[17:29:55.447]     }, finally = {
[17:29:55.447]         if (!identical(...future.workdir, getwd())) 
[17:29:55.447]             setwd(...future.workdir)
[17:29:55.447]         {
[17:29:55.447]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:55.447]                 ...future.oldOptions$nwarnings <- NULL
[17:29:55.447]             }
[17:29:55.447]             base::options(...future.oldOptions)
[17:29:55.447]             if (.Platform$OS.type == "windows") {
[17:29:55.447]                 old_names <- names(...future.oldEnvVars)
[17:29:55.447]                 envs <- base::Sys.getenv()
[17:29:55.447]                 names <- names(envs)
[17:29:55.447]                 common <- intersect(names, old_names)
[17:29:55.447]                 added <- setdiff(names, old_names)
[17:29:55.447]                 removed <- setdiff(old_names, names)
[17:29:55.447]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:55.447]                   envs[common]]
[17:29:55.447]                 NAMES <- toupper(changed)
[17:29:55.447]                 args <- list()
[17:29:55.447]                 for (kk in seq_along(NAMES)) {
[17:29:55.447]                   name <- changed[[kk]]
[17:29:55.447]                   NAME <- NAMES[[kk]]
[17:29:55.447]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.447]                     next
[17:29:55.447]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.447]                 }
[17:29:55.447]                 NAMES <- toupper(added)
[17:29:55.447]                 for (kk in seq_along(NAMES)) {
[17:29:55.447]                   name <- added[[kk]]
[17:29:55.447]                   NAME <- NAMES[[kk]]
[17:29:55.447]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.447]                     next
[17:29:55.447]                   args[[name]] <- ""
[17:29:55.447]                 }
[17:29:55.447]                 NAMES <- toupper(removed)
[17:29:55.447]                 for (kk in seq_along(NAMES)) {
[17:29:55.447]                   name <- removed[[kk]]
[17:29:55.447]                   NAME <- NAMES[[kk]]
[17:29:55.447]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:55.447]                     next
[17:29:55.447]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:55.447]                 }
[17:29:55.447]                 if (length(args) > 0) 
[17:29:55.447]                   base::do.call(base::Sys.setenv, args = args)
[17:29:55.447]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:55.447]             }
[17:29:55.447]             else {
[17:29:55.447]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:55.447]             }
[17:29:55.447]             {
[17:29:55.447]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:55.447]                   0L) {
[17:29:55.447]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:55.447]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:55.447]                   base::options(opts)
[17:29:55.447]                 }
[17:29:55.447]                 {
[17:29:55.447]                   {
[17:29:55.447]                     NULL
[17:29:55.447]                     RNGkind("Mersenne-Twister")
[17:29:55.447]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:55.447]                       inherits = FALSE)
[17:29:55.447]                   }
[17:29:55.447]                   options(future.plan = NULL)
[17:29:55.447]                   if (is.na(NA_character_)) 
[17:29:55.447]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:55.447]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:55.447]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:55.447]                     .init = FALSE)
[17:29:55.447]                 }
[17:29:55.447]             }
[17:29:55.447]         }
[17:29:55.447]     })
[17:29:55.447]     if (TRUE) {
[17:29:55.447]         base::sink(type = "output", split = FALSE)
[17:29:55.447]         if (TRUE) {
[17:29:55.447]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:55.447]         }
[17:29:55.447]         else {
[17:29:55.447]             ...future.result["stdout"] <- base::list(NULL)
[17:29:55.447]         }
[17:29:55.447]         base::close(...future.stdout)
[17:29:55.447]         ...future.stdout <- NULL
[17:29:55.447]     }
[17:29:55.447]     ...future.result$conditions <- ...future.conditions
[17:29:55.447]     ...future.result$finished <- base::Sys.time()
[17:29:55.447]     ...future.result
[17:29:55.447] }
[17:29:55.455] plan(): Setting new future strategy stack:
[17:29:55.455] List of future strategies:
[17:29:55.455] 1. sequential:
[17:29:55.455]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.455]    - tweaked: FALSE
[17:29:55.455]    - call: NULL
[17:29:55.456] plan(): nbrOfWorkers() = 1
[17:29:55.458] plan(): Setting new future strategy stack:
[17:29:55.458] List of future strategies:
[17:29:55.458] 1. sequential:
[17:29:55.458]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:55.458]    - tweaked: FALSE
[17:29:55.458]    - call: plan(strategy)
[17:29:55.459] plan(): nbrOfWorkers() = 1
[17:29:55.459] SequentialFuture started (and completed)
[17:29:55.459] - Launch lazy future ... done
[17:29:55.460] run() for 'SequentialFuture' ... done
[1] 42
sequential ... done
Testing with 1 cores ... done
Testing with 2 cores ...
multisession ...
[17:29:55.471] plan(): Setting new future strategy stack:
[17:29:55.471] List of future strategies:
[17:29:55.471] 1. multisession:
[17:29:55.471]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:29:55.471]    - tweaked: FALSE
[17:29:55.471]    - call: plan(strategy)
[17:29:55.472] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:29:55.475] multisession:
[17:29:55.475] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:29:55.475] - tweaked: FALSE
[17:29:55.475] - call: plan(strategy)
[17:29:55.481] getGlobalsAndPackages() ...
[17:29:55.481] Not searching for globals
[17:29:55.481] - globals: [0] <none>
[17:29:55.482] getGlobalsAndPackages() ... DONE
[17:29:55.482] [local output] makeClusterPSOCK() ...
[17:29:55.535] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:29:55.543] [local output] Base port: 22667
[17:29:55.544] [local output] Getting setup options for 2 cluster nodes ...
[17:29:55.544] [local output]  - Node #1 of 2 ...
[17:29:55.545] [local output] localMachine=TRUE => revtunnel=FALSE

[17:29:55.548] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpcPLDCY/worker.rank=1.parallelly.parent=189084.2e29c511b6115.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpcPLDCY/worker.rank=1.parallelly.parent=189084.2e29c511b6115.pid\")"'
[17:29:55.879] - Possible to infer worker's PID: TRUE
[17:29:55.880] [local output] Rscript port: 22667

[17:29:55.881] [local output]  - Node #2 of 2 ...
[17:29:55.882] [local output] localMachine=TRUE => revtunnel=FALSE

[17:29:55.884] [local output] Rscript port: 22667

[17:29:55.884] [local output] Getting setup options for 2 cluster nodes ... done
[17:29:55.885] [local output]  - Parallel setup requested for some PSOCK nodes
[17:29:55.886] [local output] Setting up PSOCK nodes in parallel
[17:29:55.886] List of 36
[17:29:55.886]  $ worker          : chr "localhost"
[17:29:55.886]   ..- attr(*, "localhost")= logi TRUE
[17:29:55.886]  $ master          : chr "localhost"
[17:29:55.886]  $ port            : int 22667
[17:29:55.886]  $ connectTimeout  : num 120
[17:29:55.886]  $ timeout         : num 120
[17:29:55.886]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:29:55.886]  $ homogeneous     : logi TRUE
[17:29:55.886]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=stdout.R:189084:CRANWIN3:CRAN\" "| __truncated__
[17:29:55.886]  $ rscript_envs    : NULL
[17:29:55.886]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:29:55.886]  $ rscript_startup : NULL
[17:29:55.886]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:29:55.886]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:29:55.886]  $ methods         : logi TRUE
[17:29:55.886]  $ socketOptions   : chr "no-delay"
[17:29:55.886]  $ useXDR          : logi FALSE
[17:29:55.886]  $ outfile         : chr "/dev/null"
[17:29:55.886]  $ renice          : int NA
[17:29:55.886]  $ rshcmd          : NULL
[17:29:55.886]  $ user            : chr(0) 
[17:29:55.886]  $ revtunnel       : logi FALSE
[17:29:55.886]  $ rshlogfile      : NULL
[17:29:55.886]  $ rshopts         : chr(0) 
[17:29:55.886]  $ rank            : int 1
[17:29:55.886]  $ manual          : logi FALSE
[17:29:55.886]  $ dryrun          : logi FALSE
[17:29:55.886]  $ quiet           : logi FALSE
[17:29:55.886]  $ setup_strategy  : chr "parallel"
[17:29:55.886]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:29:55.886]  $ pidfile         : chr "D:/temp/RtmpcPLDCY/worker.rank=1.parallelly.parent=189084.2e29c511b6115.pid"
[17:29:55.886]  $ rshcmd_label    : NULL
[17:29:55.886]  $ rsh_call        : NULL
[17:29:55.886]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:29:55.886]  $ localMachine    : logi TRUE
[17:29:55.886]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:29:55.886]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:29:55.886]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:29:55.886]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:29:55.886]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:29:55.886]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:29:55.886]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:29:55.886]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:29:55.886]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:29:55.886]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:29:55.886]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:29:55.886]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:29:55.886]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:29:55.886]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:29:55.886]  $ arguments       :List of 28
[17:29:55.886]   ..$ worker          : chr "localhost"
[17:29:55.886]   ..$ master          : NULL
[17:29:55.886]   ..$ port            : int 22667
[17:29:55.886]   ..$ connectTimeout  : num 120
[17:29:55.886]   ..$ timeout         : num 120
[17:29:55.886]   ..$ rscript         : NULL
[17:29:55.886]   ..$ homogeneous     : NULL
[17:29:55.886]   ..$ rscript_args    : NULL
[17:29:55.886]   ..$ rscript_envs    : NULL
[17:29:55.886]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:29:55.886]   ..$ rscript_startup : NULL
[17:29:55.886]   ..$ rscript_sh      : chr "auto"
[17:29:55.886]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:29:55.886]   ..$ methods         : logi TRUE
[17:29:55.886]   ..$ socketOptions   : chr "no-delay"
[17:29:55.886]   ..$ useXDR          : logi FALSE
[17:29:55.886]   ..$ outfile         : chr "/dev/null"
[17:29:55.886]   ..$ renice          : int NA
[17:29:55.886]   ..$ rshcmd          : NULL
[17:29:55.886]   ..$ user            : NULL
[17:29:55.886]   ..$ revtunnel       : logi NA
[17:29:55.886]   ..$ rshlogfile      : NULL
[17:29:55.886]   ..$ rshopts         : NULL
[17:29:55.886]   ..$ rank            : int 1
[17:29:55.886]   ..$ manual          : logi FALSE
[17:29:55.886]   ..$ dryrun          : logi FALSE
[17:29:55.886]   ..$ quiet           : logi FALSE
[17:29:55.886]   ..$ setup_strategy  : chr "parallel"
[17:29:55.886]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:29:55.925] [local output] System call to launch all workers:
[17:29:55.926] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=stdout.R:189084:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpcPLDCY/worker.rank=1.parallelly.parent=189084.2e29c511b6115.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=22667 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:29:55.926] [local output] Starting PSOCK main server
[17:29:55.937] [local output] Workers launched
[17:29:55.937] [local output] Waiting for workers to connect back
[17:29:55.938]  - [local output] 0 workers out of 2 ready
[17:29:56.179]  - [local output] 0 workers out of 2 ready
[17:29:56.180]  - [local output] 1 workers out of 2 ready
[17:29:56.185]  - [local output] 1 workers out of 2 ready
[17:29:56.185]  - [local output] 2 workers out of 2 ready
[17:29:56.186] [local output] Launching of 2 workers completed
[17:29:56.186] [local output] Number of nodes in cluster: 2
[17:29:56.186] [local output] Collecting session information from 2 workers
[17:29:56.188] [local output]  - Worker #1 of 2
[17:29:56.189] [local output]  - Worker #2 of 2
[17:29:56.189] [local output] makeClusterPSOCK() ... done
[17:29:56.210] Packages needed by the future expression (n = 0): <none>
[17:29:56.210] Packages needed by future strategies (n = 0): <none>
[17:29:56.211] {
[17:29:56.211]     {
[17:29:56.211]         {
[17:29:56.211]             ...future.startTime <- base::Sys.time()
[17:29:56.211]             {
[17:29:56.211]                 {
[17:29:56.211]                   {
[17:29:56.211]                     {
[17:29:56.211]                       base::local({
[17:29:56.211]                         has_future <- base::requireNamespace("future", 
[17:29:56.211]                           quietly = TRUE)
[17:29:56.211]                         if (has_future) {
[17:29:56.211]                           ns <- base::getNamespace("future")
[17:29:56.211]                           version <- ns[[".package"]][["version"]]
[17:29:56.211]                           if (is.null(version)) 
[17:29:56.211]                             version <- utils::packageVersion("future")
[17:29:56.211]                         }
[17:29:56.211]                         else {
[17:29:56.211]                           version <- NULL
[17:29:56.211]                         }
[17:29:56.211]                         if (!has_future || version < "1.8.0") {
[17:29:56.211]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:56.211]                             "", base::R.version$version.string), 
[17:29:56.211]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:56.211]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:56.211]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:56.211]                               "release", "version")], collapse = " "), 
[17:29:56.211]                             hostname = base::Sys.info()[["nodename"]])
[17:29:56.211]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:56.211]                             info)
[17:29:56.211]                           info <- base::paste(info, collapse = "; ")
[17:29:56.211]                           if (!has_future) {
[17:29:56.211]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:56.211]                               info)
[17:29:56.211]                           }
[17:29:56.211]                           else {
[17:29:56.211]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:56.211]                               info, version)
[17:29:56.211]                           }
[17:29:56.211]                           base::stop(msg)
[17:29:56.211]                         }
[17:29:56.211]                       })
[17:29:56.211]                     }
[17:29:56.211]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:56.211]                     base::options(mc.cores = 1L)
[17:29:56.211]                   }
[17:29:56.211]                   ...future.strategy.old <- future::plan("list")
[17:29:56.211]                   options(future.plan = NULL)
[17:29:56.211]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.211]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:56.211]                 }
[17:29:56.211]                 ...future.workdir <- getwd()
[17:29:56.211]             }
[17:29:56.211]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:56.211]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:56.211]         }
[17:29:56.211]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:56.211]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:56.211]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:56.211]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:56.211]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:56.211]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:56.211]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:56.211]             base::names(...future.oldOptions))
[17:29:56.211]     }
[17:29:56.211]     if (FALSE) {
[17:29:56.211]     }
[17:29:56.211]     else {
[17:29:56.211]         if (TRUE) {
[17:29:56.211]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:56.211]                 open = "w")
[17:29:56.211]         }
[17:29:56.211]         else {
[17:29:56.211]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:56.211]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:56.211]         }
[17:29:56.211]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:56.211]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:56.211]             base::sink(type = "output", split = FALSE)
[17:29:56.211]             base::close(...future.stdout)
[17:29:56.211]         }, add = TRUE)
[17:29:56.211]     }
[17:29:56.211]     ...future.frame <- base::sys.nframe()
[17:29:56.211]     ...future.conditions <- base::list()
[17:29:56.211]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:56.211]     if (FALSE) {
[17:29:56.211]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:56.211]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:56.211]     }
[17:29:56.211]     ...future.result <- base::tryCatch({
[17:29:56.211]         base::withCallingHandlers({
[17:29:56.211]             ...future.value <- base::withVisible(base::local({
[17:29:56.211]                 ...future.makeSendCondition <- base::local({
[17:29:56.211]                   sendCondition <- NULL
[17:29:56.211]                   function(frame = 1L) {
[17:29:56.211]                     if (is.function(sendCondition)) 
[17:29:56.211]                       return(sendCondition)
[17:29:56.211]                     ns <- getNamespace("parallel")
[17:29:56.211]                     if (exists("sendData", mode = "function", 
[17:29:56.211]                       envir = ns)) {
[17:29:56.211]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:56.211]                         envir = ns)
[17:29:56.211]                       envir <- sys.frame(frame)
[17:29:56.211]                       master <- NULL
[17:29:56.211]                       while (!identical(envir, .GlobalEnv) && 
[17:29:56.211]                         !identical(envir, emptyenv())) {
[17:29:56.211]                         if (exists("master", mode = "list", envir = envir, 
[17:29:56.211]                           inherits = FALSE)) {
[17:29:56.211]                           master <- get("master", mode = "list", 
[17:29:56.211]                             envir = envir, inherits = FALSE)
[17:29:56.211]                           if (inherits(master, c("SOCKnode", 
[17:29:56.211]                             "SOCK0node"))) {
[17:29:56.211]                             sendCondition <<- function(cond) {
[17:29:56.211]                               data <- list(type = "VALUE", value = cond, 
[17:29:56.211]                                 success = TRUE)
[17:29:56.211]                               parallel_sendData(master, data)
[17:29:56.211]                             }
[17:29:56.211]                             return(sendCondition)
[17:29:56.211]                           }
[17:29:56.211]                         }
[17:29:56.211]                         frame <- frame + 1L
[17:29:56.211]                         envir <- sys.frame(frame)
[17:29:56.211]                       }
[17:29:56.211]                     }
[17:29:56.211]                     sendCondition <<- function(cond) NULL
[17:29:56.211]                   }
[17:29:56.211]                 })
[17:29:56.211]                 withCallingHandlers({
[17:29:56.211]                   NA
[17:29:56.211]                 }, immediateCondition = function(cond) {
[17:29:56.211]                   sendCondition <- ...future.makeSendCondition()
[17:29:56.211]                   sendCondition(cond)
[17:29:56.211]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.211]                   {
[17:29:56.211]                     inherits <- base::inherits
[17:29:56.211]                     invokeRestart <- base::invokeRestart
[17:29:56.211]                     is.null <- base::is.null
[17:29:56.211]                     muffled <- FALSE
[17:29:56.211]                     if (inherits(cond, "message")) {
[17:29:56.211]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:56.211]                       if (muffled) 
[17:29:56.211]                         invokeRestart("muffleMessage")
[17:29:56.211]                     }
[17:29:56.211]                     else if (inherits(cond, "warning")) {
[17:29:56.211]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:56.211]                       if (muffled) 
[17:29:56.211]                         invokeRestart("muffleWarning")
[17:29:56.211]                     }
[17:29:56.211]                     else if (inherits(cond, "condition")) {
[17:29:56.211]                       if (!is.null(pattern)) {
[17:29:56.211]                         computeRestarts <- base::computeRestarts
[17:29:56.211]                         grepl <- base::grepl
[17:29:56.211]                         restarts <- computeRestarts(cond)
[17:29:56.211]                         for (restart in restarts) {
[17:29:56.211]                           name <- restart$name
[17:29:56.211]                           if (is.null(name)) 
[17:29:56.211]                             next
[17:29:56.211]                           if (!grepl(pattern, name)) 
[17:29:56.211]                             next
[17:29:56.211]                           invokeRestart(restart)
[17:29:56.211]                           muffled <- TRUE
[17:29:56.211]                           break
[17:29:56.211]                         }
[17:29:56.211]                       }
[17:29:56.211]                     }
[17:29:56.211]                     invisible(muffled)
[17:29:56.211]                   }
[17:29:56.211]                   muffleCondition(cond)
[17:29:56.211]                 })
[17:29:56.211]             }))
[17:29:56.211]             future::FutureResult(value = ...future.value$value, 
[17:29:56.211]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.211]                   ...future.rng), globalenv = if (FALSE) 
[17:29:56.211]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:56.211]                     ...future.globalenv.names))
[17:29:56.211]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:56.211]         }, condition = base::local({
[17:29:56.211]             c <- base::c
[17:29:56.211]             inherits <- base::inherits
[17:29:56.211]             invokeRestart <- base::invokeRestart
[17:29:56.211]             length <- base::length
[17:29:56.211]             list <- base::list
[17:29:56.211]             seq.int <- base::seq.int
[17:29:56.211]             signalCondition <- base::signalCondition
[17:29:56.211]             sys.calls <- base::sys.calls
[17:29:56.211]             `[[` <- base::`[[`
[17:29:56.211]             `+` <- base::`+`
[17:29:56.211]             `<<-` <- base::`<<-`
[17:29:56.211]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:56.211]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:56.211]                   3L)]
[17:29:56.211]             }
[17:29:56.211]             function(cond) {
[17:29:56.211]                 is_error <- inherits(cond, "error")
[17:29:56.211]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:56.211]                   NULL)
[17:29:56.211]                 if (is_error) {
[17:29:56.211]                   sessionInformation <- function() {
[17:29:56.211]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:56.211]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:56.211]                       search = base::search(), system = base::Sys.info())
[17:29:56.211]                   }
[17:29:56.211]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.211]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:56.211]                     cond$call), session = sessionInformation(), 
[17:29:56.211]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:56.211]                   signalCondition(cond)
[17:29:56.211]                 }
[17:29:56.211]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:56.211]                 "immediateCondition"))) {
[17:29:56.211]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:56.211]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.211]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:56.211]                   if (TRUE && !signal) {
[17:29:56.211]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.211]                     {
[17:29:56.211]                       inherits <- base::inherits
[17:29:56.211]                       invokeRestart <- base::invokeRestart
[17:29:56.211]                       is.null <- base::is.null
[17:29:56.211]                       muffled <- FALSE
[17:29:56.211]                       if (inherits(cond, "message")) {
[17:29:56.211]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.211]                         if (muffled) 
[17:29:56.211]                           invokeRestart("muffleMessage")
[17:29:56.211]                       }
[17:29:56.211]                       else if (inherits(cond, "warning")) {
[17:29:56.211]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.211]                         if (muffled) 
[17:29:56.211]                           invokeRestart("muffleWarning")
[17:29:56.211]                       }
[17:29:56.211]                       else if (inherits(cond, "condition")) {
[17:29:56.211]                         if (!is.null(pattern)) {
[17:29:56.211]                           computeRestarts <- base::computeRestarts
[17:29:56.211]                           grepl <- base::grepl
[17:29:56.211]                           restarts <- computeRestarts(cond)
[17:29:56.211]                           for (restart in restarts) {
[17:29:56.211]                             name <- restart$name
[17:29:56.211]                             if (is.null(name)) 
[17:29:56.211]                               next
[17:29:56.211]                             if (!grepl(pattern, name)) 
[17:29:56.211]                               next
[17:29:56.211]                             invokeRestart(restart)
[17:29:56.211]                             muffled <- TRUE
[17:29:56.211]                             break
[17:29:56.211]                           }
[17:29:56.211]                         }
[17:29:56.211]                       }
[17:29:56.211]                       invisible(muffled)
[17:29:56.211]                     }
[17:29:56.211]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.211]                   }
[17:29:56.211]                 }
[17:29:56.211]                 else {
[17:29:56.211]                   if (TRUE) {
[17:29:56.211]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.211]                     {
[17:29:56.211]                       inherits <- base::inherits
[17:29:56.211]                       invokeRestart <- base::invokeRestart
[17:29:56.211]                       is.null <- base::is.null
[17:29:56.211]                       muffled <- FALSE
[17:29:56.211]                       if (inherits(cond, "message")) {
[17:29:56.211]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.211]                         if (muffled) 
[17:29:56.211]                           invokeRestart("muffleMessage")
[17:29:56.211]                       }
[17:29:56.211]                       else if (inherits(cond, "warning")) {
[17:29:56.211]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.211]                         if (muffled) 
[17:29:56.211]                           invokeRestart("muffleWarning")
[17:29:56.211]                       }
[17:29:56.211]                       else if (inherits(cond, "condition")) {
[17:29:56.211]                         if (!is.null(pattern)) {
[17:29:56.211]                           computeRestarts <- base::computeRestarts
[17:29:56.211]                           grepl <- base::grepl
[17:29:56.211]                           restarts <- computeRestarts(cond)
[17:29:56.211]                           for (restart in restarts) {
[17:29:56.211]                             name <- restart$name
[17:29:56.211]                             if (is.null(name)) 
[17:29:56.211]                               next
[17:29:56.211]                             if (!grepl(pattern, name)) 
[17:29:56.211]                               next
[17:29:56.211]                             invokeRestart(restart)
[17:29:56.211]                             muffled <- TRUE
[17:29:56.211]                             break
[17:29:56.211]                           }
[17:29:56.211]                         }
[17:29:56.211]                       }
[17:29:56.211]                       invisible(muffled)
[17:29:56.211]                     }
[17:29:56.211]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.211]                   }
[17:29:56.211]                 }
[17:29:56.211]             }
[17:29:56.211]         }))
[17:29:56.211]     }, error = function(ex) {
[17:29:56.211]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:56.211]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.211]                 ...future.rng), started = ...future.startTime, 
[17:29:56.211]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:56.211]             version = "1.8"), class = "FutureResult")
[17:29:56.211]     }, finally = {
[17:29:56.211]         if (!identical(...future.workdir, getwd())) 
[17:29:56.211]             setwd(...future.workdir)
[17:29:56.211]         {
[17:29:56.211]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:56.211]                 ...future.oldOptions$nwarnings <- NULL
[17:29:56.211]             }
[17:29:56.211]             base::options(...future.oldOptions)
[17:29:56.211]             if (.Platform$OS.type == "windows") {
[17:29:56.211]                 old_names <- names(...future.oldEnvVars)
[17:29:56.211]                 envs <- base::Sys.getenv()
[17:29:56.211]                 names <- names(envs)
[17:29:56.211]                 common <- intersect(names, old_names)
[17:29:56.211]                 added <- setdiff(names, old_names)
[17:29:56.211]                 removed <- setdiff(old_names, names)
[17:29:56.211]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:56.211]                   envs[common]]
[17:29:56.211]                 NAMES <- toupper(changed)
[17:29:56.211]                 args <- list()
[17:29:56.211]                 for (kk in seq_along(NAMES)) {
[17:29:56.211]                   name <- changed[[kk]]
[17:29:56.211]                   NAME <- NAMES[[kk]]
[17:29:56.211]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.211]                     next
[17:29:56.211]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.211]                 }
[17:29:56.211]                 NAMES <- toupper(added)
[17:29:56.211]                 for (kk in seq_along(NAMES)) {
[17:29:56.211]                   name <- added[[kk]]
[17:29:56.211]                   NAME <- NAMES[[kk]]
[17:29:56.211]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.211]                     next
[17:29:56.211]                   args[[name]] <- ""
[17:29:56.211]                 }
[17:29:56.211]                 NAMES <- toupper(removed)
[17:29:56.211]                 for (kk in seq_along(NAMES)) {
[17:29:56.211]                   name <- removed[[kk]]
[17:29:56.211]                   NAME <- NAMES[[kk]]
[17:29:56.211]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.211]                     next
[17:29:56.211]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.211]                 }
[17:29:56.211]                 if (length(args) > 0) 
[17:29:56.211]                   base::do.call(base::Sys.setenv, args = args)
[17:29:56.211]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:56.211]             }
[17:29:56.211]             else {
[17:29:56.211]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:56.211]             }
[17:29:56.211]             {
[17:29:56.211]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:56.211]                   0L) {
[17:29:56.211]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:56.211]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:56.211]                   base::options(opts)
[17:29:56.211]                 }
[17:29:56.211]                 {
[17:29:56.211]                   {
[17:29:56.211]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:56.211]                     NULL
[17:29:56.211]                   }
[17:29:56.211]                   options(future.plan = NULL)
[17:29:56.211]                   if (is.na(NA_character_)) 
[17:29:56.211]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.211]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:56.211]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:56.211]                     .init = FALSE)
[17:29:56.211]                 }
[17:29:56.211]             }
[17:29:56.211]         }
[17:29:56.211]     })
[17:29:56.211]     if (TRUE) {
[17:29:56.211]         base::sink(type = "output", split = FALSE)
[17:29:56.211]         if (TRUE) {
[17:29:56.211]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:56.211]         }
[17:29:56.211]         else {
[17:29:56.211]             ...future.result["stdout"] <- base::list(NULL)
[17:29:56.211]         }
[17:29:56.211]         base::close(...future.stdout)
[17:29:56.211]         ...future.stdout <- NULL
[17:29:56.211]     }
[17:29:56.211]     ...future.result$conditions <- ...future.conditions
[17:29:56.211]     ...future.result$finished <- base::Sys.time()
[17:29:56.211]     ...future.result
[17:29:56.211] }
[17:29:56.355] MultisessionFuture started
[17:29:56.355] result() for ClusterFuture ...
[17:29:56.356] receiveMessageFromWorker() for ClusterFuture ...
[17:29:56.357] - Validating connection of MultisessionFuture
[17:29:56.426] - received message: FutureResult
[17:29:56.427] - Received FutureResult
[17:29:56.433] - Erased future from FutureRegistry
[17:29:56.434] result() for ClusterFuture ...
[17:29:56.434] - result already collected: FutureResult
[17:29:56.435] result() for ClusterFuture ... done
[17:29:56.435] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:56.435] result() for ClusterFuture ... done
[17:29:56.436] result() for ClusterFuture ...
[17:29:56.436] - result already collected: FutureResult
[17:29:56.436] result() for ClusterFuture ... done
[17:29:56.437] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:29:56.442] plan(): nbrOfWorkers() = 2
- stdout = TRUE
[17:29:56.443] getGlobalsAndPackages() ...
[17:29:56.443] Searching for globals...
[17:29:56.451] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:29:56.452] Searching for globals ... DONE
[17:29:56.452] Resolving globals: FALSE
[17:29:56.454] 
[17:29:56.454] - packages: [1] 'utils'
[17:29:56.454] getGlobalsAndPackages() ... DONE
[17:29:56.455] run() for 'Future' ...
[17:29:56.456] - state: 'created'
[17:29:56.456] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:56.478] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:56.478] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:56.478]   - Field: 'node'
[17:29:56.479]   - Field: 'label'
[17:29:56.479]   - Field: 'local'
[17:29:56.479]   - Field: 'owner'
[17:29:56.480]   - Field: 'envir'
[17:29:56.480]   - Field: 'workers'
[17:29:56.480]   - Field: 'packages'
[17:29:56.480]   - Field: 'gc'
[17:29:56.481]   - Field: 'conditions'
[17:29:56.481]   - Field: 'persistent'
[17:29:56.481]   - Field: 'expr'
[17:29:56.482]   - Field: 'uuid'
[17:29:56.482]   - Field: 'seed'
[17:29:56.482]   - Field: 'version'
[17:29:56.483]   - Field: 'result'
[17:29:56.483]   - Field: 'asynchronous'
[17:29:56.483]   - Field: 'calls'
[17:29:56.483]   - Field: 'globals'
[17:29:56.484]   - Field: 'stdout'
[17:29:56.484]   - Field: 'earlySignal'
[17:29:56.484]   - Field: 'lazy'
[17:29:56.485]   - Field: 'state'
[17:29:56.485] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:56.485] - Launch lazy future ...
[17:29:56.486] Packages needed by the future expression (n = 1): 'utils'
[17:29:56.486] Packages needed by future strategies (n = 0): <none>
[17:29:56.487] {
[17:29:56.487]     {
[17:29:56.487]         {
[17:29:56.487]             ...future.startTime <- base::Sys.time()
[17:29:56.487]             {
[17:29:56.487]                 {
[17:29:56.487]                   {
[17:29:56.487]                     {
[17:29:56.487]                       {
[17:29:56.487]                         base::local({
[17:29:56.487]                           has_future <- base::requireNamespace("future", 
[17:29:56.487]                             quietly = TRUE)
[17:29:56.487]                           if (has_future) {
[17:29:56.487]                             ns <- base::getNamespace("future")
[17:29:56.487]                             version <- ns[[".package"]][["version"]]
[17:29:56.487]                             if (is.null(version)) 
[17:29:56.487]                               version <- utils::packageVersion("future")
[17:29:56.487]                           }
[17:29:56.487]                           else {
[17:29:56.487]                             version <- NULL
[17:29:56.487]                           }
[17:29:56.487]                           if (!has_future || version < "1.8.0") {
[17:29:56.487]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:56.487]                               "", base::R.version$version.string), 
[17:29:56.487]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:56.487]                                 base::R.version$platform, 8 * 
[17:29:56.487]                                   base::.Machine$sizeof.pointer), 
[17:29:56.487]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:56.487]                                 "release", "version")], collapse = " "), 
[17:29:56.487]                               hostname = base::Sys.info()[["nodename"]])
[17:29:56.487]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:56.487]                               info)
[17:29:56.487]                             info <- base::paste(info, collapse = "; ")
[17:29:56.487]                             if (!has_future) {
[17:29:56.487]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:56.487]                                 info)
[17:29:56.487]                             }
[17:29:56.487]                             else {
[17:29:56.487]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:56.487]                                 info, version)
[17:29:56.487]                             }
[17:29:56.487]                             base::stop(msg)
[17:29:56.487]                           }
[17:29:56.487]                         })
[17:29:56.487]                       }
[17:29:56.487]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:56.487]                       base::options(mc.cores = 1L)
[17:29:56.487]                     }
[17:29:56.487]                     base::local({
[17:29:56.487]                       for (pkg in "utils") {
[17:29:56.487]                         base::loadNamespace(pkg)
[17:29:56.487]                         base::library(pkg, character.only = TRUE)
[17:29:56.487]                       }
[17:29:56.487]                     })
[17:29:56.487]                   }
[17:29:56.487]                   ...future.strategy.old <- future::plan("list")
[17:29:56.487]                   options(future.plan = NULL)
[17:29:56.487]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.487]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:56.487]                 }
[17:29:56.487]                 ...future.workdir <- getwd()
[17:29:56.487]             }
[17:29:56.487]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:56.487]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:56.487]         }
[17:29:56.487]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:56.487]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:56.487]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:56.487]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:56.487]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:56.487]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:56.487]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:56.487]             base::names(...future.oldOptions))
[17:29:56.487]     }
[17:29:56.487]     if (FALSE) {
[17:29:56.487]     }
[17:29:56.487]     else {
[17:29:56.487]         if (TRUE) {
[17:29:56.487]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:56.487]                 open = "w")
[17:29:56.487]         }
[17:29:56.487]         else {
[17:29:56.487]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:56.487]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:56.487]         }
[17:29:56.487]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:56.487]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:56.487]             base::sink(type = "output", split = FALSE)
[17:29:56.487]             base::close(...future.stdout)
[17:29:56.487]         }, add = TRUE)
[17:29:56.487]     }
[17:29:56.487]     ...future.frame <- base::sys.nframe()
[17:29:56.487]     ...future.conditions <- base::list()
[17:29:56.487]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:56.487]     if (FALSE) {
[17:29:56.487]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:56.487]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:56.487]     }
[17:29:56.487]     ...future.result <- base::tryCatch({
[17:29:56.487]         base::withCallingHandlers({
[17:29:56.487]             ...future.value <- base::withVisible(base::local({
[17:29:56.487]                 ...future.makeSendCondition <- base::local({
[17:29:56.487]                   sendCondition <- NULL
[17:29:56.487]                   function(frame = 1L) {
[17:29:56.487]                     if (is.function(sendCondition)) 
[17:29:56.487]                       return(sendCondition)
[17:29:56.487]                     ns <- getNamespace("parallel")
[17:29:56.487]                     if (exists("sendData", mode = "function", 
[17:29:56.487]                       envir = ns)) {
[17:29:56.487]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:56.487]                         envir = ns)
[17:29:56.487]                       envir <- sys.frame(frame)
[17:29:56.487]                       master <- NULL
[17:29:56.487]                       while (!identical(envir, .GlobalEnv) && 
[17:29:56.487]                         !identical(envir, emptyenv())) {
[17:29:56.487]                         if (exists("master", mode = "list", envir = envir, 
[17:29:56.487]                           inherits = FALSE)) {
[17:29:56.487]                           master <- get("master", mode = "list", 
[17:29:56.487]                             envir = envir, inherits = FALSE)
[17:29:56.487]                           if (inherits(master, c("SOCKnode", 
[17:29:56.487]                             "SOCK0node"))) {
[17:29:56.487]                             sendCondition <<- function(cond) {
[17:29:56.487]                               data <- list(type = "VALUE", value = cond, 
[17:29:56.487]                                 success = TRUE)
[17:29:56.487]                               parallel_sendData(master, data)
[17:29:56.487]                             }
[17:29:56.487]                             return(sendCondition)
[17:29:56.487]                           }
[17:29:56.487]                         }
[17:29:56.487]                         frame <- frame + 1L
[17:29:56.487]                         envir <- sys.frame(frame)
[17:29:56.487]                       }
[17:29:56.487]                     }
[17:29:56.487]                     sendCondition <<- function(cond) NULL
[17:29:56.487]                   }
[17:29:56.487]                 })
[17:29:56.487]                 withCallingHandlers({
[17:29:56.487]                   {
[17:29:56.487]                     print(1:50)
[17:29:56.487]                     str(1:50)
[17:29:56.487]                     cat(letters, sep = "-")
[17:29:56.487]                     cat(1:6, collapse = "\n")
[17:29:56.487]                     write.table(datasets::iris[1:10, ], sep = "\t")
[17:29:56.487]                     42L
[17:29:56.487]                   }
[17:29:56.487]                 }, immediateCondition = function(cond) {
[17:29:56.487]                   sendCondition <- ...future.makeSendCondition()
[17:29:56.487]                   sendCondition(cond)
[17:29:56.487]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.487]                   {
[17:29:56.487]                     inherits <- base::inherits
[17:29:56.487]                     invokeRestart <- base::invokeRestart
[17:29:56.487]                     is.null <- base::is.null
[17:29:56.487]                     muffled <- FALSE
[17:29:56.487]                     if (inherits(cond, "message")) {
[17:29:56.487]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:56.487]                       if (muffled) 
[17:29:56.487]                         invokeRestart("muffleMessage")
[17:29:56.487]                     }
[17:29:56.487]                     else if (inherits(cond, "warning")) {
[17:29:56.487]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:56.487]                       if (muffled) 
[17:29:56.487]                         invokeRestart("muffleWarning")
[17:29:56.487]                     }
[17:29:56.487]                     else if (inherits(cond, "condition")) {
[17:29:56.487]                       if (!is.null(pattern)) {
[17:29:56.487]                         computeRestarts <- base::computeRestarts
[17:29:56.487]                         grepl <- base::grepl
[17:29:56.487]                         restarts <- computeRestarts(cond)
[17:29:56.487]                         for (restart in restarts) {
[17:29:56.487]                           name <- restart$name
[17:29:56.487]                           if (is.null(name)) 
[17:29:56.487]                             next
[17:29:56.487]                           if (!grepl(pattern, name)) 
[17:29:56.487]                             next
[17:29:56.487]                           invokeRestart(restart)
[17:29:56.487]                           muffled <- TRUE
[17:29:56.487]                           break
[17:29:56.487]                         }
[17:29:56.487]                       }
[17:29:56.487]                     }
[17:29:56.487]                     invisible(muffled)
[17:29:56.487]                   }
[17:29:56.487]                   muffleCondition(cond)
[17:29:56.487]                 })
[17:29:56.487]             }))
[17:29:56.487]             future::FutureResult(value = ...future.value$value, 
[17:29:56.487]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.487]                   ...future.rng), globalenv = if (FALSE) 
[17:29:56.487]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:56.487]                     ...future.globalenv.names))
[17:29:56.487]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:56.487]         }, condition = base::local({
[17:29:56.487]             c <- base::c
[17:29:56.487]             inherits <- base::inherits
[17:29:56.487]             invokeRestart <- base::invokeRestart
[17:29:56.487]             length <- base::length
[17:29:56.487]             list <- base::list
[17:29:56.487]             seq.int <- base::seq.int
[17:29:56.487]             signalCondition <- base::signalCondition
[17:29:56.487]             sys.calls <- base::sys.calls
[17:29:56.487]             `[[` <- base::`[[`
[17:29:56.487]             `+` <- base::`+`
[17:29:56.487]             `<<-` <- base::`<<-`
[17:29:56.487]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:56.487]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:56.487]                   3L)]
[17:29:56.487]             }
[17:29:56.487]             function(cond) {
[17:29:56.487]                 is_error <- inherits(cond, "error")
[17:29:56.487]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:56.487]                   NULL)
[17:29:56.487]                 if (is_error) {
[17:29:56.487]                   sessionInformation <- function() {
[17:29:56.487]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:56.487]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:56.487]                       search = base::search(), system = base::Sys.info())
[17:29:56.487]                   }
[17:29:56.487]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.487]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:56.487]                     cond$call), session = sessionInformation(), 
[17:29:56.487]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:56.487]                   signalCondition(cond)
[17:29:56.487]                 }
[17:29:56.487]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:56.487]                 "immediateCondition"))) {
[17:29:56.487]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:56.487]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.487]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:56.487]                   if (TRUE && !signal) {
[17:29:56.487]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.487]                     {
[17:29:56.487]                       inherits <- base::inherits
[17:29:56.487]                       invokeRestart <- base::invokeRestart
[17:29:56.487]                       is.null <- base::is.null
[17:29:56.487]                       muffled <- FALSE
[17:29:56.487]                       if (inherits(cond, "message")) {
[17:29:56.487]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.487]                         if (muffled) 
[17:29:56.487]                           invokeRestart("muffleMessage")
[17:29:56.487]                       }
[17:29:56.487]                       else if (inherits(cond, "warning")) {
[17:29:56.487]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.487]                         if (muffled) 
[17:29:56.487]                           invokeRestart("muffleWarning")
[17:29:56.487]                       }
[17:29:56.487]                       else if (inherits(cond, "condition")) {
[17:29:56.487]                         if (!is.null(pattern)) {
[17:29:56.487]                           computeRestarts <- base::computeRestarts
[17:29:56.487]                           grepl <- base::grepl
[17:29:56.487]                           restarts <- computeRestarts(cond)
[17:29:56.487]                           for (restart in restarts) {
[17:29:56.487]                             name <- restart$name
[17:29:56.487]                             if (is.null(name)) 
[17:29:56.487]                               next
[17:29:56.487]                             if (!grepl(pattern, name)) 
[17:29:56.487]                               next
[17:29:56.487]                             invokeRestart(restart)
[17:29:56.487]                             muffled <- TRUE
[17:29:56.487]                             break
[17:29:56.487]                           }
[17:29:56.487]                         }
[17:29:56.487]                       }
[17:29:56.487]                       invisible(muffled)
[17:29:56.487]                     }
[17:29:56.487]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.487]                   }
[17:29:56.487]                 }
[17:29:56.487]                 else {
[17:29:56.487]                   if (TRUE) {
[17:29:56.487]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.487]                     {
[17:29:56.487]                       inherits <- base::inherits
[17:29:56.487]                       invokeRestart <- base::invokeRestart
[17:29:56.487]                       is.null <- base::is.null
[17:29:56.487]                       muffled <- FALSE
[17:29:56.487]                       if (inherits(cond, "message")) {
[17:29:56.487]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.487]                         if (muffled) 
[17:29:56.487]                           invokeRestart("muffleMessage")
[17:29:56.487]                       }
[17:29:56.487]                       else if (inherits(cond, "warning")) {
[17:29:56.487]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.487]                         if (muffled) 
[17:29:56.487]                           invokeRestart("muffleWarning")
[17:29:56.487]                       }
[17:29:56.487]                       else if (inherits(cond, "condition")) {
[17:29:56.487]                         if (!is.null(pattern)) {
[17:29:56.487]                           computeRestarts <- base::computeRestarts
[17:29:56.487]                           grepl <- base::grepl
[17:29:56.487]                           restarts <- computeRestarts(cond)
[17:29:56.487]                           for (restart in restarts) {
[17:29:56.487]                             name <- restart$name
[17:29:56.487]                             if (is.null(name)) 
[17:29:56.487]                               next
[17:29:56.487]                             if (!grepl(pattern, name)) 
[17:29:56.487]                               next
[17:29:56.487]                             invokeRestart(restart)
[17:29:56.487]                             muffled <- TRUE
[17:29:56.487]                             break
[17:29:56.487]                           }
[17:29:56.487]                         }
[17:29:56.487]                       }
[17:29:56.487]                       invisible(muffled)
[17:29:56.487]                     }
[17:29:56.487]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.487]                   }
[17:29:56.487]                 }
[17:29:56.487]             }
[17:29:56.487]         }))
[17:29:56.487]     }, error = function(ex) {
[17:29:56.487]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:56.487]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.487]                 ...future.rng), started = ...future.startTime, 
[17:29:56.487]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:56.487]             version = "1.8"), class = "FutureResult")
[17:29:56.487]     }, finally = {
[17:29:56.487]         if (!identical(...future.workdir, getwd())) 
[17:29:56.487]             setwd(...future.workdir)
[17:29:56.487]         {
[17:29:56.487]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:56.487]                 ...future.oldOptions$nwarnings <- NULL
[17:29:56.487]             }
[17:29:56.487]             base::options(...future.oldOptions)
[17:29:56.487]             if (.Platform$OS.type == "windows") {
[17:29:56.487]                 old_names <- names(...future.oldEnvVars)
[17:29:56.487]                 envs <- base::Sys.getenv()
[17:29:56.487]                 names <- names(envs)
[17:29:56.487]                 common <- intersect(names, old_names)
[17:29:56.487]                 added <- setdiff(names, old_names)
[17:29:56.487]                 removed <- setdiff(old_names, names)
[17:29:56.487]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:56.487]                   envs[common]]
[17:29:56.487]                 NAMES <- toupper(changed)
[17:29:56.487]                 args <- list()
[17:29:56.487]                 for (kk in seq_along(NAMES)) {
[17:29:56.487]                   name <- changed[[kk]]
[17:29:56.487]                   NAME <- NAMES[[kk]]
[17:29:56.487]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.487]                     next
[17:29:56.487]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.487]                 }
[17:29:56.487]                 NAMES <- toupper(added)
[17:29:56.487]                 for (kk in seq_along(NAMES)) {
[17:29:56.487]                   name <- added[[kk]]
[17:29:56.487]                   NAME <- NAMES[[kk]]
[17:29:56.487]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.487]                     next
[17:29:56.487]                   args[[name]] <- ""
[17:29:56.487]                 }
[17:29:56.487]                 NAMES <- toupper(removed)
[17:29:56.487]                 for (kk in seq_along(NAMES)) {
[17:29:56.487]                   name <- removed[[kk]]
[17:29:56.487]                   NAME <- NAMES[[kk]]
[17:29:56.487]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.487]                     next
[17:29:56.487]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.487]                 }
[17:29:56.487]                 if (length(args) > 0) 
[17:29:56.487]                   base::do.call(base::Sys.setenv, args = args)
[17:29:56.487]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:56.487]             }
[17:29:56.487]             else {
[17:29:56.487]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:56.487]             }
[17:29:56.487]             {
[17:29:56.487]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:56.487]                   0L) {
[17:29:56.487]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:56.487]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:56.487]                   base::options(opts)
[17:29:56.487]                 }
[17:29:56.487]                 {
[17:29:56.487]                   {
[17:29:56.487]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:56.487]                     NULL
[17:29:56.487]                   }
[17:29:56.487]                   options(future.plan = NULL)
[17:29:56.487]                   if (is.na(NA_character_)) 
[17:29:56.487]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.487]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:56.487]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:56.487]                     .init = FALSE)
[17:29:56.487]                 }
[17:29:56.487]             }
[17:29:56.487]         }
[17:29:56.487]     })
[17:29:56.487]     if (TRUE) {
[17:29:56.487]         base::sink(type = "output", split = FALSE)
[17:29:56.487]         if (TRUE) {
[17:29:56.487]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:56.487]         }
[17:29:56.487]         else {
[17:29:56.487]             ...future.result["stdout"] <- base::list(NULL)
[17:29:56.487]         }
[17:29:56.487]         base::close(...future.stdout)
[17:29:56.487]         ...future.stdout <- NULL
[17:29:56.487]     }
[17:29:56.487]     ...future.result$conditions <- ...future.conditions
[17:29:56.487]     ...future.result$finished <- base::Sys.time()
[17:29:56.487]     ...future.result
[17:29:56.487] }
[17:29:56.497] MultisessionFuture started
[17:29:56.498] - Launch lazy future ... done
[17:29:56.498] run() for 'MultisessionFuture' ... done
[17:29:56.498] result() for ClusterFuture ...
[17:29:56.499] receiveMessageFromWorker() for ClusterFuture ...
[17:29:56.499] - Validating connection of MultisessionFuture
[17:29:56.522] - received message: FutureResult
[17:29:56.522] - Received FutureResult
[17:29:56.523] - Erased future from FutureRegistry
[17:29:56.523] result() for ClusterFuture ...
[17:29:56.524] - result already collected: FutureResult
[17:29:56.524] result() for ClusterFuture ... done
[17:29:56.524] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:56.525] 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: "2024-07-29 17:29:56"
 $ finished    : POSIXct[1:1], format: "2024-07-29 17:29:56"
 $ session_uuid: chr "e25fa336-1319-3de5-50c6-8c7ff8013db5"
  ..- 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 176124
  .. ..$ time  : POSIXct[1:1], format: "2024-07-29 17:29:56"
  .. ..$ 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 5 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[17:29:56.542] result() for ClusterFuture ...
[17:29:56.542] - result already collected: FutureResult
[17:29:56.543] result() for ClusterFuture ... done
[17:29:56.543] result() for ClusterFuture ...
[17:29:56.543] - result already collected: FutureResult
[17:29:56.544] 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.02453303 secs (started 2024-07-29 17:29:56.497462)
version: 1.8
[17:29:56.545] getGlobalsAndPackages() ...
[17:29:56.546] Searching for globals...
[17:29:56.554] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:29:56.555] Searching for globals ... DONE
[17:29:56.555] Resolving globals: FALSE
[17:29:56.556] 
[17:29:56.557] - packages: [1] 'utils'
[17:29:56.557] getGlobalsAndPackages() ... DONE
[17:29:56.558] run() for 'Future' ...
[17:29:56.558] - state: 'created'
[17:29:56.559] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:56.581] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:56.581] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:56.582]   - Field: 'node'
[17:29:56.582]   - Field: 'label'
[17:29:56.582]   - Field: 'local'
[17:29:56.582]   - Field: 'owner'
[17:29:56.582]   - Field: 'envir'
[17:29:56.583]   - Field: 'workers'
[17:29:56.583]   - Field: 'packages'
[17:29:56.583]   - Field: 'gc'
[17:29:56.583]   - Field: 'conditions'
[17:29:56.583]   - Field: 'persistent'
[17:29:56.584]   - Field: 'expr'
[17:29:56.584]   - Field: 'uuid'
[17:29:56.584]   - Field: 'seed'
[17:29:56.584]   - Field: 'version'
[17:29:56.584]   - Field: 'result'
[17:29:56.585]   - Field: 'asynchronous'
[17:29:56.585]   - Field: 'calls'
[17:29:56.585]   - Field: 'globals'
[17:29:56.585]   - Field: 'stdout'
[17:29:56.586]   - Field: 'earlySignal'
[17:29:56.586]   - Field: 'lazy'
[17:29:56.586]   - Field: 'state'
[17:29:56.586] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:56.586] - Launch lazy future ...
[17:29:56.587] Packages needed by the future expression (n = 1): 'utils'
[17:29:56.587] Packages needed by future strategies (n = 0): <none>
[17:29:56.588] {
[17:29:56.588]     {
[17:29:56.588]         {
[17:29:56.588]             ...future.startTime <- base::Sys.time()
[17:29:56.588]             {
[17:29:56.588]                 {
[17:29:56.588]                   {
[17:29:56.588]                     {
[17:29:56.588]                       {
[17:29:56.588]                         base::local({
[17:29:56.588]                           has_future <- base::requireNamespace("future", 
[17:29:56.588]                             quietly = TRUE)
[17:29:56.588]                           if (has_future) {
[17:29:56.588]                             ns <- base::getNamespace("future")
[17:29:56.588]                             version <- ns[[".package"]][["version"]]
[17:29:56.588]                             if (is.null(version)) 
[17:29:56.588]                               version <- utils::packageVersion("future")
[17:29:56.588]                           }
[17:29:56.588]                           else {
[17:29:56.588]                             version <- NULL
[17:29:56.588]                           }
[17:29:56.588]                           if (!has_future || version < "1.8.0") {
[17:29:56.588]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:56.588]                               "", base::R.version$version.string), 
[17:29:56.588]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:56.588]                                 base::R.version$platform, 8 * 
[17:29:56.588]                                   base::.Machine$sizeof.pointer), 
[17:29:56.588]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:56.588]                                 "release", "version")], collapse = " "), 
[17:29:56.588]                               hostname = base::Sys.info()[["nodename"]])
[17:29:56.588]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:56.588]                               info)
[17:29:56.588]                             info <- base::paste(info, collapse = "; ")
[17:29:56.588]                             if (!has_future) {
[17:29:56.588]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:56.588]                                 info)
[17:29:56.588]                             }
[17:29:56.588]                             else {
[17:29:56.588]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:56.588]                                 info, version)
[17:29:56.588]                             }
[17:29:56.588]                             base::stop(msg)
[17:29:56.588]                           }
[17:29:56.588]                         })
[17:29:56.588]                       }
[17:29:56.588]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:56.588]                       base::options(mc.cores = 1L)
[17:29:56.588]                     }
[17:29:56.588]                     base::local({
[17:29:56.588]                       for (pkg in "utils") {
[17:29:56.588]                         base::loadNamespace(pkg)
[17:29:56.588]                         base::library(pkg, character.only = TRUE)
[17:29:56.588]                       }
[17:29:56.588]                     })
[17:29:56.588]                   }
[17:29:56.588]                   ...future.strategy.old <- future::plan("list")
[17:29:56.588]                   options(future.plan = NULL)
[17:29:56.588]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.588]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:56.588]                 }
[17:29:56.588]                 ...future.workdir <- getwd()
[17:29:56.588]             }
[17:29:56.588]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:56.588]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:56.588]         }
[17:29:56.588]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:56.588]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:56.588]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:56.588]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:56.588]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:56.588]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:56.588]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:56.588]             base::names(...future.oldOptions))
[17:29:56.588]     }
[17:29:56.588]     if (FALSE) {
[17:29:56.588]     }
[17:29:56.588]     else {
[17:29:56.588]         if (TRUE) {
[17:29:56.588]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:56.588]                 open = "w")
[17:29:56.588]         }
[17:29:56.588]         else {
[17:29:56.588]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:56.588]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:56.588]         }
[17:29:56.588]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:56.588]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:56.588]             base::sink(type = "output", split = FALSE)
[17:29:56.588]             base::close(...future.stdout)
[17:29:56.588]         }, add = TRUE)
[17:29:56.588]     }
[17:29:56.588]     ...future.frame <- base::sys.nframe()
[17:29:56.588]     ...future.conditions <- base::list()
[17:29:56.588]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:56.588]     if (FALSE) {
[17:29:56.588]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:56.588]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:56.588]     }
[17:29:56.588]     ...future.result <- base::tryCatch({
[17:29:56.588]         base::withCallingHandlers({
[17:29:56.588]             ...future.value <- base::withVisible(base::local({
[17:29:56.588]                 ...future.makeSendCondition <- base::local({
[17:29:56.588]                   sendCondition <- NULL
[17:29:56.588]                   function(frame = 1L) {
[17:29:56.588]                     if (is.function(sendCondition)) 
[17:29:56.588]                       return(sendCondition)
[17:29:56.588]                     ns <- getNamespace("parallel")
[17:29:56.588]                     if (exists("sendData", mode = "function", 
[17:29:56.588]                       envir = ns)) {
[17:29:56.588]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:56.588]                         envir = ns)
[17:29:56.588]                       envir <- sys.frame(frame)
[17:29:56.588]                       master <- NULL
[17:29:56.588]                       while (!identical(envir, .GlobalEnv) && 
[17:29:56.588]                         !identical(envir, emptyenv())) {
[17:29:56.588]                         if (exists("master", mode = "list", envir = envir, 
[17:29:56.588]                           inherits = FALSE)) {
[17:29:56.588]                           master <- get("master", mode = "list", 
[17:29:56.588]                             envir = envir, inherits = FALSE)
[17:29:56.588]                           if (inherits(master, c("SOCKnode", 
[17:29:56.588]                             "SOCK0node"))) {
[17:29:56.588]                             sendCondition <<- function(cond) {
[17:29:56.588]                               data <- list(type = "VALUE", value = cond, 
[17:29:56.588]                                 success = TRUE)
[17:29:56.588]                               parallel_sendData(master, data)
[17:29:56.588]                             }
[17:29:56.588]                             return(sendCondition)
[17:29:56.588]                           }
[17:29:56.588]                         }
[17:29:56.588]                         frame <- frame + 1L
[17:29:56.588]                         envir <- sys.frame(frame)
[17:29:56.588]                       }
[17:29:56.588]                     }
[17:29:56.588]                     sendCondition <<- function(cond) NULL
[17:29:56.588]                   }
[17:29:56.588]                 })
[17:29:56.588]                 withCallingHandlers({
[17:29:56.588]                   {
[17:29:56.588]                     print(1:50)
[17:29:56.588]                     str(1:50)
[17:29:56.588]                     cat(letters, sep = "-")
[17:29:56.588]                     cat(1:6, collapse = "\n")
[17:29:56.588]                     write.table(datasets::iris[1:10, ], sep = "\t")
[17:29:56.588]                     42L
[17:29:56.588]                   }
[17:29:56.588]                 }, immediateCondition = function(cond) {
[17:29:56.588]                   sendCondition <- ...future.makeSendCondition()
[17:29:56.588]                   sendCondition(cond)
[17:29:56.588]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.588]                   {
[17:29:56.588]                     inherits <- base::inherits
[17:29:56.588]                     invokeRestart <- base::invokeRestart
[17:29:56.588]                     is.null <- base::is.null
[17:29:56.588]                     muffled <- FALSE
[17:29:56.588]                     if (inherits(cond, "message")) {
[17:29:56.588]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:56.588]                       if (muffled) 
[17:29:56.588]                         invokeRestart("muffleMessage")
[17:29:56.588]                     }
[17:29:56.588]                     else if (inherits(cond, "warning")) {
[17:29:56.588]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:56.588]                       if (muffled) 
[17:29:56.588]                         invokeRestart("muffleWarning")
[17:29:56.588]                     }
[17:29:56.588]                     else if (inherits(cond, "condition")) {
[17:29:56.588]                       if (!is.null(pattern)) {
[17:29:56.588]                         computeRestarts <- base::computeRestarts
[17:29:56.588]                         grepl <- base::grepl
[17:29:56.588]                         restarts <- computeRestarts(cond)
[17:29:56.588]                         for (restart in restarts) {
[17:29:56.588]                           name <- restart$name
[17:29:56.588]                           if (is.null(name)) 
[17:29:56.588]                             next
[17:29:56.588]                           if (!grepl(pattern, name)) 
[17:29:56.588]                             next
[17:29:56.588]                           invokeRestart(restart)
[17:29:56.588]                           muffled <- TRUE
[17:29:56.588]                           break
[17:29:56.588]                         }
[17:29:56.588]                       }
[17:29:56.588]                     }
[17:29:56.588]                     invisible(muffled)
[17:29:56.588]                   }
[17:29:56.588]                   muffleCondition(cond)
[17:29:56.588]                 })
[17:29:56.588]             }))
[17:29:56.588]             future::FutureResult(value = ...future.value$value, 
[17:29:56.588]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.588]                   ...future.rng), globalenv = if (FALSE) 
[17:29:56.588]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:56.588]                     ...future.globalenv.names))
[17:29:56.588]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:56.588]         }, condition = base::local({
[17:29:56.588]             c <- base::c
[17:29:56.588]             inherits <- base::inherits
[17:29:56.588]             invokeRestart <- base::invokeRestart
[17:29:56.588]             length <- base::length
[17:29:56.588]             list <- base::list
[17:29:56.588]             seq.int <- base::seq.int
[17:29:56.588]             signalCondition <- base::signalCondition
[17:29:56.588]             sys.calls <- base::sys.calls
[17:29:56.588]             `[[` <- base::`[[`
[17:29:56.588]             `+` <- base::`+`
[17:29:56.588]             `<<-` <- base::`<<-`
[17:29:56.588]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:56.588]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:56.588]                   3L)]
[17:29:56.588]             }
[17:29:56.588]             function(cond) {
[17:29:56.588]                 is_error <- inherits(cond, "error")
[17:29:56.588]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:56.588]                   NULL)
[17:29:56.588]                 if (is_error) {
[17:29:56.588]                   sessionInformation <- function() {
[17:29:56.588]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:56.588]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:56.588]                       search = base::search(), system = base::Sys.info())
[17:29:56.588]                   }
[17:29:56.588]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.588]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:56.588]                     cond$call), session = sessionInformation(), 
[17:29:56.588]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:56.588]                   signalCondition(cond)
[17:29:56.588]                 }
[17:29:56.588]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:56.588]                 "immediateCondition"))) {
[17:29:56.588]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:56.588]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.588]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:56.588]                   if (TRUE && !signal) {
[17:29:56.588]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.588]                     {
[17:29:56.588]                       inherits <- base::inherits
[17:29:56.588]                       invokeRestart <- base::invokeRestart
[17:29:56.588]                       is.null <- base::is.null
[17:29:56.588]                       muffled <- FALSE
[17:29:56.588]                       if (inherits(cond, "message")) {
[17:29:56.588]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.588]                         if (muffled) 
[17:29:56.588]                           invokeRestart("muffleMessage")
[17:29:56.588]                       }
[17:29:56.588]                       else if (inherits(cond, "warning")) {
[17:29:56.588]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.588]                         if (muffled) 
[17:29:56.588]                           invokeRestart("muffleWarning")
[17:29:56.588]                       }
[17:29:56.588]                       else if (inherits(cond, "condition")) {
[17:29:56.588]                         if (!is.null(pattern)) {
[17:29:56.588]                           computeRestarts <- base::computeRestarts
[17:29:56.588]                           grepl <- base::grepl
[17:29:56.588]                           restarts <- computeRestarts(cond)
[17:29:56.588]                           for (restart in restarts) {
[17:29:56.588]                             name <- restart$name
[17:29:56.588]                             if (is.null(name)) 
[17:29:56.588]                               next
[17:29:56.588]                             if (!grepl(pattern, name)) 
[17:29:56.588]                               next
[17:29:56.588]                             invokeRestart(restart)
[17:29:56.588]                             muffled <- TRUE
[17:29:56.588]                             break
[17:29:56.588]                           }
[17:29:56.588]                         }
[17:29:56.588]                       }
[17:29:56.588]                       invisible(muffled)
[17:29:56.588]                     }
[17:29:56.588]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.588]                   }
[17:29:56.588]                 }
[17:29:56.588]                 else {
[17:29:56.588]                   if (TRUE) {
[17:29:56.588]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.588]                     {
[17:29:56.588]                       inherits <- base::inherits
[17:29:56.588]                       invokeRestart <- base::invokeRestart
[17:29:56.588]                       is.null <- base::is.null
[17:29:56.588]                       muffled <- FALSE
[17:29:56.588]                       if (inherits(cond, "message")) {
[17:29:56.588]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.588]                         if (muffled) 
[17:29:56.588]                           invokeRestart("muffleMessage")
[17:29:56.588]                       }
[17:29:56.588]                       else if (inherits(cond, "warning")) {
[17:29:56.588]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.588]                         if (muffled) 
[17:29:56.588]                           invokeRestart("muffleWarning")
[17:29:56.588]                       }
[17:29:56.588]                       else if (inherits(cond, "condition")) {
[17:29:56.588]                         if (!is.null(pattern)) {
[17:29:56.588]                           computeRestarts <- base::computeRestarts
[17:29:56.588]                           grepl <- base::grepl
[17:29:56.588]                           restarts <- computeRestarts(cond)
[17:29:56.588]                           for (restart in restarts) {
[17:29:56.588]                             name <- restart$name
[17:29:56.588]                             if (is.null(name)) 
[17:29:56.588]                               next
[17:29:56.588]                             if (!grepl(pattern, name)) 
[17:29:56.588]                               next
[17:29:56.588]                             invokeRestart(restart)
[17:29:56.588]                             muffled <- TRUE
[17:29:56.588]                             break
[17:29:56.588]                           }
[17:29:56.588]                         }
[17:29:56.588]                       }
[17:29:56.588]                       invisible(muffled)
[17:29:56.588]                     }
[17:29:56.588]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.588]                   }
[17:29:56.588]                 }
[17:29:56.588]             }
[17:29:56.588]         }))
[17:29:56.588]     }, error = function(ex) {
[17:29:56.588]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:56.588]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.588]                 ...future.rng), started = ...future.startTime, 
[17:29:56.588]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:56.588]             version = "1.8"), class = "FutureResult")
[17:29:56.588]     }, finally = {
[17:29:56.588]         if (!identical(...future.workdir, getwd())) 
[17:29:56.588]             setwd(...future.workdir)
[17:29:56.588]         {
[17:29:56.588]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:56.588]                 ...future.oldOptions$nwarnings <- NULL
[17:29:56.588]             }
[17:29:56.588]             base::options(...future.oldOptions)
[17:29:56.588]             if (.Platform$OS.type == "windows") {
[17:29:56.588]                 old_names <- names(...future.oldEnvVars)
[17:29:56.588]                 envs <- base::Sys.getenv()
[17:29:56.588]                 names <- names(envs)
[17:29:56.588]                 common <- intersect(names, old_names)
[17:29:56.588]                 added <- setdiff(names, old_names)
[17:29:56.588]                 removed <- setdiff(old_names, names)
[17:29:56.588]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:56.588]                   envs[common]]
[17:29:56.588]                 NAMES <- toupper(changed)
[17:29:56.588]                 args <- list()
[17:29:56.588]                 for (kk in seq_along(NAMES)) {
[17:29:56.588]                   name <- changed[[kk]]
[17:29:56.588]                   NAME <- NAMES[[kk]]
[17:29:56.588]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.588]                     next
[17:29:56.588]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.588]                 }
[17:29:56.588]                 NAMES <- toupper(added)
[17:29:56.588]                 for (kk in seq_along(NAMES)) {
[17:29:56.588]                   name <- added[[kk]]
[17:29:56.588]                   NAME <- NAMES[[kk]]
[17:29:56.588]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.588]                     next
[17:29:56.588]                   args[[name]] <- ""
[17:29:56.588]                 }
[17:29:56.588]                 NAMES <- toupper(removed)
[17:29:56.588]                 for (kk in seq_along(NAMES)) {
[17:29:56.588]                   name <- removed[[kk]]
[17:29:56.588]                   NAME <- NAMES[[kk]]
[17:29:56.588]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.588]                     next
[17:29:56.588]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.588]                 }
[17:29:56.588]                 if (length(args) > 0) 
[17:29:56.588]                   base::do.call(base::Sys.setenv, args = args)
[17:29:56.588]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:56.588]             }
[17:29:56.588]             else {
[17:29:56.588]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:56.588]             }
[17:29:56.588]             {
[17:29:56.588]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:56.588]                   0L) {
[17:29:56.588]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:56.588]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:56.588]                   base::options(opts)
[17:29:56.588]                 }
[17:29:56.588]                 {
[17:29:56.588]                   {
[17:29:56.588]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:56.588]                     NULL
[17:29:56.588]                   }
[17:29:56.588]                   options(future.plan = NULL)
[17:29:56.588]                   if (is.na(NA_character_)) 
[17:29:56.588]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.588]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:56.588]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:56.588]                     .init = FALSE)
[17:29:56.588]                 }
[17:29:56.588]             }
[17:29:56.588]         }
[17:29:56.588]     })
[17:29:56.588]     if (TRUE) {
[17:29:56.588]         base::sink(type = "output", split = FALSE)
[17:29:56.588]         if (TRUE) {
[17:29:56.588]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:56.588]         }
[17:29:56.588]         else {
[17:29:56.588]             ...future.result["stdout"] <- base::list(NULL)
[17:29:56.588]         }
[17:29:56.588]         base::close(...future.stdout)
[17:29:56.588]         ...future.stdout <- NULL
[17:29:56.588]     }
[17:29:56.588]     ...future.result$conditions <- ...future.conditions
[17:29:56.588]     ...future.result$finished <- base::Sys.time()
[17:29:56.588]     ...future.result
[17:29:56.588] }
[17:29:56.596] MultisessionFuture started
[17:29:56.597] - Launch lazy future ... done
[17:29:56.597] run() for 'MultisessionFuture' ... done
[17:29:56.598] result() for ClusterFuture ...
[17:29:56.599] receiveMessageFromWorker() for ClusterFuture ...
[17:29:56.599] - Validating connection of MultisessionFuture
[17:29:56.626] - received message: FutureResult
[17:29:56.627] - Received FutureResult
[17:29:56.627] - Erased future from FutureRegistry
[17:29:56.628] result() for ClusterFuture ...
[17:29:56.628] - result already collected: FutureResult
[17:29:56.628] result() for ClusterFuture ... done
[17:29:56.629] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:56.632] result() for ClusterFuture ... done
[17:29:56.632] result() for ClusterFuture ...
[17:29:56.632] - result already collected: FutureResult
[17:29:56.632] 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)
[17:29:56.633] getGlobalsAndPackages() ...
[17:29:56.633] Searching for globals...
[17:29:56.634] - globals found: [1] 'print'
[17:29:56.634] Searching for globals ... DONE
[17:29:56.635] Resolving globals: FALSE
[17:29:56.635] 
[17:29:56.635] 
[17:29:56.635] getGlobalsAndPackages() ... DONE
[17:29:56.636] run() for 'Future' ...
[17:29:56.636] - state: 'created'
[17:29:56.636] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:56.656] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:56.657] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:56.657]   - Field: 'node'
[17:29:56.657]   - Field: 'label'
[17:29:56.658]   - Field: 'local'
[17:29:56.658]   - Field: 'owner'
[17:29:56.658]   - Field: 'envir'
[17:29:56.659]   - Field: 'workers'
[17:29:56.659]   - Field: 'packages'
[17:29:56.659]   - Field: 'gc'
[17:29:56.659]   - Field: 'conditions'
[17:29:56.660]   - Field: 'persistent'
[17:29:56.660]   - Field: 'expr'
[17:29:56.660]   - Field: 'uuid'
[17:29:56.661]   - Field: 'seed'
[17:29:56.661]   - Field: 'version'
[17:29:56.661]   - Field: 'result'
[17:29:56.661]   - Field: 'asynchronous'
[17:29:56.662]   - Field: 'calls'
[17:29:56.662]   - Field: 'globals'
[17:29:56.662]   - Field: 'stdout'
[17:29:56.663]   - Field: 'earlySignal'
[17:29:56.663]   - Field: 'lazy'
[17:29:56.663]   - Field: 'state'
[17:29:56.663] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:56.664] - Launch lazy future ...
[17:29:56.664] Packages needed by the future expression (n = 0): <none>
[17:29:56.665] Packages needed by future strategies (n = 0): <none>
[17:29:56.666] {
[17:29:56.666]     {
[17:29:56.666]         {
[17:29:56.666]             ...future.startTime <- base::Sys.time()
[17:29:56.666]             {
[17:29:56.666]                 {
[17:29:56.666]                   {
[17:29:56.666]                     {
[17:29:56.666]                       base::local({
[17:29:56.666]                         has_future <- base::requireNamespace("future", 
[17:29:56.666]                           quietly = TRUE)
[17:29:56.666]                         if (has_future) {
[17:29:56.666]                           ns <- base::getNamespace("future")
[17:29:56.666]                           version <- ns[[".package"]][["version"]]
[17:29:56.666]                           if (is.null(version)) 
[17:29:56.666]                             version <- utils::packageVersion("future")
[17:29:56.666]                         }
[17:29:56.666]                         else {
[17:29:56.666]                           version <- NULL
[17:29:56.666]                         }
[17:29:56.666]                         if (!has_future || version < "1.8.0") {
[17:29:56.666]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:56.666]                             "", base::R.version$version.string), 
[17:29:56.666]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:56.666]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:56.666]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:56.666]                               "release", "version")], collapse = " "), 
[17:29:56.666]                             hostname = base::Sys.info()[["nodename"]])
[17:29:56.666]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:56.666]                             info)
[17:29:56.666]                           info <- base::paste(info, collapse = "; ")
[17:29:56.666]                           if (!has_future) {
[17:29:56.666]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:56.666]                               info)
[17:29:56.666]                           }
[17:29:56.666]                           else {
[17:29:56.666]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:56.666]                               info, version)
[17:29:56.666]                           }
[17:29:56.666]                           base::stop(msg)
[17:29:56.666]                         }
[17:29:56.666]                       })
[17:29:56.666]                     }
[17:29:56.666]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:56.666]                     base::options(mc.cores = 1L)
[17:29:56.666]                   }
[17:29:56.666]                   ...future.strategy.old <- future::plan("list")
[17:29:56.666]                   options(future.plan = NULL)
[17:29:56.666]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.666]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:56.666]                 }
[17:29:56.666]                 ...future.workdir <- getwd()
[17:29:56.666]             }
[17:29:56.666]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:56.666]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:56.666]         }
[17:29:56.666]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:56.666]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:56.666]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:56.666]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:56.666]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:56.666]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:56.666]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:56.666]             base::names(...future.oldOptions))
[17:29:56.666]     }
[17:29:56.666]     if (FALSE) {
[17:29:56.666]     }
[17:29:56.666]     else {
[17:29:56.666]         if (TRUE) {
[17:29:56.666]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:56.666]                 open = "w")
[17:29:56.666]         }
[17:29:56.666]         else {
[17:29:56.666]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:56.666]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:56.666]         }
[17:29:56.666]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:56.666]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:56.666]             base::sink(type = "output", split = FALSE)
[17:29:56.666]             base::close(...future.stdout)
[17:29:56.666]         }, add = TRUE)
[17:29:56.666]     }
[17:29:56.666]     ...future.frame <- base::sys.nframe()
[17:29:56.666]     ...future.conditions <- base::list()
[17:29:56.666]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:56.666]     if (FALSE) {
[17:29:56.666]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:56.666]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:56.666]     }
[17:29:56.666]     ...future.result <- base::tryCatch({
[17:29:56.666]         base::withCallingHandlers({
[17:29:56.666]             ...future.value <- base::withVisible(base::local({
[17:29:56.666]                 ...future.makeSendCondition <- base::local({
[17:29:56.666]                   sendCondition <- NULL
[17:29:56.666]                   function(frame = 1L) {
[17:29:56.666]                     if (is.function(sendCondition)) 
[17:29:56.666]                       return(sendCondition)
[17:29:56.666]                     ns <- getNamespace("parallel")
[17:29:56.666]                     if (exists("sendData", mode = "function", 
[17:29:56.666]                       envir = ns)) {
[17:29:56.666]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:56.666]                         envir = ns)
[17:29:56.666]                       envir <- sys.frame(frame)
[17:29:56.666]                       master <- NULL
[17:29:56.666]                       while (!identical(envir, .GlobalEnv) && 
[17:29:56.666]                         !identical(envir, emptyenv())) {
[17:29:56.666]                         if (exists("master", mode = "list", envir = envir, 
[17:29:56.666]                           inherits = FALSE)) {
[17:29:56.666]                           master <- get("master", mode = "list", 
[17:29:56.666]                             envir = envir, inherits = FALSE)
[17:29:56.666]                           if (inherits(master, c("SOCKnode", 
[17:29:56.666]                             "SOCK0node"))) {
[17:29:56.666]                             sendCondition <<- function(cond) {
[17:29:56.666]                               data <- list(type = "VALUE", value = cond, 
[17:29:56.666]                                 success = TRUE)
[17:29:56.666]                               parallel_sendData(master, data)
[17:29:56.666]                             }
[17:29:56.666]                             return(sendCondition)
[17:29:56.666]                           }
[17:29:56.666]                         }
[17:29:56.666]                         frame <- frame + 1L
[17:29:56.666]                         envir <- sys.frame(frame)
[17:29:56.666]                       }
[17:29:56.666]                     }
[17:29:56.666]                     sendCondition <<- function(cond) NULL
[17:29:56.666]                   }
[17:29:56.666]                 })
[17:29:56.666]                 withCallingHandlers({
[17:29:56.666]                   print(42)
[17:29:56.666]                 }, immediateCondition = function(cond) {
[17:29:56.666]                   sendCondition <- ...future.makeSendCondition()
[17:29:56.666]                   sendCondition(cond)
[17:29:56.666]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.666]                   {
[17:29:56.666]                     inherits <- base::inherits
[17:29:56.666]                     invokeRestart <- base::invokeRestart
[17:29:56.666]                     is.null <- base::is.null
[17:29:56.666]                     muffled <- FALSE
[17:29:56.666]                     if (inherits(cond, "message")) {
[17:29:56.666]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:56.666]                       if (muffled) 
[17:29:56.666]                         invokeRestart("muffleMessage")
[17:29:56.666]                     }
[17:29:56.666]                     else if (inherits(cond, "warning")) {
[17:29:56.666]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:56.666]                       if (muffled) 
[17:29:56.666]                         invokeRestart("muffleWarning")
[17:29:56.666]                     }
[17:29:56.666]                     else if (inherits(cond, "condition")) {
[17:29:56.666]                       if (!is.null(pattern)) {
[17:29:56.666]                         computeRestarts <- base::computeRestarts
[17:29:56.666]                         grepl <- base::grepl
[17:29:56.666]                         restarts <- computeRestarts(cond)
[17:29:56.666]                         for (restart in restarts) {
[17:29:56.666]                           name <- restart$name
[17:29:56.666]                           if (is.null(name)) 
[17:29:56.666]                             next
[17:29:56.666]                           if (!grepl(pattern, name)) 
[17:29:56.666]                             next
[17:29:56.666]                           invokeRestart(restart)
[17:29:56.666]                           muffled <- TRUE
[17:29:56.666]                           break
[17:29:56.666]                         }
[17:29:56.666]                       }
[17:29:56.666]                     }
[17:29:56.666]                     invisible(muffled)
[17:29:56.666]                   }
[17:29:56.666]                   muffleCondition(cond)
[17:29:56.666]                 })
[17:29:56.666]             }))
[17:29:56.666]             future::FutureResult(value = ...future.value$value, 
[17:29:56.666]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.666]                   ...future.rng), globalenv = if (FALSE) 
[17:29:56.666]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:56.666]                     ...future.globalenv.names))
[17:29:56.666]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:56.666]         }, condition = base::local({
[17:29:56.666]             c <- base::c
[17:29:56.666]             inherits <- base::inherits
[17:29:56.666]             invokeRestart <- base::invokeRestart
[17:29:56.666]             length <- base::length
[17:29:56.666]             list <- base::list
[17:29:56.666]             seq.int <- base::seq.int
[17:29:56.666]             signalCondition <- base::signalCondition
[17:29:56.666]             sys.calls <- base::sys.calls
[17:29:56.666]             `[[` <- base::`[[`
[17:29:56.666]             `+` <- base::`+`
[17:29:56.666]             `<<-` <- base::`<<-`
[17:29:56.666]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:56.666]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:56.666]                   3L)]
[17:29:56.666]             }
[17:29:56.666]             function(cond) {
[17:29:56.666]                 is_error <- inherits(cond, "error")
[17:29:56.666]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:56.666]                   NULL)
[17:29:56.666]                 if (is_error) {
[17:29:56.666]                   sessionInformation <- function() {
[17:29:56.666]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:56.666]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:56.666]                       search = base::search(), system = base::Sys.info())
[17:29:56.666]                   }
[17:29:56.666]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.666]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:56.666]                     cond$call), session = sessionInformation(), 
[17:29:56.666]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:56.666]                   signalCondition(cond)
[17:29:56.666]                 }
[17:29:56.666]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:56.666]                 "immediateCondition"))) {
[17:29:56.666]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:56.666]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.666]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:56.666]                   if (TRUE && !signal) {
[17:29:56.666]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.666]                     {
[17:29:56.666]                       inherits <- base::inherits
[17:29:56.666]                       invokeRestart <- base::invokeRestart
[17:29:56.666]                       is.null <- base::is.null
[17:29:56.666]                       muffled <- FALSE
[17:29:56.666]                       if (inherits(cond, "message")) {
[17:29:56.666]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.666]                         if (muffled) 
[17:29:56.666]                           invokeRestart("muffleMessage")
[17:29:56.666]                       }
[17:29:56.666]                       else if (inherits(cond, "warning")) {
[17:29:56.666]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.666]                         if (muffled) 
[17:29:56.666]                           invokeRestart("muffleWarning")
[17:29:56.666]                       }
[17:29:56.666]                       else if (inherits(cond, "condition")) {
[17:29:56.666]                         if (!is.null(pattern)) {
[17:29:56.666]                           computeRestarts <- base::computeRestarts
[17:29:56.666]                           grepl <- base::grepl
[17:29:56.666]                           restarts <- computeRestarts(cond)
[17:29:56.666]                           for (restart in restarts) {
[17:29:56.666]                             name <- restart$name
[17:29:56.666]                             if (is.null(name)) 
[17:29:56.666]                               next
[17:29:56.666]                             if (!grepl(pattern, name)) 
[17:29:56.666]                               next
[17:29:56.666]                             invokeRestart(restart)
[17:29:56.666]                             muffled <- TRUE
[17:29:56.666]                             break
[17:29:56.666]                           }
[17:29:56.666]                         }
[17:29:56.666]                       }
[17:29:56.666]                       invisible(muffled)
[17:29:56.666]                     }
[17:29:56.666]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.666]                   }
[17:29:56.666]                 }
[17:29:56.666]                 else {
[17:29:56.666]                   if (TRUE) {
[17:29:56.666]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.666]                     {
[17:29:56.666]                       inherits <- base::inherits
[17:29:56.666]                       invokeRestart <- base::invokeRestart
[17:29:56.666]                       is.null <- base::is.null
[17:29:56.666]                       muffled <- FALSE
[17:29:56.666]                       if (inherits(cond, "message")) {
[17:29:56.666]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.666]                         if (muffled) 
[17:29:56.666]                           invokeRestart("muffleMessage")
[17:29:56.666]                       }
[17:29:56.666]                       else if (inherits(cond, "warning")) {
[17:29:56.666]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.666]                         if (muffled) 
[17:29:56.666]                           invokeRestart("muffleWarning")
[17:29:56.666]                       }
[17:29:56.666]                       else if (inherits(cond, "condition")) {
[17:29:56.666]                         if (!is.null(pattern)) {
[17:29:56.666]                           computeRestarts <- base::computeRestarts
[17:29:56.666]                           grepl <- base::grepl
[17:29:56.666]                           restarts <- computeRestarts(cond)
[17:29:56.666]                           for (restart in restarts) {
[17:29:56.666]                             name <- restart$name
[17:29:56.666]                             if (is.null(name)) 
[17:29:56.666]                               next
[17:29:56.666]                             if (!grepl(pattern, name)) 
[17:29:56.666]                               next
[17:29:56.666]                             invokeRestart(restart)
[17:29:56.666]                             muffled <- TRUE
[17:29:56.666]                             break
[17:29:56.666]                           }
[17:29:56.666]                         }
[17:29:56.666]                       }
[17:29:56.666]                       invisible(muffled)
[17:29:56.666]                     }
[17:29:56.666]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.666]                   }
[17:29:56.666]                 }
[17:29:56.666]             }
[17:29:56.666]         }))
[17:29:56.666]     }, error = function(ex) {
[17:29:56.666]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:56.666]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.666]                 ...future.rng), started = ...future.startTime, 
[17:29:56.666]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:56.666]             version = "1.8"), class = "FutureResult")
[17:29:56.666]     }, finally = {
[17:29:56.666]         if (!identical(...future.workdir, getwd())) 
[17:29:56.666]             setwd(...future.workdir)
[17:29:56.666]         {
[17:29:56.666]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:56.666]                 ...future.oldOptions$nwarnings <- NULL
[17:29:56.666]             }
[17:29:56.666]             base::options(...future.oldOptions)
[17:29:56.666]             if (.Platform$OS.type == "windows") {
[17:29:56.666]                 old_names <- names(...future.oldEnvVars)
[17:29:56.666]                 envs <- base::Sys.getenv()
[17:29:56.666]                 names <- names(envs)
[17:29:56.666]                 common <- intersect(names, old_names)
[17:29:56.666]                 added <- setdiff(names, old_names)
[17:29:56.666]                 removed <- setdiff(old_names, names)
[17:29:56.666]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:56.666]                   envs[common]]
[17:29:56.666]                 NAMES <- toupper(changed)
[17:29:56.666]                 args <- list()
[17:29:56.666]                 for (kk in seq_along(NAMES)) {
[17:29:56.666]                   name <- changed[[kk]]
[17:29:56.666]                   NAME <- NAMES[[kk]]
[17:29:56.666]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.666]                     next
[17:29:56.666]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.666]                 }
[17:29:56.666]                 NAMES <- toupper(added)
[17:29:56.666]                 for (kk in seq_along(NAMES)) {
[17:29:56.666]                   name <- added[[kk]]
[17:29:56.666]                   NAME <- NAMES[[kk]]
[17:29:56.666]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.666]                     next
[17:29:56.666]                   args[[name]] <- ""
[17:29:56.666]                 }
[17:29:56.666]                 NAMES <- toupper(removed)
[17:29:56.666]                 for (kk in seq_along(NAMES)) {
[17:29:56.666]                   name <- removed[[kk]]
[17:29:56.666]                   NAME <- NAMES[[kk]]
[17:29:56.666]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.666]                     next
[17:29:56.666]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.666]                 }
[17:29:56.666]                 if (length(args) > 0) 
[17:29:56.666]                   base::do.call(base::Sys.setenv, args = args)
[17:29:56.666]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:56.666]             }
[17:29:56.666]             else {
[17:29:56.666]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:56.666]             }
[17:29:56.666]             {
[17:29:56.666]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:56.666]                   0L) {
[17:29:56.666]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:56.666]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:56.666]                   base::options(opts)
[17:29:56.666]                 }
[17:29:56.666]                 {
[17:29:56.666]                   {
[17:29:56.666]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:56.666]                     NULL
[17:29:56.666]                   }
[17:29:56.666]                   options(future.plan = NULL)
[17:29:56.666]                   if (is.na(NA_character_)) 
[17:29:56.666]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.666]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:56.666]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:56.666]                     .init = FALSE)
[17:29:56.666]                 }
[17:29:56.666]             }
[17:29:56.666]         }
[17:29:56.666]     })
[17:29:56.666]     if (TRUE) {
[17:29:56.666]         base::sink(type = "output", split = FALSE)
[17:29:56.666]         if (TRUE) {
[17:29:56.666]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:56.666]         }
[17:29:56.666]         else {
[17:29:56.666]             ...future.result["stdout"] <- base::list(NULL)
[17:29:56.666]         }
[17:29:56.666]         base::close(...future.stdout)
[17:29:56.666]         ...future.stdout <- NULL
[17:29:56.666]     }
[17:29:56.666]     ...future.result$conditions <- ...future.conditions
[17:29:56.666]     ...future.result$finished <- base::Sys.time()
[17:29:56.666]     ...future.result
[17:29:56.666] }
[17:29:56.676] MultisessionFuture started
[17:29:56.676] - Launch lazy future ... done
[17:29:56.676] run() for 'MultisessionFuture' ... done
[17:29:56.677] result() for ClusterFuture ...
[17:29:56.677] receiveMessageFromWorker() for ClusterFuture ...
[17:29:56.677] - Validating connection of MultisessionFuture
[17:29:56.695] - received message: FutureResult
[17:29:56.696] - Received FutureResult
[17:29:56.696] - Erased future from FutureRegistry
[17:29:56.697] result() for ClusterFuture ...
[17:29:56.697] - result already collected: FutureResult
[17:29:56.697] result() for ClusterFuture ... done
[17:29:56.698] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:56.698] result() for ClusterFuture ... done
[17:29:56.698] result() for ClusterFuture ...
[17:29:56.698] - result already collected: FutureResult
[17:29:56.699] result() for ClusterFuture ... done
[17:29:56.699] result() for ClusterFuture ...
[17:29:56.699] - result already collected: FutureResult
[17:29:56.699] result() for ClusterFuture ... done
[1] 42
[17:29:56.700] result() for ClusterFuture ...
[17:29:56.700] - result already collected: FutureResult
[17:29:56.700] result() for ClusterFuture ... done
- stdout = FALSE
[17:29:56.701] getGlobalsAndPackages() ...
[17:29:56.701] Searching for globals...
[17:29:56.706] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:29:56.706] Searching for globals ... DONE
[17:29:56.707] Resolving globals: FALSE
[17:29:56.707] 
[17:29:56.708] - packages: [1] 'utils'
[17:29:56.708] getGlobalsAndPackages() ... DONE
[17:29:56.708] run() for 'Future' ...
[17:29:56.709] - state: 'created'
[17:29:56.709] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:56.732] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:56.732] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:56.733]   - Field: 'node'
[17:29:56.733]   - Field: 'label'
[17:29:56.733]   - Field: 'local'
[17:29:56.733]   - Field: 'owner'
[17:29:56.733]   - Field: 'envir'
[17:29:56.734]   - Field: 'workers'
[17:29:56.734]   - Field: 'packages'
[17:29:56.734]   - Field: 'gc'
[17:29:56.734]   - Field: 'conditions'
[17:29:56.734]   - Field: 'persistent'
[17:29:56.734]   - Field: 'expr'
[17:29:56.735]   - Field: 'uuid'
[17:29:56.735]   - Field: 'seed'
[17:29:56.735]   - Field: 'version'
[17:29:56.735]   - Field: 'result'
[17:29:56.735]   - Field: 'asynchronous'
[17:29:56.736]   - Field: 'calls'
[17:29:56.736]   - Field: 'globals'
[17:29:56.736]   - Field: 'stdout'
[17:29:56.736]   - Field: 'earlySignal'
[17:29:56.737]   - Field: 'lazy'
[17:29:56.737]   - Field: 'state'
[17:29:56.737] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:56.737] - Launch lazy future ...
[17:29:56.738] Packages needed by the future expression (n = 1): 'utils'
[17:29:56.738] Packages needed by future strategies (n = 0): <none>
[17:29:56.739] {
[17:29:56.739]     {
[17:29:56.739]         {
[17:29:56.739]             ...future.startTime <- base::Sys.time()
[17:29:56.739]             {
[17:29:56.739]                 {
[17:29:56.739]                   {
[17:29:56.739]                     {
[17:29:56.739]                       {
[17:29:56.739]                         base::local({
[17:29:56.739]                           has_future <- base::requireNamespace("future", 
[17:29:56.739]                             quietly = TRUE)
[17:29:56.739]                           if (has_future) {
[17:29:56.739]                             ns <- base::getNamespace("future")
[17:29:56.739]                             version <- ns[[".package"]][["version"]]
[17:29:56.739]                             if (is.null(version)) 
[17:29:56.739]                               version <- utils::packageVersion("future")
[17:29:56.739]                           }
[17:29:56.739]                           else {
[17:29:56.739]                             version <- NULL
[17:29:56.739]                           }
[17:29:56.739]                           if (!has_future || version < "1.8.0") {
[17:29:56.739]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:56.739]                               "", base::R.version$version.string), 
[17:29:56.739]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:56.739]                                 base::R.version$platform, 8 * 
[17:29:56.739]                                   base::.Machine$sizeof.pointer), 
[17:29:56.739]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:56.739]                                 "release", "version")], collapse = " "), 
[17:29:56.739]                               hostname = base::Sys.info()[["nodename"]])
[17:29:56.739]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:56.739]                               info)
[17:29:56.739]                             info <- base::paste(info, collapse = "; ")
[17:29:56.739]                             if (!has_future) {
[17:29:56.739]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:56.739]                                 info)
[17:29:56.739]                             }
[17:29:56.739]                             else {
[17:29:56.739]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:56.739]                                 info, version)
[17:29:56.739]                             }
[17:29:56.739]                             base::stop(msg)
[17:29:56.739]                           }
[17:29:56.739]                         })
[17:29:56.739]                       }
[17:29:56.739]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:56.739]                       base::options(mc.cores = 1L)
[17:29:56.739]                     }
[17:29:56.739]                     base::local({
[17:29:56.739]                       for (pkg in "utils") {
[17:29:56.739]                         base::loadNamespace(pkg)
[17:29:56.739]                         base::library(pkg, character.only = TRUE)
[17:29:56.739]                       }
[17:29:56.739]                     })
[17:29:56.739]                   }
[17:29:56.739]                   ...future.strategy.old <- future::plan("list")
[17:29:56.739]                   options(future.plan = NULL)
[17:29:56.739]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.739]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:56.739]                 }
[17:29:56.739]                 ...future.workdir <- getwd()
[17:29:56.739]             }
[17:29:56.739]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:56.739]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:56.739]         }
[17:29:56.739]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:56.739]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:56.739]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:56.739]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:56.739]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:56.739]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:56.739]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:56.739]             base::names(...future.oldOptions))
[17:29:56.739]     }
[17:29:56.739]     if (FALSE) {
[17:29:56.739]     }
[17:29:56.739]     else {
[17:29:56.739]         if (FALSE) {
[17:29:56.739]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:56.739]                 open = "w")
[17:29:56.739]         }
[17:29:56.739]         else {
[17:29:56.739]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:56.739]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:56.739]         }
[17:29:56.739]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:56.739]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:56.739]             base::sink(type = "output", split = FALSE)
[17:29:56.739]             base::close(...future.stdout)
[17:29:56.739]         }, add = TRUE)
[17:29:56.739]     }
[17:29:56.739]     ...future.frame <- base::sys.nframe()
[17:29:56.739]     ...future.conditions <- base::list()
[17:29:56.739]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:56.739]     if (FALSE) {
[17:29:56.739]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:56.739]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:56.739]     }
[17:29:56.739]     ...future.result <- base::tryCatch({
[17:29:56.739]         base::withCallingHandlers({
[17:29:56.739]             ...future.value <- base::withVisible(base::local({
[17:29:56.739]                 ...future.makeSendCondition <- base::local({
[17:29:56.739]                   sendCondition <- NULL
[17:29:56.739]                   function(frame = 1L) {
[17:29:56.739]                     if (is.function(sendCondition)) 
[17:29:56.739]                       return(sendCondition)
[17:29:56.739]                     ns <- getNamespace("parallel")
[17:29:56.739]                     if (exists("sendData", mode = "function", 
[17:29:56.739]                       envir = ns)) {
[17:29:56.739]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:56.739]                         envir = ns)
[17:29:56.739]                       envir <- sys.frame(frame)
[17:29:56.739]                       master <- NULL
[17:29:56.739]                       while (!identical(envir, .GlobalEnv) && 
[17:29:56.739]                         !identical(envir, emptyenv())) {
[17:29:56.739]                         if (exists("master", mode = "list", envir = envir, 
[17:29:56.739]                           inherits = FALSE)) {
[17:29:56.739]                           master <- get("master", mode = "list", 
[17:29:56.739]                             envir = envir, inherits = FALSE)
[17:29:56.739]                           if (inherits(master, c("SOCKnode", 
[17:29:56.739]                             "SOCK0node"))) {
[17:29:56.739]                             sendCondition <<- function(cond) {
[17:29:56.739]                               data <- list(type = "VALUE", value = cond, 
[17:29:56.739]                                 success = TRUE)
[17:29:56.739]                               parallel_sendData(master, data)
[17:29:56.739]                             }
[17:29:56.739]                             return(sendCondition)
[17:29:56.739]                           }
[17:29:56.739]                         }
[17:29:56.739]                         frame <- frame + 1L
[17:29:56.739]                         envir <- sys.frame(frame)
[17:29:56.739]                       }
[17:29:56.739]                     }
[17:29:56.739]                     sendCondition <<- function(cond) NULL
[17:29:56.739]                   }
[17:29:56.739]                 })
[17:29:56.739]                 withCallingHandlers({
[17:29:56.739]                   {
[17:29:56.739]                     print(1:50)
[17:29:56.739]                     str(1:50)
[17:29:56.739]                     cat(letters, sep = "-")
[17:29:56.739]                     cat(1:6, collapse = "\n")
[17:29:56.739]                     write.table(datasets::iris[1:10, ], sep = "\t")
[17:29:56.739]                     42L
[17:29:56.739]                   }
[17:29:56.739]                 }, immediateCondition = function(cond) {
[17:29:56.739]                   sendCondition <- ...future.makeSendCondition()
[17:29:56.739]                   sendCondition(cond)
[17:29:56.739]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.739]                   {
[17:29:56.739]                     inherits <- base::inherits
[17:29:56.739]                     invokeRestart <- base::invokeRestart
[17:29:56.739]                     is.null <- base::is.null
[17:29:56.739]                     muffled <- FALSE
[17:29:56.739]                     if (inherits(cond, "message")) {
[17:29:56.739]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:56.739]                       if (muffled) 
[17:29:56.739]                         invokeRestart("muffleMessage")
[17:29:56.739]                     }
[17:29:56.739]                     else if (inherits(cond, "warning")) {
[17:29:56.739]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:56.739]                       if (muffled) 
[17:29:56.739]                         invokeRestart("muffleWarning")
[17:29:56.739]                     }
[17:29:56.739]                     else if (inherits(cond, "condition")) {
[17:29:56.739]                       if (!is.null(pattern)) {
[17:29:56.739]                         computeRestarts <- base::computeRestarts
[17:29:56.739]                         grepl <- base::grepl
[17:29:56.739]                         restarts <- computeRestarts(cond)
[17:29:56.739]                         for (restart in restarts) {
[17:29:56.739]                           name <- restart$name
[17:29:56.739]                           if (is.null(name)) 
[17:29:56.739]                             next
[17:29:56.739]                           if (!grepl(pattern, name)) 
[17:29:56.739]                             next
[17:29:56.739]                           invokeRestart(restart)
[17:29:56.739]                           muffled <- TRUE
[17:29:56.739]                           break
[17:29:56.739]                         }
[17:29:56.739]                       }
[17:29:56.739]                     }
[17:29:56.739]                     invisible(muffled)
[17:29:56.739]                   }
[17:29:56.739]                   muffleCondition(cond)
[17:29:56.739]                 })
[17:29:56.739]             }))
[17:29:56.739]             future::FutureResult(value = ...future.value$value, 
[17:29:56.739]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.739]                   ...future.rng), globalenv = if (FALSE) 
[17:29:56.739]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:56.739]                     ...future.globalenv.names))
[17:29:56.739]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:56.739]         }, condition = base::local({
[17:29:56.739]             c <- base::c
[17:29:56.739]             inherits <- base::inherits
[17:29:56.739]             invokeRestart <- base::invokeRestart
[17:29:56.739]             length <- base::length
[17:29:56.739]             list <- base::list
[17:29:56.739]             seq.int <- base::seq.int
[17:29:56.739]             signalCondition <- base::signalCondition
[17:29:56.739]             sys.calls <- base::sys.calls
[17:29:56.739]             `[[` <- base::`[[`
[17:29:56.739]             `+` <- base::`+`
[17:29:56.739]             `<<-` <- base::`<<-`
[17:29:56.739]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:56.739]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:56.739]                   3L)]
[17:29:56.739]             }
[17:29:56.739]             function(cond) {
[17:29:56.739]                 is_error <- inherits(cond, "error")
[17:29:56.739]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:56.739]                   NULL)
[17:29:56.739]                 if (is_error) {
[17:29:56.739]                   sessionInformation <- function() {
[17:29:56.739]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:56.739]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:56.739]                       search = base::search(), system = base::Sys.info())
[17:29:56.739]                   }
[17:29:56.739]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.739]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:56.739]                     cond$call), session = sessionInformation(), 
[17:29:56.739]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:56.739]                   signalCondition(cond)
[17:29:56.739]                 }
[17:29:56.739]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:56.739]                 "immediateCondition"))) {
[17:29:56.739]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:56.739]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.739]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:56.739]                   if (TRUE && !signal) {
[17:29:56.739]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.739]                     {
[17:29:56.739]                       inherits <- base::inherits
[17:29:56.739]                       invokeRestart <- base::invokeRestart
[17:29:56.739]                       is.null <- base::is.null
[17:29:56.739]                       muffled <- FALSE
[17:29:56.739]                       if (inherits(cond, "message")) {
[17:29:56.739]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.739]                         if (muffled) 
[17:29:56.739]                           invokeRestart("muffleMessage")
[17:29:56.739]                       }
[17:29:56.739]                       else if (inherits(cond, "warning")) {
[17:29:56.739]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.739]                         if (muffled) 
[17:29:56.739]                           invokeRestart("muffleWarning")
[17:29:56.739]                       }
[17:29:56.739]                       else if (inherits(cond, "condition")) {
[17:29:56.739]                         if (!is.null(pattern)) {
[17:29:56.739]                           computeRestarts <- base::computeRestarts
[17:29:56.739]                           grepl <- base::grepl
[17:29:56.739]                           restarts <- computeRestarts(cond)
[17:29:56.739]                           for (restart in restarts) {
[17:29:56.739]                             name <- restart$name
[17:29:56.739]                             if (is.null(name)) 
[17:29:56.739]                               next
[17:29:56.739]                             if (!grepl(pattern, name)) 
[17:29:56.739]                               next
[17:29:56.739]                             invokeRestart(restart)
[17:29:56.739]                             muffled <- TRUE
[17:29:56.739]                             break
[17:29:56.739]                           }
[17:29:56.739]                         }
[17:29:56.739]                       }
[17:29:56.739]                       invisible(muffled)
[17:29:56.739]                     }
[17:29:56.739]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.739]                   }
[17:29:56.739]                 }
[17:29:56.739]                 else {
[17:29:56.739]                   if (TRUE) {
[17:29:56.739]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.739]                     {
[17:29:56.739]                       inherits <- base::inherits
[17:29:56.739]                       invokeRestart <- base::invokeRestart
[17:29:56.739]                       is.null <- base::is.null
[17:29:56.739]                       muffled <- FALSE
[17:29:56.739]                       if (inherits(cond, "message")) {
[17:29:56.739]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.739]                         if (muffled) 
[17:29:56.739]                           invokeRestart("muffleMessage")
[17:29:56.739]                       }
[17:29:56.739]                       else if (inherits(cond, "warning")) {
[17:29:56.739]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.739]                         if (muffled) 
[17:29:56.739]                           invokeRestart("muffleWarning")
[17:29:56.739]                       }
[17:29:56.739]                       else if (inherits(cond, "condition")) {
[17:29:56.739]                         if (!is.null(pattern)) {
[17:29:56.739]                           computeRestarts <- base::computeRestarts
[17:29:56.739]                           grepl <- base::grepl
[17:29:56.739]                           restarts <- computeRestarts(cond)
[17:29:56.739]                           for (restart in restarts) {
[17:29:56.739]                             name <- restart$name
[17:29:56.739]                             if (is.null(name)) 
[17:29:56.739]                               next
[17:29:56.739]                             if (!grepl(pattern, name)) 
[17:29:56.739]                               next
[17:29:56.739]                             invokeRestart(restart)
[17:29:56.739]                             muffled <- TRUE
[17:29:56.739]                             break
[17:29:56.739]                           }
[17:29:56.739]                         }
[17:29:56.739]                       }
[17:29:56.739]                       invisible(muffled)
[17:29:56.739]                     }
[17:29:56.739]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.739]                   }
[17:29:56.739]                 }
[17:29:56.739]             }
[17:29:56.739]         }))
[17:29:56.739]     }, error = function(ex) {
[17:29:56.739]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:56.739]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.739]                 ...future.rng), started = ...future.startTime, 
[17:29:56.739]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:56.739]             version = "1.8"), class = "FutureResult")
[17:29:56.739]     }, finally = {
[17:29:56.739]         if (!identical(...future.workdir, getwd())) 
[17:29:56.739]             setwd(...future.workdir)
[17:29:56.739]         {
[17:29:56.739]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:56.739]                 ...future.oldOptions$nwarnings <- NULL
[17:29:56.739]             }
[17:29:56.739]             base::options(...future.oldOptions)
[17:29:56.739]             if (.Platform$OS.type == "windows") {
[17:29:56.739]                 old_names <- names(...future.oldEnvVars)
[17:29:56.739]                 envs <- base::Sys.getenv()
[17:29:56.739]                 names <- names(envs)
[17:29:56.739]                 common <- intersect(names, old_names)
[17:29:56.739]                 added <- setdiff(names, old_names)
[17:29:56.739]                 removed <- setdiff(old_names, names)
[17:29:56.739]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:56.739]                   envs[common]]
[17:29:56.739]                 NAMES <- toupper(changed)
[17:29:56.739]                 args <- list()
[17:29:56.739]                 for (kk in seq_along(NAMES)) {
[17:29:56.739]                   name <- changed[[kk]]
[17:29:56.739]                   NAME <- NAMES[[kk]]
[17:29:56.739]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.739]                     next
[17:29:56.739]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.739]                 }
[17:29:56.739]                 NAMES <- toupper(added)
[17:29:56.739]                 for (kk in seq_along(NAMES)) {
[17:29:56.739]                   name <- added[[kk]]
[17:29:56.739]                   NAME <- NAMES[[kk]]
[17:29:56.739]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.739]                     next
[17:29:56.739]                   args[[name]] <- ""
[17:29:56.739]                 }
[17:29:56.739]                 NAMES <- toupper(removed)
[17:29:56.739]                 for (kk in seq_along(NAMES)) {
[17:29:56.739]                   name <- removed[[kk]]
[17:29:56.739]                   NAME <- NAMES[[kk]]
[17:29:56.739]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.739]                     next
[17:29:56.739]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.739]                 }
[17:29:56.739]                 if (length(args) > 0) 
[17:29:56.739]                   base::do.call(base::Sys.setenv, args = args)
[17:29:56.739]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:56.739]             }
[17:29:56.739]             else {
[17:29:56.739]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:56.739]             }
[17:29:56.739]             {
[17:29:56.739]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:56.739]                   0L) {
[17:29:56.739]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:56.739]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:56.739]                   base::options(opts)
[17:29:56.739]                 }
[17:29:56.739]                 {
[17:29:56.739]                   {
[17:29:56.739]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:56.739]                     NULL
[17:29:56.739]                   }
[17:29:56.739]                   options(future.plan = NULL)
[17:29:56.739]                   if (is.na(NA_character_)) 
[17:29:56.739]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.739]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:56.739]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:56.739]                     .init = FALSE)
[17:29:56.739]                 }
[17:29:56.739]             }
[17:29:56.739]         }
[17:29:56.739]     })
[17:29:56.739]     if (TRUE) {
[17:29:56.739]         base::sink(type = "output", split = FALSE)
[17:29:56.739]         if (FALSE) {
[17:29:56.739]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:56.739]         }
[17:29:56.739]         else {
[17:29:56.739]             ...future.result["stdout"] <- base::list(NULL)
[17:29:56.739]         }
[17:29:56.739]         base::close(...future.stdout)
[17:29:56.739]         ...future.stdout <- NULL
[17:29:56.739]     }
[17:29:56.739]     ...future.result$conditions <- ...future.conditions
[17:29:56.739]     ...future.result$finished <- base::Sys.time()
[17:29:56.739]     ...future.result
[17:29:56.739] }
[17:29:56.750] MultisessionFuture started
[17:29:56.750] - Launch lazy future ... done
[17:29:56.750] run() for 'MultisessionFuture' ... done
[17:29:56.751] result() for ClusterFuture ...
[17:29:56.751] receiveMessageFromWorker() for ClusterFuture ...
[17:29:56.751] - Validating connection of MultisessionFuture
[17:29:56.777] - received message: FutureResult
[17:29:56.777] - Received FutureResult
[17:29:56.778] - Erased future from FutureRegistry
[17:29:56.778] result() for ClusterFuture ...
[17:29:56.779] - result already collected: FutureResult
[17:29:56.779] result() for ClusterFuture ... done
[17:29:56.779] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:56.780] 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: "2024-07-29 17:29:56"
 $ finished    : POSIXct[1:1], format: "2024-07-29 17:29:56"
 $ session_uuid: chr "e25fa336-1319-3de5-50c6-8c7ff8013db5"
  ..- 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 176124
  .. ..$ time  : POSIXct[1:1], format: "2024-07-29 17:29:56"
  .. ..$ 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 5 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[17:29:56.798] result() for ClusterFuture ...
[17:29:56.798] - result already collected: FutureResult
[17:29:56.798] result() for ClusterFuture ... done
[17:29:56.799] result() for ClusterFuture ...
[17:29:56.799] - result already collected: FutureResult
[17:29:56.799] result() for ClusterFuture ... done
[17:29:56.800] getGlobalsAndPackages() ...
[17:29:56.801] Searching for globals...
[17:29:56.808] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:29:56.808] Searching for globals ... DONE
[17:29:56.808] Resolving globals: FALSE
[17:29:56.810] 
[17:29:56.810] - packages: [1] 'utils'
[17:29:56.810] getGlobalsAndPackages() ... DONE
[17:29:56.811] run() for 'Future' ...
[17:29:56.811] - state: 'created'
[17:29:56.812] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:56.833] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:56.834] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:56.834]   - Field: 'node'
[17:29:56.835]   - Field: 'label'
[17:29:56.835]   - Field: 'local'
[17:29:56.835]   - Field: 'owner'
[17:29:56.836]   - Field: 'envir'
[17:29:56.836]   - Field: 'workers'
[17:29:56.836]   - Field: 'packages'
[17:29:56.837]   - Field: 'gc'
[17:29:56.837]   - Field: 'conditions'
[17:29:56.838]   - Field: 'persistent'
[17:29:56.838]   - Field: 'expr'
[17:29:56.838]   - Field: 'uuid'
[17:29:56.839]   - Field: 'seed'
[17:29:56.839]   - Field: 'version'
[17:29:56.839]   - Field: 'result'
[17:29:56.840]   - Field: 'asynchronous'
[17:29:56.840]   - Field: 'calls'
[17:29:56.840]   - Field: 'globals'
[17:29:56.841]   - Field: 'stdout'
[17:29:56.841]   - Field: 'earlySignal'
[17:29:56.841]   - Field: 'lazy'
[17:29:56.841]   - Field: 'state'
[17:29:56.842] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:56.842] - Launch lazy future ...
[17:29:56.843] Packages needed by the future expression (n = 1): 'utils'
[17:29:56.843] Packages needed by future strategies (n = 0): <none>
[17:29:56.845] {
[17:29:56.845]     {
[17:29:56.845]         {
[17:29:56.845]             ...future.startTime <- base::Sys.time()
[17:29:56.845]             {
[17:29:56.845]                 {
[17:29:56.845]                   {
[17:29:56.845]                     {
[17:29:56.845]                       {
[17:29:56.845]                         base::local({
[17:29:56.845]                           has_future <- base::requireNamespace("future", 
[17:29:56.845]                             quietly = TRUE)
[17:29:56.845]                           if (has_future) {
[17:29:56.845]                             ns <- base::getNamespace("future")
[17:29:56.845]                             version <- ns[[".package"]][["version"]]
[17:29:56.845]                             if (is.null(version)) 
[17:29:56.845]                               version <- utils::packageVersion("future")
[17:29:56.845]                           }
[17:29:56.845]                           else {
[17:29:56.845]                             version <- NULL
[17:29:56.845]                           }
[17:29:56.845]                           if (!has_future || version < "1.8.0") {
[17:29:56.845]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:56.845]                               "", base::R.version$version.string), 
[17:29:56.845]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:56.845]                                 base::R.version$platform, 8 * 
[17:29:56.845]                                   base::.Machine$sizeof.pointer), 
[17:29:56.845]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:56.845]                                 "release", "version")], collapse = " "), 
[17:29:56.845]                               hostname = base::Sys.info()[["nodename"]])
[17:29:56.845]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:56.845]                               info)
[17:29:56.845]                             info <- base::paste(info, collapse = "; ")
[17:29:56.845]                             if (!has_future) {
[17:29:56.845]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:56.845]                                 info)
[17:29:56.845]                             }
[17:29:56.845]                             else {
[17:29:56.845]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:56.845]                                 info, version)
[17:29:56.845]                             }
[17:29:56.845]                             base::stop(msg)
[17:29:56.845]                           }
[17:29:56.845]                         })
[17:29:56.845]                       }
[17:29:56.845]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:56.845]                       base::options(mc.cores = 1L)
[17:29:56.845]                     }
[17:29:56.845]                     base::local({
[17:29:56.845]                       for (pkg in "utils") {
[17:29:56.845]                         base::loadNamespace(pkg)
[17:29:56.845]                         base::library(pkg, character.only = TRUE)
[17:29:56.845]                       }
[17:29:56.845]                     })
[17:29:56.845]                   }
[17:29:56.845]                   ...future.strategy.old <- future::plan("list")
[17:29:56.845]                   options(future.plan = NULL)
[17:29:56.845]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.845]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:56.845]                 }
[17:29:56.845]                 ...future.workdir <- getwd()
[17:29:56.845]             }
[17:29:56.845]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:56.845]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:56.845]         }
[17:29:56.845]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:56.845]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:56.845]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:56.845]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:56.845]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:56.845]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:56.845]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:56.845]             base::names(...future.oldOptions))
[17:29:56.845]     }
[17:29:56.845]     if (FALSE) {
[17:29:56.845]     }
[17:29:56.845]     else {
[17:29:56.845]         if (FALSE) {
[17:29:56.845]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:56.845]                 open = "w")
[17:29:56.845]         }
[17:29:56.845]         else {
[17:29:56.845]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:56.845]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:56.845]         }
[17:29:56.845]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:56.845]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:56.845]             base::sink(type = "output", split = FALSE)
[17:29:56.845]             base::close(...future.stdout)
[17:29:56.845]         }, add = TRUE)
[17:29:56.845]     }
[17:29:56.845]     ...future.frame <- base::sys.nframe()
[17:29:56.845]     ...future.conditions <- base::list()
[17:29:56.845]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:56.845]     if (FALSE) {
[17:29:56.845]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:56.845]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:56.845]     }
[17:29:56.845]     ...future.result <- base::tryCatch({
[17:29:56.845]         base::withCallingHandlers({
[17:29:56.845]             ...future.value <- base::withVisible(base::local({
[17:29:56.845]                 ...future.makeSendCondition <- base::local({
[17:29:56.845]                   sendCondition <- NULL
[17:29:56.845]                   function(frame = 1L) {
[17:29:56.845]                     if (is.function(sendCondition)) 
[17:29:56.845]                       return(sendCondition)
[17:29:56.845]                     ns <- getNamespace("parallel")
[17:29:56.845]                     if (exists("sendData", mode = "function", 
[17:29:56.845]                       envir = ns)) {
[17:29:56.845]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:56.845]                         envir = ns)
[17:29:56.845]                       envir <- sys.frame(frame)
[17:29:56.845]                       master <- NULL
[17:29:56.845]                       while (!identical(envir, .GlobalEnv) && 
[17:29:56.845]                         !identical(envir, emptyenv())) {
[17:29:56.845]                         if (exists("master", mode = "list", envir = envir, 
[17:29:56.845]                           inherits = FALSE)) {
[17:29:56.845]                           master <- get("master", mode = "list", 
[17:29:56.845]                             envir = envir, inherits = FALSE)
[17:29:56.845]                           if (inherits(master, c("SOCKnode", 
[17:29:56.845]                             "SOCK0node"))) {
[17:29:56.845]                             sendCondition <<- function(cond) {
[17:29:56.845]                               data <- list(type = "VALUE", value = cond, 
[17:29:56.845]                                 success = TRUE)
[17:29:56.845]                               parallel_sendData(master, data)
[17:29:56.845]                             }
[17:29:56.845]                             return(sendCondition)
[17:29:56.845]                           }
[17:29:56.845]                         }
[17:29:56.845]                         frame <- frame + 1L
[17:29:56.845]                         envir <- sys.frame(frame)
[17:29:56.845]                       }
[17:29:56.845]                     }
[17:29:56.845]                     sendCondition <<- function(cond) NULL
[17:29:56.845]                   }
[17:29:56.845]                 })
[17:29:56.845]                 withCallingHandlers({
[17:29:56.845]                   {
[17:29:56.845]                     print(1:50)
[17:29:56.845]                     str(1:50)
[17:29:56.845]                     cat(letters, sep = "-")
[17:29:56.845]                     cat(1:6, collapse = "\n")
[17:29:56.845]                     write.table(datasets::iris[1:10, ], sep = "\t")
[17:29:56.845]                     42L
[17:29:56.845]                   }
[17:29:56.845]                 }, immediateCondition = function(cond) {
[17:29:56.845]                   sendCondition <- ...future.makeSendCondition()
[17:29:56.845]                   sendCondition(cond)
[17:29:56.845]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.845]                   {
[17:29:56.845]                     inherits <- base::inherits
[17:29:56.845]                     invokeRestart <- base::invokeRestart
[17:29:56.845]                     is.null <- base::is.null
[17:29:56.845]                     muffled <- FALSE
[17:29:56.845]                     if (inherits(cond, "message")) {
[17:29:56.845]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:56.845]                       if (muffled) 
[17:29:56.845]                         invokeRestart("muffleMessage")
[17:29:56.845]                     }
[17:29:56.845]                     else if (inherits(cond, "warning")) {
[17:29:56.845]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:56.845]                       if (muffled) 
[17:29:56.845]                         invokeRestart("muffleWarning")
[17:29:56.845]                     }
[17:29:56.845]                     else if (inherits(cond, "condition")) {
[17:29:56.845]                       if (!is.null(pattern)) {
[17:29:56.845]                         computeRestarts <- base::computeRestarts
[17:29:56.845]                         grepl <- base::grepl
[17:29:56.845]                         restarts <- computeRestarts(cond)
[17:29:56.845]                         for (restart in restarts) {
[17:29:56.845]                           name <- restart$name
[17:29:56.845]                           if (is.null(name)) 
[17:29:56.845]                             next
[17:29:56.845]                           if (!grepl(pattern, name)) 
[17:29:56.845]                             next
[17:29:56.845]                           invokeRestart(restart)
[17:29:56.845]                           muffled <- TRUE
[17:29:56.845]                           break
[17:29:56.845]                         }
[17:29:56.845]                       }
[17:29:56.845]                     }
[17:29:56.845]                     invisible(muffled)
[17:29:56.845]                   }
[17:29:56.845]                   muffleCondition(cond)
[17:29:56.845]                 })
[17:29:56.845]             }))
[17:29:56.845]             future::FutureResult(value = ...future.value$value, 
[17:29:56.845]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.845]                   ...future.rng), globalenv = if (FALSE) 
[17:29:56.845]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:56.845]                     ...future.globalenv.names))
[17:29:56.845]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:56.845]         }, condition = base::local({
[17:29:56.845]             c <- base::c
[17:29:56.845]             inherits <- base::inherits
[17:29:56.845]             invokeRestart <- base::invokeRestart
[17:29:56.845]             length <- base::length
[17:29:56.845]             list <- base::list
[17:29:56.845]             seq.int <- base::seq.int
[17:29:56.845]             signalCondition <- base::signalCondition
[17:29:56.845]             sys.calls <- base::sys.calls
[17:29:56.845]             `[[` <- base::`[[`
[17:29:56.845]             `+` <- base::`+`
[17:29:56.845]             `<<-` <- base::`<<-`
[17:29:56.845]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:56.845]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:56.845]                   3L)]
[17:29:56.845]             }
[17:29:56.845]             function(cond) {
[17:29:56.845]                 is_error <- inherits(cond, "error")
[17:29:56.845]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:56.845]                   NULL)
[17:29:56.845]                 if (is_error) {
[17:29:56.845]                   sessionInformation <- function() {
[17:29:56.845]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:56.845]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:56.845]                       search = base::search(), system = base::Sys.info())
[17:29:56.845]                   }
[17:29:56.845]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.845]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:56.845]                     cond$call), session = sessionInformation(), 
[17:29:56.845]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:56.845]                   signalCondition(cond)
[17:29:56.845]                 }
[17:29:56.845]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:56.845]                 "immediateCondition"))) {
[17:29:56.845]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:56.845]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.845]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:56.845]                   if (TRUE && !signal) {
[17:29:56.845]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.845]                     {
[17:29:56.845]                       inherits <- base::inherits
[17:29:56.845]                       invokeRestart <- base::invokeRestart
[17:29:56.845]                       is.null <- base::is.null
[17:29:56.845]                       muffled <- FALSE
[17:29:56.845]                       if (inherits(cond, "message")) {
[17:29:56.845]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.845]                         if (muffled) 
[17:29:56.845]                           invokeRestart("muffleMessage")
[17:29:56.845]                       }
[17:29:56.845]                       else if (inherits(cond, "warning")) {
[17:29:56.845]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.845]                         if (muffled) 
[17:29:56.845]                           invokeRestart("muffleWarning")
[17:29:56.845]                       }
[17:29:56.845]                       else if (inherits(cond, "condition")) {
[17:29:56.845]                         if (!is.null(pattern)) {
[17:29:56.845]                           computeRestarts <- base::computeRestarts
[17:29:56.845]                           grepl <- base::grepl
[17:29:56.845]                           restarts <- computeRestarts(cond)
[17:29:56.845]                           for (restart in restarts) {
[17:29:56.845]                             name <- restart$name
[17:29:56.845]                             if (is.null(name)) 
[17:29:56.845]                               next
[17:29:56.845]                             if (!grepl(pattern, name)) 
[17:29:56.845]                               next
[17:29:56.845]                             invokeRestart(restart)
[17:29:56.845]                             muffled <- TRUE
[17:29:56.845]                             break
[17:29:56.845]                           }
[17:29:56.845]                         }
[17:29:56.845]                       }
[17:29:56.845]                       invisible(muffled)
[17:29:56.845]                     }
[17:29:56.845]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.845]                   }
[17:29:56.845]                 }
[17:29:56.845]                 else {
[17:29:56.845]                   if (TRUE) {
[17:29:56.845]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.845]                     {
[17:29:56.845]                       inherits <- base::inherits
[17:29:56.845]                       invokeRestart <- base::invokeRestart
[17:29:56.845]                       is.null <- base::is.null
[17:29:56.845]                       muffled <- FALSE
[17:29:56.845]                       if (inherits(cond, "message")) {
[17:29:56.845]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.845]                         if (muffled) 
[17:29:56.845]                           invokeRestart("muffleMessage")
[17:29:56.845]                       }
[17:29:56.845]                       else if (inherits(cond, "warning")) {
[17:29:56.845]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.845]                         if (muffled) 
[17:29:56.845]                           invokeRestart("muffleWarning")
[17:29:56.845]                       }
[17:29:56.845]                       else if (inherits(cond, "condition")) {
[17:29:56.845]                         if (!is.null(pattern)) {
[17:29:56.845]                           computeRestarts <- base::computeRestarts
[17:29:56.845]                           grepl <- base::grepl
[17:29:56.845]                           restarts <- computeRestarts(cond)
[17:29:56.845]                           for (restart in restarts) {
[17:29:56.845]                             name <- restart$name
[17:29:56.845]                             if (is.null(name)) 
[17:29:56.845]                               next
[17:29:56.845]                             if (!grepl(pattern, name)) 
[17:29:56.845]                               next
[17:29:56.845]                             invokeRestart(restart)
[17:29:56.845]                             muffled <- TRUE
[17:29:56.845]                             break
[17:29:56.845]                           }
[17:29:56.845]                         }
[17:29:56.845]                       }
[17:29:56.845]                       invisible(muffled)
[17:29:56.845]                     }
[17:29:56.845]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.845]                   }
[17:29:56.845]                 }
[17:29:56.845]             }
[17:29:56.845]         }))
[17:29:56.845]     }, error = function(ex) {
[17:29:56.845]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:56.845]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.845]                 ...future.rng), started = ...future.startTime, 
[17:29:56.845]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:56.845]             version = "1.8"), class = "FutureResult")
[17:29:56.845]     }, finally = {
[17:29:56.845]         if (!identical(...future.workdir, getwd())) 
[17:29:56.845]             setwd(...future.workdir)
[17:29:56.845]         {
[17:29:56.845]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:56.845]                 ...future.oldOptions$nwarnings <- NULL
[17:29:56.845]             }
[17:29:56.845]             base::options(...future.oldOptions)
[17:29:56.845]             if (.Platform$OS.type == "windows") {
[17:29:56.845]                 old_names <- names(...future.oldEnvVars)
[17:29:56.845]                 envs <- base::Sys.getenv()
[17:29:56.845]                 names <- names(envs)
[17:29:56.845]                 common <- intersect(names, old_names)
[17:29:56.845]                 added <- setdiff(names, old_names)
[17:29:56.845]                 removed <- setdiff(old_names, names)
[17:29:56.845]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:56.845]                   envs[common]]
[17:29:56.845]                 NAMES <- toupper(changed)
[17:29:56.845]                 args <- list()
[17:29:56.845]                 for (kk in seq_along(NAMES)) {
[17:29:56.845]                   name <- changed[[kk]]
[17:29:56.845]                   NAME <- NAMES[[kk]]
[17:29:56.845]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.845]                     next
[17:29:56.845]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.845]                 }
[17:29:56.845]                 NAMES <- toupper(added)
[17:29:56.845]                 for (kk in seq_along(NAMES)) {
[17:29:56.845]                   name <- added[[kk]]
[17:29:56.845]                   NAME <- NAMES[[kk]]
[17:29:56.845]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.845]                     next
[17:29:56.845]                   args[[name]] <- ""
[17:29:56.845]                 }
[17:29:56.845]                 NAMES <- toupper(removed)
[17:29:56.845]                 for (kk in seq_along(NAMES)) {
[17:29:56.845]                   name <- removed[[kk]]
[17:29:56.845]                   NAME <- NAMES[[kk]]
[17:29:56.845]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.845]                     next
[17:29:56.845]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.845]                 }
[17:29:56.845]                 if (length(args) > 0) 
[17:29:56.845]                   base::do.call(base::Sys.setenv, args = args)
[17:29:56.845]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:56.845]             }
[17:29:56.845]             else {
[17:29:56.845]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:56.845]             }
[17:29:56.845]             {
[17:29:56.845]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:56.845]                   0L) {
[17:29:56.845]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:56.845]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:56.845]                   base::options(opts)
[17:29:56.845]                 }
[17:29:56.845]                 {
[17:29:56.845]                   {
[17:29:56.845]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:56.845]                     NULL
[17:29:56.845]                   }
[17:29:56.845]                   options(future.plan = NULL)
[17:29:56.845]                   if (is.na(NA_character_)) 
[17:29:56.845]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.845]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:56.845]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:56.845]                     .init = FALSE)
[17:29:56.845]                 }
[17:29:56.845]             }
[17:29:56.845]         }
[17:29:56.845]     })
[17:29:56.845]     if (TRUE) {
[17:29:56.845]         base::sink(type = "output", split = FALSE)
[17:29:56.845]         if (FALSE) {
[17:29:56.845]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:56.845]         }
[17:29:56.845]         else {
[17:29:56.845]             ...future.result["stdout"] <- base::list(NULL)
[17:29:56.845]         }
[17:29:56.845]         base::close(...future.stdout)
[17:29:56.845]         ...future.stdout <- NULL
[17:29:56.845]     }
[17:29:56.845]     ...future.result$conditions <- ...future.conditions
[17:29:56.845]     ...future.result$finished <- base::Sys.time()
[17:29:56.845]     ...future.result
[17:29:56.845] }
[17:29:56.856] MultisessionFuture started
[17:29:56.856] - Launch lazy future ... done
[17:29:56.856] run() for 'MultisessionFuture' ... done
[17:29:56.857] result() for ClusterFuture ...
[17:29:56.858] receiveMessageFromWorker() for ClusterFuture ...
[17:29:56.858] - Validating connection of MultisessionFuture
[17:29:56.884] - received message: FutureResult
[17:29:56.885] - Received FutureResult
[17:29:56.885] - Erased future from FutureRegistry
[17:29:56.886] result() for ClusterFuture ...
[17:29:56.886] - result already collected: FutureResult
[17:29:56.886] result() for ClusterFuture ... done
[17:29:56.887] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:56.887] result() for ClusterFuture ... done
[17:29:56.887] result() for ClusterFuture ...
[17:29:56.888] - result already collected: FutureResult
[17:29:56.888] result() for ClusterFuture ... done
- stdout = structure(TRUE, drop = TRUE)
[17:29:56.889] getGlobalsAndPackages() ...
[17:29:56.889] Searching for globals...
[17:29:56.890] - globals found: [1] 'print'
[17:29:56.891] Searching for globals ... DONE
[17:29:56.891] Resolving globals: FALSE
[17:29:56.892] 
[17:29:56.892] 
[17:29:56.892] getGlobalsAndPackages() ... DONE
[17:29:56.893] run() for 'Future' ...
[17:29:56.893] - state: 'created'
[17:29:56.894] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:56.915] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:56.915] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:56.915]   - Field: 'node'
[17:29:56.916]   - Field: 'label'
[17:29:56.916]   - Field: 'local'
[17:29:56.916]   - Field: 'owner'
[17:29:56.917]   - Field: 'envir'
[17:29:56.917]   - Field: 'workers'
[17:29:56.917]   - Field: 'packages'
[17:29:56.918]   - Field: 'gc'
[17:29:56.918]   - Field: 'conditions'
[17:29:56.918]   - Field: 'persistent'
[17:29:56.919]   - Field: 'expr'
[17:29:56.919]   - Field: 'uuid'
[17:29:56.919]   - Field: 'seed'
[17:29:56.919]   - Field: 'version'
[17:29:56.920]   - Field: 'result'
[17:29:56.920]   - Field: 'asynchronous'
[17:29:56.920]   - Field: 'calls'
[17:29:56.921]   - Field: 'globals'
[17:29:56.921]   - Field: 'stdout'
[17:29:56.921]   - Field: 'earlySignal'
[17:29:56.922]   - Field: 'lazy'
[17:29:56.922]   - Field: 'state'
[17:29:56.922] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:56.923] - Launch lazy future ...
[17:29:56.924] Packages needed by the future expression (n = 0): <none>
[17:29:56.924] Packages needed by future strategies (n = 0): <none>
[17:29:56.925] {
[17:29:56.925]     {
[17:29:56.925]         {
[17:29:56.925]             ...future.startTime <- base::Sys.time()
[17:29:56.925]             {
[17:29:56.925]                 {
[17:29:56.925]                   {
[17:29:56.925]                     {
[17:29:56.925]                       base::local({
[17:29:56.925]                         has_future <- base::requireNamespace("future", 
[17:29:56.925]                           quietly = TRUE)
[17:29:56.925]                         if (has_future) {
[17:29:56.925]                           ns <- base::getNamespace("future")
[17:29:56.925]                           version <- ns[[".package"]][["version"]]
[17:29:56.925]                           if (is.null(version)) 
[17:29:56.925]                             version <- utils::packageVersion("future")
[17:29:56.925]                         }
[17:29:56.925]                         else {
[17:29:56.925]                           version <- NULL
[17:29:56.925]                         }
[17:29:56.925]                         if (!has_future || version < "1.8.0") {
[17:29:56.925]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:56.925]                             "", base::R.version$version.string), 
[17:29:56.925]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:56.925]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:56.925]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:56.925]                               "release", "version")], collapse = " "), 
[17:29:56.925]                             hostname = base::Sys.info()[["nodename"]])
[17:29:56.925]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:56.925]                             info)
[17:29:56.925]                           info <- base::paste(info, collapse = "; ")
[17:29:56.925]                           if (!has_future) {
[17:29:56.925]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:56.925]                               info)
[17:29:56.925]                           }
[17:29:56.925]                           else {
[17:29:56.925]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:56.925]                               info, version)
[17:29:56.925]                           }
[17:29:56.925]                           base::stop(msg)
[17:29:56.925]                         }
[17:29:56.925]                       })
[17:29:56.925]                     }
[17:29:56.925]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:56.925]                     base::options(mc.cores = 1L)
[17:29:56.925]                   }
[17:29:56.925]                   ...future.strategy.old <- future::plan("list")
[17:29:56.925]                   options(future.plan = NULL)
[17:29:56.925]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.925]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:56.925]                 }
[17:29:56.925]                 ...future.workdir <- getwd()
[17:29:56.925]             }
[17:29:56.925]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:56.925]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:56.925]         }
[17:29:56.925]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:56.925]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:56.925]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:56.925]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:56.925]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:56.925]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:56.925]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:56.925]             base::names(...future.oldOptions))
[17:29:56.925]     }
[17:29:56.925]     if (FALSE) {
[17:29:56.925]     }
[17:29:56.925]     else {
[17:29:56.925]         if (TRUE) {
[17:29:56.925]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:56.925]                 open = "w")
[17:29:56.925]         }
[17:29:56.925]         else {
[17:29:56.925]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:56.925]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:56.925]         }
[17:29:56.925]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:56.925]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:56.925]             base::sink(type = "output", split = FALSE)
[17:29:56.925]             base::close(...future.stdout)
[17:29:56.925]         }, add = TRUE)
[17:29:56.925]     }
[17:29:56.925]     ...future.frame <- base::sys.nframe()
[17:29:56.925]     ...future.conditions <- base::list()
[17:29:56.925]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:56.925]     if (FALSE) {
[17:29:56.925]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:56.925]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:56.925]     }
[17:29:56.925]     ...future.result <- base::tryCatch({
[17:29:56.925]         base::withCallingHandlers({
[17:29:56.925]             ...future.value <- base::withVisible(base::local({
[17:29:56.925]                 ...future.makeSendCondition <- base::local({
[17:29:56.925]                   sendCondition <- NULL
[17:29:56.925]                   function(frame = 1L) {
[17:29:56.925]                     if (is.function(sendCondition)) 
[17:29:56.925]                       return(sendCondition)
[17:29:56.925]                     ns <- getNamespace("parallel")
[17:29:56.925]                     if (exists("sendData", mode = "function", 
[17:29:56.925]                       envir = ns)) {
[17:29:56.925]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:56.925]                         envir = ns)
[17:29:56.925]                       envir <- sys.frame(frame)
[17:29:56.925]                       master <- NULL
[17:29:56.925]                       while (!identical(envir, .GlobalEnv) && 
[17:29:56.925]                         !identical(envir, emptyenv())) {
[17:29:56.925]                         if (exists("master", mode = "list", envir = envir, 
[17:29:56.925]                           inherits = FALSE)) {
[17:29:56.925]                           master <- get("master", mode = "list", 
[17:29:56.925]                             envir = envir, inherits = FALSE)
[17:29:56.925]                           if (inherits(master, c("SOCKnode", 
[17:29:56.925]                             "SOCK0node"))) {
[17:29:56.925]                             sendCondition <<- function(cond) {
[17:29:56.925]                               data <- list(type = "VALUE", value = cond, 
[17:29:56.925]                                 success = TRUE)
[17:29:56.925]                               parallel_sendData(master, data)
[17:29:56.925]                             }
[17:29:56.925]                             return(sendCondition)
[17:29:56.925]                           }
[17:29:56.925]                         }
[17:29:56.925]                         frame <- frame + 1L
[17:29:56.925]                         envir <- sys.frame(frame)
[17:29:56.925]                       }
[17:29:56.925]                     }
[17:29:56.925]                     sendCondition <<- function(cond) NULL
[17:29:56.925]                   }
[17:29:56.925]                 })
[17:29:56.925]                 withCallingHandlers({
[17:29:56.925]                   print(42)
[17:29:56.925]                 }, immediateCondition = function(cond) {
[17:29:56.925]                   sendCondition <- ...future.makeSendCondition()
[17:29:56.925]                   sendCondition(cond)
[17:29:56.925]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.925]                   {
[17:29:56.925]                     inherits <- base::inherits
[17:29:56.925]                     invokeRestart <- base::invokeRestart
[17:29:56.925]                     is.null <- base::is.null
[17:29:56.925]                     muffled <- FALSE
[17:29:56.925]                     if (inherits(cond, "message")) {
[17:29:56.925]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:56.925]                       if (muffled) 
[17:29:56.925]                         invokeRestart("muffleMessage")
[17:29:56.925]                     }
[17:29:56.925]                     else if (inherits(cond, "warning")) {
[17:29:56.925]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:56.925]                       if (muffled) 
[17:29:56.925]                         invokeRestart("muffleWarning")
[17:29:56.925]                     }
[17:29:56.925]                     else if (inherits(cond, "condition")) {
[17:29:56.925]                       if (!is.null(pattern)) {
[17:29:56.925]                         computeRestarts <- base::computeRestarts
[17:29:56.925]                         grepl <- base::grepl
[17:29:56.925]                         restarts <- computeRestarts(cond)
[17:29:56.925]                         for (restart in restarts) {
[17:29:56.925]                           name <- restart$name
[17:29:56.925]                           if (is.null(name)) 
[17:29:56.925]                             next
[17:29:56.925]                           if (!grepl(pattern, name)) 
[17:29:56.925]                             next
[17:29:56.925]                           invokeRestart(restart)
[17:29:56.925]                           muffled <- TRUE
[17:29:56.925]                           break
[17:29:56.925]                         }
[17:29:56.925]                       }
[17:29:56.925]                     }
[17:29:56.925]                     invisible(muffled)
[17:29:56.925]                   }
[17:29:56.925]                   muffleCondition(cond)
[17:29:56.925]                 })
[17:29:56.925]             }))
[17:29:56.925]             future::FutureResult(value = ...future.value$value, 
[17:29:56.925]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.925]                   ...future.rng), globalenv = if (FALSE) 
[17:29:56.925]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:56.925]                     ...future.globalenv.names))
[17:29:56.925]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:56.925]         }, condition = base::local({
[17:29:56.925]             c <- base::c
[17:29:56.925]             inherits <- base::inherits
[17:29:56.925]             invokeRestart <- base::invokeRestart
[17:29:56.925]             length <- base::length
[17:29:56.925]             list <- base::list
[17:29:56.925]             seq.int <- base::seq.int
[17:29:56.925]             signalCondition <- base::signalCondition
[17:29:56.925]             sys.calls <- base::sys.calls
[17:29:56.925]             `[[` <- base::`[[`
[17:29:56.925]             `+` <- base::`+`
[17:29:56.925]             `<<-` <- base::`<<-`
[17:29:56.925]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:56.925]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:56.925]                   3L)]
[17:29:56.925]             }
[17:29:56.925]             function(cond) {
[17:29:56.925]                 is_error <- inherits(cond, "error")
[17:29:56.925]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:56.925]                   NULL)
[17:29:56.925]                 if (is_error) {
[17:29:56.925]                   sessionInformation <- function() {
[17:29:56.925]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:56.925]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:56.925]                       search = base::search(), system = base::Sys.info())
[17:29:56.925]                   }
[17:29:56.925]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.925]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:56.925]                     cond$call), session = sessionInformation(), 
[17:29:56.925]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:56.925]                   signalCondition(cond)
[17:29:56.925]                 }
[17:29:56.925]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:56.925]                 "immediateCondition"))) {
[17:29:56.925]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:56.925]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.925]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:56.925]                   if (TRUE && !signal) {
[17:29:56.925]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.925]                     {
[17:29:56.925]                       inherits <- base::inherits
[17:29:56.925]                       invokeRestart <- base::invokeRestart
[17:29:56.925]                       is.null <- base::is.null
[17:29:56.925]                       muffled <- FALSE
[17:29:56.925]                       if (inherits(cond, "message")) {
[17:29:56.925]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.925]                         if (muffled) 
[17:29:56.925]                           invokeRestart("muffleMessage")
[17:29:56.925]                       }
[17:29:56.925]                       else if (inherits(cond, "warning")) {
[17:29:56.925]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.925]                         if (muffled) 
[17:29:56.925]                           invokeRestart("muffleWarning")
[17:29:56.925]                       }
[17:29:56.925]                       else if (inherits(cond, "condition")) {
[17:29:56.925]                         if (!is.null(pattern)) {
[17:29:56.925]                           computeRestarts <- base::computeRestarts
[17:29:56.925]                           grepl <- base::grepl
[17:29:56.925]                           restarts <- computeRestarts(cond)
[17:29:56.925]                           for (restart in restarts) {
[17:29:56.925]                             name <- restart$name
[17:29:56.925]                             if (is.null(name)) 
[17:29:56.925]                               next
[17:29:56.925]                             if (!grepl(pattern, name)) 
[17:29:56.925]                               next
[17:29:56.925]                             invokeRestart(restart)
[17:29:56.925]                             muffled <- TRUE
[17:29:56.925]                             break
[17:29:56.925]                           }
[17:29:56.925]                         }
[17:29:56.925]                       }
[17:29:56.925]                       invisible(muffled)
[17:29:56.925]                     }
[17:29:56.925]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.925]                   }
[17:29:56.925]                 }
[17:29:56.925]                 else {
[17:29:56.925]                   if (TRUE) {
[17:29:56.925]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.925]                     {
[17:29:56.925]                       inherits <- base::inherits
[17:29:56.925]                       invokeRestart <- base::invokeRestart
[17:29:56.925]                       is.null <- base::is.null
[17:29:56.925]                       muffled <- FALSE
[17:29:56.925]                       if (inherits(cond, "message")) {
[17:29:56.925]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.925]                         if (muffled) 
[17:29:56.925]                           invokeRestart("muffleMessage")
[17:29:56.925]                       }
[17:29:56.925]                       else if (inherits(cond, "warning")) {
[17:29:56.925]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.925]                         if (muffled) 
[17:29:56.925]                           invokeRestart("muffleWarning")
[17:29:56.925]                       }
[17:29:56.925]                       else if (inherits(cond, "condition")) {
[17:29:56.925]                         if (!is.null(pattern)) {
[17:29:56.925]                           computeRestarts <- base::computeRestarts
[17:29:56.925]                           grepl <- base::grepl
[17:29:56.925]                           restarts <- computeRestarts(cond)
[17:29:56.925]                           for (restart in restarts) {
[17:29:56.925]                             name <- restart$name
[17:29:56.925]                             if (is.null(name)) 
[17:29:56.925]                               next
[17:29:56.925]                             if (!grepl(pattern, name)) 
[17:29:56.925]                               next
[17:29:56.925]                             invokeRestart(restart)
[17:29:56.925]                             muffled <- TRUE
[17:29:56.925]                             break
[17:29:56.925]                           }
[17:29:56.925]                         }
[17:29:56.925]                       }
[17:29:56.925]                       invisible(muffled)
[17:29:56.925]                     }
[17:29:56.925]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.925]                   }
[17:29:56.925]                 }
[17:29:56.925]             }
[17:29:56.925]         }))
[17:29:56.925]     }, error = function(ex) {
[17:29:56.925]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:56.925]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.925]                 ...future.rng), started = ...future.startTime, 
[17:29:56.925]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:56.925]             version = "1.8"), class = "FutureResult")
[17:29:56.925]     }, finally = {
[17:29:56.925]         if (!identical(...future.workdir, getwd())) 
[17:29:56.925]             setwd(...future.workdir)
[17:29:56.925]         {
[17:29:56.925]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:56.925]                 ...future.oldOptions$nwarnings <- NULL
[17:29:56.925]             }
[17:29:56.925]             base::options(...future.oldOptions)
[17:29:56.925]             if (.Platform$OS.type == "windows") {
[17:29:56.925]                 old_names <- names(...future.oldEnvVars)
[17:29:56.925]                 envs <- base::Sys.getenv()
[17:29:56.925]                 names <- names(envs)
[17:29:56.925]                 common <- intersect(names, old_names)
[17:29:56.925]                 added <- setdiff(names, old_names)
[17:29:56.925]                 removed <- setdiff(old_names, names)
[17:29:56.925]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:56.925]                   envs[common]]
[17:29:56.925]                 NAMES <- toupper(changed)
[17:29:56.925]                 args <- list()
[17:29:56.925]                 for (kk in seq_along(NAMES)) {
[17:29:56.925]                   name <- changed[[kk]]
[17:29:56.925]                   NAME <- NAMES[[kk]]
[17:29:56.925]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.925]                     next
[17:29:56.925]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.925]                 }
[17:29:56.925]                 NAMES <- toupper(added)
[17:29:56.925]                 for (kk in seq_along(NAMES)) {
[17:29:56.925]                   name <- added[[kk]]
[17:29:56.925]                   NAME <- NAMES[[kk]]
[17:29:56.925]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.925]                     next
[17:29:56.925]                   args[[name]] <- ""
[17:29:56.925]                 }
[17:29:56.925]                 NAMES <- toupper(removed)
[17:29:56.925]                 for (kk in seq_along(NAMES)) {
[17:29:56.925]                   name <- removed[[kk]]
[17:29:56.925]                   NAME <- NAMES[[kk]]
[17:29:56.925]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.925]                     next
[17:29:56.925]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.925]                 }
[17:29:56.925]                 if (length(args) > 0) 
[17:29:56.925]                   base::do.call(base::Sys.setenv, args = args)
[17:29:56.925]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:56.925]             }
[17:29:56.925]             else {
[17:29:56.925]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:56.925]             }
[17:29:56.925]             {
[17:29:56.925]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:56.925]                   0L) {
[17:29:56.925]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:56.925]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:56.925]                   base::options(opts)
[17:29:56.925]                 }
[17:29:56.925]                 {
[17:29:56.925]                   {
[17:29:56.925]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:56.925]                     NULL
[17:29:56.925]                   }
[17:29:56.925]                   options(future.plan = NULL)
[17:29:56.925]                   if (is.na(NA_character_)) 
[17:29:56.925]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.925]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:56.925]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:56.925]                     .init = FALSE)
[17:29:56.925]                 }
[17:29:56.925]             }
[17:29:56.925]         }
[17:29:56.925]     })
[17:29:56.925]     if (TRUE) {
[17:29:56.925]         base::sink(type = "output", split = FALSE)
[17:29:56.925]         if (TRUE) {
[17:29:56.925]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:56.925]         }
[17:29:56.925]         else {
[17:29:56.925]             ...future.result["stdout"] <- base::list(NULL)
[17:29:56.925]         }
[17:29:56.925]         base::close(...future.stdout)
[17:29:56.925]         ...future.stdout <- NULL
[17:29:56.925]     }
[17:29:56.925]     ...future.result$conditions <- ...future.conditions
[17:29:56.925]     ...future.result$finished <- base::Sys.time()
[17:29:56.925]     ...future.result
[17:29:56.925] }
[17:29:56.935] MultisessionFuture started
[17:29:56.935] - Launch lazy future ... done
[17:29:56.935] run() for 'MultisessionFuture' ... done
[17:29:56.936] result() for ClusterFuture ...
[17:29:56.936] receiveMessageFromWorker() for ClusterFuture ...
[17:29:56.936] - Validating connection of MultisessionFuture
[17:29:56.957] - received message: FutureResult
[17:29:56.957] - Received FutureResult
[17:29:56.958] - Erased future from FutureRegistry
[17:29:56.958] result() for ClusterFuture ...
[17:29:56.958] - result already collected: FutureResult
[17:29:56.959] result() for ClusterFuture ... done
[17:29:56.959] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:56.959] result() for ClusterFuture ... done
[17:29:56.959] result() for ClusterFuture ...
[17:29:56.959] - result already collected: FutureResult
[17:29:56.960] result() for ClusterFuture ... done
[17:29:56.960] result() for ClusterFuture ...
[17:29:56.960] - result already collected: FutureResult
[17:29:56.960] result() for ClusterFuture ... done
[1] 42
[17:29:56.960] result() for ClusterFuture ...
[17:29:56.961] - result already collected: FutureResult
[17:29:56.961] result() for ClusterFuture ... done
- stdout = NA
[17:29:56.961] getGlobalsAndPackages() ...
[17:29:56.961] Searching for globals...
[17:29:56.966] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:29:56.966] Searching for globals ... DONE
[17:29:56.966] Resolving globals: FALSE
[17:29:56.967] 
[17:29:56.968] - packages: [1] 'utils'
[17:29:56.968] getGlobalsAndPackages() ... DONE
[17:29:56.969] run() for 'Future' ...
[17:29:56.969] - state: 'created'
[17:29:56.970] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:56.992] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:56.992] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:56.992]   - Field: 'node'
[17:29:56.993]   - Field: 'label'
[17:29:56.993]   - Field: 'local'
[17:29:56.993]   - Field: 'owner'
[17:29:56.993]   - Field: 'envir'
[17:29:56.994]   - Field: 'workers'
[17:29:56.994]   - Field: 'packages'
[17:29:56.994]   - Field: 'gc'
[17:29:56.994]   - Field: 'conditions'
[17:29:56.994]   - Field: 'persistent'
[17:29:56.995]   - Field: 'expr'
[17:29:56.995]   - Field: 'uuid'
[17:29:56.995]   - Field: 'seed'
[17:29:56.995]   - Field: 'version'
[17:29:56.995]   - Field: 'result'
[17:29:56.996]   - Field: 'asynchronous'
[17:29:56.996]   - Field: 'calls'
[17:29:56.996]   - Field: 'globals'
[17:29:56.996]   - Field: 'stdout'
[17:29:56.997]   - Field: 'earlySignal'
[17:29:56.997]   - Field: 'lazy'
[17:29:56.997]   - Field: 'state'
[17:29:56.997] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:56.997] - Launch lazy future ...
[17:29:56.998] Packages needed by the future expression (n = 1): 'utils'
[17:29:56.998] Packages needed by future strategies (n = 0): <none>
[17:29:56.999] {
[17:29:56.999]     {
[17:29:56.999]         {
[17:29:56.999]             ...future.startTime <- base::Sys.time()
[17:29:56.999]             {
[17:29:56.999]                 {
[17:29:56.999]                   {
[17:29:56.999]                     {
[17:29:56.999]                       {
[17:29:56.999]                         base::local({
[17:29:56.999]                           has_future <- base::requireNamespace("future", 
[17:29:56.999]                             quietly = TRUE)
[17:29:56.999]                           if (has_future) {
[17:29:56.999]                             ns <- base::getNamespace("future")
[17:29:56.999]                             version <- ns[[".package"]][["version"]]
[17:29:56.999]                             if (is.null(version)) 
[17:29:56.999]                               version <- utils::packageVersion("future")
[17:29:56.999]                           }
[17:29:56.999]                           else {
[17:29:56.999]                             version <- NULL
[17:29:56.999]                           }
[17:29:56.999]                           if (!has_future || version < "1.8.0") {
[17:29:56.999]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:56.999]                               "", base::R.version$version.string), 
[17:29:56.999]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:56.999]                                 base::R.version$platform, 8 * 
[17:29:56.999]                                   base::.Machine$sizeof.pointer), 
[17:29:56.999]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:56.999]                                 "release", "version")], collapse = " "), 
[17:29:56.999]                               hostname = base::Sys.info()[["nodename"]])
[17:29:56.999]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:56.999]                               info)
[17:29:56.999]                             info <- base::paste(info, collapse = "; ")
[17:29:56.999]                             if (!has_future) {
[17:29:56.999]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:56.999]                                 info)
[17:29:56.999]                             }
[17:29:56.999]                             else {
[17:29:56.999]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:56.999]                                 info, version)
[17:29:56.999]                             }
[17:29:56.999]                             base::stop(msg)
[17:29:56.999]                           }
[17:29:56.999]                         })
[17:29:56.999]                       }
[17:29:56.999]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:56.999]                       base::options(mc.cores = 1L)
[17:29:56.999]                     }
[17:29:56.999]                     base::local({
[17:29:56.999]                       for (pkg in "utils") {
[17:29:56.999]                         base::loadNamespace(pkg)
[17:29:56.999]                         base::library(pkg, character.only = TRUE)
[17:29:56.999]                       }
[17:29:56.999]                     })
[17:29:56.999]                   }
[17:29:56.999]                   ...future.strategy.old <- future::plan("list")
[17:29:56.999]                   options(future.plan = NULL)
[17:29:56.999]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.999]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:56.999]                 }
[17:29:56.999]                 ...future.workdir <- getwd()
[17:29:56.999]             }
[17:29:56.999]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:56.999]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:56.999]         }
[17:29:56.999]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:56.999]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:56.999]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:56.999]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:56.999]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:56.999]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:56.999]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:56.999]             base::names(...future.oldOptions))
[17:29:56.999]     }
[17:29:56.999]     if (TRUE) {
[17:29:56.999]     }
[17:29:56.999]     else {
[17:29:56.999]         if (NA) {
[17:29:56.999]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:56.999]                 open = "w")
[17:29:56.999]         }
[17:29:56.999]         else {
[17:29:56.999]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:56.999]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:56.999]         }
[17:29:56.999]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:56.999]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:56.999]             base::sink(type = "output", split = FALSE)
[17:29:56.999]             base::close(...future.stdout)
[17:29:56.999]         }, add = TRUE)
[17:29:56.999]     }
[17:29:56.999]     ...future.frame <- base::sys.nframe()
[17:29:56.999]     ...future.conditions <- base::list()
[17:29:56.999]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:56.999]     if (FALSE) {
[17:29:56.999]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:56.999]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:56.999]     }
[17:29:56.999]     ...future.result <- base::tryCatch({
[17:29:56.999]         base::withCallingHandlers({
[17:29:56.999]             ...future.value <- base::withVisible(base::local({
[17:29:56.999]                 ...future.makeSendCondition <- base::local({
[17:29:56.999]                   sendCondition <- NULL
[17:29:56.999]                   function(frame = 1L) {
[17:29:56.999]                     if (is.function(sendCondition)) 
[17:29:56.999]                       return(sendCondition)
[17:29:56.999]                     ns <- getNamespace("parallel")
[17:29:56.999]                     if (exists("sendData", mode = "function", 
[17:29:56.999]                       envir = ns)) {
[17:29:56.999]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:56.999]                         envir = ns)
[17:29:56.999]                       envir <- sys.frame(frame)
[17:29:56.999]                       master <- NULL
[17:29:56.999]                       while (!identical(envir, .GlobalEnv) && 
[17:29:56.999]                         !identical(envir, emptyenv())) {
[17:29:56.999]                         if (exists("master", mode = "list", envir = envir, 
[17:29:56.999]                           inherits = FALSE)) {
[17:29:56.999]                           master <- get("master", mode = "list", 
[17:29:56.999]                             envir = envir, inherits = FALSE)
[17:29:56.999]                           if (inherits(master, c("SOCKnode", 
[17:29:56.999]                             "SOCK0node"))) {
[17:29:56.999]                             sendCondition <<- function(cond) {
[17:29:56.999]                               data <- list(type = "VALUE", value = cond, 
[17:29:56.999]                                 success = TRUE)
[17:29:56.999]                               parallel_sendData(master, data)
[17:29:56.999]                             }
[17:29:56.999]                             return(sendCondition)
[17:29:56.999]                           }
[17:29:56.999]                         }
[17:29:56.999]                         frame <- frame + 1L
[17:29:56.999]                         envir <- sys.frame(frame)
[17:29:56.999]                       }
[17:29:56.999]                     }
[17:29:56.999]                     sendCondition <<- function(cond) NULL
[17:29:56.999]                   }
[17:29:56.999]                 })
[17:29:56.999]                 withCallingHandlers({
[17:29:56.999]                   {
[17:29:56.999]                     print(1:50)
[17:29:56.999]                     str(1:50)
[17:29:56.999]                     cat(letters, sep = "-")
[17:29:56.999]                     cat(1:6, collapse = "\n")
[17:29:56.999]                     write.table(datasets::iris[1:10, ], sep = "\t")
[17:29:56.999]                     42L
[17:29:56.999]                   }
[17:29:56.999]                 }, immediateCondition = function(cond) {
[17:29:56.999]                   sendCondition <- ...future.makeSendCondition()
[17:29:56.999]                   sendCondition(cond)
[17:29:56.999]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.999]                   {
[17:29:56.999]                     inherits <- base::inherits
[17:29:56.999]                     invokeRestart <- base::invokeRestart
[17:29:56.999]                     is.null <- base::is.null
[17:29:56.999]                     muffled <- FALSE
[17:29:56.999]                     if (inherits(cond, "message")) {
[17:29:56.999]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:56.999]                       if (muffled) 
[17:29:56.999]                         invokeRestart("muffleMessage")
[17:29:56.999]                     }
[17:29:56.999]                     else if (inherits(cond, "warning")) {
[17:29:56.999]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:56.999]                       if (muffled) 
[17:29:56.999]                         invokeRestart("muffleWarning")
[17:29:56.999]                     }
[17:29:56.999]                     else if (inherits(cond, "condition")) {
[17:29:56.999]                       if (!is.null(pattern)) {
[17:29:56.999]                         computeRestarts <- base::computeRestarts
[17:29:56.999]                         grepl <- base::grepl
[17:29:56.999]                         restarts <- computeRestarts(cond)
[17:29:56.999]                         for (restart in restarts) {
[17:29:56.999]                           name <- restart$name
[17:29:56.999]                           if (is.null(name)) 
[17:29:56.999]                             next
[17:29:56.999]                           if (!grepl(pattern, name)) 
[17:29:56.999]                             next
[17:29:56.999]                           invokeRestart(restart)
[17:29:56.999]                           muffled <- TRUE
[17:29:56.999]                           break
[17:29:56.999]                         }
[17:29:56.999]                       }
[17:29:56.999]                     }
[17:29:56.999]                     invisible(muffled)
[17:29:56.999]                   }
[17:29:56.999]                   muffleCondition(cond)
[17:29:56.999]                 })
[17:29:56.999]             }))
[17:29:56.999]             future::FutureResult(value = ...future.value$value, 
[17:29:56.999]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.999]                   ...future.rng), globalenv = if (FALSE) 
[17:29:56.999]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:56.999]                     ...future.globalenv.names))
[17:29:56.999]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:56.999]         }, condition = base::local({
[17:29:56.999]             c <- base::c
[17:29:56.999]             inherits <- base::inherits
[17:29:56.999]             invokeRestart <- base::invokeRestart
[17:29:56.999]             length <- base::length
[17:29:56.999]             list <- base::list
[17:29:56.999]             seq.int <- base::seq.int
[17:29:56.999]             signalCondition <- base::signalCondition
[17:29:56.999]             sys.calls <- base::sys.calls
[17:29:56.999]             `[[` <- base::`[[`
[17:29:56.999]             `+` <- base::`+`
[17:29:56.999]             `<<-` <- base::`<<-`
[17:29:56.999]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:56.999]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:56.999]                   3L)]
[17:29:56.999]             }
[17:29:56.999]             function(cond) {
[17:29:56.999]                 is_error <- inherits(cond, "error")
[17:29:56.999]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:56.999]                   NULL)
[17:29:56.999]                 if (is_error) {
[17:29:56.999]                   sessionInformation <- function() {
[17:29:56.999]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:56.999]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:56.999]                       search = base::search(), system = base::Sys.info())
[17:29:56.999]                   }
[17:29:56.999]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.999]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:56.999]                     cond$call), session = sessionInformation(), 
[17:29:56.999]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:56.999]                   signalCondition(cond)
[17:29:56.999]                 }
[17:29:56.999]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:56.999]                 "immediateCondition"))) {
[17:29:56.999]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:56.999]                   ...future.conditions[[length(...future.conditions) + 
[17:29:56.999]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:56.999]                   if (TRUE && !signal) {
[17:29:56.999]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.999]                     {
[17:29:56.999]                       inherits <- base::inherits
[17:29:56.999]                       invokeRestart <- base::invokeRestart
[17:29:56.999]                       is.null <- base::is.null
[17:29:56.999]                       muffled <- FALSE
[17:29:56.999]                       if (inherits(cond, "message")) {
[17:29:56.999]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.999]                         if (muffled) 
[17:29:56.999]                           invokeRestart("muffleMessage")
[17:29:56.999]                       }
[17:29:56.999]                       else if (inherits(cond, "warning")) {
[17:29:56.999]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.999]                         if (muffled) 
[17:29:56.999]                           invokeRestart("muffleWarning")
[17:29:56.999]                       }
[17:29:56.999]                       else if (inherits(cond, "condition")) {
[17:29:56.999]                         if (!is.null(pattern)) {
[17:29:56.999]                           computeRestarts <- base::computeRestarts
[17:29:56.999]                           grepl <- base::grepl
[17:29:56.999]                           restarts <- computeRestarts(cond)
[17:29:56.999]                           for (restart in restarts) {
[17:29:56.999]                             name <- restart$name
[17:29:56.999]                             if (is.null(name)) 
[17:29:56.999]                               next
[17:29:56.999]                             if (!grepl(pattern, name)) 
[17:29:56.999]                               next
[17:29:56.999]                             invokeRestart(restart)
[17:29:56.999]                             muffled <- TRUE
[17:29:56.999]                             break
[17:29:56.999]                           }
[17:29:56.999]                         }
[17:29:56.999]                       }
[17:29:56.999]                       invisible(muffled)
[17:29:56.999]                     }
[17:29:56.999]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.999]                   }
[17:29:56.999]                 }
[17:29:56.999]                 else {
[17:29:56.999]                   if (TRUE) {
[17:29:56.999]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:56.999]                     {
[17:29:56.999]                       inherits <- base::inherits
[17:29:56.999]                       invokeRestart <- base::invokeRestart
[17:29:56.999]                       is.null <- base::is.null
[17:29:56.999]                       muffled <- FALSE
[17:29:56.999]                       if (inherits(cond, "message")) {
[17:29:56.999]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:56.999]                         if (muffled) 
[17:29:56.999]                           invokeRestart("muffleMessage")
[17:29:56.999]                       }
[17:29:56.999]                       else if (inherits(cond, "warning")) {
[17:29:56.999]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:56.999]                         if (muffled) 
[17:29:56.999]                           invokeRestart("muffleWarning")
[17:29:56.999]                       }
[17:29:56.999]                       else if (inherits(cond, "condition")) {
[17:29:56.999]                         if (!is.null(pattern)) {
[17:29:56.999]                           computeRestarts <- base::computeRestarts
[17:29:56.999]                           grepl <- base::grepl
[17:29:56.999]                           restarts <- computeRestarts(cond)
[17:29:56.999]                           for (restart in restarts) {
[17:29:56.999]                             name <- restart$name
[17:29:56.999]                             if (is.null(name)) 
[17:29:56.999]                               next
[17:29:56.999]                             if (!grepl(pattern, name)) 
[17:29:56.999]                               next
[17:29:56.999]                             invokeRestart(restart)
[17:29:56.999]                             muffled <- TRUE
[17:29:56.999]                             break
[17:29:56.999]                           }
[17:29:56.999]                         }
[17:29:56.999]                       }
[17:29:56.999]                       invisible(muffled)
[17:29:56.999]                     }
[17:29:56.999]                     muffleCondition(cond, pattern = "^muffle")
[17:29:56.999]                   }
[17:29:56.999]                 }
[17:29:56.999]             }
[17:29:56.999]         }))
[17:29:56.999]     }, error = function(ex) {
[17:29:56.999]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:56.999]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:56.999]                 ...future.rng), started = ...future.startTime, 
[17:29:56.999]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:56.999]             version = "1.8"), class = "FutureResult")
[17:29:56.999]     }, finally = {
[17:29:56.999]         if (!identical(...future.workdir, getwd())) 
[17:29:56.999]             setwd(...future.workdir)
[17:29:56.999]         {
[17:29:56.999]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:56.999]                 ...future.oldOptions$nwarnings <- NULL
[17:29:56.999]             }
[17:29:56.999]             base::options(...future.oldOptions)
[17:29:56.999]             if (.Platform$OS.type == "windows") {
[17:29:56.999]                 old_names <- names(...future.oldEnvVars)
[17:29:56.999]                 envs <- base::Sys.getenv()
[17:29:56.999]                 names <- names(envs)
[17:29:56.999]                 common <- intersect(names, old_names)
[17:29:56.999]                 added <- setdiff(names, old_names)
[17:29:56.999]                 removed <- setdiff(old_names, names)
[17:29:56.999]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:56.999]                   envs[common]]
[17:29:56.999]                 NAMES <- toupper(changed)
[17:29:56.999]                 args <- list()
[17:29:56.999]                 for (kk in seq_along(NAMES)) {
[17:29:56.999]                   name <- changed[[kk]]
[17:29:56.999]                   NAME <- NAMES[[kk]]
[17:29:56.999]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.999]                     next
[17:29:56.999]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.999]                 }
[17:29:56.999]                 NAMES <- toupper(added)
[17:29:56.999]                 for (kk in seq_along(NAMES)) {
[17:29:56.999]                   name <- added[[kk]]
[17:29:56.999]                   NAME <- NAMES[[kk]]
[17:29:56.999]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.999]                     next
[17:29:56.999]                   args[[name]] <- ""
[17:29:56.999]                 }
[17:29:56.999]                 NAMES <- toupper(removed)
[17:29:56.999]                 for (kk in seq_along(NAMES)) {
[17:29:56.999]                   name <- removed[[kk]]
[17:29:56.999]                   NAME <- NAMES[[kk]]
[17:29:56.999]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:56.999]                     next
[17:29:56.999]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:56.999]                 }
[17:29:56.999]                 if (length(args) > 0) 
[17:29:56.999]                   base::do.call(base::Sys.setenv, args = args)
[17:29:56.999]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:56.999]             }
[17:29:56.999]             else {
[17:29:56.999]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:56.999]             }
[17:29:56.999]             {
[17:29:56.999]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:56.999]                   0L) {
[17:29:56.999]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:56.999]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:56.999]                   base::options(opts)
[17:29:56.999]                 }
[17:29:56.999]                 {
[17:29:56.999]                   {
[17:29:56.999]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:56.999]                     NULL
[17:29:56.999]                   }
[17:29:56.999]                   options(future.plan = NULL)
[17:29:56.999]                   if (is.na(NA_character_)) 
[17:29:56.999]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:56.999]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:56.999]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:56.999]                     .init = FALSE)
[17:29:56.999]                 }
[17:29:56.999]             }
[17:29:56.999]         }
[17:29:56.999]     })
[17:29:56.999]     if (FALSE) {
[17:29:56.999]         base::sink(type = "output", split = FALSE)
[17:29:56.999]         if (NA) {
[17:29:56.999]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:56.999]         }
[17:29:56.999]         else {
[17:29:56.999]             ...future.result["stdout"] <- base::list(NULL)
[17:29:56.999]         }
[17:29:56.999]         base::close(...future.stdout)
[17:29:56.999]         ...future.stdout <- NULL
[17:29:56.999]     }
[17:29:56.999]     ...future.result$conditions <- ...future.conditions
[17:29:56.999]     ...future.result$finished <- base::Sys.time()
[17:29:56.999]     ...future.result
[17:29:56.999] }
[17:29:57.007] MultisessionFuture started
[17:29:57.007] - Launch lazy future ... done
[17:29:57.008] run() for 'MultisessionFuture' ... done
[17:29:57.008] result() for ClusterFuture ...
[17:29:57.008] receiveMessageFromWorker() for ClusterFuture ...
[17:29:57.009] - Validating connection of MultisessionFuture
[17:29:57.033] - received message: FutureResult
[17:29:57.033] - Received FutureResult
[17:29:57.037] - Erased future from FutureRegistry
[17:29:57.037] result() for ClusterFuture ...
[17:29:57.038] - result already collected: FutureResult
[17:29:57.038] result() for ClusterFuture ... done
[17:29:57.038] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:57.038] 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: "2024-07-29 17:29:57"
 $ finished    : POSIXct[1:1], format: "2024-07-29 17:29:57"
 $ session_uuid: chr "e25fa336-1319-3de5-50c6-8c7ff8013db5"
  ..- 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 176124
  .. ..$ time  : POSIXct[1:1], format: "2024-07-29 17:29:56"
  .. ..$ 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 5 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[17:29:57.053] result() for ClusterFuture ...
[17:29:57.054] - result already collected: FutureResult
[17:29:57.054] result() for ClusterFuture ... done
[17:29:57.054] result() for ClusterFuture ...
[17:29:57.055] - result already collected: FutureResult
[17:29:57.055] result() for ClusterFuture ... done
[17:29:57.056] getGlobalsAndPackages() ...
[17:29:57.056] Searching for globals...
[17:29:57.062] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:29:57.063] Searching for globals ... DONE
[17:29:57.063] Resolving globals: FALSE
[17:29:57.064] 
[17:29:57.064] - packages: [1] 'utils'
[17:29:57.065] getGlobalsAndPackages() ... DONE
[17:29:57.065] run() for 'Future' ...
[17:29:57.066] - state: 'created'
[17:29:57.066] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:57.082] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:57.082] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:57.083]   - Field: 'node'
[17:29:57.083]   - Field: 'label'
[17:29:57.083]   - Field: 'local'
[17:29:57.083]   - Field: 'owner'
[17:29:57.083]   - Field: 'envir'
[17:29:57.083]   - Field: 'workers'
[17:29:57.084]   - Field: 'packages'
[17:29:57.084]   - Field: 'gc'
[17:29:57.084]   - Field: 'conditions'
[17:29:57.084]   - Field: 'persistent'
[17:29:57.084]   - Field: 'expr'
[17:29:57.084]   - Field: 'uuid'
[17:29:57.085]   - Field: 'seed'
[17:29:57.085]   - Field: 'version'
[17:29:57.085]   - Field: 'result'
[17:29:57.085]   - Field: 'asynchronous'
[17:29:57.085]   - Field: 'calls'
[17:29:57.086]   - Field: 'globals'
[17:29:57.086]   - Field: 'stdout'
[17:29:57.086]   - Field: 'earlySignal'
[17:29:57.086]   - Field: 'lazy'
[17:29:57.086]   - Field: 'state'
[17:29:57.086] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:57.087] - Launch lazy future ...
[17:29:57.087] Packages needed by the future expression (n = 1): 'utils'
[17:29:57.087] Packages needed by future strategies (n = 0): <none>
[17:29:57.088] {
[17:29:57.088]     {
[17:29:57.088]         {
[17:29:57.088]             ...future.startTime <- base::Sys.time()
[17:29:57.088]             {
[17:29:57.088]                 {
[17:29:57.088]                   {
[17:29:57.088]                     {
[17:29:57.088]                       {
[17:29:57.088]                         base::local({
[17:29:57.088]                           has_future <- base::requireNamespace("future", 
[17:29:57.088]                             quietly = TRUE)
[17:29:57.088]                           if (has_future) {
[17:29:57.088]                             ns <- base::getNamespace("future")
[17:29:57.088]                             version <- ns[[".package"]][["version"]]
[17:29:57.088]                             if (is.null(version)) 
[17:29:57.088]                               version <- utils::packageVersion("future")
[17:29:57.088]                           }
[17:29:57.088]                           else {
[17:29:57.088]                             version <- NULL
[17:29:57.088]                           }
[17:29:57.088]                           if (!has_future || version < "1.8.0") {
[17:29:57.088]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:57.088]                               "", base::R.version$version.string), 
[17:29:57.088]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:57.088]                                 base::R.version$platform, 8 * 
[17:29:57.088]                                   base::.Machine$sizeof.pointer), 
[17:29:57.088]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:57.088]                                 "release", "version")], collapse = " "), 
[17:29:57.088]                               hostname = base::Sys.info()[["nodename"]])
[17:29:57.088]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:57.088]                               info)
[17:29:57.088]                             info <- base::paste(info, collapse = "; ")
[17:29:57.088]                             if (!has_future) {
[17:29:57.088]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:57.088]                                 info)
[17:29:57.088]                             }
[17:29:57.088]                             else {
[17:29:57.088]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:57.088]                                 info, version)
[17:29:57.088]                             }
[17:29:57.088]                             base::stop(msg)
[17:29:57.088]                           }
[17:29:57.088]                         })
[17:29:57.088]                       }
[17:29:57.088]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:57.088]                       base::options(mc.cores = 1L)
[17:29:57.088]                     }
[17:29:57.088]                     base::local({
[17:29:57.088]                       for (pkg in "utils") {
[17:29:57.088]                         base::loadNamespace(pkg)
[17:29:57.088]                         base::library(pkg, character.only = TRUE)
[17:29:57.088]                       }
[17:29:57.088]                     })
[17:29:57.088]                   }
[17:29:57.088]                   ...future.strategy.old <- future::plan("list")
[17:29:57.088]                   options(future.plan = NULL)
[17:29:57.088]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:57.088]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:57.088]                 }
[17:29:57.088]                 ...future.workdir <- getwd()
[17:29:57.088]             }
[17:29:57.088]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:57.088]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:57.088]         }
[17:29:57.088]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:57.088]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:57.088]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:57.088]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:57.088]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:57.088]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:57.088]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:57.088]             base::names(...future.oldOptions))
[17:29:57.088]     }
[17:29:57.088]     if (TRUE) {
[17:29:57.088]     }
[17:29:57.088]     else {
[17:29:57.088]         if (NA) {
[17:29:57.088]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:57.088]                 open = "w")
[17:29:57.088]         }
[17:29:57.088]         else {
[17:29:57.088]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:57.088]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:57.088]         }
[17:29:57.088]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:57.088]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:57.088]             base::sink(type = "output", split = FALSE)
[17:29:57.088]             base::close(...future.stdout)
[17:29:57.088]         }, add = TRUE)
[17:29:57.088]     }
[17:29:57.088]     ...future.frame <- base::sys.nframe()
[17:29:57.088]     ...future.conditions <- base::list()
[17:29:57.088]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:57.088]     if (FALSE) {
[17:29:57.088]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:57.088]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:57.088]     }
[17:29:57.088]     ...future.result <- base::tryCatch({
[17:29:57.088]         base::withCallingHandlers({
[17:29:57.088]             ...future.value <- base::withVisible(base::local({
[17:29:57.088]                 ...future.makeSendCondition <- base::local({
[17:29:57.088]                   sendCondition <- NULL
[17:29:57.088]                   function(frame = 1L) {
[17:29:57.088]                     if (is.function(sendCondition)) 
[17:29:57.088]                       return(sendCondition)
[17:29:57.088]                     ns <- getNamespace("parallel")
[17:29:57.088]                     if (exists("sendData", mode = "function", 
[17:29:57.088]                       envir = ns)) {
[17:29:57.088]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:57.088]                         envir = ns)
[17:29:57.088]                       envir <- sys.frame(frame)
[17:29:57.088]                       master <- NULL
[17:29:57.088]                       while (!identical(envir, .GlobalEnv) && 
[17:29:57.088]                         !identical(envir, emptyenv())) {
[17:29:57.088]                         if (exists("master", mode = "list", envir = envir, 
[17:29:57.088]                           inherits = FALSE)) {
[17:29:57.088]                           master <- get("master", mode = "list", 
[17:29:57.088]                             envir = envir, inherits = FALSE)
[17:29:57.088]                           if (inherits(master, c("SOCKnode", 
[17:29:57.088]                             "SOCK0node"))) {
[17:29:57.088]                             sendCondition <<- function(cond) {
[17:29:57.088]                               data <- list(type = "VALUE", value = cond, 
[17:29:57.088]                                 success = TRUE)
[17:29:57.088]                               parallel_sendData(master, data)
[17:29:57.088]                             }
[17:29:57.088]                             return(sendCondition)
[17:29:57.088]                           }
[17:29:57.088]                         }
[17:29:57.088]                         frame <- frame + 1L
[17:29:57.088]                         envir <- sys.frame(frame)
[17:29:57.088]                       }
[17:29:57.088]                     }
[17:29:57.088]                     sendCondition <<- function(cond) NULL
[17:29:57.088]                   }
[17:29:57.088]                 })
[17:29:57.088]                 withCallingHandlers({
[17:29:57.088]                   {
[17:29:57.088]                     print(1:50)
[17:29:57.088]                     str(1:50)
[17:29:57.088]                     cat(letters, sep = "-")
[17:29:57.088]                     cat(1:6, collapse = "\n")
[17:29:57.088]                     write.table(datasets::iris[1:10, ], sep = "\t")
[17:29:57.088]                     42L
[17:29:57.088]                   }
[17:29:57.088]                 }, immediateCondition = function(cond) {
[17:29:57.088]                   sendCondition <- ...future.makeSendCondition()
[17:29:57.088]                   sendCondition(cond)
[17:29:57.088]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:57.088]                   {
[17:29:57.088]                     inherits <- base::inherits
[17:29:57.088]                     invokeRestart <- base::invokeRestart
[17:29:57.088]                     is.null <- base::is.null
[17:29:57.088]                     muffled <- FALSE
[17:29:57.088]                     if (inherits(cond, "message")) {
[17:29:57.088]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:57.088]                       if (muffled) 
[17:29:57.088]                         invokeRestart("muffleMessage")
[17:29:57.088]                     }
[17:29:57.088]                     else if (inherits(cond, "warning")) {
[17:29:57.088]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:57.088]                       if (muffled) 
[17:29:57.088]                         invokeRestart("muffleWarning")
[17:29:57.088]                     }
[17:29:57.088]                     else if (inherits(cond, "condition")) {
[17:29:57.088]                       if (!is.null(pattern)) {
[17:29:57.088]                         computeRestarts <- base::computeRestarts
[17:29:57.088]                         grepl <- base::grepl
[17:29:57.088]                         restarts <- computeRestarts(cond)
[17:29:57.088]                         for (restart in restarts) {
[17:29:57.088]                           name <- restart$name
[17:29:57.088]                           if (is.null(name)) 
[17:29:57.088]                             next
[17:29:57.088]                           if (!grepl(pattern, name)) 
[17:29:57.088]                             next
[17:29:57.088]                           invokeRestart(restart)
[17:29:57.088]                           muffled <- TRUE
[17:29:57.088]                           break
[17:29:57.088]                         }
[17:29:57.088]                       }
[17:29:57.088]                     }
[17:29:57.088]                     invisible(muffled)
[17:29:57.088]                   }
[17:29:57.088]                   muffleCondition(cond)
[17:29:57.088]                 })
[17:29:57.088]             }))
[17:29:57.088]             future::FutureResult(value = ...future.value$value, 
[17:29:57.088]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:57.088]                   ...future.rng), globalenv = if (FALSE) 
[17:29:57.088]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:57.088]                     ...future.globalenv.names))
[17:29:57.088]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:57.088]         }, condition = base::local({
[17:29:57.088]             c <- base::c
[17:29:57.088]             inherits <- base::inherits
[17:29:57.088]             invokeRestart <- base::invokeRestart
[17:29:57.088]             length <- base::length
[17:29:57.088]             list <- base::list
[17:29:57.088]             seq.int <- base::seq.int
[17:29:57.088]             signalCondition <- base::signalCondition
[17:29:57.088]             sys.calls <- base::sys.calls
[17:29:57.088]             `[[` <- base::`[[`
[17:29:57.088]             `+` <- base::`+`
[17:29:57.088]             `<<-` <- base::`<<-`
[17:29:57.088]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:57.088]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:57.088]                   3L)]
[17:29:57.088]             }
[17:29:57.088]             function(cond) {
[17:29:57.088]                 is_error <- inherits(cond, "error")
[17:29:57.088]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:57.088]                   NULL)
[17:29:57.088]                 if (is_error) {
[17:29:57.088]                   sessionInformation <- function() {
[17:29:57.088]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:57.088]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:57.088]                       search = base::search(), system = base::Sys.info())
[17:29:57.088]                   }
[17:29:57.088]                   ...future.conditions[[length(...future.conditions) + 
[17:29:57.088]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:57.088]                     cond$call), session = sessionInformation(), 
[17:29:57.088]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:57.088]                   signalCondition(cond)
[17:29:57.088]                 }
[17:29:57.088]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:57.088]                 "immediateCondition"))) {
[17:29:57.088]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:57.088]                   ...future.conditions[[length(...future.conditions) + 
[17:29:57.088]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:57.088]                   if (TRUE && !signal) {
[17:29:57.088]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:57.088]                     {
[17:29:57.088]                       inherits <- base::inherits
[17:29:57.088]                       invokeRestart <- base::invokeRestart
[17:29:57.088]                       is.null <- base::is.null
[17:29:57.088]                       muffled <- FALSE
[17:29:57.088]                       if (inherits(cond, "message")) {
[17:29:57.088]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:57.088]                         if (muffled) 
[17:29:57.088]                           invokeRestart("muffleMessage")
[17:29:57.088]                       }
[17:29:57.088]                       else if (inherits(cond, "warning")) {
[17:29:57.088]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:57.088]                         if (muffled) 
[17:29:57.088]                           invokeRestart("muffleWarning")
[17:29:57.088]                       }
[17:29:57.088]                       else if (inherits(cond, "condition")) {
[17:29:57.088]                         if (!is.null(pattern)) {
[17:29:57.088]                           computeRestarts <- base::computeRestarts
[17:29:57.088]                           grepl <- base::grepl
[17:29:57.088]                           restarts <- computeRestarts(cond)
[17:29:57.088]                           for (restart in restarts) {
[17:29:57.088]                             name <- restart$name
[17:29:57.088]                             if (is.null(name)) 
[17:29:57.088]                               next
[17:29:57.088]                             if (!grepl(pattern, name)) 
[17:29:57.088]                               next
[17:29:57.088]                             invokeRestart(restart)
[17:29:57.088]                             muffled <- TRUE
[17:29:57.088]                             break
[17:29:57.088]                           }
[17:29:57.088]                         }
[17:29:57.088]                       }
[17:29:57.088]                       invisible(muffled)
[17:29:57.088]                     }
[17:29:57.088]                     muffleCondition(cond, pattern = "^muffle")
[17:29:57.088]                   }
[17:29:57.088]                 }
[17:29:57.088]                 else {
[17:29:57.088]                   if (TRUE) {
[17:29:57.088]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:57.088]                     {
[17:29:57.088]                       inherits <- base::inherits
[17:29:57.088]                       invokeRestart <- base::invokeRestart
[17:29:57.088]                       is.null <- base::is.null
[17:29:57.088]                       muffled <- FALSE
[17:29:57.088]                       if (inherits(cond, "message")) {
[17:29:57.088]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:57.088]                         if (muffled) 
[17:29:57.088]                           invokeRestart("muffleMessage")
[17:29:57.088]                       }
[17:29:57.088]                       else if (inherits(cond, "warning")) {
[17:29:57.088]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:57.088]                         if (muffled) 
[17:29:57.088]                           invokeRestart("muffleWarning")
[17:29:57.088]                       }
[17:29:57.088]                       else if (inherits(cond, "condition")) {
[17:29:57.088]                         if (!is.null(pattern)) {
[17:29:57.088]                           computeRestarts <- base::computeRestarts
[17:29:57.088]                           grepl <- base::grepl
[17:29:57.088]                           restarts <- computeRestarts(cond)
[17:29:57.088]                           for (restart in restarts) {
[17:29:57.088]                             name <- restart$name
[17:29:57.088]                             if (is.null(name)) 
[17:29:57.088]                               next
[17:29:57.088]                             if (!grepl(pattern, name)) 
[17:29:57.088]                               next
[17:29:57.088]                             invokeRestart(restart)
[17:29:57.088]                             muffled <- TRUE
[17:29:57.088]                             break
[17:29:57.088]                           }
[17:29:57.088]                         }
[17:29:57.088]                       }
[17:29:57.088]                       invisible(muffled)
[17:29:57.088]                     }
[17:29:57.088]                     muffleCondition(cond, pattern = "^muffle")
[17:29:57.088]                   }
[17:29:57.088]                 }
[17:29:57.088]             }
[17:29:57.088]         }))
[17:29:57.088]     }, error = function(ex) {
[17:29:57.088]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:57.088]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:57.088]                 ...future.rng), started = ...future.startTime, 
[17:29:57.088]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:57.088]             version = "1.8"), class = "FutureResult")
[17:29:57.088]     }, finally = {
[17:29:57.088]         if (!identical(...future.workdir, getwd())) 
[17:29:57.088]             setwd(...future.workdir)
[17:29:57.088]         {
[17:29:57.088]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:57.088]                 ...future.oldOptions$nwarnings <- NULL
[17:29:57.088]             }
[17:29:57.088]             base::options(...future.oldOptions)
[17:29:57.088]             if (.Platform$OS.type == "windows") {
[17:29:57.088]                 old_names <- names(...future.oldEnvVars)
[17:29:57.088]                 envs <- base::Sys.getenv()
[17:29:57.088]                 names <- names(envs)
[17:29:57.088]                 common <- intersect(names, old_names)
[17:29:57.088]                 added <- setdiff(names, old_names)
[17:29:57.088]                 removed <- setdiff(old_names, names)
[17:29:57.088]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:57.088]                   envs[common]]
[17:29:57.088]                 NAMES <- toupper(changed)
[17:29:57.088]                 args <- list()
[17:29:57.088]                 for (kk in seq_along(NAMES)) {
[17:29:57.088]                   name <- changed[[kk]]
[17:29:57.088]                   NAME <- NAMES[[kk]]
[17:29:57.088]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:57.088]                     next
[17:29:57.088]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:57.088]                 }
[17:29:57.088]                 NAMES <- toupper(added)
[17:29:57.088]                 for (kk in seq_along(NAMES)) {
[17:29:57.088]                   name <- added[[kk]]
[17:29:57.088]                   NAME <- NAMES[[kk]]
[17:29:57.088]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:57.088]                     next
[17:29:57.088]                   args[[name]] <- ""
[17:29:57.088]                 }
[17:29:57.088]                 NAMES <- toupper(removed)
[17:29:57.088]                 for (kk in seq_along(NAMES)) {
[17:29:57.088]                   name <- removed[[kk]]
[17:29:57.088]                   NAME <- NAMES[[kk]]
[17:29:57.088]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:57.088]                     next
[17:29:57.088]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:57.088]                 }
[17:29:57.088]                 if (length(args) > 0) 
[17:29:57.088]                   base::do.call(base::Sys.setenv, args = args)
[17:29:57.088]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:57.088]             }
[17:29:57.088]             else {
[17:29:57.088]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:57.088]             }
[17:29:57.088]             {
[17:29:57.088]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:57.088]                   0L) {
[17:29:57.088]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:57.088]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:57.088]                   base::options(opts)
[17:29:57.088]                 }
[17:29:57.088]                 {
[17:29:57.088]                   {
[17:29:57.088]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:57.088]                     NULL
[17:29:57.088]                   }
[17:29:57.088]                   options(future.plan = NULL)
[17:29:57.088]                   if (is.na(NA_character_)) 
[17:29:57.088]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:57.088]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:57.088]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:57.088]                     .init = FALSE)
[17:29:57.088]                 }
[17:29:57.088]             }
[17:29:57.088]         }
[17:29:57.088]     })
[17:29:57.088]     if (FALSE) {
[17:29:57.088]         base::sink(type = "output", split = FALSE)
[17:29:57.088]         if (NA) {
[17:29:57.088]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:57.088]         }
[17:29:57.088]         else {
[17:29:57.088]             ...future.result["stdout"] <- base::list(NULL)
[17:29:57.088]         }
[17:29:57.088]         base::close(...future.stdout)
[17:29:57.088]         ...future.stdout <- NULL
[17:29:57.088]     }
[17:29:57.088]     ...future.result$conditions <- ...future.conditions
[17:29:57.088]     ...future.result$finished <- base::Sys.time()
[17:29:57.088]     ...future.result
[17:29:57.088] }
[17:29:57.094] MultisessionFuture started
[17:29:57.094] - Launch lazy future ... done
[17:29:57.095] run() for 'MultisessionFuture' ... done
[17:29:57.095] result() for ClusterFuture ...
[17:29:57.096] receiveMessageFromWorker() for ClusterFuture ...
[17:29:57.096] - Validating connection of MultisessionFuture
[17:29:57.125] - received message: FutureResult
[17:29:57.126] - Received FutureResult
[17:29:57.126] - Erased future from FutureRegistry
[17:29:57.127] result() for ClusterFuture ...
[17:29:57.127] - result already collected: FutureResult
[17:29:57.127] result() for ClusterFuture ... done
[17:29:57.128] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:57.128] result() for ClusterFuture ... done
[17:29:57.128] result() for ClusterFuture ...
[17:29:57.129] - result already collected: FutureResult
[17:29:57.129] result() for ClusterFuture ... done
- stdout = structure(TRUE, drop = TRUE)
[17:29:57.130] getGlobalsAndPackages() ...
[17:29:57.130] Searching for globals...
[17:29:57.131] - globals found: [1] 'print'
[17:29:57.131] Searching for globals ... DONE
[17:29:57.132] Resolving globals: FALSE
[17:29:57.132] 
[17:29:57.132] 
[17:29:57.133] getGlobalsAndPackages() ... DONE
[17:29:57.133] run() for 'Future' ...
[17:29:57.134] - state: 'created'
[17:29:57.134] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:57.153] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:57.153] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:57.154]   - Field: 'node'
[17:29:57.154]   - Field: 'label'
[17:29:57.154]   - Field: 'local'
[17:29:57.154]   - Field: 'owner'
[17:29:57.155]   - Field: 'envir'
[17:29:57.155]   - Field: 'workers'
[17:29:57.155]   - Field: 'packages'
[17:29:57.155]   - Field: 'gc'
[17:29:57.155]   - Field: 'conditions'
[17:29:57.155]   - Field: 'persistent'
[17:29:57.156]   - Field: 'expr'
[17:29:57.156]   - Field: 'uuid'
[17:29:57.156]   - Field: 'seed'
[17:29:57.156]   - Field: 'version'
[17:29:57.156]   - Field: 'result'
[17:29:57.157]   - Field: 'asynchronous'
[17:29:57.157]   - Field: 'calls'
[17:29:57.157]   - Field: 'globals'
[17:29:57.158]   - Field: 'stdout'
[17:29:57.158]   - Field: 'earlySignal'
[17:29:57.158]   - Field: 'lazy'
[17:29:57.159]   - Field: 'state'
[17:29:57.159] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:57.159] - Launch lazy future ...
[17:29:57.160] Packages needed by the future expression (n = 0): <none>
[17:29:57.160] Packages needed by future strategies (n = 0): <none>
[17:29:57.161] {
[17:29:57.161]     {
[17:29:57.161]         {
[17:29:57.161]             ...future.startTime <- base::Sys.time()
[17:29:57.161]             {
[17:29:57.161]                 {
[17:29:57.161]                   {
[17:29:57.161]                     {
[17:29:57.161]                       base::local({
[17:29:57.161]                         has_future <- base::requireNamespace("future", 
[17:29:57.161]                           quietly = TRUE)
[17:29:57.161]                         if (has_future) {
[17:29:57.161]                           ns <- base::getNamespace("future")
[17:29:57.161]                           version <- ns[[".package"]][["version"]]
[17:29:57.161]                           if (is.null(version)) 
[17:29:57.161]                             version <- utils::packageVersion("future")
[17:29:57.161]                         }
[17:29:57.161]                         else {
[17:29:57.161]                           version <- NULL
[17:29:57.161]                         }
[17:29:57.161]                         if (!has_future || version < "1.8.0") {
[17:29:57.161]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:57.161]                             "", base::R.version$version.string), 
[17:29:57.161]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:57.161]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:57.161]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:57.161]                               "release", "version")], collapse = " "), 
[17:29:57.161]                             hostname = base::Sys.info()[["nodename"]])
[17:29:57.161]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:57.161]                             info)
[17:29:57.161]                           info <- base::paste(info, collapse = "; ")
[17:29:57.161]                           if (!has_future) {
[17:29:57.161]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:57.161]                               info)
[17:29:57.161]                           }
[17:29:57.161]                           else {
[17:29:57.161]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:57.161]                               info, version)
[17:29:57.161]                           }
[17:29:57.161]                           base::stop(msg)
[17:29:57.161]                         }
[17:29:57.161]                       })
[17:29:57.161]                     }
[17:29:57.161]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:57.161]                     base::options(mc.cores = 1L)
[17:29:57.161]                   }
[17:29:57.161]                   ...future.strategy.old <- future::plan("list")
[17:29:57.161]                   options(future.plan = NULL)
[17:29:57.161]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:57.161]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:57.161]                 }
[17:29:57.161]                 ...future.workdir <- getwd()
[17:29:57.161]             }
[17:29:57.161]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:57.161]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:57.161]         }
[17:29:57.161]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:57.161]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:57.161]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:57.161]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:57.161]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:57.161]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:57.161]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:57.161]             base::names(...future.oldOptions))
[17:29:57.161]     }
[17:29:57.161]     if (FALSE) {
[17:29:57.161]     }
[17:29:57.161]     else {
[17:29:57.161]         if (TRUE) {
[17:29:57.161]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:57.161]                 open = "w")
[17:29:57.161]         }
[17:29:57.161]         else {
[17:29:57.161]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:57.161]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:57.161]         }
[17:29:57.161]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:57.161]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:57.161]             base::sink(type = "output", split = FALSE)
[17:29:57.161]             base::close(...future.stdout)
[17:29:57.161]         }, add = TRUE)
[17:29:57.161]     }
[17:29:57.161]     ...future.frame <- base::sys.nframe()
[17:29:57.161]     ...future.conditions <- base::list()
[17:29:57.161]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:57.161]     if (FALSE) {
[17:29:57.161]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:57.161]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:57.161]     }
[17:29:57.161]     ...future.result <- base::tryCatch({
[17:29:57.161]         base::withCallingHandlers({
[17:29:57.161]             ...future.value <- base::withVisible(base::local({
[17:29:57.161]                 ...future.makeSendCondition <- base::local({
[17:29:57.161]                   sendCondition <- NULL
[17:29:57.161]                   function(frame = 1L) {
[17:29:57.161]                     if (is.function(sendCondition)) 
[17:29:57.161]                       return(sendCondition)
[17:29:57.161]                     ns <- getNamespace("parallel")
[17:29:57.161]                     if (exists("sendData", mode = "function", 
[17:29:57.161]                       envir = ns)) {
[17:29:57.161]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:57.161]                         envir = ns)
[17:29:57.161]                       envir <- sys.frame(frame)
[17:29:57.161]                       master <- NULL
[17:29:57.161]                       while (!identical(envir, .GlobalEnv) && 
[17:29:57.161]                         !identical(envir, emptyenv())) {
[17:29:57.161]                         if (exists("master", mode = "list", envir = envir, 
[17:29:57.161]                           inherits = FALSE)) {
[17:29:57.161]                           master <- get("master", mode = "list", 
[17:29:57.161]                             envir = envir, inherits = FALSE)
[17:29:57.161]                           if (inherits(master, c("SOCKnode", 
[17:29:57.161]                             "SOCK0node"))) {
[17:29:57.161]                             sendCondition <<- function(cond) {
[17:29:57.161]                               data <- list(type = "VALUE", value = cond, 
[17:29:57.161]                                 success = TRUE)
[17:29:57.161]                               parallel_sendData(master, data)
[17:29:57.161]                             }
[17:29:57.161]                             return(sendCondition)
[17:29:57.161]                           }
[17:29:57.161]                         }
[17:29:57.161]                         frame <- frame + 1L
[17:29:57.161]                         envir <- sys.frame(frame)
[17:29:57.161]                       }
[17:29:57.161]                     }
[17:29:57.161]                     sendCondition <<- function(cond) NULL
[17:29:57.161]                   }
[17:29:57.161]                 })
[17:29:57.161]                 withCallingHandlers({
[17:29:57.161]                   print(42)
[17:29:57.161]                 }, immediateCondition = function(cond) {
[17:29:57.161]                   sendCondition <- ...future.makeSendCondition()
[17:29:57.161]                   sendCondition(cond)
[17:29:57.161]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:57.161]                   {
[17:29:57.161]                     inherits <- base::inherits
[17:29:57.161]                     invokeRestart <- base::invokeRestart
[17:29:57.161]                     is.null <- base::is.null
[17:29:57.161]                     muffled <- FALSE
[17:29:57.161]                     if (inherits(cond, "message")) {
[17:29:57.161]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:57.161]                       if (muffled) 
[17:29:57.161]                         invokeRestart("muffleMessage")
[17:29:57.161]                     }
[17:29:57.161]                     else if (inherits(cond, "warning")) {
[17:29:57.161]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:57.161]                       if (muffled) 
[17:29:57.161]                         invokeRestart("muffleWarning")
[17:29:57.161]                     }
[17:29:57.161]                     else if (inherits(cond, "condition")) {
[17:29:57.161]                       if (!is.null(pattern)) {
[17:29:57.161]                         computeRestarts <- base::computeRestarts
[17:29:57.161]                         grepl <- base::grepl
[17:29:57.161]                         restarts <- computeRestarts(cond)
[17:29:57.161]                         for (restart in restarts) {
[17:29:57.161]                           name <- restart$name
[17:29:57.161]                           if (is.null(name)) 
[17:29:57.161]                             next
[17:29:57.161]                           if (!grepl(pattern, name)) 
[17:29:57.161]                             next
[17:29:57.161]                           invokeRestart(restart)
[17:29:57.161]                           muffled <- TRUE
[17:29:57.161]                           break
[17:29:57.161]                         }
[17:29:57.161]                       }
[17:29:57.161]                     }
[17:29:57.161]                     invisible(muffled)
[17:29:57.161]                   }
[17:29:57.161]                   muffleCondition(cond)
[17:29:57.161]                 })
[17:29:57.161]             }))
[17:29:57.161]             future::FutureResult(value = ...future.value$value, 
[17:29:57.161]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:57.161]                   ...future.rng), globalenv = if (FALSE) 
[17:29:57.161]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:57.161]                     ...future.globalenv.names))
[17:29:57.161]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:57.161]         }, condition = base::local({
[17:29:57.161]             c <- base::c
[17:29:57.161]             inherits <- base::inherits
[17:29:57.161]             invokeRestart <- base::invokeRestart
[17:29:57.161]             length <- base::length
[17:29:57.161]             list <- base::list
[17:29:57.161]             seq.int <- base::seq.int
[17:29:57.161]             signalCondition <- base::signalCondition
[17:29:57.161]             sys.calls <- base::sys.calls
[17:29:57.161]             `[[` <- base::`[[`
[17:29:57.161]             `+` <- base::`+`
[17:29:57.161]             `<<-` <- base::`<<-`
[17:29:57.161]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:57.161]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:57.161]                   3L)]
[17:29:57.161]             }
[17:29:57.161]             function(cond) {
[17:29:57.161]                 is_error <- inherits(cond, "error")
[17:29:57.161]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:57.161]                   NULL)
[17:29:57.161]                 if (is_error) {
[17:29:57.161]                   sessionInformation <- function() {
[17:29:57.161]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:57.161]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:57.161]                       search = base::search(), system = base::Sys.info())
[17:29:57.161]                   }
[17:29:57.161]                   ...future.conditions[[length(...future.conditions) + 
[17:29:57.161]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:57.161]                     cond$call), session = sessionInformation(), 
[17:29:57.161]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:57.161]                   signalCondition(cond)
[17:29:57.161]                 }
[17:29:57.161]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:57.161]                 "immediateCondition"))) {
[17:29:57.161]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:57.161]                   ...future.conditions[[length(...future.conditions) + 
[17:29:57.161]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:57.161]                   if (TRUE && !signal) {
[17:29:57.161]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:57.161]                     {
[17:29:57.161]                       inherits <- base::inherits
[17:29:57.161]                       invokeRestart <- base::invokeRestart
[17:29:57.161]                       is.null <- base::is.null
[17:29:57.161]                       muffled <- FALSE
[17:29:57.161]                       if (inherits(cond, "message")) {
[17:29:57.161]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:57.161]                         if (muffled) 
[17:29:57.161]                           invokeRestart("muffleMessage")
[17:29:57.161]                       }
[17:29:57.161]                       else if (inherits(cond, "warning")) {
[17:29:57.161]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:57.161]                         if (muffled) 
[17:29:57.161]                           invokeRestart("muffleWarning")
[17:29:57.161]                       }
[17:29:57.161]                       else if (inherits(cond, "condition")) {
[17:29:57.161]                         if (!is.null(pattern)) {
[17:29:57.161]                           computeRestarts <- base::computeRestarts
[17:29:57.161]                           grepl <- base::grepl
[17:29:57.161]                           restarts <- computeRestarts(cond)
[17:29:57.161]                           for (restart in restarts) {
[17:29:57.161]                             name <- restart$name
[17:29:57.161]                             if (is.null(name)) 
[17:29:57.161]                               next
[17:29:57.161]                             if (!grepl(pattern, name)) 
[17:29:57.161]                               next
[17:29:57.161]                             invokeRestart(restart)
[17:29:57.161]                             muffled <- TRUE
[17:29:57.161]                             break
[17:29:57.161]                           }
[17:29:57.161]                         }
[17:29:57.161]                       }
[17:29:57.161]                       invisible(muffled)
[17:29:57.161]                     }
[17:29:57.161]                     muffleCondition(cond, pattern = "^muffle")
[17:29:57.161]                   }
[17:29:57.161]                 }
[17:29:57.161]                 else {
[17:29:57.161]                   if (TRUE) {
[17:29:57.161]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:57.161]                     {
[17:29:57.161]                       inherits <- base::inherits
[17:29:57.161]                       invokeRestart <- base::invokeRestart
[17:29:57.161]                       is.null <- base::is.null
[17:29:57.161]                       muffled <- FALSE
[17:29:57.161]                       if (inherits(cond, "message")) {
[17:29:57.161]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:57.161]                         if (muffled) 
[17:29:57.161]                           invokeRestart("muffleMessage")
[17:29:57.161]                       }
[17:29:57.161]                       else if (inherits(cond, "warning")) {
[17:29:57.161]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:57.161]                         if (muffled) 
[17:29:57.161]                           invokeRestart("muffleWarning")
[17:29:57.161]                       }
[17:29:57.161]                       else if (inherits(cond, "condition")) {
[17:29:57.161]                         if (!is.null(pattern)) {
[17:29:57.161]                           computeRestarts <- base::computeRestarts
[17:29:57.161]                           grepl <- base::grepl
[17:29:57.161]                           restarts <- computeRestarts(cond)
[17:29:57.161]                           for (restart in restarts) {
[17:29:57.161]                             name <- restart$name
[17:29:57.161]                             if (is.null(name)) 
[17:29:57.161]                               next
[17:29:57.161]                             if (!grepl(pattern, name)) 
[17:29:57.161]                               next
[17:29:57.161]                             invokeRestart(restart)
[17:29:57.161]                             muffled <- TRUE
[17:29:57.161]                             break
[17:29:57.161]                           }
[17:29:57.161]                         }
[17:29:57.161]                       }
[17:29:57.161]                       invisible(muffled)
[17:29:57.161]                     }
[17:29:57.161]                     muffleCondition(cond, pattern = "^muffle")
[17:29:57.161]                   }
[17:29:57.161]                 }
[17:29:57.161]             }
[17:29:57.161]         }))
[17:29:57.161]     }, error = function(ex) {
[17:29:57.161]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:57.161]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:57.161]                 ...future.rng), started = ...future.startTime, 
[17:29:57.161]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:57.161]             version = "1.8"), class = "FutureResult")
[17:29:57.161]     }, finally = {
[17:29:57.161]         if (!identical(...future.workdir, getwd())) 
[17:29:57.161]             setwd(...future.workdir)
[17:29:57.161]         {
[17:29:57.161]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:57.161]                 ...future.oldOptions$nwarnings <- NULL
[17:29:57.161]             }
[17:29:57.161]             base::options(...future.oldOptions)
[17:29:57.161]             if (.Platform$OS.type == "windows") {
[17:29:57.161]                 old_names <- names(...future.oldEnvVars)
[17:29:57.161]                 envs <- base::Sys.getenv()
[17:29:57.161]                 names <- names(envs)
[17:29:57.161]                 common <- intersect(names, old_names)
[17:29:57.161]                 added <- setdiff(names, old_names)
[17:29:57.161]                 removed <- setdiff(old_names, names)
[17:29:57.161]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:57.161]                   envs[common]]
[17:29:57.161]                 NAMES <- toupper(changed)
[17:29:57.161]                 args <- list()
[17:29:57.161]                 for (kk in seq_along(NAMES)) {
[17:29:57.161]                   name <- changed[[kk]]
[17:29:57.161]                   NAME <- NAMES[[kk]]
[17:29:57.161]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:57.161]                     next
[17:29:57.161]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:57.161]                 }
[17:29:57.161]                 NAMES <- toupper(added)
[17:29:57.161]                 for (kk in seq_along(NAMES)) {
[17:29:57.161]                   name <- added[[kk]]
[17:29:57.161]                   NAME <- NAMES[[kk]]
[17:29:57.161]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:57.161]                     next
[17:29:57.161]                   args[[name]] <- ""
[17:29:57.161]                 }
[17:29:57.161]                 NAMES <- toupper(removed)
[17:29:57.161]                 for (kk in seq_along(NAMES)) {
[17:29:57.161]                   name <- removed[[kk]]
[17:29:57.161]                   NAME <- NAMES[[kk]]
[17:29:57.161]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:57.161]                     next
[17:29:57.161]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:57.161]                 }
[17:29:57.161]                 if (length(args) > 0) 
[17:29:57.161]                   base::do.call(base::Sys.setenv, args = args)
[17:29:57.161]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:57.161]             }
[17:29:57.161]             else {
[17:29:57.161]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:57.161]             }
[17:29:57.161]             {
[17:29:57.161]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:57.161]                   0L) {
[17:29:57.161]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:57.161]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:57.161]                   base::options(opts)
[17:29:57.161]                 }
[17:29:57.161]                 {
[17:29:57.161]                   {
[17:29:57.161]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:57.161]                     NULL
[17:29:57.161]                   }
[17:29:57.161]                   options(future.plan = NULL)
[17:29:57.161]                   if (is.na(NA_character_)) 
[17:29:57.161]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:57.161]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:57.161]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:57.161]                     .init = FALSE)
[17:29:57.161]                 }
[17:29:57.161]             }
[17:29:57.161]         }
[17:29:57.161]     })
[17:29:57.161]     if (TRUE) {
[17:29:57.161]         base::sink(type = "output", split = FALSE)
[17:29:57.161]         if (TRUE) {
[17:29:57.161]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:57.161]         }
[17:29:57.161]         else {
[17:29:57.161]             ...future.result["stdout"] <- base::list(NULL)
[17:29:57.161]         }
[17:29:57.161]         base::close(...future.stdout)
[17:29:57.161]         ...future.stdout <- NULL
[17:29:57.161]     }
[17:29:57.161]     ...future.result$conditions <- ...future.conditions
[17:29:57.161]     ...future.result$finished <- base::Sys.time()
[17:29:57.161]     ...future.result
[17:29:57.161] }
[17:29:57.172] MultisessionFuture started
[17:29:57.172] - Launch lazy future ... done
[17:29:57.173] run() for 'MultisessionFuture' ... done
[17:29:57.173] result() for ClusterFuture ...
[17:29:57.174] receiveMessageFromWorker() for ClusterFuture ...
[17:29:57.174] - Validating connection of MultisessionFuture
[17:29:57.199] - received message: FutureResult
[17:29:57.199] - Received FutureResult
[17:29:57.199] - Erased future from FutureRegistry
[17:29:57.200] result() for ClusterFuture ...
[17:29:57.200] - result already collected: FutureResult
[17:29:57.200] result() for ClusterFuture ... done
[17:29:57.200] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:57.201] result() for ClusterFuture ... done
[17:29:57.201] result() for ClusterFuture ...
[17:29:57.201] - result already collected: FutureResult
[17:29:57.201] result() for ClusterFuture ... done
[17:29:57.202] result() for ClusterFuture ...
[17:29:57.202] - result already collected: FutureResult
[17:29:57.202] result() for ClusterFuture ... done
[1] 42
[17:29:57.202] result() for ClusterFuture ...
[17:29:57.203] - result already collected: FutureResult
[17:29:57.203] result() for ClusterFuture ... done
multisession ... done
Testing with 2 cores ... done
> 
> message("*** Standard output ... DONE")
*** Standard output ... DONE
> 
> source("incl/end.R")
[17:29:57.204] plan(): Setting new future strategy stack:
[17:29:57.205] List of future strategies:
[17:29:57.205] 1. FutureStrategy:
[17:29:57.205]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:57.205]    - tweaked: FALSE
[17:29:57.205]    - call: future::plan(oplan)
[17:29:57.212] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=205] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'RTOOLS44_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS44_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_NOTE_MISSING_PACKAGE_ANCHORS_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_DEPRECATED_IS_R_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   1.59    0.20    2.79