R Under development (unstable) (2024-03-25 r86192 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:28:26.419] plan(): Setting new future strategy stack:
[17:28:26.421] List of future strategies:
[17:28:26.421] 1. sequential:
[17:28:26.421]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.421]    - tweaked: FALSE
[17:28:26.421]    - call: future::plan("sequential")
[17:28:26.436] 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:28:26.489] plan(): Setting new future strategy stack:
[17:28:26.489] List of future strategies:
[17:28:26.489] 1. sequential:
[17:28:26.489]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.489]    - tweaked: FALSE
[17:28:26.489]    - call: plan(strategy)
[17:28:26.502] plan(): nbrOfWorkers() = 1
- stdout = TRUE
[17:28:26.503] getGlobalsAndPackages() ...
[17:28:26.503] Searching for globals...
[17:28:26.513] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:28:26.513] Searching for globals ... DONE
[17:28:26.514] Resolving globals: FALSE
[17:28:26.515] 
[17:28:26.515] - packages: [1] 'utils'
[17:28:26.515] getGlobalsAndPackages() ... DONE
[17:28:26.516] run() for 'Future' ...
[17:28:26.516] - state: 'created'
[17:28:26.516] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:26.517] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:26.517] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:26.517]   - Field: 'label'
[17:28:26.517]   - Field: 'local'
[17:28:26.517]   - Field: 'owner'
[17:28:26.517]   - Field: 'envir'
[17:28:26.518]   - Field: 'packages'
[17:28:26.518]   - Field: 'gc'
[17:28:26.518]   - Field: 'conditions'
[17:28:26.518]   - Field: 'expr'
[17:28:26.518]   - Field: 'uuid'
[17:28:26.518]   - Field: 'seed'
[17:28:26.519]   - Field: 'version'
[17:28:26.519]   - Field: 'result'
[17:28:26.519]   - Field: 'asynchronous'
[17:28:26.519]   - Field: 'calls'
[17:28:26.519]   - Field: 'globals'
[17:28:26.520]   - Field: 'stdout'
[17:28:26.520]   - Field: 'earlySignal'
[17:28:26.520]   - Field: 'lazy'
[17:28:26.520]   - Field: 'state'
[17:28:26.520] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:26.520] - Launch lazy future ...
[17:28:26.521] Packages needed by the future expression (n = 1): 'utils'
[17:28:26.521] Packages needed by future strategies (n = 0): <none>
[17:28:26.522] {
[17:28:26.522]     {
[17:28:26.522]         {
[17:28:26.522]             ...future.startTime <- base::Sys.time()
[17:28:26.522]             {
[17:28:26.522]                 {
[17:28:26.522]                   {
[17:28:26.522]                     {
[17:28:26.522]                       base::local({
[17:28:26.522]                         has_future <- base::requireNamespace("future", 
[17:28:26.522]                           quietly = TRUE)
[17:28:26.522]                         if (has_future) {
[17:28:26.522]                           ns <- base::getNamespace("future")
[17:28:26.522]                           version <- ns[[".package"]][["version"]]
[17:28:26.522]                           if (is.null(version)) 
[17:28:26.522]                             version <- utils::packageVersion("future")
[17:28:26.522]                         }
[17:28:26.522]                         else {
[17:28:26.522]                           version <- NULL
[17:28:26.522]                         }
[17:28:26.522]                         if (!has_future || version < "1.8.0") {
[17:28:26.522]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:26.522]                             "", base::R.version$version.string), 
[17:28:26.522]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:26.522]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:26.522]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:26.522]                               "release", "version")], collapse = " "), 
[17:28:26.522]                             hostname = base::Sys.info()[["nodename"]])
[17:28:26.522]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:26.522]                             info)
[17:28:26.522]                           info <- base::paste(info, collapse = "; ")
[17:28:26.522]                           if (!has_future) {
[17:28:26.522]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:26.522]                               info)
[17:28:26.522]                           }
[17:28:26.522]                           else {
[17:28:26.522]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:26.522]                               info, version)
[17:28:26.522]                           }
[17:28:26.522]                           base::stop(msg)
[17:28:26.522]                         }
[17:28:26.522]                       })
[17:28:26.522]                     }
[17:28:26.522]                     base::local({
[17:28:26.522]                       for (pkg in "utils") {
[17:28:26.522]                         base::loadNamespace(pkg)
[17:28:26.522]                         base::library(pkg, character.only = TRUE)
[17:28:26.522]                       }
[17:28:26.522]                     })
[17:28:26.522]                   }
[17:28:26.522]                   ...future.strategy.old <- future::plan("list")
[17:28:26.522]                   options(future.plan = NULL)
[17:28:26.522]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.522]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:26.522]                 }
[17:28:26.522]                 ...future.workdir <- getwd()
[17:28:26.522]             }
[17:28:26.522]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:26.522]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:26.522]         }
[17:28:26.522]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:26.522]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:26.522]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:26.522]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:26.522]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:26.522]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:26.522]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:26.522]             base::names(...future.oldOptions))
[17:28:26.522]     }
[17:28:26.522]     if (FALSE) {
[17:28:26.522]     }
[17:28:26.522]     else {
[17:28:26.522]         if (TRUE) {
[17:28:26.522]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:26.522]                 open = "w")
[17:28:26.522]         }
[17:28:26.522]         else {
[17:28:26.522]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:26.522]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:26.522]         }
[17:28:26.522]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:26.522]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:26.522]             base::sink(type = "output", split = FALSE)
[17:28:26.522]             base::close(...future.stdout)
[17:28:26.522]         }, add = TRUE)
[17:28:26.522]     }
[17:28:26.522]     ...future.frame <- base::sys.nframe()
[17:28:26.522]     ...future.conditions <- base::list()
[17:28:26.522]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:26.522]     if (FALSE) {
[17:28:26.522]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:26.522]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:26.522]     }
[17:28:26.522]     ...future.result <- base::tryCatch({
[17:28:26.522]         base::withCallingHandlers({
[17:28:26.522]             ...future.value <- base::withVisible(base::local({
[17:28:26.522]                 print(1:50)
[17:28:26.522]                 str(1:50)
[17:28:26.522]                 cat(letters, sep = "-")
[17:28:26.522]                 cat(1:6, collapse = "\n")
[17:28:26.522]                 write.table(datasets::iris[1:10, ], sep = "\t")
[17:28:26.522]                 42L
[17:28:26.522]             }))
[17:28:26.522]             future::FutureResult(value = ...future.value$value, 
[17:28:26.522]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.522]                   ...future.rng), globalenv = if (FALSE) 
[17:28:26.522]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:26.522]                     ...future.globalenv.names))
[17:28:26.522]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:26.522]         }, condition = base::local({
[17:28:26.522]             c <- base::c
[17:28:26.522]             inherits <- base::inherits
[17:28:26.522]             invokeRestart <- base::invokeRestart
[17:28:26.522]             length <- base::length
[17:28:26.522]             list <- base::list
[17:28:26.522]             seq.int <- base::seq.int
[17:28:26.522]             signalCondition <- base::signalCondition
[17:28:26.522]             sys.calls <- base::sys.calls
[17:28:26.522]             `[[` <- base::`[[`
[17:28:26.522]             `+` <- base::`+`
[17:28:26.522]             `<<-` <- base::`<<-`
[17:28:26.522]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:26.522]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:26.522]                   3L)]
[17:28:26.522]             }
[17:28:26.522]             function(cond) {
[17:28:26.522]                 is_error <- inherits(cond, "error")
[17:28:26.522]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:26.522]                   NULL)
[17:28:26.522]                 if (is_error) {
[17:28:26.522]                   sessionInformation <- function() {
[17:28:26.522]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:26.522]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:26.522]                       search = base::search(), system = base::Sys.info())
[17:28:26.522]                   }
[17:28:26.522]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.522]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:26.522]                     cond$call), session = sessionInformation(), 
[17:28:26.522]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:26.522]                   signalCondition(cond)
[17:28:26.522]                 }
[17:28:26.522]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:26.522]                 "immediateCondition"))) {
[17:28:26.522]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:26.522]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.522]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:26.522]                   if (TRUE && !signal) {
[17:28:26.522]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.522]                     {
[17:28:26.522]                       inherits <- base::inherits
[17:28:26.522]                       invokeRestart <- base::invokeRestart
[17:28:26.522]                       is.null <- base::is.null
[17:28:26.522]                       muffled <- FALSE
[17:28:26.522]                       if (inherits(cond, "message")) {
[17:28:26.522]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.522]                         if (muffled) 
[17:28:26.522]                           invokeRestart("muffleMessage")
[17:28:26.522]                       }
[17:28:26.522]                       else if (inherits(cond, "warning")) {
[17:28:26.522]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.522]                         if (muffled) 
[17:28:26.522]                           invokeRestart("muffleWarning")
[17:28:26.522]                       }
[17:28:26.522]                       else if (inherits(cond, "condition")) {
[17:28:26.522]                         if (!is.null(pattern)) {
[17:28:26.522]                           computeRestarts <- base::computeRestarts
[17:28:26.522]                           grepl <- base::grepl
[17:28:26.522]                           restarts <- computeRestarts(cond)
[17:28:26.522]                           for (restart in restarts) {
[17:28:26.522]                             name <- restart$name
[17:28:26.522]                             if (is.null(name)) 
[17:28:26.522]                               next
[17:28:26.522]                             if (!grepl(pattern, name)) 
[17:28:26.522]                               next
[17:28:26.522]                             invokeRestart(restart)
[17:28:26.522]                             muffled <- TRUE
[17:28:26.522]                             break
[17:28:26.522]                           }
[17:28:26.522]                         }
[17:28:26.522]                       }
[17:28:26.522]                       invisible(muffled)
[17:28:26.522]                     }
[17:28:26.522]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.522]                   }
[17:28:26.522]                 }
[17:28:26.522]                 else {
[17:28:26.522]                   if (TRUE) {
[17:28:26.522]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.522]                     {
[17:28:26.522]                       inherits <- base::inherits
[17:28:26.522]                       invokeRestart <- base::invokeRestart
[17:28:26.522]                       is.null <- base::is.null
[17:28:26.522]                       muffled <- FALSE
[17:28:26.522]                       if (inherits(cond, "message")) {
[17:28:26.522]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.522]                         if (muffled) 
[17:28:26.522]                           invokeRestart("muffleMessage")
[17:28:26.522]                       }
[17:28:26.522]                       else if (inherits(cond, "warning")) {
[17:28:26.522]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.522]                         if (muffled) 
[17:28:26.522]                           invokeRestart("muffleWarning")
[17:28:26.522]                       }
[17:28:26.522]                       else if (inherits(cond, "condition")) {
[17:28:26.522]                         if (!is.null(pattern)) {
[17:28:26.522]                           computeRestarts <- base::computeRestarts
[17:28:26.522]                           grepl <- base::grepl
[17:28:26.522]                           restarts <- computeRestarts(cond)
[17:28:26.522]                           for (restart in restarts) {
[17:28:26.522]                             name <- restart$name
[17:28:26.522]                             if (is.null(name)) 
[17:28:26.522]                               next
[17:28:26.522]                             if (!grepl(pattern, name)) 
[17:28:26.522]                               next
[17:28:26.522]                             invokeRestart(restart)
[17:28:26.522]                             muffled <- TRUE
[17:28:26.522]                             break
[17:28:26.522]                           }
[17:28:26.522]                         }
[17:28:26.522]                       }
[17:28:26.522]                       invisible(muffled)
[17:28:26.522]                     }
[17:28:26.522]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.522]                   }
[17:28:26.522]                 }
[17:28:26.522]             }
[17:28:26.522]         }))
[17:28:26.522]     }, error = function(ex) {
[17:28:26.522]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:26.522]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.522]                 ...future.rng), started = ...future.startTime, 
[17:28:26.522]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:26.522]             version = "1.8"), class = "FutureResult")
[17:28:26.522]     }, finally = {
[17:28:26.522]         if (!identical(...future.workdir, getwd())) 
[17:28:26.522]             setwd(...future.workdir)
[17:28:26.522]         {
[17:28:26.522]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:26.522]                 ...future.oldOptions$nwarnings <- NULL
[17:28:26.522]             }
[17:28:26.522]             base::options(...future.oldOptions)
[17:28:26.522]             if (.Platform$OS.type == "windows") {
[17:28:26.522]                 old_names <- names(...future.oldEnvVars)
[17:28:26.522]                 envs <- base::Sys.getenv()
[17:28:26.522]                 names <- names(envs)
[17:28:26.522]                 common <- intersect(names, old_names)
[17:28:26.522]                 added <- setdiff(names, old_names)
[17:28:26.522]                 removed <- setdiff(old_names, names)
[17:28:26.522]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:26.522]                   envs[common]]
[17:28:26.522]                 NAMES <- toupper(changed)
[17:28:26.522]                 args <- list()
[17:28:26.522]                 for (kk in seq_along(NAMES)) {
[17:28:26.522]                   name <- changed[[kk]]
[17:28:26.522]                   NAME <- NAMES[[kk]]
[17:28:26.522]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.522]                     next
[17:28:26.522]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.522]                 }
[17:28:26.522]                 NAMES <- toupper(added)
[17:28:26.522]                 for (kk in seq_along(NAMES)) {
[17:28:26.522]                   name <- added[[kk]]
[17:28:26.522]                   NAME <- NAMES[[kk]]
[17:28:26.522]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.522]                     next
[17:28:26.522]                   args[[name]] <- ""
[17:28:26.522]                 }
[17:28:26.522]                 NAMES <- toupper(removed)
[17:28:26.522]                 for (kk in seq_along(NAMES)) {
[17:28:26.522]                   name <- removed[[kk]]
[17:28:26.522]                   NAME <- NAMES[[kk]]
[17:28:26.522]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.522]                     next
[17:28:26.522]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.522]                 }
[17:28:26.522]                 if (length(args) > 0) 
[17:28:26.522]                   base::do.call(base::Sys.setenv, args = args)
[17:28:26.522]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:26.522]             }
[17:28:26.522]             else {
[17:28:26.522]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:26.522]             }
[17:28:26.522]             {
[17:28:26.522]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:26.522]                   0L) {
[17:28:26.522]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:26.522]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:26.522]                   base::options(opts)
[17:28:26.522]                 }
[17:28:26.522]                 {
[17:28:26.522]                   {
[17:28:26.522]                     NULL
[17:28:26.522]                     RNGkind("Mersenne-Twister")
[17:28:26.522]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:26.522]                       inherits = FALSE)
[17:28:26.522]                   }
[17:28:26.522]                   options(future.plan = NULL)
[17:28:26.522]                   if (is.na(NA_character_)) 
[17:28:26.522]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.522]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:26.522]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:26.522]                     .init = FALSE)
[17:28:26.522]                 }
[17:28:26.522]             }
[17:28:26.522]         }
[17:28:26.522]     })
[17:28:26.522]     if (TRUE) {
[17:28:26.522]         base::sink(type = "output", split = FALSE)
[17:28:26.522]         if (TRUE) {
[17:28:26.522]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:26.522]         }
[17:28:26.522]         else {
[17:28:26.522]             ...future.result["stdout"] <- base::list(NULL)
[17:28:26.522]         }
[17:28:26.522]         base::close(...future.stdout)
[17:28:26.522]         ...future.stdout <- NULL
[17:28:26.522]     }
[17:28:26.522]     ...future.result$conditions <- ...future.conditions
[17:28:26.522]     ...future.result$finished <- base::Sys.time()
[17:28:26.522]     ...future.result
[17:28:26.522] }
[17:28:26.529] plan(): Setting new future strategy stack:
[17:28:26.529] List of future strategies:
[17:28:26.529] 1. sequential:
[17:28:26.529]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.529]    - tweaked: FALSE
[17:28:26.529]    - call: NULL
[17:28:26.530] plan(): nbrOfWorkers() = 1
[17:28:26.532] plan(): Setting new future strategy stack:
[17:28:26.533] List of future strategies:
[17:28:26.533] 1. sequential:
[17:28:26.533]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.533]    - tweaked: FALSE
[17:28:26.533]    - call: plan(strategy)
[17:28:26.533] plan(): nbrOfWorkers() = 1
[17:28:26.533] SequentialFuture started (and completed)
[17:28:26.534] - Launch lazy future ... done
[17:28:26.534] 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-03-26 17:28:26"
 $ finished    : POSIXct[1:1], format: "2024-03-26 17:28:26"
 $ session_uuid: chr "4b64b601-8666-ff45-2fee-4b34ef3f3009"
  ..- 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 162072
  .. ..$ time  : POSIXct[1:1], format: "2024-03-26 17:28:26"
  .. ..$ random: int 2147483647
 $ r_info      :List of 4
  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1
  .. ..$ : int [1:3] 4 4 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
 int [1:50] 1 2 3 4 5 6 7 8 9 10 ...
a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 
"Sepal.Length"	"Sepal.Width"	"Petal.Length"	"Petal.Width"	"Species"
"1"	5.1	3.5	1.4	0.2	"setosa"
"2"	4.9	3	1.4	0.2	"setosa"
"3"	4.7	3.2	1.3	0.2	"setosa"
"4"	4.6	3.1	1.5	0.2	"setosa"
"5"	5	3.6	1.4	0.2	"setosa"
"6"	5.4	3.9	1.7	0.4	"setosa"
"7"	4.6	3.4	1.4	0.3	"setosa"
"8"	5	3.4	1.5	0.2	"setosa"
"9"	4.4	2.9	1.4	0.2	"setosa"
"10"	4.9	3.1	1.5	0.1	"setosa"
FutureResult:
value: 'integer'
visible: TRUE
stdout: character
conditions: [n = 0] 
RNG used: FALSE
duration: 0.005195141 secs (started 2024-03-26 17:28:26.528678)
version: 1.8
[17:28:26.546] getGlobalsAndPackages() ...
[17:28:26.546] Searching for globals...
[17:28:26.551] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:28:26.551] Searching for globals ... DONE
[17:28:26.551] Resolving globals: FALSE
[17:28:26.552] 
[17:28:26.552] - packages: [1] 'utils'
[17:28:26.552] getGlobalsAndPackages() ... DONE
[17:28:26.552] run() for 'Future' ...
[17:28:26.552] - state: 'created'
[17:28:26.553] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:26.553] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:26.553] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:26.553]   - Field: 'label'
[17:28:26.554]   - Field: 'local'
[17:28:26.554]   - Field: 'owner'
[17:28:26.554]   - Field: 'envir'
[17:28:26.554]   - Field: 'packages'
[17:28:26.554]   - Field: 'gc'
[17:28:26.554]   - Field: 'conditions'
[17:28:26.555]   - Field: 'expr'
[17:28:26.555]   - Field: 'uuid'
[17:28:26.555]   - Field: 'seed'
[17:28:26.555]   - Field: 'version'
[17:28:26.555]   - Field: 'result'
[17:28:26.556]   - Field: 'asynchronous'
[17:28:26.556]   - Field: 'calls'
[17:28:26.556]   - Field: 'globals'
[17:28:26.556]   - Field: 'stdout'
[17:28:26.556]   - Field: 'earlySignal'
[17:28:26.556]   - Field: 'lazy'
[17:28:26.557]   - Field: 'state'
[17:28:26.557] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:26.557] - Launch lazy future ...
[17:28:26.557] Packages needed by the future expression (n = 1): 'utils'
[17:28:26.557] Packages needed by future strategies (n = 0): <none>
[17:28:26.558] {
[17:28:26.558]     {
[17:28:26.558]         {
[17:28:26.558]             ...future.startTime <- base::Sys.time()
[17:28:26.558]             {
[17:28:26.558]                 {
[17:28:26.558]                   {
[17:28:26.558]                     {
[17:28:26.558]                       base::local({
[17:28:26.558]                         has_future <- base::requireNamespace("future", 
[17:28:26.558]                           quietly = TRUE)
[17:28:26.558]                         if (has_future) {
[17:28:26.558]                           ns <- base::getNamespace("future")
[17:28:26.558]                           version <- ns[[".package"]][["version"]]
[17:28:26.558]                           if (is.null(version)) 
[17:28:26.558]                             version <- utils::packageVersion("future")
[17:28:26.558]                         }
[17:28:26.558]                         else {
[17:28:26.558]                           version <- NULL
[17:28:26.558]                         }
[17:28:26.558]                         if (!has_future || version < "1.8.0") {
[17:28:26.558]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:26.558]                             "", base::R.version$version.string), 
[17:28:26.558]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:26.558]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:26.558]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:26.558]                               "release", "version")], collapse = " "), 
[17:28:26.558]                             hostname = base::Sys.info()[["nodename"]])
[17:28:26.558]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:26.558]                             info)
[17:28:26.558]                           info <- base::paste(info, collapse = "; ")
[17:28:26.558]                           if (!has_future) {
[17:28:26.558]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:26.558]                               info)
[17:28:26.558]                           }
[17:28:26.558]                           else {
[17:28:26.558]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:26.558]                               info, version)
[17:28:26.558]                           }
[17:28:26.558]                           base::stop(msg)
[17:28:26.558]                         }
[17:28:26.558]                       })
[17:28:26.558]                     }
[17:28:26.558]                     base::local({
[17:28:26.558]                       for (pkg in "utils") {
[17:28:26.558]                         base::loadNamespace(pkg)
[17:28:26.558]                         base::library(pkg, character.only = TRUE)
[17:28:26.558]                       }
[17:28:26.558]                     })
[17:28:26.558]                   }
[17:28:26.558]                   ...future.strategy.old <- future::plan("list")
[17:28:26.558]                   options(future.plan = NULL)
[17:28:26.558]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.558]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:26.558]                 }
[17:28:26.558]                 ...future.workdir <- getwd()
[17:28:26.558]             }
[17:28:26.558]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:26.558]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:26.558]         }
[17:28:26.558]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:26.558]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:26.558]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:26.558]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:26.558]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:26.558]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:26.558]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:26.558]             base::names(...future.oldOptions))
[17:28:26.558]     }
[17:28:26.558]     if (FALSE) {
[17:28:26.558]     }
[17:28:26.558]     else {
[17:28:26.558]         if (TRUE) {
[17:28:26.558]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:26.558]                 open = "w")
[17:28:26.558]         }
[17:28:26.558]         else {
[17:28:26.558]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:26.558]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:26.558]         }
[17:28:26.558]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:26.558]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:26.558]             base::sink(type = "output", split = FALSE)
[17:28:26.558]             base::close(...future.stdout)
[17:28:26.558]         }, add = TRUE)
[17:28:26.558]     }
[17:28:26.558]     ...future.frame <- base::sys.nframe()
[17:28:26.558]     ...future.conditions <- base::list()
[17:28:26.558]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:26.558]     if (FALSE) {
[17:28:26.558]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:26.558]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:26.558]     }
[17:28:26.558]     ...future.result <- base::tryCatch({
[17:28:26.558]         base::withCallingHandlers({
[17:28:26.558]             ...future.value <- base::withVisible(base::local({
[17:28:26.558]                 print(1:50)
[17:28:26.558]                 str(1:50)
[17:28:26.558]                 cat(letters, sep = "-")
[17:28:26.558]                 cat(1:6, collapse = "\n")
[17:28:26.558]                 write.table(datasets::iris[1:10, ], sep = "\t")
[17:28:26.558]                 42L
[17:28:26.558]             }))
[17:28:26.558]             future::FutureResult(value = ...future.value$value, 
[17:28:26.558]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.558]                   ...future.rng), globalenv = if (FALSE) 
[17:28:26.558]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:26.558]                     ...future.globalenv.names))
[17:28:26.558]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:26.558]         }, condition = base::local({
[17:28:26.558]             c <- base::c
[17:28:26.558]             inherits <- base::inherits
[17:28:26.558]             invokeRestart <- base::invokeRestart
[17:28:26.558]             length <- base::length
[17:28:26.558]             list <- base::list
[17:28:26.558]             seq.int <- base::seq.int
[17:28:26.558]             signalCondition <- base::signalCondition
[17:28:26.558]             sys.calls <- base::sys.calls
[17:28:26.558]             `[[` <- base::`[[`
[17:28:26.558]             `+` <- base::`+`
[17:28:26.558]             `<<-` <- base::`<<-`
[17:28:26.558]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:26.558]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:26.558]                   3L)]
[17:28:26.558]             }
[17:28:26.558]             function(cond) {
[17:28:26.558]                 is_error <- inherits(cond, "error")
[17:28:26.558]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:26.558]                   NULL)
[17:28:26.558]                 if (is_error) {
[17:28:26.558]                   sessionInformation <- function() {
[17:28:26.558]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:26.558]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:26.558]                       search = base::search(), system = base::Sys.info())
[17:28:26.558]                   }
[17:28:26.558]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.558]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:26.558]                     cond$call), session = sessionInformation(), 
[17:28:26.558]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:26.558]                   signalCondition(cond)
[17:28:26.558]                 }
[17:28:26.558]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:26.558]                 "immediateCondition"))) {
[17:28:26.558]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:26.558]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.558]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:26.558]                   if (TRUE && !signal) {
[17:28:26.558]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.558]                     {
[17:28:26.558]                       inherits <- base::inherits
[17:28:26.558]                       invokeRestart <- base::invokeRestart
[17:28:26.558]                       is.null <- base::is.null
[17:28:26.558]                       muffled <- FALSE
[17:28:26.558]                       if (inherits(cond, "message")) {
[17:28:26.558]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.558]                         if (muffled) 
[17:28:26.558]                           invokeRestart("muffleMessage")
[17:28:26.558]                       }
[17:28:26.558]                       else if (inherits(cond, "warning")) {
[17:28:26.558]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.558]                         if (muffled) 
[17:28:26.558]                           invokeRestart("muffleWarning")
[17:28:26.558]                       }
[17:28:26.558]                       else if (inherits(cond, "condition")) {
[17:28:26.558]                         if (!is.null(pattern)) {
[17:28:26.558]                           computeRestarts <- base::computeRestarts
[17:28:26.558]                           grepl <- base::grepl
[17:28:26.558]                           restarts <- computeRestarts(cond)
[17:28:26.558]                           for (restart in restarts) {
[17:28:26.558]                             name <- restart$name
[17:28:26.558]                             if (is.null(name)) 
[17:28:26.558]                               next
[17:28:26.558]                             if (!grepl(pattern, name)) 
[17:28:26.558]                               next
[17:28:26.558]                             invokeRestart(restart)
[17:28:26.558]                             muffled <- TRUE
[17:28:26.558]                             break
[17:28:26.558]                           }
[17:28:26.558]                         }
[17:28:26.558]                       }
[17:28:26.558]                       invisible(muffled)
[17:28:26.558]                     }
[17:28:26.558]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.558]                   }
[17:28:26.558]                 }
[17:28:26.558]                 else {
[17:28:26.558]                   if (TRUE) {
[17:28:26.558]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.558]                     {
[17:28:26.558]                       inherits <- base::inherits
[17:28:26.558]                       invokeRestart <- base::invokeRestart
[17:28:26.558]                       is.null <- base::is.null
[17:28:26.558]                       muffled <- FALSE
[17:28:26.558]                       if (inherits(cond, "message")) {
[17:28:26.558]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.558]                         if (muffled) 
[17:28:26.558]                           invokeRestart("muffleMessage")
[17:28:26.558]                       }
[17:28:26.558]                       else if (inherits(cond, "warning")) {
[17:28:26.558]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.558]                         if (muffled) 
[17:28:26.558]                           invokeRestart("muffleWarning")
[17:28:26.558]                       }
[17:28:26.558]                       else if (inherits(cond, "condition")) {
[17:28:26.558]                         if (!is.null(pattern)) {
[17:28:26.558]                           computeRestarts <- base::computeRestarts
[17:28:26.558]                           grepl <- base::grepl
[17:28:26.558]                           restarts <- computeRestarts(cond)
[17:28:26.558]                           for (restart in restarts) {
[17:28:26.558]                             name <- restart$name
[17:28:26.558]                             if (is.null(name)) 
[17:28:26.558]                               next
[17:28:26.558]                             if (!grepl(pattern, name)) 
[17:28:26.558]                               next
[17:28:26.558]                             invokeRestart(restart)
[17:28:26.558]                             muffled <- TRUE
[17:28:26.558]                             break
[17:28:26.558]                           }
[17:28:26.558]                         }
[17:28:26.558]                       }
[17:28:26.558]                       invisible(muffled)
[17:28:26.558]                     }
[17:28:26.558]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.558]                   }
[17:28:26.558]                 }
[17:28:26.558]             }
[17:28:26.558]         }))
[17:28:26.558]     }, error = function(ex) {
[17:28:26.558]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:26.558]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.558]                 ...future.rng), started = ...future.startTime, 
[17:28:26.558]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:26.558]             version = "1.8"), class = "FutureResult")
[17:28:26.558]     }, finally = {
[17:28:26.558]         if (!identical(...future.workdir, getwd())) 
[17:28:26.558]             setwd(...future.workdir)
[17:28:26.558]         {
[17:28:26.558]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:26.558]                 ...future.oldOptions$nwarnings <- NULL
[17:28:26.558]             }
[17:28:26.558]             base::options(...future.oldOptions)
[17:28:26.558]             if (.Platform$OS.type == "windows") {
[17:28:26.558]                 old_names <- names(...future.oldEnvVars)
[17:28:26.558]                 envs <- base::Sys.getenv()
[17:28:26.558]                 names <- names(envs)
[17:28:26.558]                 common <- intersect(names, old_names)
[17:28:26.558]                 added <- setdiff(names, old_names)
[17:28:26.558]                 removed <- setdiff(old_names, names)
[17:28:26.558]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:26.558]                   envs[common]]
[17:28:26.558]                 NAMES <- toupper(changed)
[17:28:26.558]                 args <- list()
[17:28:26.558]                 for (kk in seq_along(NAMES)) {
[17:28:26.558]                   name <- changed[[kk]]
[17:28:26.558]                   NAME <- NAMES[[kk]]
[17:28:26.558]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.558]                     next
[17:28:26.558]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.558]                 }
[17:28:26.558]                 NAMES <- toupper(added)
[17:28:26.558]                 for (kk in seq_along(NAMES)) {
[17:28:26.558]                   name <- added[[kk]]
[17:28:26.558]                   NAME <- NAMES[[kk]]
[17:28:26.558]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.558]                     next
[17:28:26.558]                   args[[name]] <- ""
[17:28:26.558]                 }
[17:28:26.558]                 NAMES <- toupper(removed)
[17:28:26.558]                 for (kk in seq_along(NAMES)) {
[17:28:26.558]                   name <- removed[[kk]]
[17:28:26.558]                   NAME <- NAMES[[kk]]
[17:28:26.558]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.558]                     next
[17:28:26.558]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.558]                 }
[17:28:26.558]                 if (length(args) > 0) 
[17:28:26.558]                   base::do.call(base::Sys.setenv, args = args)
[17:28:26.558]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:26.558]             }
[17:28:26.558]             else {
[17:28:26.558]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:26.558]             }
[17:28:26.558]             {
[17:28:26.558]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:26.558]                   0L) {
[17:28:26.558]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:26.558]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:26.558]                   base::options(opts)
[17:28:26.558]                 }
[17:28:26.558]                 {
[17:28:26.558]                   {
[17:28:26.558]                     NULL
[17:28:26.558]                     RNGkind("Mersenne-Twister")
[17:28:26.558]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:26.558]                       inherits = FALSE)
[17:28:26.558]                   }
[17:28:26.558]                   options(future.plan = NULL)
[17:28:26.558]                   if (is.na(NA_character_)) 
[17:28:26.558]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.558]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:26.558]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:26.558]                     .init = FALSE)
[17:28:26.558]                 }
[17:28:26.558]             }
[17:28:26.558]         }
[17:28:26.558]     })
[17:28:26.558]     if (TRUE) {
[17:28:26.558]         base::sink(type = "output", split = FALSE)
[17:28:26.558]         if (TRUE) {
[17:28:26.558]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:26.558]         }
[17:28:26.558]         else {
[17:28:26.558]             ...future.result["stdout"] <- base::list(NULL)
[17:28:26.558]         }
[17:28:26.558]         base::close(...future.stdout)
[17:28:26.558]         ...future.stdout <- NULL
[17:28:26.558]     }
[17:28:26.558]     ...future.result$conditions <- ...future.conditions
[17:28:26.558]     ...future.result$finished <- base::Sys.time()
[17:28:26.558]     ...future.result
[17:28:26.558] }
[17:28:26.562] plan(): Setting new future strategy stack:
[17:28:26.562] List of future strategies:
[17:28:26.562] 1. sequential:
[17:28:26.562]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.562]    - tweaked: FALSE
[17:28:26.562]    - call: NULL
[17:28:26.563] plan(): nbrOfWorkers() = 1
[17:28:26.565] plan(): Setting new future strategy stack:
[17:28:26.565] List of future strategies:
[17:28:26.565] 1. sequential:
[17:28:26.565]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.565]    - tweaked: FALSE
[17:28:26.565]    - call: plan(strategy)
[17:28:26.566] plan(): nbrOfWorkers() = 1
[17:28:26.566] SequentialFuture started (and completed)
[17:28:26.566] - Launch lazy future ... done
[17:28:26.566] 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:28:26.567] getGlobalsAndPackages() ...
[17:28:26.567] Searching for globals...
[17:28:26.568] - globals found: [1] 'print'
[17:28:26.568] Searching for globals ... DONE
[17:28:26.568] Resolving globals: FALSE
[17:28:26.569] 
[17:28:26.569] 
[17:28:26.569] getGlobalsAndPackages() ... DONE
[17:28:26.569] run() for 'Future' ...
[17:28:26.569] - state: 'created'
[17:28:26.570] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:26.570] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:26.570] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:26.570]   - Field: 'label'
[17:28:26.570]   - Field: 'local'
[17:28:26.571]   - Field: 'owner'
[17:28:26.571]   - Field: 'envir'
[17:28:26.571]   - Field: 'packages'
[17:28:26.571]   - Field: 'gc'
[17:28:26.571]   - Field: 'conditions'
[17:28:26.571]   - Field: 'expr'
[17:28:26.572]   - Field: 'uuid'
[17:28:26.572]   - Field: 'seed'
[17:28:26.572]   - Field: 'version'
[17:28:26.572]   - Field: 'result'
[17:28:26.572]   - Field: 'asynchronous'
[17:28:26.572]   - Field: 'calls'
[17:28:26.573]   - Field: 'globals'
[17:28:26.573]   - Field: 'stdout'
[17:28:26.573]   - Field: 'earlySignal'
[17:28:26.573]   - Field: 'lazy'
[17:28:26.573]   - Field: 'state'
[17:28:26.573] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:26.574] - Launch lazy future ...
[17:28:26.574] Packages needed by the future expression (n = 0): <none>
[17:28:26.574] Packages needed by future strategies (n = 0): <none>
[17:28:26.575] {
[17:28:26.575]     {
[17:28:26.575]         {
[17:28:26.575]             ...future.startTime <- base::Sys.time()
[17:28:26.575]             {
[17:28:26.575]                 {
[17:28:26.575]                   {
[17:28:26.575]                     base::local({
[17:28:26.575]                       has_future <- base::requireNamespace("future", 
[17:28:26.575]                         quietly = TRUE)
[17:28:26.575]                       if (has_future) {
[17:28:26.575]                         ns <- base::getNamespace("future")
[17:28:26.575]                         version <- ns[[".package"]][["version"]]
[17:28:26.575]                         if (is.null(version)) 
[17:28:26.575]                           version <- utils::packageVersion("future")
[17:28:26.575]                       }
[17:28:26.575]                       else {
[17:28:26.575]                         version <- NULL
[17:28:26.575]                       }
[17:28:26.575]                       if (!has_future || version < "1.8.0") {
[17:28:26.575]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:26.575]                           "", base::R.version$version.string), 
[17:28:26.575]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:26.575]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:26.575]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:26.575]                             "release", "version")], collapse = " "), 
[17:28:26.575]                           hostname = base::Sys.info()[["nodename"]])
[17:28:26.575]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:26.575]                           info)
[17:28:26.575]                         info <- base::paste(info, collapse = "; ")
[17:28:26.575]                         if (!has_future) {
[17:28:26.575]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:26.575]                             info)
[17:28:26.575]                         }
[17:28:26.575]                         else {
[17:28:26.575]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:26.575]                             info, version)
[17:28:26.575]                         }
[17:28:26.575]                         base::stop(msg)
[17:28:26.575]                       }
[17:28:26.575]                     })
[17:28:26.575]                   }
[17:28:26.575]                   ...future.strategy.old <- future::plan("list")
[17:28:26.575]                   options(future.plan = NULL)
[17:28:26.575]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.575]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:26.575]                 }
[17:28:26.575]                 ...future.workdir <- getwd()
[17:28:26.575]             }
[17:28:26.575]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:26.575]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:26.575]         }
[17:28:26.575]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:26.575]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:26.575]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:26.575]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:26.575]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:26.575]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:26.575]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:26.575]             base::names(...future.oldOptions))
[17:28:26.575]     }
[17:28:26.575]     if (FALSE) {
[17:28:26.575]     }
[17:28:26.575]     else {
[17:28:26.575]         if (TRUE) {
[17:28:26.575]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:26.575]                 open = "w")
[17:28:26.575]         }
[17:28:26.575]         else {
[17:28:26.575]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:26.575]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:26.575]         }
[17:28:26.575]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:26.575]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:26.575]             base::sink(type = "output", split = FALSE)
[17:28:26.575]             base::close(...future.stdout)
[17:28:26.575]         }, add = TRUE)
[17:28:26.575]     }
[17:28:26.575]     ...future.frame <- base::sys.nframe()
[17:28:26.575]     ...future.conditions <- base::list()
[17:28:26.575]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:26.575]     if (FALSE) {
[17:28:26.575]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:26.575]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:26.575]     }
[17:28:26.575]     ...future.result <- base::tryCatch({
[17:28:26.575]         base::withCallingHandlers({
[17:28:26.575]             ...future.value <- base::withVisible(base::local(print(42)))
[17:28:26.575]             future::FutureResult(value = ...future.value$value, 
[17:28:26.575]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.575]                   ...future.rng), globalenv = if (FALSE) 
[17:28:26.575]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:26.575]                     ...future.globalenv.names))
[17:28:26.575]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:26.575]         }, condition = base::local({
[17:28:26.575]             c <- base::c
[17:28:26.575]             inherits <- base::inherits
[17:28:26.575]             invokeRestart <- base::invokeRestart
[17:28:26.575]             length <- base::length
[17:28:26.575]             list <- base::list
[17:28:26.575]             seq.int <- base::seq.int
[17:28:26.575]             signalCondition <- base::signalCondition
[17:28:26.575]             sys.calls <- base::sys.calls
[17:28:26.575]             `[[` <- base::`[[`
[17:28:26.575]             `+` <- base::`+`
[17:28:26.575]             `<<-` <- base::`<<-`
[17:28:26.575]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:26.575]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:26.575]                   3L)]
[17:28:26.575]             }
[17:28:26.575]             function(cond) {
[17:28:26.575]                 is_error <- inherits(cond, "error")
[17:28:26.575]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:26.575]                   NULL)
[17:28:26.575]                 if (is_error) {
[17:28:26.575]                   sessionInformation <- function() {
[17:28:26.575]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:26.575]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:26.575]                       search = base::search(), system = base::Sys.info())
[17:28:26.575]                   }
[17:28:26.575]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.575]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:26.575]                     cond$call), session = sessionInformation(), 
[17:28:26.575]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:26.575]                   signalCondition(cond)
[17:28:26.575]                 }
[17:28:26.575]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:26.575]                 "immediateCondition"))) {
[17:28:26.575]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:26.575]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.575]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:26.575]                   if (TRUE && !signal) {
[17:28:26.575]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.575]                     {
[17:28:26.575]                       inherits <- base::inherits
[17:28:26.575]                       invokeRestart <- base::invokeRestart
[17:28:26.575]                       is.null <- base::is.null
[17:28:26.575]                       muffled <- FALSE
[17:28:26.575]                       if (inherits(cond, "message")) {
[17:28:26.575]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.575]                         if (muffled) 
[17:28:26.575]                           invokeRestart("muffleMessage")
[17:28:26.575]                       }
[17:28:26.575]                       else if (inherits(cond, "warning")) {
[17:28:26.575]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.575]                         if (muffled) 
[17:28:26.575]                           invokeRestart("muffleWarning")
[17:28:26.575]                       }
[17:28:26.575]                       else if (inherits(cond, "condition")) {
[17:28:26.575]                         if (!is.null(pattern)) {
[17:28:26.575]                           computeRestarts <- base::computeRestarts
[17:28:26.575]                           grepl <- base::grepl
[17:28:26.575]                           restarts <- computeRestarts(cond)
[17:28:26.575]                           for (restart in restarts) {
[17:28:26.575]                             name <- restart$name
[17:28:26.575]                             if (is.null(name)) 
[17:28:26.575]                               next
[17:28:26.575]                             if (!grepl(pattern, name)) 
[17:28:26.575]                               next
[17:28:26.575]                             invokeRestart(restart)
[17:28:26.575]                             muffled <- TRUE
[17:28:26.575]                             break
[17:28:26.575]                           }
[17:28:26.575]                         }
[17:28:26.575]                       }
[17:28:26.575]                       invisible(muffled)
[17:28:26.575]                     }
[17:28:26.575]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.575]                   }
[17:28:26.575]                 }
[17:28:26.575]                 else {
[17:28:26.575]                   if (TRUE) {
[17:28:26.575]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.575]                     {
[17:28:26.575]                       inherits <- base::inherits
[17:28:26.575]                       invokeRestart <- base::invokeRestart
[17:28:26.575]                       is.null <- base::is.null
[17:28:26.575]                       muffled <- FALSE
[17:28:26.575]                       if (inherits(cond, "message")) {
[17:28:26.575]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.575]                         if (muffled) 
[17:28:26.575]                           invokeRestart("muffleMessage")
[17:28:26.575]                       }
[17:28:26.575]                       else if (inherits(cond, "warning")) {
[17:28:26.575]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.575]                         if (muffled) 
[17:28:26.575]                           invokeRestart("muffleWarning")
[17:28:26.575]                       }
[17:28:26.575]                       else if (inherits(cond, "condition")) {
[17:28:26.575]                         if (!is.null(pattern)) {
[17:28:26.575]                           computeRestarts <- base::computeRestarts
[17:28:26.575]                           grepl <- base::grepl
[17:28:26.575]                           restarts <- computeRestarts(cond)
[17:28:26.575]                           for (restart in restarts) {
[17:28:26.575]                             name <- restart$name
[17:28:26.575]                             if (is.null(name)) 
[17:28:26.575]                               next
[17:28:26.575]                             if (!grepl(pattern, name)) 
[17:28:26.575]                               next
[17:28:26.575]                             invokeRestart(restart)
[17:28:26.575]                             muffled <- TRUE
[17:28:26.575]                             break
[17:28:26.575]                           }
[17:28:26.575]                         }
[17:28:26.575]                       }
[17:28:26.575]                       invisible(muffled)
[17:28:26.575]                     }
[17:28:26.575]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.575]                   }
[17:28:26.575]                 }
[17:28:26.575]             }
[17:28:26.575]         }))
[17:28:26.575]     }, error = function(ex) {
[17:28:26.575]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:26.575]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.575]                 ...future.rng), started = ...future.startTime, 
[17:28:26.575]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:26.575]             version = "1.8"), class = "FutureResult")
[17:28:26.575]     }, finally = {
[17:28:26.575]         if (!identical(...future.workdir, getwd())) 
[17:28:26.575]             setwd(...future.workdir)
[17:28:26.575]         {
[17:28:26.575]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:26.575]                 ...future.oldOptions$nwarnings <- NULL
[17:28:26.575]             }
[17:28:26.575]             base::options(...future.oldOptions)
[17:28:26.575]             if (.Platform$OS.type == "windows") {
[17:28:26.575]                 old_names <- names(...future.oldEnvVars)
[17:28:26.575]                 envs <- base::Sys.getenv()
[17:28:26.575]                 names <- names(envs)
[17:28:26.575]                 common <- intersect(names, old_names)
[17:28:26.575]                 added <- setdiff(names, old_names)
[17:28:26.575]                 removed <- setdiff(old_names, names)
[17:28:26.575]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:26.575]                   envs[common]]
[17:28:26.575]                 NAMES <- toupper(changed)
[17:28:26.575]                 args <- list()
[17:28:26.575]                 for (kk in seq_along(NAMES)) {
[17:28:26.575]                   name <- changed[[kk]]
[17:28:26.575]                   NAME <- NAMES[[kk]]
[17:28:26.575]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.575]                     next
[17:28:26.575]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.575]                 }
[17:28:26.575]                 NAMES <- toupper(added)
[17:28:26.575]                 for (kk in seq_along(NAMES)) {
[17:28:26.575]                   name <- added[[kk]]
[17:28:26.575]                   NAME <- NAMES[[kk]]
[17:28:26.575]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.575]                     next
[17:28:26.575]                   args[[name]] <- ""
[17:28:26.575]                 }
[17:28:26.575]                 NAMES <- toupper(removed)
[17:28:26.575]                 for (kk in seq_along(NAMES)) {
[17:28:26.575]                   name <- removed[[kk]]
[17:28:26.575]                   NAME <- NAMES[[kk]]
[17:28:26.575]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.575]                     next
[17:28:26.575]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.575]                 }
[17:28:26.575]                 if (length(args) > 0) 
[17:28:26.575]                   base::do.call(base::Sys.setenv, args = args)
[17:28:26.575]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:26.575]             }
[17:28:26.575]             else {
[17:28:26.575]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:26.575]             }
[17:28:26.575]             {
[17:28:26.575]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:26.575]                   0L) {
[17:28:26.575]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:26.575]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:26.575]                   base::options(opts)
[17:28:26.575]                 }
[17:28:26.575]                 {
[17:28:26.575]                   {
[17:28:26.575]                     NULL
[17:28:26.575]                     RNGkind("Mersenne-Twister")
[17:28:26.575]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:26.575]                       inherits = FALSE)
[17:28:26.575]                   }
[17:28:26.575]                   options(future.plan = NULL)
[17:28:26.575]                   if (is.na(NA_character_)) 
[17:28:26.575]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.575]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:26.575]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:26.575]                     .init = FALSE)
[17:28:26.575]                 }
[17:28:26.575]             }
[17:28:26.575]         }
[17:28:26.575]     })
[17:28:26.575]     if (TRUE) {
[17:28:26.575]         base::sink(type = "output", split = FALSE)
[17:28:26.575]         if (TRUE) {
[17:28:26.575]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:26.575]         }
[17:28:26.575]         else {
[17:28:26.575]             ...future.result["stdout"] <- base::list(NULL)
[17:28:26.575]         }
[17:28:26.575]         base::close(...future.stdout)
[17:28:26.575]         ...future.stdout <- NULL
[17:28:26.575]     }
[17:28:26.575]     ...future.result$conditions <- ...future.conditions
[17:28:26.575]     ...future.result$finished <- base::Sys.time()
[17:28:26.575]     ...future.result
[17:28:26.575] }
[17:28:26.578] plan(): Setting new future strategy stack:
[17:28:26.579] List of future strategies:
[17:28:26.579] 1. sequential:
[17:28:26.579]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.579]    - tweaked: FALSE
[17:28:26.579]    - call: NULL
[17:28:26.579] plan(): nbrOfWorkers() = 1
[17:28:26.580] plan(): Setting new future strategy stack:
[17:28:26.581] List of future strategies:
[17:28:26.581] 1. sequential:
[17:28:26.581]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.581]    - tweaked: FALSE
[17:28:26.581]    - call: plan(strategy)
[17:28:26.581] plan(): nbrOfWorkers() = 1
[17:28:26.581] SequentialFuture started (and completed)
[17:28:26.582] - Launch lazy future ... done
[17:28:26.582] run() for 'SequentialFuture' ... done
[1] 42
- stdout = FALSE
[17:28:26.582] getGlobalsAndPackages() ...
[17:28:26.582] Searching for globals...
[17:28:26.587] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:28:26.587] Searching for globals ... DONE
[17:28:26.587] Resolving globals: FALSE
[17:28:26.588] 
[17:28:26.588] - packages: [1] 'utils'
[17:28:26.588] getGlobalsAndPackages() ... DONE
[17:28:26.588] run() for 'Future' ...
[17:28:26.589] - state: 'created'
[17:28:26.589] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:26.589] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:26.589] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:26.589]   - Field: 'label'
[17:28:26.590]   - Field: 'local'
[17:28:26.590]   - Field: 'owner'
[17:28:26.590]   - Field: 'envir'
[17:28:26.590]   - Field: 'packages'
[17:28:26.590]   - Field: 'gc'
[17:28:26.591]   - Field: 'conditions'
[17:28:26.591]   - Field: 'expr'
[17:28:26.591]   - Field: 'uuid'
[17:28:26.591]   - Field: 'seed'
[17:28:26.591]   - Field: 'version'
[17:28:26.591]   - Field: 'result'
[17:28:26.592]   - Field: 'asynchronous'
[17:28:26.592]   - Field: 'calls'
[17:28:26.592]   - Field: 'globals'
[17:28:26.592]   - Field: 'stdout'
[17:28:26.592]   - Field: 'earlySignal'
[17:28:26.592]   - Field: 'lazy'
[17:28:26.593]   - Field: 'state'
[17:28:26.593] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:26.593] - Launch lazy future ...
[17:28:26.593] Packages needed by the future expression (n = 1): 'utils'
[17:28:26.593] Packages needed by future strategies (n = 0): <none>
[17:28:26.594] {
[17:28:26.594]     {
[17:28:26.594]         {
[17:28:26.594]             ...future.startTime <- base::Sys.time()
[17:28:26.594]             {
[17:28:26.594]                 {
[17:28:26.594]                   {
[17:28:26.594]                     {
[17:28:26.594]                       base::local({
[17:28:26.594]                         has_future <- base::requireNamespace("future", 
[17:28:26.594]                           quietly = TRUE)
[17:28:26.594]                         if (has_future) {
[17:28:26.594]                           ns <- base::getNamespace("future")
[17:28:26.594]                           version <- ns[[".package"]][["version"]]
[17:28:26.594]                           if (is.null(version)) 
[17:28:26.594]                             version <- utils::packageVersion("future")
[17:28:26.594]                         }
[17:28:26.594]                         else {
[17:28:26.594]                           version <- NULL
[17:28:26.594]                         }
[17:28:26.594]                         if (!has_future || version < "1.8.0") {
[17:28:26.594]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:26.594]                             "", base::R.version$version.string), 
[17:28:26.594]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:26.594]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:26.594]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:26.594]                               "release", "version")], collapse = " "), 
[17:28:26.594]                             hostname = base::Sys.info()[["nodename"]])
[17:28:26.594]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:26.594]                             info)
[17:28:26.594]                           info <- base::paste(info, collapse = "; ")
[17:28:26.594]                           if (!has_future) {
[17:28:26.594]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:26.594]                               info)
[17:28:26.594]                           }
[17:28:26.594]                           else {
[17:28:26.594]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:26.594]                               info, version)
[17:28:26.594]                           }
[17:28:26.594]                           base::stop(msg)
[17:28:26.594]                         }
[17:28:26.594]                       })
[17:28:26.594]                     }
[17:28:26.594]                     base::local({
[17:28:26.594]                       for (pkg in "utils") {
[17:28:26.594]                         base::loadNamespace(pkg)
[17:28:26.594]                         base::library(pkg, character.only = TRUE)
[17:28:26.594]                       }
[17:28:26.594]                     })
[17:28:26.594]                   }
[17:28:26.594]                   ...future.strategy.old <- future::plan("list")
[17:28:26.594]                   options(future.plan = NULL)
[17:28:26.594]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.594]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:26.594]                 }
[17:28:26.594]                 ...future.workdir <- getwd()
[17:28:26.594]             }
[17:28:26.594]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:26.594]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:26.594]         }
[17:28:26.594]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:26.594]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:26.594]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:26.594]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:26.594]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:26.594]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:26.594]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:26.594]             base::names(...future.oldOptions))
[17:28:26.594]     }
[17:28:26.594]     if (FALSE) {
[17:28:26.594]     }
[17:28:26.594]     else {
[17:28:26.594]         if (FALSE) {
[17:28:26.594]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:26.594]                 open = "w")
[17:28:26.594]         }
[17:28:26.594]         else {
[17:28:26.594]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:26.594]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:26.594]         }
[17:28:26.594]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:26.594]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:26.594]             base::sink(type = "output", split = FALSE)
[17:28:26.594]             base::close(...future.stdout)
[17:28:26.594]         }, add = TRUE)
[17:28:26.594]     }
[17:28:26.594]     ...future.frame <- base::sys.nframe()
[17:28:26.594]     ...future.conditions <- base::list()
[17:28:26.594]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:26.594]     if (FALSE) {
[17:28:26.594]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:26.594]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:26.594]     }
[17:28:26.594]     ...future.result <- base::tryCatch({
[17:28:26.594]         base::withCallingHandlers({
[17:28:26.594]             ...future.value <- base::withVisible(base::local({
[17:28:26.594]                 print(1:50)
[17:28:26.594]                 str(1:50)
[17:28:26.594]                 cat(letters, sep = "-")
[17:28:26.594]                 cat(1:6, collapse = "\n")
[17:28:26.594]                 write.table(datasets::iris[1:10, ], sep = "\t")
[17:28:26.594]                 42L
[17:28:26.594]             }))
[17:28:26.594]             future::FutureResult(value = ...future.value$value, 
[17:28:26.594]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.594]                   ...future.rng), globalenv = if (FALSE) 
[17:28:26.594]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:26.594]                     ...future.globalenv.names))
[17:28:26.594]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:26.594]         }, condition = base::local({
[17:28:26.594]             c <- base::c
[17:28:26.594]             inherits <- base::inherits
[17:28:26.594]             invokeRestart <- base::invokeRestart
[17:28:26.594]             length <- base::length
[17:28:26.594]             list <- base::list
[17:28:26.594]             seq.int <- base::seq.int
[17:28:26.594]             signalCondition <- base::signalCondition
[17:28:26.594]             sys.calls <- base::sys.calls
[17:28:26.594]             `[[` <- base::`[[`
[17:28:26.594]             `+` <- base::`+`
[17:28:26.594]             `<<-` <- base::`<<-`
[17:28:26.594]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:26.594]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:26.594]                   3L)]
[17:28:26.594]             }
[17:28:26.594]             function(cond) {
[17:28:26.594]                 is_error <- inherits(cond, "error")
[17:28:26.594]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:26.594]                   NULL)
[17:28:26.594]                 if (is_error) {
[17:28:26.594]                   sessionInformation <- function() {
[17:28:26.594]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:26.594]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:26.594]                       search = base::search(), system = base::Sys.info())
[17:28:26.594]                   }
[17:28:26.594]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.594]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:26.594]                     cond$call), session = sessionInformation(), 
[17:28:26.594]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:26.594]                   signalCondition(cond)
[17:28:26.594]                 }
[17:28:26.594]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:26.594]                 "immediateCondition"))) {
[17:28:26.594]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:26.594]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.594]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:26.594]                   if (TRUE && !signal) {
[17:28:26.594]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.594]                     {
[17:28:26.594]                       inherits <- base::inherits
[17:28:26.594]                       invokeRestart <- base::invokeRestart
[17:28:26.594]                       is.null <- base::is.null
[17:28:26.594]                       muffled <- FALSE
[17:28:26.594]                       if (inherits(cond, "message")) {
[17:28:26.594]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.594]                         if (muffled) 
[17:28:26.594]                           invokeRestart("muffleMessage")
[17:28:26.594]                       }
[17:28:26.594]                       else if (inherits(cond, "warning")) {
[17:28:26.594]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.594]                         if (muffled) 
[17:28:26.594]                           invokeRestart("muffleWarning")
[17:28:26.594]                       }
[17:28:26.594]                       else if (inherits(cond, "condition")) {
[17:28:26.594]                         if (!is.null(pattern)) {
[17:28:26.594]                           computeRestarts <- base::computeRestarts
[17:28:26.594]                           grepl <- base::grepl
[17:28:26.594]                           restarts <- computeRestarts(cond)
[17:28:26.594]                           for (restart in restarts) {
[17:28:26.594]                             name <- restart$name
[17:28:26.594]                             if (is.null(name)) 
[17:28:26.594]                               next
[17:28:26.594]                             if (!grepl(pattern, name)) 
[17:28:26.594]                               next
[17:28:26.594]                             invokeRestart(restart)
[17:28:26.594]                             muffled <- TRUE
[17:28:26.594]                             break
[17:28:26.594]                           }
[17:28:26.594]                         }
[17:28:26.594]                       }
[17:28:26.594]                       invisible(muffled)
[17:28:26.594]                     }
[17:28:26.594]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.594]                   }
[17:28:26.594]                 }
[17:28:26.594]                 else {
[17:28:26.594]                   if (TRUE) {
[17:28:26.594]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.594]                     {
[17:28:26.594]                       inherits <- base::inherits
[17:28:26.594]                       invokeRestart <- base::invokeRestart
[17:28:26.594]                       is.null <- base::is.null
[17:28:26.594]                       muffled <- FALSE
[17:28:26.594]                       if (inherits(cond, "message")) {
[17:28:26.594]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.594]                         if (muffled) 
[17:28:26.594]                           invokeRestart("muffleMessage")
[17:28:26.594]                       }
[17:28:26.594]                       else if (inherits(cond, "warning")) {
[17:28:26.594]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.594]                         if (muffled) 
[17:28:26.594]                           invokeRestart("muffleWarning")
[17:28:26.594]                       }
[17:28:26.594]                       else if (inherits(cond, "condition")) {
[17:28:26.594]                         if (!is.null(pattern)) {
[17:28:26.594]                           computeRestarts <- base::computeRestarts
[17:28:26.594]                           grepl <- base::grepl
[17:28:26.594]                           restarts <- computeRestarts(cond)
[17:28:26.594]                           for (restart in restarts) {
[17:28:26.594]                             name <- restart$name
[17:28:26.594]                             if (is.null(name)) 
[17:28:26.594]                               next
[17:28:26.594]                             if (!grepl(pattern, name)) 
[17:28:26.594]                               next
[17:28:26.594]                             invokeRestart(restart)
[17:28:26.594]                             muffled <- TRUE
[17:28:26.594]                             break
[17:28:26.594]                           }
[17:28:26.594]                         }
[17:28:26.594]                       }
[17:28:26.594]                       invisible(muffled)
[17:28:26.594]                     }
[17:28:26.594]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.594]                   }
[17:28:26.594]                 }
[17:28:26.594]             }
[17:28:26.594]         }))
[17:28:26.594]     }, error = function(ex) {
[17:28:26.594]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:26.594]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.594]                 ...future.rng), started = ...future.startTime, 
[17:28:26.594]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:26.594]             version = "1.8"), class = "FutureResult")
[17:28:26.594]     }, finally = {
[17:28:26.594]         if (!identical(...future.workdir, getwd())) 
[17:28:26.594]             setwd(...future.workdir)
[17:28:26.594]         {
[17:28:26.594]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:26.594]                 ...future.oldOptions$nwarnings <- NULL
[17:28:26.594]             }
[17:28:26.594]             base::options(...future.oldOptions)
[17:28:26.594]             if (.Platform$OS.type == "windows") {
[17:28:26.594]                 old_names <- names(...future.oldEnvVars)
[17:28:26.594]                 envs <- base::Sys.getenv()
[17:28:26.594]                 names <- names(envs)
[17:28:26.594]                 common <- intersect(names, old_names)
[17:28:26.594]                 added <- setdiff(names, old_names)
[17:28:26.594]                 removed <- setdiff(old_names, names)
[17:28:26.594]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:26.594]                   envs[common]]
[17:28:26.594]                 NAMES <- toupper(changed)
[17:28:26.594]                 args <- list()
[17:28:26.594]                 for (kk in seq_along(NAMES)) {
[17:28:26.594]                   name <- changed[[kk]]
[17:28:26.594]                   NAME <- NAMES[[kk]]
[17:28:26.594]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.594]                     next
[17:28:26.594]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.594]                 }
[17:28:26.594]                 NAMES <- toupper(added)
[17:28:26.594]                 for (kk in seq_along(NAMES)) {
[17:28:26.594]                   name <- added[[kk]]
[17:28:26.594]                   NAME <- NAMES[[kk]]
[17:28:26.594]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.594]                     next
[17:28:26.594]                   args[[name]] <- ""
[17:28:26.594]                 }
[17:28:26.594]                 NAMES <- toupper(removed)
[17:28:26.594]                 for (kk in seq_along(NAMES)) {
[17:28:26.594]                   name <- removed[[kk]]
[17:28:26.594]                   NAME <- NAMES[[kk]]
[17:28:26.594]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.594]                     next
[17:28:26.594]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.594]                 }
[17:28:26.594]                 if (length(args) > 0) 
[17:28:26.594]                   base::do.call(base::Sys.setenv, args = args)
[17:28:26.594]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:26.594]             }
[17:28:26.594]             else {
[17:28:26.594]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:26.594]             }
[17:28:26.594]             {
[17:28:26.594]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:26.594]                   0L) {
[17:28:26.594]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:26.594]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:26.594]                   base::options(opts)
[17:28:26.594]                 }
[17:28:26.594]                 {
[17:28:26.594]                   {
[17:28:26.594]                     NULL
[17:28:26.594]                     RNGkind("Mersenne-Twister")
[17:28:26.594]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:26.594]                       inherits = FALSE)
[17:28:26.594]                   }
[17:28:26.594]                   options(future.plan = NULL)
[17:28:26.594]                   if (is.na(NA_character_)) 
[17:28:26.594]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.594]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:26.594]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:26.594]                     .init = FALSE)
[17:28:26.594]                 }
[17:28:26.594]             }
[17:28:26.594]         }
[17:28:26.594]     })
[17:28:26.594]     if (TRUE) {
[17:28:26.594]         base::sink(type = "output", split = FALSE)
[17:28:26.594]         if (FALSE) {
[17:28:26.594]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:26.594]         }
[17:28:26.594]         else {
[17:28:26.594]             ...future.result["stdout"] <- base::list(NULL)
[17:28:26.594]         }
[17:28:26.594]         base::close(...future.stdout)
[17:28:26.594]         ...future.stdout <- NULL
[17:28:26.594]     }
[17:28:26.594]     ...future.result$conditions <- ...future.conditions
[17:28:26.594]     ...future.result$finished <- base::Sys.time()
[17:28:26.594]     ...future.result
[17:28:26.594] }
[17:28:26.598] plan(): Setting new future strategy stack:
[17:28:26.598] List of future strategies:
[17:28:26.598] 1. sequential:
[17:28:26.598]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.598]    - tweaked: FALSE
[17:28:26.598]    - call: NULL
[17:28:26.599] plan(): nbrOfWorkers() = 1
[17:28:26.601] plan(): Setting new future strategy stack:
[17:28:26.601] List of future strategies:
[17:28:26.601] 1. sequential:
[17:28:26.601]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.601]    - tweaked: FALSE
[17:28:26.601]    - call: plan(strategy)
[17:28:26.602] plan(): nbrOfWorkers() = 1
[17:28:26.602] SequentialFuture started (and completed)
[17:28:26.602] - Launch lazy future ... done
[17:28:26.602] 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-03-26 17:28:26"
 $ finished    : POSIXct[1:1], format: "2024-03-26 17:28:26"
 $ session_uuid: chr "4b64b601-8666-ff45-2fee-4b34ef3f3009"
  ..- 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 162072
  .. ..$ time  : POSIXct[1:1], format: "2024-03-26 17:28:26"
  .. ..$ random: int 2147483647
 $ r_info      :List of 4
  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1
  .. ..$ : int [1:3] 4 4 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[17:28:26.612] getGlobalsAndPackages() ...
[17:28:26.612] Searching for globals...
[17:28:26.616] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:28:26.616] Searching for globals ... DONE
[17:28:26.616] Resolving globals: FALSE
[17:28:26.617] 
[17:28:26.617] - packages: [1] 'utils'
[17:28:26.617] getGlobalsAndPackages() ... DONE
[17:28:26.618] run() for 'Future' ...
[17:28:26.618] - state: 'created'
[17:28:26.618] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:26.618] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:26.619] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:26.619]   - Field: 'label'
[17:28:26.619]   - Field: 'local'
[17:28:26.619]   - Field: 'owner'
[17:28:26.619]   - Field: 'envir'
[17:28:26.619]   - Field: 'packages'
[17:28:26.620]   - Field: 'gc'
[17:28:26.620]   - Field: 'conditions'
[17:28:26.620]   - Field: 'expr'
[17:28:26.620]   - Field: 'uuid'
[17:28:26.620]   - Field: 'seed'
[17:28:26.620]   - Field: 'version'
[17:28:26.621]   - Field: 'result'
[17:28:26.621]   - Field: 'asynchronous'
[17:28:26.621]   - Field: 'calls'
[17:28:26.621]   - Field: 'globals'
[17:28:26.621]   - Field: 'stdout'
[17:28:26.621]   - Field: 'earlySignal'
[17:28:26.622]   - Field: 'lazy'
[17:28:26.622]   - Field: 'state'
[17:28:26.622] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:26.622] - Launch lazy future ...
[17:28:26.622] Packages needed by the future expression (n = 1): 'utils'
[17:28:26.623] Packages needed by future strategies (n = 0): <none>
[17:28:26.623] {
[17:28:26.623]     {
[17:28:26.623]         {
[17:28:26.623]             ...future.startTime <- base::Sys.time()
[17:28:26.623]             {
[17:28:26.623]                 {
[17:28:26.623]                   {
[17:28:26.623]                     {
[17:28:26.623]                       base::local({
[17:28:26.623]                         has_future <- base::requireNamespace("future", 
[17:28:26.623]                           quietly = TRUE)
[17:28:26.623]                         if (has_future) {
[17:28:26.623]                           ns <- base::getNamespace("future")
[17:28:26.623]                           version <- ns[[".package"]][["version"]]
[17:28:26.623]                           if (is.null(version)) 
[17:28:26.623]                             version <- utils::packageVersion("future")
[17:28:26.623]                         }
[17:28:26.623]                         else {
[17:28:26.623]                           version <- NULL
[17:28:26.623]                         }
[17:28:26.623]                         if (!has_future || version < "1.8.0") {
[17:28:26.623]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:26.623]                             "", base::R.version$version.string), 
[17:28:26.623]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:26.623]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:26.623]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:26.623]                               "release", "version")], collapse = " "), 
[17:28:26.623]                             hostname = base::Sys.info()[["nodename"]])
[17:28:26.623]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:26.623]                             info)
[17:28:26.623]                           info <- base::paste(info, collapse = "; ")
[17:28:26.623]                           if (!has_future) {
[17:28:26.623]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:26.623]                               info)
[17:28:26.623]                           }
[17:28:26.623]                           else {
[17:28:26.623]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:26.623]                               info, version)
[17:28:26.623]                           }
[17:28:26.623]                           base::stop(msg)
[17:28:26.623]                         }
[17:28:26.623]                       })
[17:28:26.623]                     }
[17:28:26.623]                     base::local({
[17:28:26.623]                       for (pkg in "utils") {
[17:28:26.623]                         base::loadNamespace(pkg)
[17:28:26.623]                         base::library(pkg, character.only = TRUE)
[17:28:26.623]                       }
[17:28:26.623]                     })
[17:28:26.623]                   }
[17:28:26.623]                   ...future.strategy.old <- future::plan("list")
[17:28:26.623]                   options(future.plan = NULL)
[17:28:26.623]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.623]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:26.623]                 }
[17:28:26.623]                 ...future.workdir <- getwd()
[17:28:26.623]             }
[17:28:26.623]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:26.623]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:26.623]         }
[17:28:26.623]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:26.623]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:26.623]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:26.623]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:26.623]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:26.623]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:26.623]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:26.623]             base::names(...future.oldOptions))
[17:28:26.623]     }
[17:28:26.623]     if (FALSE) {
[17:28:26.623]     }
[17:28:26.623]     else {
[17:28:26.623]         if (FALSE) {
[17:28:26.623]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:26.623]                 open = "w")
[17:28:26.623]         }
[17:28:26.623]         else {
[17:28:26.623]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:26.623]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:26.623]         }
[17:28:26.623]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:26.623]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:26.623]             base::sink(type = "output", split = FALSE)
[17:28:26.623]             base::close(...future.stdout)
[17:28:26.623]         }, add = TRUE)
[17:28:26.623]     }
[17:28:26.623]     ...future.frame <- base::sys.nframe()
[17:28:26.623]     ...future.conditions <- base::list()
[17:28:26.623]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:26.623]     if (FALSE) {
[17:28:26.623]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:26.623]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:26.623]     }
[17:28:26.623]     ...future.result <- base::tryCatch({
[17:28:26.623]         base::withCallingHandlers({
[17:28:26.623]             ...future.value <- base::withVisible(base::local({
[17:28:26.623]                 print(1:50)
[17:28:26.623]                 str(1:50)
[17:28:26.623]                 cat(letters, sep = "-")
[17:28:26.623]                 cat(1:6, collapse = "\n")
[17:28:26.623]                 write.table(datasets::iris[1:10, ], sep = "\t")
[17:28:26.623]                 42L
[17:28:26.623]             }))
[17:28:26.623]             future::FutureResult(value = ...future.value$value, 
[17:28:26.623]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.623]                   ...future.rng), globalenv = if (FALSE) 
[17:28:26.623]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:26.623]                     ...future.globalenv.names))
[17:28:26.623]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:26.623]         }, condition = base::local({
[17:28:26.623]             c <- base::c
[17:28:26.623]             inherits <- base::inherits
[17:28:26.623]             invokeRestart <- base::invokeRestart
[17:28:26.623]             length <- base::length
[17:28:26.623]             list <- base::list
[17:28:26.623]             seq.int <- base::seq.int
[17:28:26.623]             signalCondition <- base::signalCondition
[17:28:26.623]             sys.calls <- base::sys.calls
[17:28:26.623]             `[[` <- base::`[[`
[17:28:26.623]             `+` <- base::`+`
[17:28:26.623]             `<<-` <- base::`<<-`
[17:28:26.623]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:26.623]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:26.623]                   3L)]
[17:28:26.623]             }
[17:28:26.623]             function(cond) {
[17:28:26.623]                 is_error <- inherits(cond, "error")
[17:28:26.623]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:26.623]                   NULL)
[17:28:26.623]                 if (is_error) {
[17:28:26.623]                   sessionInformation <- function() {
[17:28:26.623]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:26.623]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:26.623]                       search = base::search(), system = base::Sys.info())
[17:28:26.623]                   }
[17:28:26.623]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.623]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:26.623]                     cond$call), session = sessionInformation(), 
[17:28:26.623]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:26.623]                   signalCondition(cond)
[17:28:26.623]                 }
[17:28:26.623]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:26.623]                 "immediateCondition"))) {
[17:28:26.623]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:26.623]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.623]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:26.623]                   if (TRUE && !signal) {
[17:28:26.623]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.623]                     {
[17:28:26.623]                       inherits <- base::inherits
[17:28:26.623]                       invokeRestart <- base::invokeRestart
[17:28:26.623]                       is.null <- base::is.null
[17:28:26.623]                       muffled <- FALSE
[17:28:26.623]                       if (inherits(cond, "message")) {
[17:28:26.623]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.623]                         if (muffled) 
[17:28:26.623]                           invokeRestart("muffleMessage")
[17:28:26.623]                       }
[17:28:26.623]                       else if (inherits(cond, "warning")) {
[17:28:26.623]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.623]                         if (muffled) 
[17:28:26.623]                           invokeRestart("muffleWarning")
[17:28:26.623]                       }
[17:28:26.623]                       else if (inherits(cond, "condition")) {
[17:28:26.623]                         if (!is.null(pattern)) {
[17:28:26.623]                           computeRestarts <- base::computeRestarts
[17:28:26.623]                           grepl <- base::grepl
[17:28:26.623]                           restarts <- computeRestarts(cond)
[17:28:26.623]                           for (restart in restarts) {
[17:28:26.623]                             name <- restart$name
[17:28:26.623]                             if (is.null(name)) 
[17:28:26.623]                               next
[17:28:26.623]                             if (!grepl(pattern, name)) 
[17:28:26.623]                               next
[17:28:26.623]                             invokeRestart(restart)
[17:28:26.623]                             muffled <- TRUE
[17:28:26.623]                             break
[17:28:26.623]                           }
[17:28:26.623]                         }
[17:28:26.623]                       }
[17:28:26.623]                       invisible(muffled)
[17:28:26.623]                     }
[17:28:26.623]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.623]                   }
[17:28:26.623]                 }
[17:28:26.623]                 else {
[17:28:26.623]                   if (TRUE) {
[17:28:26.623]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.623]                     {
[17:28:26.623]                       inherits <- base::inherits
[17:28:26.623]                       invokeRestart <- base::invokeRestart
[17:28:26.623]                       is.null <- base::is.null
[17:28:26.623]                       muffled <- FALSE
[17:28:26.623]                       if (inherits(cond, "message")) {
[17:28:26.623]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.623]                         if (muffled) 
[17:28:26.623]                           invokeRestart("muffleMessage")
[17:28:26.623]                       }
[17:28:26.623]                       else if (inherits(cond, "warning")) {
[17:28:26.623]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.623]                         if (muffled) 
[17:28:26.623]                           invokeRestart("muffleWarning")
[17:28:26.623]                       }
[17:28:26.623]                       else if (inherits(cond, "condition")) {
[17:28:26.623]                         if (!is.null(pattern)) {
[17:28:26.623]                           computeRestarts <- base::computeRestarts
[17:28:26.623]                           grepl <- base::grepl
[17:28:26.623]                           restarts <- computeRestarts(cond)
[17:28:26.623]                           for (restart in restarts) {
[17:28:26.623]                             name <- restart$name
[17:28:26.623]                             if (is.null(name)) 
[17:28:26.623]                               next
[17:28:26.623]                             if (!grepl(pattern, name)) 
[17:28:26.623]                               next
[17:28:26.623]                             invokeRestart(restart)
[17:28:26.623]                             muffled <- TRUE
[17:28:26.623]                             break
[17:28:26.623]                           }
[17:28:26.623]                         }
[17:28:26.623]                       }
[17:28:26.623]                       invisible(muffled)
[17:28:26.623]                     }
[17:28:26.623]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.623]                   }
[17:28:26.623]                 }
[17:28:26.623]             }
[17:28:26.623]         }))
[17:28:26.623]     }, error = function(ex) {
[17:28:26.623]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:26.623]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.623]                 ...future.rng), started = ...future.startTime, 
[17:28:26.623]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:26.623]             version = "1.8"), class = "FutureResult")
[17:28:26.623]     }, finally = {
[17:28:26.623]         if (!identical(...future.workdir, getwd())) 
[17:28:26.623]             setwd(...future.workdir)
[17:28:26.623]         {
[17:28:26.623]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:26.623]                 ...future.oldOptions$nwarnings <- NULL
[17:28:26.623]             }
[17:28:26.623]             base::options(...future.oldOptions)
[17:28:26.623]             if (.Platform$OS.type == "windows") {
[17:28:26.623]                 old_names <- names(...future.oldEnvVars)
[17:28:26.623]                 envs <- base::Sys.getenv()
[17:28:26.623]                 names <- names(envs)
[17:28:26.623]                 common <- intersect(names, old_names)
[17:28:26.623]                 added <- setdiff(names, old_names)
[17:28:26.623]                 removed <- setdiff(old_names, names)
[17:28:26.623]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:26.623]                   envs[common]]
[17:28:26.623]                 NAMES <- toupper(changed)
[17:28:26.623]                 args <- list()
[17:28:26.623]                 for (kk in seq_along(NAMES)) {
[17:28:26.623]                   name <- changed[[kk]]
[17:28:26.623]                   NAME <- NAMES[[kk]]
[17:28:26.623]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.623]                     next
[17:28:26.623]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.623]                 }
[17:28:26.623]                 NAMES <- toupper(added)
[17:28:26.623]                 for (kk in seq_along(NAMES)) {
[17:28:26.623]                   name <- added[[kk]]
[17:28:26.623]                   NAME <- NAMES[[kk]]
[17:28:26.623]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.623]                     next
[17:28:26.623]                   args[[name]] <- ""
[17:28:26.623]                 }
[17:28:26.623]                 NAMES <- toupper(removed)
[17:28:26.623]                 for (kk in seq_along(NAMES)) {
[17:28:26.623]                   name <- removed[[kk]]
[17:28:26.623]                   NAME <- NAMES[[kk]]
[17:28:26.623]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.623]                     next
[17:28:26.623]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.623]                 }
[17:28:26.623]                 if (length(args) > 0) 
[17:28:26.623]                   base::do.call(base::Sys.setenv, args = args)
[17:28:26.623]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:26.623]             }
[17:28:26.623]             else {
[17:28:26.623]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:26.623]             }
[17:28:26.623]             {
[17:28:26.623]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:26.623]                   0L) {
[17:28:26.623]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:26.623]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:26.623]                   base::options(opts)
[17:28:26.623]                 }
[17:28:26.623]                 {
[17:28:26.623]                   {
[17:28:26.623]                     NULL
[17:28:26.623]                     RNGkind("Mersenne-Twister")
[17:28:26.623]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:26.623]                       inherits = FALSE)
[17:28:26.623]                   }
[17:28:26.623]                   options(future.plan = NULL)
[17:28:26.623]                   if (is.na(NA_character_)) 
[17:28:26.623]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.623]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:26.623]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:26.623]                     .init = FALSE)
[17:28:26.623]                 }
[17:28:26.623]             }
[17:28:26.623]         }
[17:28:26.623]     })
[17:28:26.623]     if (TRUE) {
[17:28:26.623]         base::sink(type = "output", split = FALSE)
[17:28:26.623]         if (FALSE) {
[17:28:26.623]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:26.623]         }
[17:28:26.623]         else {
[17:28:26.623]             ...future.result["stdout"] <- base::list(NULL)
[17:28:26.623]         }
[17:28:26.623]         base::close(...future.stdout)
[17:28:26.623]         ...future.stdout <- NULL
[17:28:26.623]     }
[17:28:26.623]     ...future.result$conditions <- ...future.conditions
[17:28:26.623]     ...future.result$finished <- base::Sys.time()
[17:28:26.623]     ...future.result
[17:28:26.623] }
[17:28:26.627] plan(): Setting new future strategy stack:
[17:28:26.628] List of future strategies:
[17:28:26.628] 1. sequential:
[17:28:26.628]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.628]    - tweaked: FALSE
[17:28:26.628]    - call: NULL
[17:28:26.628] plan(): nbrOfWorkers() = 1
[17:28:26.630] plan(): Setting new future strategy stack:
[17:28:26.630] List of future strategies:
[17:28:26.630] 1. sequential:
[17:28:26.630]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.630]    - tweaked: FALSE
[17:28:26.630]    - call: plan(strategy)
[17:28:26.631] plan(): nbrOfWorkers() = 1
[17:28:26.631] SequentialFuture started (and completed)
[17:28:26.632] - Launch lazy future ... done
[17:28:26.632] run() for 'SequentialFuture' ... done
- stdout = structure(TRUE, drop = TRUE)
[17:28:26.632] getGlobalsAndPackages() ...
[17:28:26.632] Searching for globals...
[17:28:26.633] - globals found: [1] 'print'
[17:28:26.633] Searching for globals ... DONE
[17:28:26.633] Resolving globals: FALSE
[17:28:26.634] 
[17:28:26.634] 
[17:28:26.634] getGlobalsAndPackages() ... DONE
[17:28:26.634] run() for 'Future' ...
[17:28:26.634] - state: 'created'
[17:28:26.635] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:26.635] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:26.635] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:26.635]   - Field: 'label'
[17:28:26.636]   - Field: 'local'
[17:28:26.636]   - Field: 'owner'
[17:28:26.636]   - Field: 'envir'
[17:28:26.636]   - Field: 'packages'
[17:28:26.636]   - Field: 'gc'
[17:28:26.636]   - Field: 'conditions'
[17:28:26.637]   - Field: 'expr'
[17:28:26.637]   - Field: 'uuid'
[17:28:26.637]   - Field: 'seed'
[17:28:26.637]   - Field: 'version'
[17:28:26.637]   - Field: 'result'
[17:28:26.637]   - Field: 'asynchronous'
[17:28:26.638]   - Field: 'calls'
[17:28:26.638]   - Field: 'globals'
[17:28:26.638]   - Field: 'stdout'
[17:28:26.638]   - Field: 'earlySignal'
[17:28:26.638]   - Field: 'lazy'
[17:28:26.638]   - Field: 'state'
[17:28:26.639] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:26.639] - Launch lazy future ...
[17:28:26.639] Packages needed by the future expression (n = 0): <none>
[17:28:26.639] Packages needed by future strategies (n = 0): <none>
[17:28:26.640] {
[17:28:26.640]     {
[17:28:26.640]         {
[17:28:26.640]             ...future.startTime <- base::Sys.time()
[17:28:26.640]             {
[17:28:26.640]                 {
[17:28:26.640]                   {
[17:28:26.640]                     base::local({
[17:28:26.640]                       has_future <- base::requireNamespace("future", 
[17:28:26.640]                         quietly = TRUE)
[17:28:26.640]                       if (has_future) {
[17:28:26.640]                         ns <- base::getNamespace("future")
[17:28:26.640]                         version <- ns[[".package"]][["version"]]
[17:28:26.640]                         if (is.null(version)) 
[17:28:26.640]                           version <- utils::packageVersion("future")
[17:28:26.640]                       }
[17:28:26.640]                       else {
[17:28:26.640]                         version <- NULL
[17:28:26.640]                       }
[17:28:26.640]                       if (!has_future || version < "1.8.0") {
[17:28:26.640]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:26.640]                           "", base::R.version$version.string), 
[17:28:26.640]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:26.640]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:26.640]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:26.640]                             "release", "version")], collapse = " "), 
[17:28:26.640]                           hostname = base::Sys.info()[["nodename"]])
[17:28:26.640]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:26.640]                           info)
[17:28:26.640]                         info <- base::paste(info, collapse = "; ")
[17:28:26.640]                         if (!has_future) {
[17:28:26.640]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:26.640]                             info)
[17:28:26.640]                         }
[17:28:26.640]                         else {
[17:28:26.640]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:26.640]                             info, version)
[17:28:26.640]                         }
[17:28:26.640]                         base::stop(msg)
[17:28:26.640]                       }
[17:28:26.640]                     })
[17:28:26.640]                   }
[17:28:26.640]                   ...future.strategy.old <- future::plan("list")
[17:28:26.640]                   options(future.plan = NULL)
[17:28:26.640]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.640]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:26.640]                 }
[17:28:26.640]                 ...future.workdir <- getwd()
[17:28:26.640]             }
[17:28:26.640]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:26.640]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:26.640]         }
[17:28:26.640]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:26.640]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:26.640]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:26.640]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:26.640]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:26.640]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:26.640]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:26.640]             base::names(...future.oldOptions))
[17:28:26.640]     }
[17:28:26.640]     if (FALSE) {
[17:28:26.640]     }
[17:28:26.640]     else {
[17:28:26.640]         if (TRUE) {
[17:28:26.640]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:26.640]                 open = "w")
[17:28:26.640]         }
[17:28:26.640]         else {
[17:28:26.640]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:26.640]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:26.640]         }
[17:28:26.640]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:26.640]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:26.640]             base::sink(type = "output", split = FALSE)
[17:28:26.640]             base::close(...future.stdout)
[17:28:26.640]         }, add = TRUE)
[17:28:26.640]     }
[17:28:26.640]     ...future.frame <- base::sys.nframe()
[17:28:26.640]     ...future.conditions <- base::list()
[17:28:26.640]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:26.640]     if (FALSE) {
[17:28:26.640]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:26.640]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:26.640]     }
[17:28:26.640]     ...future.result <- base::tryCatch({
[17:28:26.640]         base::withCallingHandlers({
[17:28:26.640]             ...future.value <- base::withVisible(base::local(print(42)))
[17:28:26.640]             future::FutureResult(value = ...future.value$value, 
[17:28:26.640]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.640]                   ...future.rng), globalenv = if (FALSE) 
[17:28:26.640]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:26.640]                     ...future.globalenv.names))
[17:28:26.640]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:26.640]         }, condition = base::local({
[17:28:26.640]             c <- base::c
[17:28:26.640]             inherits <- base::inherits
[17:28:26.640]             invokeRestart <- base::invokeRestart
[17:28:26.640]             length <- base::length
[17:28:26.640]             list <- base::list
[17:28:26.640]             seq.int <- base::seq.int
[17:28:26.640]             signalCondition <- base::signalCondition
[17:28:26.640]             sys.calls <- base::sys.calls
[17:28:26.640]             `[[` <- base::`[[`
[17:28:26.640]             `+` <- base::`+`
[17:28:26.640]             `<<-` <- base::`<<-`
[17:28:26.640]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:26.640]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:26.640]                   3L)]
[17:28:26.640]             }
[17:28:26.640]             function(cond) {
[17:28:26.640]                 is_error <- inherits(cond, "error")
[17:28:26.640]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:26.640]                   NULL)
[17:28:26.640]                 if (is_error) {
[17:28:26.640]                   sessionInformation <- function() {
[17:28:26.640]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:26.640]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:26.640]                       search = base::search(), system = base::Sys.info())
[17:28:26.640]                   }
[17:28:26.640]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.640]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:26.640]                     cond$call), session = sessionInformation(), 
[17:28:26.640]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:26.640]                   signalCondition(cond)
[17:28:26.640]                 }
[17:28:26.640]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:26.640]                 "immediateCondition"))) {
[17:28:26.640]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:26.640]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.640]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:26.640]                   if (TRUE && !signal) {
[17:28:26.640]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.640]                     {
[17:28:26.640]                       inherits <- base::inherits
[17:28:26.640]                       invokeRestart <- base::invokeRestart
[17:28:26.640]                       is.null <- base::is.null
[17:28:26.640]                       muffled <- FALSE
[17:28:26.640]                       if (inherits(cond, "message")) {
[17:28:26.640]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.640]                         if (muffled) 
[17:28:26.640]                           invokeRestart("muffleMessage")
[17:28:26.640]                       }
[17:28:26.640]                       else if (inherits(cond, "warning")) {
[17:28:26.640]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.640]                         if (muffled) 
[17:28:26.640]                           invokeRestart("muffleWarning")
[17:28:26.640]                       }
[17:28:26.640]                       else if (inherits(cond, "condition")) {
[17:28:26.640]                         if (!is.null(pattern)) {
[17:28:26.640]                           computeRestarts <- base::computeRestarts
[17:28:26.640]                           grepl <- base::grepl
[17:28:26.640]                           restarts <- computeRestarts(cond)
[17:28:26.640]                           for (restart in restarts) {
[17:28:26.640]                             name <- restart$name
[17:28:26.640]                             if (is.null(name)) 
[17:28:26.640]                               next
[17:28:26.640]                             if (!grepl(pattern, name)) 
[17:28:26.640]                               next
[17:28:26.640]                             invokeRestart(restart)
[17:28:26.640]                             muffled <- TRUE
[17:28:26.640]                             break
[17:28:26.640]                           }
[17:28:26.640]                         }
[17:28:26.640]                       }
[17:28:26.640]                       invisible(muffled)
[17:28:26.640]                     }
[17:28:26.640]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.640]                   }
[17:28:26.640]                 }
[17:28:26.640]                 else {
[17:28:26.640]                   if (TRUE) {
[17:28:26.640]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.640]                     {
[17:28:26.640]                       inherits <- base::inherits
[17:28:26.640]                       invokeRestart <- base::invokeRestart
[17:28:26.640]                       is.null <- base::is.null
[17:28:26.640]                       muffled <- FALSE
[17:28:26.640]                       if (inherits(cond, "message")) {
[17:28:26.640]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.640]                         if (muffled) 
[17:28:26.640]                           invokeRestart("muffleMessage")
[17:28:26.640]                       }
[17:28:26.640]                       else if (inherits(cond, "warning")) {
[17:28:26.640]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.640]                         if (muffled) 
[17:28:26.640]                           invokeRestart("muffleWarning")
[17:28:26.640]                       }
[17:28:26.640]                       else if (inherits(cond, "condition")) {
[17:28:26.640]                         if (!is.null(pattern)) {
[17:28:26.640]                           computeRestarts <- base::computeRestarts
[17:28:26.640]                           grepl <- base::grepl
[17:28:26.640]                           restarts <- computeRestarts(cond)
[17:28:26.640]                           for (restart in restarts) {
[17:28:26.640]                             name <- restart$name
[17:28:26.640]                             if (is.null(name)) 
[17:28:26.640]                               next
[17:28:26.640]                             if (!grepl(pattern, name)) 
[17:28:26.640]                               next
[17:28:26.640]                             invokeRestart(restart)
[17:28:26.640]                             muffled <- TRUE
[17:28:26.640]                             break
[17:28:26.640]                           }
[17:28:26.640]                         }
[17:28:26.640]                       }
[17:28:26.640]                       invisible(muffled)
[17:28:26.640]                     }
[17:28:26.640]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.640]                   }
[17:28:26.640]                 }
[17:28:26.640]             }
[17:28:26.640]         }))
[17:28:26.640]     }, error = function(ex) {
[17:28:26.640]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:26.640]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.640]                 ...future.rng), started = ...future.startTime, 
[17:28:26.640]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:26.640]             version = "1.8"), class = "FutureResult")
[17:28:26.640]     }, finally = {
[17:28:26.640]         if (!identical(...future.workdir, getwd())) 
[17:28:26.640]             setwd(...future.workdir)
[17:28:26.640]         {
[17:28:26.640]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:26.640]                 ...future.oldOptions$nwarnings <- NULL
[17:28:26.640]             }
[17:28:26.640]             base::options(...future.oldOptions)
[17:28:26.640]             if (.Platform$OS.type == "windows") {
[17:28:26.640]                 old_names <- names(...future.oldEnvVars)
[17:28:26.640]                 envs <- base::Sys.getenv()
[17:28:26.640]                 names <- names(envs)
[17:28:26.640]                 common <- intersect(names, old_names)
[17:28:26.640]                 added <- setdiff(names, old_names)
[17:28:26.640]                 removed <- setdiff(old_names, names)
[17:28:26.640]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:26.640]                   envs[common]]
[17:28:26.640]                 NAMES <- toupper(changed)
[17:28:26.640]                 args <- list()
[17:28:26.640]                 for (kk in seq_along(NAMES)) {
[17:28:26.640]                   name <- changed[[kk]]
[17:28:26.640]                   NAME <- NAMES[[kk]]
[17:28:26.640]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.640]                     next
[17:28:26.640]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.640]                 }
[17:28:26.640]                 NAMES <- toupper(added)
[17:28:26.640]                 for (kk in seq_along(NAMES)) {
[17:28:26.640]                   name <- added[[kk]]
[17:28:26.640]                   NAME <- NAMES[[kk]]
[17:28:26.640]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.640]                     next
[17:28:26.640]                   args[[name]] <- ""
[17:28:26.640]                 }
[17:28:26.640]                 NAMES <- toupper(removed)
[17:28:26.640]                 for (kk in seq_along(NAMES)) {
[17:28:26.640]                   name <- removed[[kk]]
[17:28:26.640]                   NAME <- NAMES[[kk]]
[17:28:26.640]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.640]                     next
[17:28:26.640]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.640]                 }
[17:28:26.640]                 if (length(args) > 0) 
[17:28:26.640]                   base::do.call(base::Sys.setenv, args = args)
[17:28:26.640]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:26.640]             }
[17:28:26.640]             else {
[17:28:26.640]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:26.640]             }
[17:28:26.640]             {
[17:28:26.640]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:26.640]                   0L) {
[17:28:26.640]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:26.640]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:26.640]                   base::options(opts)
[17:28:26.640]                 }
[17:28:26.640]                 {
[17:28:26.640]                   {
[17:28:26.640]                     NULL
[17:28:26.640]                     RNGkind("Mersenne-Twister")
[17:28:26.640]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:26.640]                       inherits = FALSE)
[17:28:26.640]                   }
[17:28:26.640]                   options(future.plan = NULL)
[17:28:26.640]                   if (is.na(NA_character_)) 
[17:28:26.640]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.640]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:26.640]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:26.640]                     .init = FALSE)
[17:28:26.640]                 }
[17:28:26.640]             }
[17:28:26.640]         }
[17:28:26.640]     })
[17:28:26.640]     if (TRUE) {
[17:28:26.640]         base::sink(type = "output", split = FALSE)
[17:28:26.640]         if (TRUE) {
[17:28:26.640]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:26.640]         }
[17:28:26.640]         else {
[17:28:26.640]             ...future.result["stdout"] <- base::list(NULL)
[17:28:26.640]         }
[17:28:26.640]         base::close(...future.stdout)
[17:28:26.640]         ...future.stdout <- NULL
[17:28:26.640]     }
[17:28:26.640]     ...future.result$conditions <- ...future.conditions
[17:28:26.640]     ...future.result$finished <- base::Sys.time()
[17:28:26.640]     ...future.result
[17:28:26.640] }
[17:28:26.644] plan(): Setting new future strategy stack:
[17:28:26.644] List of future strategies:
[17:28:26.644] 1. sequential:
[17:28:26.644]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.644]    - tweaked: FALSE
[17:28:26.644]    - call: NULL
[17:28:26.644] plan(): nbrOfWorkers() = 1
[17:28:26.645] plan(): Setting new future strategy stack:
[17:28:26.646] List of future strategies:
[17:28:26.646] 1. sequential:
[17:28:26.646]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.646]    - tweaked: FALSE
[17:28:26.646]    - call: plan(strategy)
[17:28:26.646] plan(): nbrOfWorkers() = 1
[17:28:26.646] SequentialFuture started (and completed)
[17:28:26.647] - Launch lazy future ... done
[17:28:26.647] run() for 'SequentialFuture' ... done
[1] 42
- stdout = NA
[17:28:26.647] getGlobalsAndPackages() ...
[17:28:26.647] Searching for globals...
[17:28:26.652] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:28:26.652] Searching for globals ... DONE
[17:28:26.652] Resolving globals: FALSE
[17:28:26.653] 
[17:28:26.653] - packages: [1] 'utils'
[17:28:26.653] getGlobalsAndPackages() ... DONE
[17:28:26.653] run() for 'Future' ...
[17:28:26.654] - state: 'created'
[17:28:26.654] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:26.654] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:26.654] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:26.654]   - Field: 'label'
[17:28:26.655]   - Field: 'local'
[17:28:26.655]   - Field: 'owner'
[17:28:26.655]   - Field: 'envir'
[17:28:26.655]   - Field: 'packages'
[17:28:26.655]   - Field: 'gc'
[17:28:26.656]   - Field: 'conditions'
[17:28:26.656]   - Field: 'expr'
[17:28:26.656]   - Field: 'uuid'
[17:28:26.656]   - Field: 'seed'
[17:28:26.656]   - Field: 'version'
[17:28:26.656]   - Field: 'result'
[17:28:26.657]   - Field: 'asynchronous'
[17:28:26.657]   - Field: 'calls'
[17:28:26.657]   - Field: 'globals'
[17:28:26.657]   - Field: 'stdout'
[17:28:26.657]   - Field: 'earlySignal'
[17:28:26.657]   - Field: 'lazy'
[17:28:26.658]   - Field: 'state'
[17:28:26.658] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:26.658] - Launch lazy future ...
[17:28:26.658] Packages needed by the future expression (n = 1): 'utils'
[17:28:26.658] Packages needed by future strategies (n = 0): <none>
[17:28:26.659] {
[17:28:26.659]     {
[17:28:26.659]         {
[17:28:26.659]             ...future.startTime <- base::Sys.time()
[17:28:26.659]             {
[17:28:26.659]                 {
[17:28:26.659]                   {
[17:28:26.659]                     {
[17:28:26.659]                       base::local({
[17:28:26.659]                         has_future <- base::requireNamespace("future", 
[17:28:26.659]                           quietly = TRUE)
[17:28:26.659]                         if (has_future) {
[17:28:26.659]                           ns <- base::getNamespace("future")
[17:28:26.659]                           version <- ns[[".package"]][["version"]]
[17:28:26.659]                           if (is.null(version)) 
[17:28:26.659]                             version <- utils::packageVersion("future")
[17:28:26.659]                         }
[17:28:26.659]                         else {
[17:28:26.659]                           version <- NULL
[17:28:26.659]                         }
[17:28:26.659]                         if (!has_future || version < "1.8.0") {
[17:28:26.659]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:26.659]                             "", base::R.version$version.string), 
[17:28:26.659]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:26.659]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:26.659]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:26.659]                               "release", "version")], collapse = " "), 
[17:28:26.659]                             hostname = base::Sys.info()[["nodename"]])
[17:28:26.659]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:26.659]                             info)
[17:28:26.659]                           info <- base::paste(info, collapse = "; ")
[17:28:26.659]                           if (!has_future) {
[17:28:26.659]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:26.659]                               info)
[17:28:26.659]                           }
[17:28:26.659]                           else {
[17:28:26.659]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:26.659]                               info, version)
[17:28:26.659]                           }
[17:28:26.659]                           base::stop(msg)
[17:28:26.659]                         }
[17:28:26.659]                       })
[17:28:26.659]                     }
[17:28:26.659]                     base::local({
[17:28:26.659]                       for (pkg in "utils") {
[17:28:26.659]                         base::loadNamespace(pkg)
[17:28:26.659]                         base::library(pkg, character.only = TRUE)
[17:28:26.659]                       }
[17:28:26.659]                     })
[17:28:26.659]                   }
[17:28:26.659]                   ...future.strategy.old <- future::plan("list")
[17:28:26.659]                   options(future.plan = NULL)
[17:28:26.659]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.659]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:26.659]                 }
[17:28:26.659]                 ...future.workdir <- getwd()
[17:28:26.659]             }
[17:28:26.659]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:26.659]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:26.659]         }
[17:28:26.659]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:26.659]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:26.659]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:26.659]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:26.659]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:26.659]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:26.659]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:26.659]             base::names(...future.oldOptions))
[17:28:26.659]     }
[17:28:26.659]     if (TRUE) {
[17:28:26.659]     }
[17:28:26.659]     else {
[17:28:26.659]         if (NA) {
[17:28:26.659]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:26.659]                 open = "w")
[17:28:26.659]         }
[17:28:26.659]         else {
[17:28:26.659]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:26.659]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:26.659]         }
[17:28:26.659]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:26.659]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:26.659]             base::sink(type = "output", split = FALSE)
[17:28:26.659]             base::close(...future.stdout)
[17:28:26.659]         }, add = TRUE)
[17:28:26.659]     }
[17:28:26.659]     ...future.frame <- base::sys.nframe()
[17:28:26.659]     ...future.conditions <- base::list()
[17:28:26.659]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:26.659]     if (FALSE) {
[17:28:26.659]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:26.659]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:26.659]     }
[17:28:26.659]     ...future.result <- base::tryCatch({
[17:28:26.659]         base::withCallingHandlers({
[17:28:26.659]             ...future.value <- base::withVisible(base::local({
[17:28:26.659]                 print(1:50)
[17:28:26.659]                 str(1:50)
[17:28:26.659]                 cat(letters, sep = "-")
[17:28:26.659]                 cat(1:6, collapse = "\n")
[17:28:26.659]                 write.table(datasets::iris[1:10, ], sep = "\t")
[17:28:26.659]                 42L
[17:28:26.659]             }))
[17:28:26.659]             future::FutureResult(value = ...future.value$value, 
[17:28:26.659]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.659]                   ...future.rng), globalenv = if (FALSE) 
[17:28:26.659]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:26.659]                     ...future.globalenv.names))
[17:28:26.659]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:26.659]         }, condition = base::local({
[17:28:26.659]             c <- base::c
[17:28:26.659]             inherits <- base::inherits
[17:28:26.659]             invokeRestart <- base::invokeRestart
[17:28:26.659]             length <- base::length
[17:28:26.659]             list <- base::list
[17:28:26.659]             seq.int <- base::seq.int
[17:28:26.659]             signalCondition <- base::signalCondition
[17:28:26.659]             sys.calls <- base::sys.calls
[17:28:26.659]             `[[` <- base::`[[`
[17:28:26.659]             `+` <- base::`+`
[17:28:26.659]             `<<-` <- base::`<<-`
[17:28:26.659]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:26.659]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:26.659]                   3L)]
[17:28:26.659]             }
[17:28:26.659]             function(cond) {
[17:28:26.659]                 is_error <- inherits(cond, "error")
[17:28:26.659]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:26.659]                   NULL)
[17:28:26.659]                 if (is_error) {
[17:28:26.659]                   sessionInformation <- function() {
[17:28:26.659]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:26.659]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:26.659]                       search = base::search(), system = base::Sys.info())
[17:28:26.659]                   }
[17:28:26.659]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.659]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:26.659]                     cond$call), session = sessionInformation(), 
[17:28:26.659]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:26.659]                   signalCondition(cond)
[17:28:26.659]                 }
[17:28:26.659]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:26.659]                 "immediateCondition"))) {
[17:28:26.659]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:26.659]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.659]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:26.659]                   if (TRUE && !signal) {
[17:28:26.659]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.659]                     {
[17:28:26.659]                       inherits <- base::inherits
[17:28:26.659]                       invokeRestart <- base::invokeRestart
[17:28:26.659]                       is.null <- base::is.null
[17:28:26.659]                       muffled <- FALSE
[17:28:26.659]                       if (inherits(cond, "message")) {
[17:28:26.659]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.659]                         if (muffled) 
[17:28:26.659]                           invokeRestart("muffleMessage")
[17:28:26.659]                       }
[17:28:26.659]                       else if (inherits(cond, "warning")) {
[17:28:26.659]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.659]                         if (muffled) 
[17:28:26.659]                           invokeRestart("muffleWarning")
[17:28:26.659]                       }
[17:28:26.659]                       else if (inherits(cond, "condition")) {
[17:28:26.659]                         if (!is.null(pattern)) {
[17:28:26.659]                           computeRestarts <- base::computeRestarts
[17:28:26.659]                           grepl <- base::grepl
[17:28:26.659]                           restarts <- computeRestarts(cond)
[17:28:26.659]                           for (restart in restarts) {
[17:28:26.659]                             name <- restart$name
[17:28:26.659]                             if (is.null(name)) 
[17:28:26.659]                               next
[17:28:26.659]                             if (!grepl(pattern, name)) 
[17:28:26.659]                               next
[17:28:26.659]                             invokeRestart(restart)
[17:28:26.659]                             muffled <- TRUE
[17:28:26.659]                             break
[17:28:26.659]                           }
[17:28:26.659]                         }
[17:28:26.659]                       }
[17:28:26.659]                       invisible(muffled)
[17:28:26.659]                     }
[17:28:26.659]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.659]                   }
[17:28:26.659]                 }
[17:28:26.659]                 else {
[17:28:26.659]                   if (TRUE) {
[17:28:26.659]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.659]                     {
[17:28:26.659]                       inherits <- base::inherits
[17:28:26.659]                       invokeRestart <- base::invokeRestart
[17:28:26.659]                       is.null <- base::is.null
[17:28:26.659]                       muffled <- FALSE
[17:28:26.659]                       if (inherits(cond, "message")) {
[17:28:26.659]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.659]                         if (muffled) 
[17:28:26.659]                           invokeRestart("muffleMessage")
[17:28:26.659]                       }
[17:28:26.659]                       else if (inherits(cond, "warning")) {
[17:28:26.659]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.659]                         if (muffled) 
[17:28:26.659]                           invokeRestart("muffleWarning")
[17:28:26.659]                       }
[17:28:26.659]                       else if (inherits(cond, "condition")) {
[17:28:26.659]                         if (!is.null(pattern)) {
[17:28:26.659]                           computeRestarts <- base::computeRestarts
[17:28:26.659]                           grepl <- base::grepl
[17:28:26.659]                           restarts <- computeRestarts(cond)
[17:28:26.659]                           for (restart in restarts) {
[17:28:26.659]                             name <- restart$name
[17:28:26.659]                             if (is.null(name)) 
[17:28:26.659]                               next
[17:28:26.659]                             if (!grepl(pattern, name)) 
[17:28:26.659]                               next
[17:28:26.659]                             invokeRestart(restart)
[17:28:26.659]                             muffled <- TRUE
[17:28:26.659]                             break
[17:28:26.659]                           }
[17:28:26.659]                         }
[17:28:26.659]                       }
[17:28:26.659]                       invisible(muffled)
[17:28:26.659]                     }
[17:28:26.659]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.659]                   }
[17:28:26.659]                 }
[17:28:26.659]             }
[17:28:26.659]         }))
[17:28:26.659]     }, error = function(ex) {
[17:28:26.659]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:26.659]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.659]                 ...future.rng), started = ...future.startTime, 
[17:28:26.659]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:26.659]             version = "1.8"), class = "FutureResult")
[17:28:26.659]     }, finally = {
[17:28:26.659]         if (!identical(...future.workdir, getwd())) 
[17:28:26.659]             setwd(...future.workdir)
[17:28:26.659]         {
[17:28:26.659]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:26.659]                 ...future.oldOptions$nwarnings <- NULL
[17:28:26.659]             }
[17:28:26.659]             base::options(...future.oldOptions)
[17:28:26.659]             if (.Platform$OS.type == "windows") {
[17:28:26.659]                 old_names <- names(...future.oldEnvVars)
[17:28:26.659]                 envs <- base::Sys.getenv()
[17:28:26.659]                 names <- names(envs)
[17:28:26.659]                 common <- intersect(names, old_names)
[17:28:26.659]                 added <- setdiff(names, old_names)
[17:28:26.659]                 removed <- setdiff(old_names, names)
[17:28:26.659]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:26.659]                   envs[common]]
[17:28:26.659]                 NAMES <- toupper(changed)
[17:28:26.659]                 args <- list()
[17:28:26.659]                 for (kk in seq_along(NAMES)) {
[17:28:26.659]                   name <- changed[[kk]]
[17:28:26.659]                   NAME <- NAMES[[kk]]
[17:28:26.659]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.659]                     next
[17:28:26.659]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.659]                 }
[17:28:26.659]                 NAMES <- toupper(added)
[17:28:26.659]                 for (kk in seq_along(NAMES)) {
[17:28:26.659]                   name <- added[[kk]]
[17:28:26.659]                   NAME <- NAMES[[kk]]
[17:28:26.659]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.659]                     next
[17:28:26.659]                   args[[name]] <- ""
[17:28:26.659]                 }
[17:28:26.659]                 NAMES <- toupper(removed)
[17:28:26.659]                 for (kk in seq_along(NAMES)) {
[17:28:26.659]                   name <- removed[[kk]]
[17:28:26.659]                   NAME <- NAMES[[kk]]
[17:28:26.659]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.659]                     next
[17:28:26.659]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.659]                 }
[17:28:26.659]                 if (length(args) > 0) 
[17:28:26.659]                   base::do.call(base::Sys.setenv, args = args)
[17:28:26.659]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:26.659]             }
[17:28:26.659]             else {
[17:28:26.659]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:26.659]             }
[17:28:26.659]             {
[17:28:26.659]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:26.659]                   0L) {
[17:28:26.659]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:26.659]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:26.659]                   base::options(opts)
[17:28:26.659]                 }
[17:28:26.659]                 {
[17:28:26.659]                   {
[17:28:26.659]                     NULL
[17:28:26.659]                     RNGkind("Mersenne-Twister")
[17:28:26.659]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:26.659]                       inherits = FALSE)
[17:28:26.659]                   }
[17:28:26.659]                   options(future.plan = NULL)
[17:28:26.659]                   if (is.na(NA_character_)) 
[17:28:26.659]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.659]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:26.659]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:26.659]                     .init = FALSE)
[17:28:26.659]                 }
[17:28:26.659]             }
[17:28:26.659]         }
[17:28:26.659]     })
[17:28:26.659]     if (FALSE) {
[17:28:26.659]         base::sink(type = "output", split = FALSE)
[17:28:26.659]         if (NA) {
[17:28:26.659]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:26.659]         }
[17:28:26.659]         else {
[17:28:26.659]             ...future.result["stdout"] <- base::list(NULL)
[17:28:26.659]         }
[17:28:26.659]         base::close(...future.stdout)
[17:28:26.659]         ...future.stdout <- NULL
[17:28:26.659]     }
[17:28:26.659]     ...future.result$conditions <- ...future.conditions
[17:28:26.659]     ...future.result$finished <- base::Sys.time()
[17:28:26.659]     ...future.result
[17:28:26.659] }
[17:28:26.663] plan(): Setting new future strategy stack:
[17:28:26.663] List of future strategies:
[17:28:26.663] 1. sequential:
[17:28:26.663]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.663]    - tweaked: FALSE
[17:28:26.663]    - call: NULL
[17:28:26.664] 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:28:26.666] plan(): Setting new future strategy stack:
[17:28:26.666] List of future strategies:
[17:28:26.666] 1. sequential:
[17:28:26.666]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.666]    - tweaked: FALSE
[17:28:26.666]    - call: plan(strategy)
[17:28:26.667] plan(): nbrOfWorkers() = 1
[17:28:26.667] SequentialFuture started (and completed)
[17:28:26.667] - Launch lazy future ... done
[17:28:26.667] 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-03-26 17:28:26"
 $ finished    : POSIXct[1:1], format: "2024-03-26 17:28:26"
 $ session_uuid: chr "4b64b601-8666-ff45-2fee-4b34ef3f3009"
  ..- 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 162072
  .. ..$ time  : POSIXct[1:1], format: "2024-03-26 17:28:26"
  .. ..$ random: int 2147483647
 $ r_info      :List of 4
  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1
  .. ..$ : int [1:3] 4 4 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[17:28:26.676] getGlobalsAndPackages() ...
[17:28:26.677] Searching for globals...
[17:28:26.681] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:28:26.681] Searching for globals ... DONE
[17:28:26.681] Resolving globals: FALSE
[17:28:26.682] 
[17:28:26.682] - packages: [1] 'utils'
[17:28:26.682] getGlobalsAndPackages() ... DONE
[17:28:26.682] run() for 'Future' ...
[17:28:26.683] - state: 'created'
[17:28:26.683] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:26.683] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:26.683] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:26.684]   - Field: 'label'
[17:28:26.684]   - Field: 'local'
[17:28:26.684]   - Field: 'owner'
[17:28:26.684]   - Field: 'envir'
[17:28:26.684]   - Field: 'packages'
[17:28:26.684]   - Field: 'gc'
[17:28:26.685]   - Field: 'conditions'
[17:28:26.685]   - Field: 'expr'
[17:28:26.685]   - Field: 'uuid'
[17:28:26.685]   - Field: 'seed'
[17:28:26.685]   - Field: 'version'
[17:28:26.686]   - Field: 'result'
[17:28:26.686]   - Field: 'asynchronous'
[17:28:26.686]   - Field: 'calls'
[17:28:26.686]   - Field: 'globals'
[17:28:26.686]   - Field: 'stdout'
[17:28:26.686]   - Field: 'earlySignal'
[17:28:26.687]   - Field: 'lazy'
[17:28:26.687]   - Field: 'state'
[17:28:26.687] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:26.687] - Launch lazy future ...
[17:28:26.687] Packages needed by the future expression (n = 1): 'utils'
[17:28:26.687] Packages needed by future strategies (n = 0): <none>
[17:28:26.688] {
[17:28:26.688]     {
[17:28:26.688]         {
[17:28:26.688]             ...future.startTime <- base::Sys.time()
[17:28:26.688]             {
[17:28:26.688]                 {
[17:28:26.688]                   {
[17:28:26.688]                     {
[17:28:26.688]                       base::local({
[17:28:26.688]                         has_future <- base::requireNamespace("future", 
[17:28:26.688]                           quietly = TRUE)
[17:28:26.688]                         if (has_future) {
[17:28:26.688]                           ns <- base::getNamespace("future")
[17:28:26.688]                           version <- ns[[".package"]][["version"]]
[17:28:26.688]                           if (is.null(version)) 
[17:28:26.688]                             version <- utils::packageVersion("future")
[17:28:26.688]                         }
[17:28:26.688]                         else {
[17:28:26.688]                           version <- NULL
[17:28:26.688]                         }
[17:28:26.688]                         if (!has_future || version < "1.8.0") {
[17:28:26.688]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:26.688]                             "", base::R.version$version.string), 
[17:28:26.688]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:26.688]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:26.688]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:26.688]                               "release", "version")], collapse = " "), 
[17:28:26.688]                             hostname = base::Sys.info()[["nodename"]])
[17:28:26.688]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:26.688]                             info)
[17:28:26.688]                           info <- base::paste(info, collapse = "; ")
[17:28:26.688]                           if (!has_future) {
[17:28:26.688]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:26.688]                               info)
[17:28:26.688]                           }
[17:28:26.688]                           else {
[17:28:26.688]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:26.688]                               info, version)
[17:28:26.688]                           }
[17:28:26.688]                           base::stop(msg)
[17:28:26.688]                         }
[17:28:26.688]                       })
[17:28:26.688]                     }
[17:28:26.688]                     base::local({
[17:28:26.688]                       for (pkg in "utils") {
[17:28:26.688]                         base::loadNamespace(pkg)
[17:28:26.688]                         base::library(pkg, character.only = TRUE)
[17:28:26.688]                       }
[17:28:26.688]                     })
[17:28:26.688]                   }
[17:28:26.688]                   ...future.strategy.old <- future::plan("list")
[17:28:26.688]                   options(future.plan = NULL)
[17:28:26.688]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.688]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:26.688]                 }
[17:28:26.688]                 ...future.workdir <- getwd()
[17:28:26.688]             }
[17:28:26.688]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:26.688]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:26.688]         }
[17:28:26.688]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:26.688]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:26.688]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:26.688]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:26.688]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:26.688]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:26.688]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:26.688]             base::names(...future.oldOptions))
[17:28:26.688]     }
[17:28:26.688]     if (TRUE) {
[17:28:26.688]     }
[17:28:26.688]     else {
[17:28:26.688]         if (NA) {
[17:28:26.688]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:26.688]                 open = "w")
[17:28:26.688]         }
[17:28:26.688]         else {
[17:28:26.688]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:26.688]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:26.688]         }
[17:28:26.688]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:26.688]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:26.688]             base::sink(type = "output", split = FALSE)
[17:28:26.688]             base::close(...future.stdout)
[17:28:26.688]         }, add = TRUE)
[17:28:26.688]     }
[17:28:26.688]     ...future.frame <- base::sys.nframe()
[17:28:26.688]     ...future.conditions <- base::list()
[17:28:26.688]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:26.688]     if (FALSE) {
[17:28:26.688]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:26.688]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:26.688]     }
[17:28:26.688]     ...future.result <- base::tryCatch({
[17:28:26.688]         base::withCallingHandlers({
[17:28:26.688]             ...future.value <- base::withVisible(base::local({
[17:28:26.688]                 print(1:50)
[17:28:26.688]                 str(1:50)
[17:28:26.688]                 cat(letters, sep = "-")
[17:28:26.688]                 cat(1:6, collapse = "\n")
[17:28:26.688]                 write.table(datasets::iris[1:10, ], sep = "\t")
[17:28:26.688]                 42L
[17:28:26.688]             }))
[17:28:26.688]             future::FutureResult(value = ...future.value$value, 
[17:28:26.688]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.688]                   ...future.rng), globalenv = if (FALSE) 
[17:28:26.688]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:26.688]                     ...future.globalenv.names))
[17:28:26.688]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:26.688]         }, condition = base::local({
[17:28:26.688]             c <- base::c
[17:28:26.688]             inherits <- base::inherits
[17:28:26.688]             invokeRestart <- base::invokeRestart
[17:28:26.688]             length <- base::length
[17:28:26.688]             list <- base::list
[17:28:26.688]             seq.int <- base::seq.int
[17:28:26.688]             signalCondition <- base::signalCondition
[17:28:26.688]             sys.calls <- base::sys.calls
[17:28:26.688]             `[[` <- base::`[[`
[17:28:26.688]             `+` <- base::`+`
[17:28:26.688]             `<<-` <- base::`<<-`
[17:28:26.688]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:26.688]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:26.688]                   3L)]
[17:28:26.688]             }
[17:28:26.688]             function(cond) {
[17:28:26.688]                 is_error <- inherits(cond, "error")
[17:28:26.688]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:26.688]                   NULL)
[17:28:26.688]                 if (is_error) {
[17:28:26.688]                   sessionInformation <- function() {
[17:28:26.688]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:26.688]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:26.688]                       search = base::search(), system = base::Sys.info())
[17:28:26.688]                   }
[17:28:26.688]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.688]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:26.688]                     cond$call), session = sessionInformation(), 
[17:28:26.688]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:26.688]                   signalCondition(cond)
[17:28:26.688]                 }
[17:28:26.688]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:26.688]                 "immediateCondition"))) {
[17:28:26.688]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:26.688]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.688]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:26.688]                   if (TRUE && !signal) {
[17:28:26.688]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.688]                     {
[17:28:26.688]                       inherits <- base::inherits
[17:28:26.688]                       invokeRestart <- base::invokeRestart
[17:28:26.688]                       is.null <- base::is.null
[17:28:26.688]                       muffled <- FALSE
[17:28:26.688]                       if (inherits(cond, "message")) {
[17:28:26.688]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.688]                         if (muffled) 
[17:28:26.688]                           invokeRestart("muffleMessage")
[17:28:26.688]                       }
[17:28:26.688]                       else if (inherits(cond, "warning")) {
[17:28:26.688]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.688]                         if (muffled) 
[17:28:26.688]                           invokeRestart("muffleWarning")
[17:28:26.688]                       }
[17:28:26.688]                       else if (inherits(cond, "condition")) {
[17:28:26.688]                         if (!is.null(pattern)) {
[17:28:26.688]                           computeRestarts <- base::computeRestarts
[17:28:26.688]                           grepl <- base::grepl
[17:28:26.688]                           restarts <- computeRestarts(cond)
[17:28:26.688]                           for (restart in restarts) {
[17:28:26.688]                             name <- restart$name
[17:28:26.688]                             if (is.null(name)) 
[17:28:26.688]                               next
[17:28:26.688]                             if (!grepl(pattern, name)) 
[17:28:26.688]                               next
[17:28:26.688]                             invokeRestart(restart)
[17:28:26.688]                             muffled <- TRUE
[17:28:26.688]                             break
[17:28:26.688]                           }
[17:28:26.688]                         }
[17:28:26.688]                       }
[17:28:26.688]                       invisible(muffled)
[17:28:26.688]                     }
[17:28:26.688]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.688]                   }
[17:28:26.688]                 }
[17:28:26.688]                 else {
[17:28:26.688]                   if (TRUE) {
[17:28:26.688]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.688]                     {
[17:28:26.688]                       inherits <- base::inherits
[17:28:26.688]                       invokeRestart <- base::invokeRestart
[17:28:26.688]                       is.null <- base::is.null
[17:28:26.688]                       muffled <- FALSE
[17:28:26.688]                       if (inherits(cond, "message")) {
[17:28:26.688]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.688]                         if (muffled) 
[17:28:26.688]                           invokeRestart("muffleMessage")
[17:28:26.688]                       }
[17:28:26.688]                       else if (inherits(cond, "warning")) {
[17:28:26.688]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.688]                         if (muffled) 
[17:28:26.688]                           invokeRestart("muffleWarning")
[17:28:26.688]                       }
[17:28:26.688]                       else if (inherits(cond, "condition")) {
[17:28:26.688]                         if (!is.null(pattern)) {
[17:28:26.688]                           computeRestarts <- base::computeRestarts
[17:28:26.688]                           grepl <- base::grepl
[17:28:26.688]                           restarts <- computeRestarts(cond)
[17:28:26.688]                           for (restart in restarts) {
[17:28:26.688]                             name <- restart$name
[17:28:26.688]                             if (is.null(name)) 
[17:28:26.688]                               next
[17:28:26.688]                             if (!grepl(pattern, name)) 
[17:28:26.688]                               next
[17:28:26.688]                             invokeRestart(restart)
[17:28:26.688]                             muffled <- TRUE
[17:28:26.688]                             break
[17:28:26.688]                           }
[17:28:26.688]                         }
[17:28:26.688]                       }
[17:28:26.688]                       invisible(muffled)
[17:28:26.688]                     }
[17:28:26.688]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.688]                   }
[17:28:26.688]                 }
[17:28:26.688]             }
[17:28:26.688]         }))
[17:28:26.688]     }, error = function(ex) {
[17:28:26.688]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:26.688]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.688]                 ...future.rng), started = ...future.startTime, 
[17:28:26.688]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:26.688]             version = "1.8"), class = "FutureResult")
[17:28:26.688]     }, finally = {
[17:28:26.688]         if (!identical(...future.workdir, getwd())) 
[17:28:26.688]             setwd(...future.workdir)
[17:28:26.688]         {
[17:28:26.688]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:26.688]                 ...future.oldOptions$nwarnings <- NULL
[17:28:26.688]             }
[17:28:26.688]             base::options(...future.oldOptions)
[17:28:26.688]             if (.Platform$OS.type == "windows") {
[17:28:26.688]                 old_names <- names(...future.oldEnvVars)
[17:28:26.688]                 envs <- base::Sys.getenv()
[17:28:26.688]                 names <- names(envs)
[17:28:26.688]                 common <- intersect(names, old_names)
[17:28:26.688]                 added <- setdiff(names, old_names)
[17:28:26.688]                 removed <- setdiff(old_names, names)
[17:28:26.688]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:26.688]                   envs[common]]
[17:28:26.688]                 NAMES <- toupper(changed)
[17:28:26.688]                 args <- list()
[17:28:26.688]                 for (kk in seq_along(NAMES)) {
[17:28:26.688]                   name <- changed[[kk]]
[17:28:26.688]                   NAME <- NAMES[[kk]]
[17:28:26.688]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.688]                     next
[17:28:26.688]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.688]                 }
[17:28:26.688]                 NAMES <- toupper(added)
[17:28:26.688]                 for (kk in seq_along(NAMES)) {
[17:28:26.688]                   name <- added[[kk]]
[17:28:26.688]                   NAME <- NAMES[[kk]]
[17:28:26.688]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.688]                     next
[17:28:26.688]                   args[[name]] <- ""
[17:28:26.688]                 }
[17:28:26.688]                 NAMES <- toupper(removed)
[17:28:26.688]                 for (kk in seq_along(NAMES)) {
[17:28:26.688]                   name <- removed[[kk]]
[17:28:26.688]                   NAME <- NAMES[[kk]]
[17:28:26.688]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.688]                     next
[17:28:26.688]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.688]                 }
[17:28:26.688]                 if (length(args) > 0) 
[17:28:26.688]                   base::do.call(base::Sys.setenv, args = args)
[17:28:26.688]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:26.688]             }
[17:28:26.688]             else {
[17:28:26.688]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:26.688]             }
[17:28:26.688]             {
[17:28:26.688]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:26.688]                   0L) {
[17:28:26.688]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:26.688]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:26.688]                   base::options(opts)
[17:28:26.688]                 }
[17:28:26.688]                 {
[17:28:26.688]                   {
[17:28:26.688]                     NULL
[17:28:26.688]                     RNGkind("Mersenne-Twister")
[17:28:26.688]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:26.688]                       inherits = FALSE)
[17:28:26.688]                   }
[17:28:26.688]                   options(future.plan = NULL)
[17:28:26.688]                   if (is.na(NA_character_)) 
[17:28:26.688]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.688]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:26.688]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:26.688]                     .init = FALSE)
[17:28:26.688]                 }
[17:28:26.688]             }
[17:28:26.688]         }
[17:28:26.688]     })
[17:28:26.688]     if (FALSE) {
[17:28:26.688]         base::sink(type = "output", split = FALSE)
[17:28:26.688]         if (NA) {
[17:28:26.688]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:26.688]         }
[17:28:26.688]         else {
[17:28:26.688]             ...future.result["stdout"] <- base::list(NULL)
[17:28:26.688]         }
[17:28:26.688]         base::close(...future.stdout)
[17:28:26.688]         ...future.stdout <- NULL
[17:28:26.688]     }
[17:28:26.688]     ...future.result$conditions <- ...future.conditions
[17:28:26.688]     ...future.result$finished <- base::Sys.time()
[17:28:26.688]     ...future.result
[17:28:26.688] }
[17:28:26.692] plan(): Setting new future strategy stack:
[17:28:26.692] List of future strategies:
[17:28:26.692] 1. sequential:
[17:28:26.692]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.692]    - tweaked: FALSE
[17:28:26.692]    - call: NULL
[17:28:26.693] 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:28:26.695] plan(): Setting new future strategy stack:
[17:28:26.695] List of future strategies:
[17:28:26.695] 1. sequential:
[17:28:26.695]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.695]    - tweaked: FALSE
[17:28:26.695]    - call: plan(strategy)
[17:28:26.696] plan(): nbrOfWorkers() = 1
[17:28:26.696] SequentialFuture started (and completed)
[17:28:26.696] - Launch lazy future ... done
[17:28:26.697] run() for 'SequentialFuture' ... done
- stdout = structure(TRUE, drop = TRUE)
[17:28:26.697] getGlobalsAndPackages() ...
[17:28:26.697] Searching for globals...
[17:28:26.698] - globals found: [1] 'print'
[17:28:26.698] Searching for globals ... DONE
[17:28:26.698] Resolving globals: FALSE
[17:28:26.698] 
[17:28:26.699] 
[17:28:26.699] getGlobalsAndPackages() ... DONE
[17:28:26.699] run() for 'Future' ...
[17:28:26.699] - state: 'created'
[17:28:26.699] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:26.700] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:26.700] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:26.700]   - Field: 'label'
[17:28:26.700]   - Field: 'local'
[17:28:26.701]   - Field: 'owner'
[17:28:26.701]   - Field: 'envir'
[17:28:26.701]   - Field: 'packages'
[17:28:26.701]   - Field: 'gc'
[17:28:26.701]   - Field: 'conditions'
[17:28:26.701]   - Field: 'expr'
[17:28:26.702]   - Field: 'uuid'
[17:28:26.702]   - Field: 'seed'
[17:28:26.702]   - Field: 'version'
[17:28:26.702]   - Field: 'result'
[17:28:26.702]   - Field: 'asynchronous'
[17:28:26.702]   - Field: 'calls'
[17:28:26.703]   - Field: 'globals'
[17:28:26.703]   - Field: 'stdout'
[17:28:26.703]   - Field: 'earlySignal'
[17:28:26.703]   - Field: 'lazy'
[17:28:26.703]   - Field: 'state'
[17:28:26.703] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:26.704] - Launch lazy future ...
[17:28:26.704] Packages needed by the future expression (n = 0): <none>
[17:28:26.704] Packages needed by future strategies (n = 0): <none>
[17:28:26.705] {
[17:28:26.705]     {
[17:28:26.705]         {
[17:28:26.705]             ...future.startTime <- base::Sys.time()
[17:28:26.705]             {
[17:28:26.705]                 {
[17:28:26.705]                   {
[17:28:26.705]                     base::local({
[17:28:26.705]                       has_future <- base::requireNamespace("future", 
[17:28:26.705]                         quietly = TRUE)
[17:28:26.705]                       if (has_future) {
[17:28:26.705]                         ns <- base::getNamespace("future")
[17:28:26.705]                         version <- ns[[".package"]][["version"]]
[17:28:26.705]                         if (is.null(version)) 
[17:28:26.705]                           version <- utils::packageVersion("future")
[17:28:26.705]                       }
[17:28:26.705]                       else {
[17:28:26.705]                         version <- NULL
[17:28:26.705]                       }
[17:28:26.705]                       if (!has_future || version < "1.8.0") {
[17:28:26.705]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:26.705]                           "", base::R.version$version.string), 
[17:28:26.705]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:26.705]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:26.705]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:26.705]                             "release", "version")], collapse = " "), 
[17:28:26.705]                           hostname = base::Sys.info()[["nodename"]])
[17:28:26.705]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:26.705]                           info)
[17:28:26.705]                         info <- base::paste(info, collapse = "; ")
[17:28:26.705]                         if (!has_future) {
[17:28:26.705]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:26.705]                             info)
[17:28:26.705]                         }
[17:28:26.705]                         else {
[17:28:26.705]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:26.705]                             info, version)
[17:28:26.705]                         }
[17:28:26.705]                         base::stop(msg)
[17:28:26.705]                       }
[17:28:26.705]                     })
[17:28:26.705]                   }
[17:28:26.705]                   ...future.strategy.old <- future::plan("list")
[17:28:26.705]                   options(future.plan = NULL)
[17:28:26.705]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.705]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:26.705]                 }
[17:28:26.705]                 ...future.workdir <- getwd()
[17:28:26.705]             }
[17:28:26.705]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:26.705]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:26.705]         }
[17:28:26.705]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:26.705]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:26.705]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:26.705]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:26.705]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:26.705]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:26.705]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:26.705]             base::names(...future.oldOptions))
[17:28:26.705]     }
[17:28:26.705]     if (FALSE) {
[17:28:26.705]     }
[17:28:26.705]     else {
[17:28:26.705]         if (TRUE) {
[17:28:26.705]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:26.705]                 open = "w")
[17:28:26.705]         }
[17:28:26.705]         else {
[17:28:26.705]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:26.705]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:26.705]         }
[17:28:26.705]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:26.705]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:26.705]             base::sink(type = "output", split = FALSE)
[17:28:26.705]             base::close(...future.stdout)
[17:28:26.705]         }, add = TRUE)
[17:28:26.705]     }
[17:28:26.705]     ...future.frame <- base::sys.nframe()
[17:28:26.705]     ...future.conditions <- base::list()
[17:28:26.705]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:26.705]     if (FALSE) {
[17:28:26.705]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:26.705]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:26.705]     }
[17:28:26.705]     ...future.result <- base::tryCatch({
[17:28:26.705]         base::withCallingHandlers({
[17:28:26.705]             ...future.value <- base::withVisible(base::local(print(42)))
[17:28:26.705]             future::FutureResult(value = ...future.value$value, 
[17:28:26.705]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.705]                   ...future.rng), globalenv = if (FALSE) 
[17:28:26.705]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:26.705]                     ...future.globalenv.names))
[17:28:26.705]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:26.705]         }, condition = base::local({
[17:28:26.705]             c <- base::c
[17:28:26.705]             inherits <- base::inherits
[17:28:26.705]             invokeRestart <- base::invokeRestart
[17:28:26.705]             length <- base::length
[17:28:26.705]             list <- base::list
[17:28:26.705]             seq.int <- base::seq.int
[17:28:26.705]             signalCondition <- base::signalCondition
[17:28:26.705]             sys.calls <- base::sys.calls
[17:28:26.705]             `[[` <- base::`[[`
[17:28:26.705]             `+` <- base::`+`
[17:28:26.705]             `<<-` <- base::`<<-`
[17:28:26.705]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:26.705]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:26.705]                   3L)]
[17:28:26.705]             }
[17:28:26.705]             function(cond) {
[17:28:26.705]                 is_error <- inherits(cond, "error")
[17:28:26.705]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:26.705]                   NULL)
[17:28:26.705]                 if (is_error) {
[17:28:26.705]                   sessionInformation <- function() {
[17:28:26.705]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:26.705]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:26.705]                       search = base::search(), system = base::Sys.info())
[17:28:26.705]                   }
[17:28:26.705]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.705]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:26.705]                     cond$call), session = sessionInformation(), 
[17:28:26.705]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:26.705]                   signalCondition(cond)
[17:28:26.705]                 }
[17:28:26.705]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:26.705]                 "immediateCondition"))) {
[17:28:26.705]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:26.705]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.705]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:26.705]                   if (TRUE && !signal) {
[17:28:26.705]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.705]                     {
[17:28:26.705]                       inherits <- base::inherits
[17:28:26.705]                       invokeRestart <- base::invokeRestart
[17:28:26.705]                       is.null <- base::is.null
[17:28:26.705]                       muffled <- FALSE
[17:28:26.705]                       if (inherits(cond, "message")) {
[17:28:26.705]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.705]                         if (muffled) 
[17:28:26.705]                           invokeRestart("muffleMessage")
[17:28:26.705]                       }
[17:28:26.705]                       else if (inherits(cond, "warning")) {
[17:28:26.705]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.705]                         if (muffled) 
[17:28:26.705]                           invokeRestart("muffleWarning")
[17:28:26.705]                       }
[17:28:26.705]                       else if (inherits(cond, "condition")) {
[17:28:26.705]                         if (!is.null(pattern)) {
[17:28:26.705]                           computeRestarts <- base::computeRestarts
[17:28:26.705]                           grepl <- base::grepl
[17:28:26.705]                           restarts <- computeRestarts(cond)
[17:28:26.705]                           for (restart in restarts) {
[17:28:26.705]                             name <- restart$name
[17:28:26.705]                             if (is.null(name)) 
[17:28:26.705]                               next
[17:28:26.705]                             if (!grepl(pattern, name)) 
[17:28:26.705]                               next
[17:28:26.705]                             invokeRestart(restart)
[17:28:26.705]                             muffled <- TRUE
[17:28:26.705]                             break
[17:28:26.705]                           }
[17:28:26.705]                         }
[17:28:26.705]                       }
[17:28:26.705]                       invisible(muffled)
[17:28:26.705]                     }
[17:28:26.705]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.705]                   }
[17:28:26.705]                 }
[17:28:26.705]                 else {
[17:28:26.705]                   if (TRUE) {
[17:28:26.705]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.705]                     {
[17:28:26.705]                       inherits <- base::inherits
[17:28:26.705]                       invokeRestart <- base::invokeRestart
[17:28:26.705]                       is.null <- base::is.null
[17:28:26.705]                       muffled <- FALSE
[17:28:26.705]                       if (inherits(cond, "message")) {
[17:28:26.705]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.705]                         if (muffled) 
[17:28:26.705]                           invokeRestart("muffleMessage")
[17:28:26.705]                       }
[17:28:26.705]                       else if (inherits(cond, "warning")) {
[17:28:26.705]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.705]                         if (muffled) 
[17:28:26.705]                           invokeRestart("muffleWarning")
[17:28:26.705]                       }
[17:28:26.705]                       else if (inherits(cond, "condition")) {
[17:28:26.705]                         if (!is.null(pattern)) {
[17:28:26.705]                           computeRestarts <- base::computeRestarts
[17:28:26.705]                           grepl <- base::grepl
[17:28:26.705]                           restarts <- computeRestarts(cond)
[17:28:26.705]                           for (restart in restarts) {
[17:28:26.705]                             name <- restart$name
[17:28:26.705]                             if (is.null(name)) 
[17:28:26.705]                               next
[17:28:26.705]                             if (!grepl(pattern, name)) 
[17:28:26.705]                               next
[17:28:26.705]                             invokeRestart(restart)
[17:28:26.705]                             muffled <- TRUE
[17:28:26.705]                             break
[17:28:26.705]                           }
[17:28:26.705]                         }
[17:28:26.705]                       }
[17:28:26.705]                       invisible(muffled)
[17:28:26.705]                     }
[17:28:26.705]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.705]                   }
[17:28:26.705]                 }
[17:28:26.705]             }
[17:28:26.705]         }))
[17:28:26.705]     }, error = function(ex) {
[17:28:26.705]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:26.705]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.705]                 ...future.rng), started = ...future.startTime, 
[17:28:26.705]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:26.705]             version = "1.8"), class = "FutureResult")
[17:28:26.705]     }, finally = {
[17:28:26.705]         if (!identical(...future.workdir, getwd())) 
[17:28:26.705]             setwd(...future.workdir)
[17:28:26.705]         {
[17:28:26.705]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:26.705]                 ...future.oldOptions$nwarnings <- NULL
[17:28:26.705]             }
[17:28:26.705]             base::options(...future.oldOptions)
[17:28:26.705]             if (.Platform$OS.type == "windows") {
[17:28:26.705]                 old_names <- names(...future.oldEnvVars)
[17:28:26.705]                 envs <- base::Sys.getenv()
[17:28:26.705]                 names <- names(envs)
[17:28:26.705]                 common <- intersect(names, old_names)
[17:28:26.705]                 added <- setdiff(names, old_names)
[17:28:26.705]                 removed <- setdiff(old_names, names)
[17:28:26.705]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:26.705]                   envs[common]]
[17:28:26.705]                 NAMES <- toupper(changed)
[17:28:26.705]                 args <- list()
[17:28:26.705]                 for (kk in seq_along(NAMES)) {
[17:28:26.705]                   name <- changed[[kk]]
[17:28:26.705]                   NAME <- NAMES[[kk]]
[17:28:26.705]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.705]                     next
[17:28:26.705]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.705]                 }
[17:28:26.705]                 NAMES <- toupper(added)
[17:28:26.705]                 for (kk in seq_along(NAMES)) {
[17:28:26.705]                   name <- added[[kk]]
[17:28:26.705]                   NAME <- NAMES[[kk]]
[17:28:26.705]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.705]                     next
[17:28:26.705]                   args[[name]] <- ""
[17:28:26.705]                 }
[17:28:26.705]                 NAMES <- toupper(removed)
[17:28:26.705]                 for (kk in seq_along(NAMES)) {
[17:28:26.705]                   name <- removed[[kk]]
[17:28:26.705]                   NAME <- NAMES[[kk]]
[17:28:26.705]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.705]                     next
[17:28:26.705]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.705]                 }
[17:28:26.705]                 if (length(args) > 0) 
[17:28:26.705]                   base::do.call(base::Sys.setenv, args = args)
[17:28:26.705]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:26.705]             }
[17:28:26.705]             else {
[17:28:26.705]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:26.705]             }
[17:28:26.705]             {
[17:28:26.705]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:26.705]                   0L) {
[17:28:26.705]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:26.705]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:26.705]                   base::options(opts)
[17:28:26.705]                 }
[17:28:26.705]                 {
[17:28:26.705]                   {
[17:28:26.705]                     NULL
[17:28:26.705]                     RNGkind("Mersenne-Twister")
[17:28:26.705]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:26.705]                       inherits = FALSE)
[17:28:26.705]                   }
[17:28:26.705]                   options(future.plan = NULL)
[17:28:26.705]                   if (is.na(NA_character_)) 
[17:28:26.705]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.705]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:26.705]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:26.705]                     .init = FALSE)
[17:28:26.705]                 }
[17:28:26.705]             }
[17:28:26.705]         }
[17:28:26.705]     })
[17:28:26.705]     if (TRUE) {
[17:28:26.705]         base::sink(type = "output", split = FALSE)
[17:28:26.705]         if (TRUE) {
[17:28:26.705]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:26.705]         }
[17:28:26.705]         else {
[17:28:26.705]             ...future.result["stdout"] <- base::list(NULL)
[17:28:26.705]         }
[17:28:26.705]         base::close(...future.stdout)
[17:28:26.705]         ...future.stdout <- NULL
[17:28:26.705]     }
[17:28:26.705]     ...future.result$conditions <- ...future.conditions
[17:28:26.705]     ...future.result$finished <- base::Sys.time()
[17:28:26.705]     ...future.result
[17:28:26.705] }
[17:28:26.709] plan(): Setting new future strategy stack:
[17:28:26.709] List of future strategies:
[17:28:26.709] 1. sequential:
[17:28:26.709]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.709]    - tweaked: FALSE
[17:28:26.709]    - call: NULL
[17:28:26.710] plan(): nbrOfWorkers() = 1
[17:28:26.711] plan(): Setting new future strategy stack:
[17:28:26.711] List of future strategies:
[17:28:26.711] 1. sequential:
[17:28:26.711]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.711]    - tweaked: FALSE
[17:28:26.711]    - call: plan(strategy)
[17:28:26.711] plan(): nbrOfWorkers() = 1
[17:28:26.712] SequentialFuture started (and completed)
[17:28:26.712] - Launch lazy future ... done
[17:28:26.712] run() for 'SequentialFuture' ... done
[1] 42
sequential ... done
Testing with 1 cores ... done
Testing with 2 cores ...
multisession ...
[17:28:26.719] plan(): Setting new future strategy stack:
[17:28:26.719] List of future strategies:
[17:28:26.719] 1. multisession:
[17:28:26.719]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:26.719]    - tweaked: FALSE
[17:28:26.719]    - call: plan(strategy)
[17:28:26.720] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:28:26.720] multisession:
[17:28:26.720] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:26.720] - tweaked: FALSE
[17:28:26.720] - call: plan(strategy)
[17:28:26.724] getGlobalsAndPackages() ...
[17:28:26.724] Not searching for globals
[17:28:26.724] - globals: [0] <none>
[17:28:26.725] getGlobalsAndPackages() ... DONE
[17:28:26.725] [local output] makeClusterPSOCK() ...
[17:28:26.758] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:28:26.764] [local output] Base port: 28020
[17:28:26.765] [local output] Getting setup options for 2 cluster nodes ...
[17:28:26.765] [local output]  - Node 1 of 2 ...
[17:28:26.765] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:26.767] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpQXaCt4/worker.rank=1.parallelly.parent=162072.2791877925d8f.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpQXaCt4/worker.rank=1.parallelly.parent=162072.2791877925d8f.pid\")"'
[17:28:27.094] - Possible to infer worker's PID: TRUE
[17:28:27.095] [local output] Rscript port: 28020

[17:28:27.096] [local output]  - Node 2 of 2 ...
[17:28:27.096] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:27.097] [local output] Rscript port: 28020

[17:28:27.098] [local output] Getting setup options for 2 cluster nodes ... done
[17:28:27.098] [local output]  - Parallel setup requested for some PSOCK nodes
[17:28:27.099] [local output] Setting up PSOCK nodes in parallel
[17:28:27.099] List of 36
[17:28:27.099]  $ worker          : chr "localhost"
[17:28:27.099]   ..- attr(*, "localhost")= logi TRUE
[17:28:27.099]  $ master          : chr "localhost"
[17:28:27.099]  $ port            : int 28020
[17:28:27.099]  $ connectTimeout  : num 120
[17:28:27.099]  $ timeout         : num 120
[17:28:27.099]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:28:27.099]  $ homogeneous     : logi TRUE
[17:28:27.099]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=stdout.R:162072:CRANWIN3:CRAN\" "| __truncated__
[17:28:27.099]  $ rscript_envs    : NULL
[17:28:27.099]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:28:27.099]  $ rscript_startup : NULL
[17:28:27.099]  $ rscript_sh      : chr "cmd"
[17:28:27.099]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:27.099]  $ methods         : logi TRUE
[17:28:27.099]  $ socketOptions   : chr "no-delay"
[17:28:27.099]  $ useXDR          : logi FALSE
[17:28:27.099]  $ outfile         : chr "/dev/null"
[17:28:27.099]  $ renice          : int NA
[17:28:27.099]  $ rshcmd          : NULL
[17:28:27.099]  $ user            : chr(0) 
[17:28:27.099]  $ revtunnel       : logi FALSE
[17:28:27.099]  $ rshlogfile      : NULL
[17:28:27.099]  $ rshopts         : chr(0) 
[17:28:27.099]  $ rank            : int 1
[17:28:27.099]  $ manual          : logi FALSE
[17:28:27.099]  $ dryrun          : logi FALSE
[17:28:27.099]  $ quiet           : logi FALSE
[17:28:27.099]  $ setup_strategy  : chr "parallel"
[17:28:27.099]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:27.099]  $ pidfile         : chr "D:/temp/RtmpQXaCt4/worker.rank=1.parallelly.parent=162072.2791877925d8f.pid"
[17:28:27.099]  $ rshcmd_label    : NULL
[17:28:27.099]  $ rsh_call        : NULL
[17:28:27.099]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:27.099]  $ localMachine    : logi TRUE
[17:28:27.099]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:28:27.099]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:28:27.099]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:28:27.099]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:28:27.099]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:28:27.099]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[17:28:27.099]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:28:27.099]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:28:27.099]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:28:27.099]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:28:27.099]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:28:27.099]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:28:27.099]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:28:27.099]  $ arguments       :List of 28
[17:28:27.099]   ..$ worker          : chr "localhost"
[17:28:27.099]   ..$ master          : NULL
[17:28:27.099]   ..$ port            : int 28020
[17:28:27.099]   ..$ connectTimeout  : num 120
[17:28:27.099]   ..$ timeout         : num 120
[17:28:27.099]   ..$ rscript         : NULL
[17:28:27.099]   ..$ homogeneous     : NULL
[17:28:27.099]   ..$ rscript_args    : NULL
[17:28:27.099]   ..$ rscript_envs    : NULL
[17:28:27.099]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:28:27.099]   ..$ rscript_startup : NULL
[17:28:27.099]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[17:28:27.099]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:27.099]   ..$ methods         : logi TRUE
[17:28:27.099]   ..$ socketOptions   : chr "no-delay"
[17:28:27.099]   ..$ useXDR          : logi FALSE
[17:28:27.099]   ..$ outfile         : chr "/dev/null"
[17:28:27.099]   ..$ renice          : int NA
[17:28:27.099]   ..$ rshcmd          : NULL
[17:28:27.099]   ..$ user            : NULL
[17:28:27.099]   ..$ revtunnel       : logi NA
[17:28:27.099]   ..$ rshlogfile      : NULL
[17:28:27.099]   ..$ rshopts         : NULL
[17:28:27.099]   ..$ rank            : int 1
[17:28:27.099]   ..$ manual          : logi FALSE
[17:28:27.099]   ..$ dryrun          : logi FALSE
[17:28:27.099]   ..$ quiet           : logi FALSE
[17:28:27.099]   ..$ setup_strategy  : chr "parallel"
[17:28:27.099]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:28:27.120] [local output] System call to launch all workers:
[17:28:27.121] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=stdout.R:162072:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpQXaCt4/worker.rank=1.parallelly.parent=162072.2791877925d8f.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=28020 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:28:27.121] [local output] Starting PSOCK main server
[17:28:27.127] [local output] Workers launched
[17:28:27.127] [local output] Waiting for workers to connect back
[17:28:27.127]  - [local output] 0 workers out of 2 ready
[17:28:27.292]  - [local output] 0 workers out of 2 ready
[17:28:27.292]  - [local output] 1 workers out of 2 ready
[17:28:27.293]  - [local output] 2 workers out of 2 ready
[17:28:27.293] [local output] Launching of workers completed
[17:28:27.293] [local output] Collecting session information from workers
[17:28:27.294] [local output]  - Worker #1 of 2
[17:28:27.295] [local output]  - Worker #2 of 2
[17:28:27.295] [local output] makeClusterPSOCK() ... done
[17:28:27.308] Packages needed by the future expression (n = 0): <none>
[17:28:27.308] Packages needed by future strategies (n = 0): <none>
[17:28:27.309] {
[17:28:27.309]     {
[17:28:27.309]         {
[17:28:27.309]             ...future.startTime <- base::Sys.time()
[17:28:27.309]             {
[17:28:27.309]                 {
[17:28:27.309]                   {
[17:28:27.309]                     {
[17:28:27.309]                       base::local({
[17:28:27.309]                         has_future <- base::requireNamespace("future", 
[17:28:27.309]                           quietly = TRUE)
[17:28:27.309]                         if (has_future) {
[17:28:27.309]                           ns <- base::getNamespace("future")
[17:28:27.309]                           version <- ns[[".package"]][["version"]]
[17:28:27.309]                           if (is.null(version)) 
[17:28:27.309]                             version <- utils::packageVersion("future")
[17:28:27.309]                         }
[17:28:27.309]                         else {
[17:28:27.309]                           version <- NULL
[17:28:27.309]                         }
[17:28:27.309]                         if (!has_future || version < "1.8.0") {
[17:28:27.309]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.309]                             "", base::R.version$version.string), 
[17:28:27.309]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:27.309]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:27.309]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.309]                               "release", "version")], collapse = " "), 
[17:28:27.309]                             hostname = base::Sys.info()[["nodename"]])
[17:28:27.309]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.309]                             info)
[17:28:27.309]                           info <- base::paste(info, collapse = "; ")
[17:28:27.309]                           if (!has_future) {
[17:28:27.309]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.309]                               info)
[17:28:27.309]                           }
[17:28:27.309]                           else {
[17:28:27.309]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.309]                               info, version)
[17:28:27.309]                           }
[17:28:27.309]                           base::stop(msg)
[17:28:27.309]                         }
[17:28:27.309]                       })
[17:28:27.309]                     }
[17:28:27.309]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.309]                     base::options(mc.cores = 1L)
[17:28:27.309]                   }
[17:28:27.309]                   ...future.strategy.old <- future::plan("list")
[17:28:27.309]                   options(future.plan = NULL)
[17:28:27.309]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.309]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.309]                 }
[17:28:27.309]                 ...future.workdir <- getwd()
[17:28:27.309]             }
[17:28:27.309]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.309]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.309]         }
[17:28:27.309]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.309]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.309]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.309]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.309]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.309]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.309]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.309]             base::names(...future.oldOptions))
[17:28:27.309]     }
[17:28:27.309]     if (FALSE) {
[17:28:27.309]     }
[17:28:27.309]     else {
[17:28:27.309]         if (TRUE) {
[17:28:27.309]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.309]                 open = "w")
[17:28:27.309]         }
[17:28:27.309]         else {
[17:28:27.309]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.309]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.309]         }
[17:28:27.309]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.309]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.309]             base::sink(type = "output", split = FALSE)
[17:28:27.309]             base::close(...future.stdout)
[17:28:27.309]         }, add = TRUE)
[17:28:27.309]     }
[17:28:27.309]     ...future.frame <- base::sys.nframe()
[17:28:27.309]     ...future.conditions <- base::list()
[17:28:27.309]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.309]     if (FALSE) {
[17:28:27.309]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.309]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.309]     }
[17:28:27.309]     ...future.result <- base::tryCatch({
[17:28:27.309]         base::withCallingHandlers({
[17:28:27.309]             ...future.value <- base::withVisible(base::local({
[17:28:27.309]                 ...future.makeSendCondition <- base::local({
[17:28:27.309]                   sendCondition <- NULL
[17:28:27.309]                   function(frame = 1L) {
[17:28:27.309]                     if (is.function(sendCondition)) 
[17:28:27.309]                       return(sendCondition)
[17:28:27.309]                     ns <- getNamespace("parallel")
[17:28:27.309]                     if (exists("sendData", mode = "function", 
[17:28:27.309]                       envir = ns)) {
[17:28:27.309]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.309]                         envir = ns)
[17:28:27.309]                       envir <- sys.frame(frame)
[17:28:27.309]                       master <- NULL
[17:28:27.309]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.309]                         !identical(envir, emptyenv())) {
[17:28:27.309]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.309]                           inherits = FALSE)) {
[17:28:27.309]                           master <- get("master", mode = "list", 
[17:28:27.309]                             envir = envir, inherits = FALSE)
[17:28:27.309]                           if (inherits(master, c("SOCKnode", 
[17:28:27.309]                             "SOCK0node"))) {
[17:28:27.309]                             sendCondition <<- function(cond) {
[17:28:27.309]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.309]                                 success = TRUE)
[17:28:27.309]                               parallel_sendData(master, data)
[17:28:27.309]                             }
[17:28:27.309]                             return(sendCondition)
[17:28:27.309]                           }
[17:28:27.309]                         }
[17:28:27.309]                         frame <- frame + 1L
[17:28:27.309]                         envir <- sys.frame(frame)
[17:28:27.309]                       }
[17:28:27.309]                     }
[17:28:27.309]                     sendCondition <<- function(cond) NULL
[17:28:27.309]                   }
[17:28:27.309]                 })
[17:28:27.309]                 withCallingHandlers({
[17:28:27.309]                   NA
[17:28:27.309]                 }, immediateCondition = function(cond) {
[17:28:27.309]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.309]                   sendCondition(cond)
[17:28:27.309]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.309]                   {
[17:28:27.309]                     inherits <- base::inherits
[17:28:27.309]                     invokeRestart <- base::invokeRestart
[17:28:27.309]                     is.null <- base::is.null
[17:28:27.309]                     muffled <- FALSE
[17:28:27.309]                     if (inherits(cond, "message")) {
[17:28:27.309]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.309]                       if (muffled) 
[17:28:27.309]                         invokeRestart("muffleMessage")
[17:28:27.309]                     }
[17:28:27.309]                     else if (inherits(cond, "warning")) {
[17:28:27.309]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.309]                       if (muffled) 
[17:28:27.309]                         invokeRestart("muffleWarning")
[17:28:27.309]                     }
[17:28:27.309]                     else if (inherits(cond, "condition")) {
[17:28:27.309]                       if (!is.null(pattern)) {
[17:28:27.309]                         computeRestarts <- base::computeRestarts
[17:28:27.309]                         grepl <- base::grepl
[17:28:27.309]                         restarts <- computeRestarts(cond)
[17:28:27.309]                         for (restart in restarts) {
[17:28:27.309]                           name <- restart$name
[17:28:27.309]                           if (is.null(name)) 
[17:28:27.309]                             next
[17:28:27.309]                           if (!grepl(pattern, name)) 
[17:28:27.309]                             next
[17:28:27.309]                           invokeRestart(restart)
[17:28:27.309]                           muffled <- TRUE
[17:28:27.309]                           break
[17:28:27.309]                         }
[17:28:27.309]                       }
[17:28:27.309]                     }
[17:28:27.309]                     invisible(muffled)
[17:28:27.309]                   }
[17:28:27.309]                   muffleCondition(cond)
[17:28:27.309]                 })
[17:28:27.309]             }))
[17:28:27.309]             future::FutureResult(value = ...future.value$value, 
[17:28:27.309]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.309]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.309]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.309]                     ...future.globalenv.names))
[17:28:27.309]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.309]         }, condition = base::local({
[17:28:27.309]             c <- base::c
[17:28:27.309]             inherits <- base::inherits
[17:28:27.309]             invokeRestart <- base::invokeRestart
[17:28:27.309]             length <- base::length
[17:28:27.309]             list <- base::list
[17:28:27.309]             seq.int <- base::seq.int
[17:28:27.309]             signalCondition <- base::signalCondition
[17:28:27.309]             sys.calls <- base::sys.calls
[17:28:27.309]             `[[` <- base::`[[`
[17:28:27.309]             `+` <- base::`+`
[17:28:27.309]             `<<-` <- base::`<<-`
[17:28:27.309]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.309]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.309]                   3L)]
[17:28:27.309]             }
[17:28:27.309]             function(cond) {
[17:28:27.309]                 is_error <- inherits(cond, "error")
[17:28:27.309]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.309]                   NULL)
[17:28:27.309]                 if (is_error) {
[17:28:27.309]                   sessionInformation <- function() {
[17:28:27.309]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.309]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.309]                       search = base::search(), system = base::Sys.info())
[17:28:27.309]                   }
[17:28:27.309]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.309]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.309]                     cond$call), session = sessionInformation(), 
[17:28:27.309]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.309]                   signalCondition(cond)
[17:28:27.309]                 }
[17:28:27.309]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.309]                 "immediateCondition"))) {
[17:28:27.309]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.309]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.309]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.309]                   if (TRUE && !signal) {
[17:28:27.309]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.309]                     {
[17:28:27.309]                       inherits <- base::inherits
[17:28:27.309]                       invokeRestart <- base::invokeRestart
[17:28:27.309]                       is.null <- base::is.null
[17:28:27.309]                       muffled <- FALSE
[17:28:27.309]                       if (inherits(cond, "message")) {
[17:28:27.309]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.309]                         if (muffled) 
[17:28:27.309]                           invokeRestart("muffleMessage")
[17:28:27.309]                       }
[17:28:27.309]                       else if (inherits(cond, "warning")) {
[17:28:27.309]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.309]                         if (muffled) 
[17:28:27.309]                           invokeRestart("muffleWarning")
[17:28:27.309]                       }
[17:28:27.309]                       else if (inherits(cond, "condition")) {
[17:28:27.309]                         if (!is.null(pattern)) {
[17:28:27.309]                           computeRestarts <- base::computeRestarts
[17:28:27.309]                           grepl <- base::grepl
[17:28:27.309]                           restarts <- computeRestarts(cond)
[17:28:27.309]                           for (restart in restarts) {
[17:28:27.309]                             name <- restart$name
[17:28:27.309]                             if (is.null(name)) 
[17:28:27.309]                               next
[17:28:27.309]                             if (!grepl(pattern, name)) 
[17:28:27.309]                               next
[17:28:27.309]                             invokeRestart(restart)
[17:28:27.309]                             muffled <- TRUE
[17:28:27.309]                             break
[17:28:27.309]                           }
[17:28:27.309]                         }
[17:28:27.309]                       }
[17:28:27.309]                       invisible(muffled)
[17:28:27.309]                     }
[17:28:27.309]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.309]                   }
[17:28:27.309]                 }
[17:28:27.309]                 else {
[17:28:27.309]                   if (TRUE) {
[17:28:27.309]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.309]                     {
[17:28:27.309]                       inherits <- base::inherits
[17:28:27.309]                       invokeRestart <- base::invokeRestart
[17:28:27.309]                       is.null <- base::is.null
[17:28:27.309]                       muffled <- FALSE
[17:28:27.309]                       if (inherits(cond, "message")) {
[17:28:27.309]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.309]                         if (muffled) 
[17:28:27.309]                           invokeRestart("muffleMessage")
[17:28:27.309]                       }
[17:28:27.309]                       else if (inherits(cond, "warning")) {
[17:28:27.309]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.309]                         if (muffled) 
[17:28:27.309]                           invokeRestart("muffleWarning")
[17:28:27.309]                       }
[17:28:27.309]                       else if (inherits(cond, "condition")) {
[17:28:27.309]                         if (!is.null(pattern)) {
[17:28:27.309]                           computeRestarts <- base::computeRestarts
[17:28:27.309]                           grepl <- base::grepl
[17:28:27.309]                           restarts <- computeRestarts(cond)
[17:28:27.309]                           for (restart in restarts) {
[17:28:27.309]                             name <- restart$name
[17:28:27.309]                             if (is.null(name)) 
[17:28:27.309]                               next
[17:28:27.309]                             if (!grepl(pattern, name)) 
[17:28:27.309]                               next
[17:28:27.309]                             invokeRestart(restart)
[17:28:27.309]                             muffled <- TRUE
[17:28:27.309]                             break
[17:28:27.309]                           }
[17:28:27.309]                         }
[17:28:27.309]                       }
[17:28:27.309]                       invisible(muffled)
[17:28:27.309]                     }
[17:28:27.309]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.309]                   }
[17:28:27.309]                 }
[17:28:27.309]             }
[17:28:27.309]         }))
[17:28:27.309]     }, error = function(ex) {
[17:28:27.309]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.309]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.309]                 ...future.rng), started = ...future.startTime, 
[17:28:27.309]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.309]             version = "1.8"), class = "FutureResult")
[17:28:27.309]     }, finally = {
[17:28:27.309]         if (!identical(...future.workdir, getwd())) 
[17:28:27.309]             setwd(...future.workdir)
[17:28:27.309]         {
[17:28:27.309]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.309]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.309]             }
[17:28:27.309]             base::options(...future.oldOptions)
[17:28:27.309]             if (.Platform$OS.type == "windows") {
[17:28:27.309]                 old_names <- names(...future.oldEnvVars)
[17:28:27.309]                 envs <- base::Sys.getenv()
[17:28:27.309]                 names <- names(envs)
[17:28:27.309]                 common <- intersect(names, old_names)
[17:28:27.309]                 added <- setdiff(names, old_names)
[17:28:27.309]                 removed <- setdiff(old_names, names)
[17:28:27.309]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.309]                   envs[common]]
[17:28:27.309]                 NAMES <- toupper(changed)
[17:28:27.309]                 args <- list()
[17:28:27.309]                 for (kk in seq_along(NAMES)) {
[17:28:27.309]                   name <- changed[[kk]]
[17:28:27.309]                   NAME <- NAMES[[kk]]
[17:28:27.309]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.309]                     next
[17:28:27.309]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.309]                 }
[17:28:27.309]                 NAMES <- toupper(added)
[17:28:27.309]                 for (kk in seq_along(NAMES)) {
[17:28:27.309]                   name <- added[[kk]]
[17:28:27.309]                   NAME <- NAMES[[kk]]
[17:28:27.309]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.309]                     next
[17:28:27.309]                   args[[name]] <- ""
[17:28:27.309]                 }
[17:28:27.309]                 NAMES <- toupper(removed)
[17:28:27.309]                 for (kk in seq_along(NAMES)) {
[17:28:27.309]                   name <- removed[[kk]]
[17:28:27.309]                   NAME <- NAMES[[kk]]
[17:28:27.309]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.309]                     next
[17:28:27.309]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.309]                 }
[17:28:27.309]                 if (length(args) > 0) 
[17:28:27.309]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.309]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.309]             }
[17:28:27.309]             else {
[17:28:27.309]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.309]             }
[17:28:27.309]             {
[17:28:27.309]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.309]                   0L) {
[17:28:27.309]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.309]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.309]                   base::options(opts)
[17:28:27.309]                 }
[17:28:27.309]                 {
[17:28:27.309]                   {
[17:28:27.309]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.309]                     NULL
[17:28:27.309]                   }
[17:28:27.309]                   options(future.plan = NULL)
[17:28:27.309]                   if (is.na(NA_character_)) 
[17:28:27.309]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.309]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.309]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.309]                     .init = FALSE)
[17:28:27.309]                 }
[17:28:27.309]             }
[17:28:27.309]         }
[17:28:27.309]     })
[17:28:27.309]     if (TRUE) {
[17:28:27.309]         base::sink(type = "output", split = FALSE)
[17:28:27.309]         if (TRUE) {
[17:28:27.309]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.309]         }
[17:28:27.309]         else {
[17:28:27.309]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.309]         }
[17:28:27.309]         base::close(...future.stdout)
[17:28:27.309]         ...future.stdout <- NULL
[17:28:27.309]     }
[17:28:27.309]     ...future.result$conditions <- ...future.conditions
[17:28:27.309]     ...future.result$finished <- base::Sys.time()
[17:28:27.309]     ...future.result
[17:28:27.309] }
[17:28:27.390] MultisessionFuture started
[17:28:27.390] result() for ClusterFuture ...
[17:28:27.391] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.391] - Validating connection of MultisessionFuture
[17:28:27.443] - received message: FutureResult
[17:28:27.443] - Received FutureResult
[17:28:27.446] - Erased future from FutureRegistry
[17:28:27.447] result() for ClusterFuture ...
[17:28:27.447] - result already collected: FutureResult
[17:28:27.447] result() for ClusterFuture ... done
[17:28:27.447] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:27.447] result() for ClusterFuture ... done
[17:28:27.447] result() for ClusterFuture ...
[17:28:27.448] - result already collected: FutureResult
[17:28:27.448] result() for ClusterFuture ... done
[17:28:27.448] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:28:27.451] plan(): nbrOfWorkers() = 2
- stdout = TRUE
[17:28:27.451] getGlobalsAndPackages() ...
[17:28:27.451] Searching for globals...
[17:28:27.456] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:28:27.456] Searching for globals ... DONE
[17:28:27.456] Resolving globals: FALSE
[17:28:27.457] 
[17:28:27.457] - packages: [1] 'utils'
[17:28:27.457] getGlobalsAndPackages() ... DONE
[17:28:27.458] run() for 'Future' ...
[17:28:27.458] - state: 'created'
[17:28:27.458] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:27.472] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:27.472] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:27.472]   - Field: 'node'
[17:28:27.473]   - Field: 'label'
[17:28:27.473]   - Field: 'local'
[17:28:27.473]   - Field: 'owner'
[17:28:27.473]   - Field: 'envir'
[17:28:27.474]   - Field: 'workers'
[17:28:27.474]   - Field: 'packages'
[17:28:27.474]   - Field: 'gc'
[17:28:27.474]   - Field: 'conditions'
[17:28:27.474]   - Field: 'persistent'
[17:28:27.474]   - Field: 'expr'
[17:28:27.475]   - Field: 'uuid'
[17:28:27.475]   - Field: 'seed'
[17:28:27.475]   - Field: 'version'
[17:28:27.475]   - Field: 'result'
[17:28:27.475]   - Field: 'asynchronous'
[17:28:27.476]   - Field: 'calls'
[17:28:27.476]   - Field: 'globals'
[17:28:27.476]   - Field: 'stdout'
[17:28:27.476]   - Field: 'earlySignal'
[17:28:27.476]   - Field: 'lazy'
[17:28:27.477]   - Field: 'state'
[17:28:27.477] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:27.477] - Launch lazy future ...
[17:28:27.477] Packages needed by the future expression (n = 1): 'utils'
[17:28:27.478] Packages needed by future strategies (n = 0): <none>
[17:28:27.478] {
[17:28:27.478]     {
[17:28:27.478]         {
[17:28:27.478]             ...future.startTime <- base::Sys.time()
[17:28:27.478]             {
[17:28:27.478]                 {
[17:28:27.478]                   {
[17:28:27.478]                     {
[17:28:27.478]                       {
[17:28:27.478]                         base::local({
[17:28:27.478]                           has_future <- base::requireNamespace("future", 
[17:28:27.478]                             quietly = TRUE)
[17:28:27.478]                           if (has_future) {
[17:28:27.478]                             ns <- base::getNamespace("future")
[17:28:27.478]                             version <- ns[[".package"]][["version"]]
[17:28:27.478]                             if (is.null(version)) 
[17:28:27.478]                               version <- utils::packageVersion("future")
[17:28:27.478]                           }
[17:28:27.478]                           else {
[17:28:27.478]                             version <- NULL
[17:28:27.478]                           }
[17:28:27.478]                           if (!has_future || version < "1.8.0") {
[17:28:27.478]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.478]                               "", base::R.version$version.string), 
[17:28:27.478]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:27.478]                                 base::R.version$platform, 8 * 
[17:28:27.478]                                   base::.Machine$sizeof.pointer), 
[17:28:27.478]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.478]                                 "release", "version")], collapse = " "), 
[17:28:27.478]                               hostname = base::Sys.info()[["nodename"]])
[17:28:27.478]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.478]                               info)
[17:28:27.478]                             info <- base::paste(info, collapse = "; ")
[17:28:27.478]                             if (!has_future) {
[17:28:27.478]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.478]                                 info)
[17:28:27.478]                             }
[17:28:27.478]                             else {
[17:28:27.478]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.478]                                 info, version)
[17:28:27.478]                             }
[17:28:27.478]                             base::stop(msg)
[17:28:27.478]                           }
[17:28:27.478]                         })
[17:28:27.478]                       }
[17:28:27.478]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.478]                       base::options(mc.cores = 1L)
[17:28:27.478]                     }
[17:28:27.478]                     base::local({
[17:28:27.478]                       for (pkg in "utils") {
[17:28:27.478]                         base::loadNamespace(pkg)
[17:28:27.478]                         base::library(pkg, character.only = TRUE)
[17:28:27.478]                       }
[17:28:27.478]                     })
[17:28:27.478]                   }
[17:28:27.478]                   ...future.strategy.old <- future::plan("list")
[17:28:27.478]                   options(future.plan = NULL)
[17:28:27.478]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.478]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.478]                 }
[17:28:27.478]                 ...future.workdir <- getwd()
[17:28:27.478]             }
[17:28:27.478]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.478]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.478]         }
[17:28:27.478]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.478]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.478]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.478]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.478]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.478]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.478]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.478]             base::names(...future.oldOptions))
[17:28:27.478]     }
[17:28:27.478]     if (FALSE) {
[17:28:27.478]     }
[17:28:27.478]     else {
[17:28:27.478]         if (TRUE) {
[17:28:27.478]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.478]                 open = "w")
[17:28:27.478]         }
[17:28:27.478]         else {
[17:28:27.478]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.478]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.478]         }
[17:28:27.478]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.478]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.478]             base::sink(type = "output", split = FALSE)
[17:28:27.478]             base::close(...future.stdout)
[17:28:27.478]         }, add = TRUE)
[17:28:27.478]     }
[17:28:27.478]     ...future.frame <- base::sys.nframe()
[17:28:27.478]     ...future.conditions <- base::list()
[17:28:27.478]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.478]     if (FALSE) {
[17:28:27.478]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.478]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.478]     }
[17:28:27.478]     ...future.result <- base::tryCatch({
[17:28:27.478]         base::withCallingHandlers({
[17:28:27.478]             ...future.value <- base::withVisible(base::local({
[17:28:27.478]                 ...future.makeSendCondition <- base::local({
[17:28:27.478]                   sendCondition <- NULL
[17:28:27.478]                   function(frame = 1L) {
[17:28:27.478]                     if (is.function(sendCondition)) 
[17:28:27.478]                       return(sendCondition)
[17:28:27.478]                     ns <- getNamespace("parallel")
[17:28:27.478]                     if (exists("sendData", mode = "function", 
[17:28:27.478]                       envir = ns)) {
[17:28:27.478]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.478]                         envir = ns)
[17:28:27.478]                       envir <- sys.frame(frame)
[17:28:27.478]                       master <- NULL
[17:28:27.478]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.478]                         !identical(envir, emptyenv())) {
[17:28:27.478]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.478]                           inherits = FALSE)) {
[17:28:27.478]                           master <- get("master", mode = "list", 
[17:28:27.478]                             envir = envir, inherits = FALSE)
[17:28:27.478]                           if (inherits(master, c("SOCKnode", 
[17:28:27.478]                             "SOCK0node"))) {
[17:28:27.478]                             sendCondition <<- function(cond) {
[17:28:27.478]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.478]                                 success = TRUE)
[17:28:27.478]                               parallel_sendData(master, data)
[17:28:27.478]                             }
[17:28:27.478]                             return(sendCondition)
[17:28:27.478]                           }
[17:28:27.478]                         }
[17:28:27.478]                         frame <- frame + 1L
[17:28:27.478]                         envir <- sys.frame(frame)
[17:28:27.478]                       }
[17:28:27.478]                     }
[17:28:27.478]                     sendCondition <<- function(cond) NULL
[17:28:27.478]                   }
[17:28:27.478]                 })
[17:28:27.478]                 withCallingHandlers({
[17:28:27.478]                   {
[17:28:27.478]                     print(1:50)
[17:28:27.478]                     str(1:50)
[17:28:27.478]                     cat(letters, sep = "-")
[17:28:27.478]                     cat(1:6, collapse = "\n")
[17:28:27.478]                     write.table(datasets::iris[1:10, ], sep = "\t")
[17:28:27.478]                     42L
[17:28:27.478]                   }
[17:28:27.478]                 }, immediateCondition = function(cond) {
[17:28:27.478]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.478]                   sendCondition(cond)
[17:28:27.478]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.478]                   {
[17:28:27.478]                     inherits <- base::inherits
[17:28:27.478]                     invokeRestart <- base::invokeRestart
[17:28:27.478]                     is.null <- base::is.null
[17:28:27.478]                     muffled <- FALSE
[17:28:27.478]                     if (inherits(cond, "message")) {
[17:28:27.478]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.478]                       if (muffled) 
[17:28:27.478]                         invokeRestart("muffleMessage")
[17:28:27.478]                     }
[17:28:27.478]                     else if (inherits(cond, "warning")) {
[17:28:27.478]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.478]                       if (muffled) 
[17:28:27.478]                         invokeRestart("muffleWarning")
[17:28:27.478]                     }
[17:28:27.478]                     else if (inherits(cond, "condition")) {
[17:28:27.478]                       if (!is.null(pattern)) {
[17:28:27.478]                         computeRestarts <- base::computeRestarts
[17:28:27.478]                         grepl <- base::grepl
[17:28:27.478]                         restarts <- computeRestarts(cond)
[17:28:27.478]                         for (restart in restarts) {
[17:28:27.478]                           name <- restart$name
[17:28:27.478]                           if (is.null(name)) 
[17:28:27.478]                             next
[17:28:27.478]                           if (!grepl(pattern, name)) 
[17:28:27.478]                             next
[17:28:27.478]                           invokeRestart(restart)
[17:28:27.478]                           muffled <- TRUE
[17:28:27.478]                           break
[17:28:27.478]                         }
[17:28:27.478]                       }
[17:28:27.478]                     }
[17:28:27.478]                     invisible(muffled)
[17:28:27.478]                   }
[17:28:27.478]                   muffleCondition(cond)
[17:28:27.478]                 })
[17:28:27.478]             }))
[17:28:27.478]             future::FutureResult(value = ...future.value$value, 
[17:28:27.478]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.478]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.478]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.478]                     ...future.globalenv.names))
[17:28:27.478]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.478]         }, condition = base::local({
[17:28:27.478]             c <- base::c
[17:28:27.478]             inherits <- base::inherits
[17:28:27.478]             invokeRestart <- base::invokeRestart
[17:28:27.478]             length <- base::length
[17:28:27.478]             list <- base::list
[17:28:27.478]             seq.int <- base::seq.int
[17:28:27.478]             signalCondition <- base::signalCondition
[17:28:27.478]             sys.calls <- base::sys.calls
[17:28:27.478]             `[[` <- base::`[[`
[17:28:27.478]             `+` <- base::`+`
[17:28:27.478]             `<<-` <- base::`<<-`
[17:28:27.478]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.478]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.478]                   3L)]
[17:28:27.478]             }
[17:28:27.478]             function(cond) {
[17:28:27.478]                 is_error <- inherits(cond, "error")
[17:28:27.478]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.478]                   NULL)
[17:28:27.478]                 if (is_error) {
[17:28:27.478]                   sessionInformation <- function() {
[17:28:27.478]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.478]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.478]                       search = base::search(), system = base::Sys.info())
[17:28:27.478]                   }
[17:28:27.478]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.478]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.478]                     cond$call), session = sessionInformation(), 
[17:28:27.478]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.478]                   signalCondition(cond)
[17:28:27.478]                 }
[17:28:27.478]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.478]                 "immediateCondition"))) {
[17:28:27.478]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.478]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.478]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.478]                   if (TRUE && !signal) {
[17:28:27.478]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.478]                     {
[17:28:27.478]                       inherits <- base::inherits
[17:28:27.478]                       invokeRestart <- base::invokeRestart
[17:28:27.478]                       is.null <- base::is.null
[17:28:27.478]                       muffled <- FALSE
[17:28:27.478]                       if (inherits(cond, "message")) {
[17:28:27.478]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.478]                         if (muffled) 
[17:28:27.478]                           invokeRestart("muffleMessage")
[17:28:27.478]                       }
[17:28:27.478]                       else if (inherits(cond, "warning")) {
[17:28:27.478]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.478]                         if (muffled) 
[17:28:27.478]                           invokeRestart("muffleWarning")
[17:28:27.478]                       }
[17:28:27.478]                       else if (inherits(cond, "condition")) {
[17:28:27.478]                         if (!is.null(pattern)) {
[17:28:27.478]                           computeRestarts <- base::computeRestarts
[17:28:27.478]                           grepl <- base::grepl
[17:28:27.478]                           restarts <- computeRestarts(cond)
[17:28:27.478]                           for (restart in restarts) {
[17:28:27.478]                             name <- restart$name
[17:28:27.478]                             if (is.null(name)) 
[17:28:27.478]                               next
[17:28:27.478]                             if (!grepl(pattern, name)) 
[17:28:27.478]                               next
[17:28:27.478]                             invokeRestart(restart)
[17:28:27.478]                             muffled <- TRUE
[17:28:27.478]                             break
[17:28:27.478]                           }
[17:28:27.478]                         }
[17:28:27.478]                       }
[17:28:27.478]                       invisible(muffled)
[17:28:27.478]                     }
[17:28:27.478]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.478]                   }
[17:28:27.478]                 }
[17:28:27.478]                 else {
[17:28:27.478]                   if (TRUE) {
[17:28:27.478]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.478]                     {
[17:28:27.478]                       inherits <- base::inherits
[17:28:27.478]                       invokeRestart <- base::invokeRestart
[17:28:27.478]                       is.null <- base::is.null
[17:28:27.478]                       muffled <- FALSE
[17:28:27.478]                       if (inherits(cond, "message")) {
[17:28:27.478]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.478]                         if (muffled) 
[17:28:27.478]                           invokeRestart("muffleMessage")
[17:28:27.478]                       }
[17:28:27.478]                       else if (inherits(cond, "warning")) {
[17:28:27.478]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.478]                         if (muffled) 
[17:28:27.478]                           invokeRestart("muffleWarning")
[17:28:27.478]                       }
[17:28:27.478]                       else if (inherits(cond, "condition")) {
[17:28:27.478]                         if (!is.null(pattern)) {
[17:28:27.478]                           computeRestarts <- base::computeRestarts
[17:28:27.478]                           grepl <- base::grepl
[17:28:27.478]                           restarts <- computeRestarts(cond)
[17:28:27.478]                           for (restart in restarts) {
[17:28:27.478]                             name <- restart$name
[17:28:27.478]                             if (is.null(name)) 
[17:28:27.478]                               next
[17:28:27.478]                             if (!grepl(pattern, name)) 
[17:28:27.478]                               next
[17:28:27.478]                             invokeRestart(restart)
[17:28:27.478]                             muffled <- TRUE
[17:28:27.478]                             break
[17:28:27.478]                           }
[17:28:27.478]                         }
[17:28:27.478]                       }
[17:28:27.478]                       invisible(muffled)
[17:28:27.478]                     }
[17:28:27.478]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.478]                   }
[17:28:27.478]                 }
[17:28:27.478]             }
[17:28:27.478]         }))
[17:28:27.478]     }, error = function(ex) {
[17:28:27.478]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.478]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.478]                 ...future.rng), started = ...future.startTime, 
[17:28:27.478]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.478]             version = "1.8"), class = "FutureResult")
[17:28:27.478]     }, finally = {
[17:28:27.478]         if (!identical(...future.workdir, getwd())) 
[17:28:27.478]             setwd(...future.workdir)
[17:28:27.478]         {
[17:28:27.478]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.478]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.478]             }
[17:28:27.478]             base::options(...future.oldOptions)
[17:28:27.478]             if (.Platform$OS.type == "windows") {
[17:28:27.478]                 old_names <- names(...future.oldEnvVars)
[17:28:27.478]                 envs <- base::Sys.getenv()
[17:28:27.478]                 names <- names(envs)
[17:28:27.478]                 common <- intersect(names, old_names)
[17:28:27.478]                 added <- setdiff(names, old_names)
[17:28:27.478]                 removed <- setdiff(old_names, names)
[17:28:27.478]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.478]                   envs[common]]
[17:28:27.478]                 NAMES <- toupper(changed)
[17:28:27.478]                 args <- list()
[17:28:27.478]                 for (kk in seq_along(NAMES)) {
[17:28:27.478]                   name <- changed[[kk]]
[17:28:27.478]                   NAME <- NAMES[[kk]]
[17:28:27.478]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.478]                     next
[17:28:27.478]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.478]                 }
[17:28:27.478]                 NAMES <- toupper(added)
[17:28:27.478]                 for (kk in seq_along(NAMES)) {
[17:28:27.478]                   name <- added[[kk]]
[17:28:27.478]                   NAME <- NAMES[[kk]]
[17:28:27.478]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.478]                     next
[17:28:27.478]                   args[[name]] <- ""
[17:28:27.478]                 }
[17:28:27.478]                 NAMES <- toupper(removed)
[17:28:27.478]                 for (kk in seq_along(NAMES)) {
[17:28:27.478]                   name <- removed[[kk]]
[17:28:27.478]                   NAME <- NAMES[[kk]]
[17:28:27.478]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.478]                     next
[17:28:27.478]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.478]                 }
[17:28:27.478]                 if (length(args) > 0) 
[17:28:27.478]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.478]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.478]             }
[17:28:27.478]             else {
[17:28:27.478]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.478]             }
[17:28:27.478]             {
[17:28:27.478]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.478]                   0L) {
[17:28:27.478]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.478]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.478]                   base::options(opts)
[17:28:27.478]                 }
[17:28:27.478]                 {
[17:28:27.478]                   {
[17:28:27.478]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.478]                     NULL
[17:28:27.478]                   }
[17:28:27.478]                   options(future.plan = NULL)
[17:28:27.478]                   if (is.na(NA_character_)) 
[17:28:27.478]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.478]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.478]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.478]                     .init = FALSE)
[17:28:27.478]                 }
[17:28:27.478]             }
[17:28:27.478]         }
[17:28:27.478]     })
[17:28:27.478]     if (TRUE) {
[17:28:27.478]         base::sink(type = "output", split = FALSE)
[17:28:27.478]         if (TRUE) {
[17:28:27.478]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.478]         }
[17:28:27.478]         else {
[17:28:27.478]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.478]         }
[17:28:27.478]         base::close(...future.stdout)
[17:28:27.478]         ...future.stdout <- NULL
[17:28:27.478]     }
[17:28:27.478]     ...future.result$conditions <- ...future.conditions
[17:28:27.478]     ...future.result$finished <- base::Sys.time()
[17:28:27.478]     ...future.result
[17:28:27.478] }
[17:28:27.484] MultisessionFuture started
[17:28:27.485] - Launch lazy future ... done
[17:28:27.485] run() for 'MultisessionFuture' ... done
[17:28:27.485] result() for ClusterFuture ...
[17:28:27.485] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.486] - Validating connection of MultisessionFuture
[17:28:27.516] - received message: FutureResult
[17:28:27.517] - Received FutureResult
[17:28:27.517] - Erased future from FutureRegistry
[17:28:27.517] result() for ClusterFuture ...
[17:28:27.517] - result already collected: FutureResult
[17:28:27.517] result() for ClusterFuture ... done
[17:28:27.518] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:27.518] 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-03-26 17:28:27"
 $ finished    : POSIXct[1:1], format: "2024-03-26 17:28:27"
 $ session_uuid: chr "dd8dfb13-f506-00c3-2691-0463fe0fa50c"
  ..- 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 139024
  .. ..$ time  : POSIXct[1:1], format: "2024-03-26 17:28:27"
  .. ..$ random: int 2147483647
 $ r_info      :List of 4
  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1
  .. ..$ : int [1:3] 4 4 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[17:28:27.529] result() for ClusterFuture ...
[17:28:27.529] - result already collected: FutureResult
[17:28:27.529] result() for ClusterFuture ... done
[17:28:27.529] result() for ClusterFuture ...
[17:28:27.530] - result already collected: FutureResult
[17:28:27.530] 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.03177381 secs (started 2024-03-26 17:28:27.484841)
version: 1.8
[17:28:27.531] getGlobalsAndPackages() ...
[17:28:27.531] Searching for globals...
[17:28:27.535] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:28:27.535] Searching for globals ... DONE
[17:28:27.536] Resolving globals: FALSE
[17:28:27.536] 
[17:28:27.536] - packages: [1] 'utils'
[17:28:27.537] getGlobalsAndPackages() ... DONE
[17:28:27.537] run() for 'Future' ...
[17:28:27.537] - state: 'created'
[17:28:27.538] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:27.552] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:27.552] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:27.553]   - Field: 'node'
[17:28:27.553]   - Field: 'label'
[17:28:27.553]   - Field: 'local'
[17:28:27.553]   - Field: 'owner'
[17:28:27.553]   - Field: 'envir'
[17:28:27.554]   - Field: 'workers'
[17:28:27.554]   - Field: 'packages'
[17:28:27.554]   - Field: 'gc'
[17:28:27.554]   - Field: 'conditions'
[17:28:27.554]   - Field: 'persistent'
[17:28:27.555]   - Field: 'expr'
[17:28:27.555]   - Field: 'uuid'
[17:28:27.555]   - Field: 'seed'
[17:28:27.555]   - Field: 'version'
[17:28:27.555]   - Field: 'result'
[17:28:27.556]   - Field: 'asynchronous'
[17:28:27.556]   - Field: 'calls'
[17:28:27.556]   - Field: 'globals'
[17:28:27.556]   - Field: 'stdout'
[17:28:27.556]   - Field: 'earlySignal'
[17:28:27.557]   - Field: 'lazy'
[17:28:27.557]   - Field: 'state'
[17:28:27.557] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:27.557] - Launch lazy future ...
[17:28:27.558] Packages needed by the future expression (n = 1): 'utils'
[17:28:27.558] Packages needed by future strategies (n = 0): <none>
[17:28:27.559] {
[17:28:27.559]     {
[17:28:27.559]         {
[17:28:27.559]             ...future.startTime <- base::Sys.time()
[17:28:27.559]             {
[17:28:27.559]                 {
[17:28:27.559]                   {
[17:28:27.559]                     {
[17:28:27.559]                       {
[17:28:27.559]                         base::local({
[17:28:27.559]                           has_future <- base::requireNamespace("future", 
[17:28:27.559]                             quietly = TRUE)
[17:28:27.559]                           if (has_future) {
[17:28:27.559]                             ns <- base::getNamespace("future")
[17:28:27.559]                             version <- ns[[".package"]][["version"]]
[17:28:27.559]                             if (is.null(version)) 
[17:28:27.559]                               version <- utils::packageVersion("future")
[17:28:27.559]                           }
[17:28:27.559]                           else {
[17:28:27.559]                             version <- NULL
[17:28:27.559]                           }
[17:28:27.559]                           if (!has_future || version < "1.8.0") {
[17:28:27.559]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.559]                               "", base::R.version$version.string), 
[17:28:27.559]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:27.559]                                 base::R.version$platform, 8 * 
[17:28:27.559]                                   base::.Machine$sizeof.pointer), 
[17:28:27.559]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.559]                                 "release", "version")], collapse = " "), 
[17:28:27.559]                               hostname = base::Sys.info()[["nodename"]])
[17:28:27.559]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.559]                               info)
[17:28:27.559]                             info <- base::paste(info, collapse = "; ")
[17:28:27.559]                             if (!has_future) {
[17:28:27.559]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.559]                                 info)
[17:28:27.559]                             }
[17:28:27.559]                             else {
[17:28:27.559]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.559]                                 info, version)
[17:28:27.559]                             }
[17:28:27.559]                             base::stop(msg)
[17:28:27.559]                           }
[17:28:27.559]                         })
[17:28:27.559]                       }
[17:28:27.559]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.559]                       base::options(mc.cores = 1L)
[17:28:27.559]                     }
[17:28:27.559]                     base::local({
[17:28:27.559]                       for (pkg in "utils") {
[17:28:27.559]                         base::loadNamespace(pkg)
[17:28:27.559]                         base::library(pkg, character.only = TRUE)
[17:28:27.559]                       }
[17:28:27.559]                     })
[17:28:27.559]                   }
[17:28:27.559]                   ...future.strategy.old <- future::plan("list")
[17:28:27.559]                   options(future.plan = NULL)
[17:28:27.559]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.559]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.559]                 }
[17:28:27.559]                 ...future.workdir <- getwd()
[17:28:27.559]             }
[17:28:27.559]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.559]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.559]         }
[17:28:27.559]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.559]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.559]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.559]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.559]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.559]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.559]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.559]             base::names(...future.oldOptions))
[17:28:27.559]     }
[17:28:27.559]     if (FALSE) {
[17:28:27.559]     }
[17:28:27.559]     else {
[17:28:27.559]         if (TRUE) {
[17:28:27.559]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.559]                 open = "w")
[17:28:27.559]         }
[17:28:27.559]         else {
[17:28:27.559]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.559]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.559]         }
[17:28:27.559]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.559]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.559]             base::sink(type = "output", split = FALSE)
[17:28:27.559]             base::close(...future.stdout)
[17:28:27.559]         }, add = TRUE)
[17:28:27.559]     }
[17:28:27.559]     ...future.frame <- base::sys.nframe()
[17:28:27.559]     ...future.conditions <- base::list()
[17:28:27.559]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.559]     if (FALSE) {
[17:28:27.559]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.559]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.559]     }
[17:28:27.559]     ...future.result <- base::tryCatch({
[17:28:27.559]         base::withCallingHandlers({
[17:28:27.559]             ...future.value <- base::withVisible(base::local({
[17:28:27.559]                 ...future.makeSendCondition <- base::local({
[17:28:27.559]                   sendCondition <- NULL
[17:28:27.559]                   function(frame = 1L) {
[17:28:27.559]                     if (is.function(sendCondition)) 
[17:28:27.559]                       return(sendCondition)
[17:28:27.559]                     ns <- getNamespace("parallel")
[17:28:27.559]                     if (exists("sendData", mode = "function", 
[17:28:27.559]                       envir = ns)) {
[17:28:27.559]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.559]                         envir = ns)
[17:28:27.559]                       envir <- sys.frame(frame)
[17:28:27.559]                       master <- NULL
[17:28:27.559]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.559]                         !identical(envir, emptyenv())) {
[17:28:27.559]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.559]                           inherits = FALSE)) {
[17:28:27.559]                           master <- get("master", mode = "list", 
[17:28:27.559]                             envir = envir, inherits = FALSE)
[17:28:27.559]                           if (inherits(master, c("SOCKnode", 
[17:28:27.559]                             "SOCK0node"))) {
[17:28:27.559]                             sendCondition <<- function(cond) {
[17:28:27.559]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.559]                                 success = TRUE)
[17:28:27.559]                               parallel_sendData(master, data)
[17:28:27.559]                             }
[17:28:27.559]                             return(sendCondition)
[17:28:27.559]                           }
[17:28:27.559]                         }
[17:28:27.559]                         frame <- frame + 1L
[17:28:27.559]                         envir <- sys.frame(frame)
[17:28:27.559]                       }
[17:28:27.559]                     }
[17:28:27.559]                     sendCondition <<- function(cond) NULL
[17:28:27.559]                   }
[17:28:27.559]                 })
[17:28:27.559]                 withCallingHandlers({
[17:28:27.559]                   {
[17:28:27.559]                     print(1:50)
[17:28:27.559]                     str(1:50)
[17:28:27.559]                     cat(letters, sep = "-")
[17:28:27.559]                     cat(1:6, collapse = "\n")
[17:28:27.559]                     write.table(datasets::iris[1:10, ], sep = "\t")
[17:28:27.559]                     42L
[17:28:27.559]                   }
[17:28:27.559]                 }, immediateCondition = function(cond) {
[17:28:27.559]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.559]                   sendCondition(cond)
[17:28:27.559]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.559]                   {
[17:28:27.559]                     inherits <- base::inherits
[17:28:27.559]                     invokeRestart <- base::invokeRestart
[17:28:27.559]                     is.null <- base::is.null
[17:28:27.559]                     muffled <- FALSE
[17:28:27.559]                     if (inherits(cond, "message")) {
[17:28:27.559]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.559]                       if (muffled) 
[17:28:27.559]                         invokeRestart("muffleMessage")
[17:28:27.559]                     }
[17:28:27.559]                     else if (inherits(cond, "warning")) {
[17:28:27.559]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.559]                       if (muffled) 
[17:28:27.559]                         invokeRestart("muffleWarning")
[17:28:27.559]                     }
[17:28:27.559]                     else if (inherits(cond, "condition")) {
[17:28:27.559]                       if (!is.null(pattern)) {
[17:28:27.559]                         computeRestarts <- base::computeRestarts
[17:28:27.559]                         grepl <- base::grepl
[17:28:27.559]                         restarts <- computeRestarts(cond)
[17:28:27.559]                         for (restart in restarts) {
[17:28:27.559]                           name <- restart$name
[17:28:27.559]                           if (is.null(name)) 
[17:28:27.559]                             next
[17:28:27.559]                           if (!grepl(pattern, name)) 
[17:28:27.559]                             next
[17:28:27.559]                           invokeRestart(restart)
[17:28:27.559]                           muffled <- TRUE
[17:28:27.559]                           break
[17:28:27.559]                         }
[17:28:27.559]                       }
[17:28:27.559]                     }
[17:28:27.559]                     invisible(muffled)
[17:28:27.559]                   }
[17:28:27.559]                   muffleCondition(cond)
[17:28:27.559]                 })
[17:28:27.559]             }))
[17:28:27.559]             future::FutureResult(value = ...future.value$value, 
[17:28:27.559]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.559]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.559]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.559]                     ...future.globalenv.names))
[17:28:27.559]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.559]         }, condition = base::local({
[17:28:27.559]             c <- base::c
[17:28:27.559]             inherits <- base::inherits
[17:28:27.559]             invokeRestart <- base::invokeRestart
[17:28:27.559]             length <- base::length
[17:28:27.559]             list <- base::list
[17:28:27.559]             seq.int <- base::seq.int
[17:28:27.559]             signalCondition <- base::signalCondition
[17:28:27.559]             sys.calls <- base::sys.calls
[17:28:27.559]             `[[` <- base::`[[`
[17:28:27.559]             `+` <- base::`+`
[17:28:27.559]             `<<-` <- base::`<<-`
[17:28:27.559]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.559]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.559]                   3L)]
[17:28:27.559]             }
[17:28:27.559]             function(cond) {
[17:28:27.559]                 is_error <- inherits(cond, "error")
[17:28:27.559]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.559]                   NULL)
[17:28:27.559]                 if (is_error) {
[17:28:27.559]                   sessionInformation <- function() {
[17:28:27.559]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.559]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.559]                       search = base::search(), system = base::Sys.info())
[17:28:27.559]                   }
[17:28:27.559]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.559]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.559]                     cond$call), session = sessionInformation(), 
[17:28:27.559]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.559]                   signalCondition(cond)
[17:28:27.559]                 }
[17:28:27.559]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.559]                 "immediateCondition"))) {
[17:28:27.559]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.559]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.559]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.559]                   if (TRUE && !signal) {
[17:28:27.559]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.559]                     {
[17:28:27.559]                       inherits <- base::inherits
[17:28:27.559]                       invokeRestart <- base::invokeRestart
[17:28:27.559]                       is.null <- base::is.null
[17:28:27.559]                       muffled <- FALSE
[17:28:27.559]                       if (inherits(cond, "message")) {
[17:28:27.559]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.559]                         if (muffled) 
[17:28:27.559]                           invokeRestart("muffleMessage")
[17:28:27.559]                       }
[17:28:27.559]                       else if (inherits(cond, "warning")) {
[17:28:27.559]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.559]                         if (muffled) 
[17:28:27.559]                           invokeRestart("muffleWarning")
[17:28:27.559]                       }
[17:28:27.559]                       else if (inherits(cond, "condition")) {
[17:28:27.559]                         if (!is.null(pattern)) {
[17:28:27.559]                           computeRestarts <- base::computeRestarts
[17:28:27.559]                           grepl <- base::grepl
[17:28:27.559]                           restarts <- computeRestarts(cond)
[17:28:27.559]                           for (restart in restarts) {
[17:28:27.559]                             name <- restart$name
[17:28:27.559]                             if (is.null(name)) 
[17:28:27.559]                               next
[17:28:27.559]                             if (!grepl(pattern, name)) 
[17:28:27.559]                               next
[17:28:27.559]                             invokeRestart(restart)
[17:28:27.559]                             muffled <- TRUE
[17:28:27.559]                             break
[17:28:27.559]                           }
[17:28:27.559]                         }
[17:28:27.559]                       }
[17:28:27.559]                       invisible(muffled)
[17:28:27.559]                     }
[17:28:27.559]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.559]                   }
[17:28:27.559]                 }
[17:28:27.559]                 else {
[17:28:27.559]                   if (TRUE) {
[17:28:27.559]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.559]                     {
[17:28:27.559]                       inherits <- base::inherits
[17:28:27.559]                       invokeRestart <- base::invokeRestart
[17:28:27.559]                       is.null <- base::is.null
[17:28:27.559]                       muffled <- FALSE
[17:28:27.559]                       if (inherits(cond, "message")) {
[17:28:27.559]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.559]                         if (muffled) 
[17:28:27.559]                           invokeRestart("muffleMessage")
[17:28:27.559]                       }
[17:28:27.559]                       else if (inherits(cond, "warning")) {
[17:28:27.559]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.559]                         if (muffled) 
[17:28:27.559]                           invokeRestart("muffleWarning")
[17:28:27.559]                       }
[17:28:27.559]                       else if (inherits(cond, "condition")) {
[17:28:27.559]                         if (!is.null(pattern)) {
[17:28:27.559]                           computeRestarts <- base::computeRestarts
[17:28:27.559]                           grepl <- base::grepl
[17:28:27.559]                           restarts <- computeRestarts(cond)
[17:28:27.559]                           for (restart in restarts) {
[17:28:27.559]                             name <- restart$name
[17:28:27.559]                             if (is.null(name)) 
[17:28:27.559]                               next
[17:28:27.559]                             if (!grepl(pattern, name)) 
[17:28:27.559]                               next
[17:28:27.559]                             invokeRestart(restart)
[17:28:27.559]                             muffled <- TRUE
[17:28:27.559]                             break
[17:28:27.559]                           }
[17:28:27.559]                         }
[17:28:27.559]                       }
[17:28:27.559]                       invisible(muffled)
[17:28:27.559]                     }
[17:28:27.559]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.559]                   }
[17:28:27.559]                 }
[17:28:27.559]             }
[17:28:27.559]         }))
[17:28:27.559]     }, error = function(ex) {
[17:28:27.559]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.559]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.559]                 ...future.rng), started = ...future.startTime, 
[17:28:27.559]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.559]             version = "1.8"), class = "FutureResult")
[17:28:27.559]     }, finally = {
[17:28:27.559]         if (!identical(...future.workdir, getwd())) 
[17:28:27.559]             setwd(...future.workdir)
[17:28:27.559]         {
[17:28:27.559]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.559]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.559]             }
[17:28:27.559]             base::options(...future.oldOptions)
[17:28:27.559]             if (.Platform$OS.type == "windows") {
[17:28:27.559]                 old_names <- names(...future.oldEnvVars)
[17:28:27.559]                 envs <- base::Sys.getenv()
[17:28:27.559]                 names <- names(envs)
[17:28:27.559]                 common <- intersect(names, old_names)
[17:28:27.559]                 added <- setdiff(names, old_names)
[17:28:27.559]                 removed <- setdiff(old_names, names)
[17:28:27.559]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.559]                   envs[common]]
[17:28:27.559]                 NAMES <- toupper(changed)
[17:28:27.559]                 args <- list()
[17:28:27.559]                 for (kk in seq_along(NAMES)) {
[17:28:27.559]                   name <- changed[[kk]]
[17:28:27.559]                   NAME <- NAMES[[kk]]
[17:28:27.559]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.559]                     next
[17:28:27.559]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.559]                 }
[17:28:27.559]                 NAMES <- toupper(added)
[17:28:27.559]                 for (kk in seq_along(NAMES)) {
[17:28:27.559]                   name <- added[[kk]]
[17:28:27.559]                   NAME <- NAMES[[kk]]
[17:28:27.559]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.559]                     next
[17:28:27.559]                   args[[name]] <- ""
[17:28:27.559]                 }
[17:28:27.559]                 NAMES <- toupper(removed)
[17:28:27.559]                 for (kk in seq_along(NAMES)) {
[17:28:27.559]                   name <- removed[[kk]]
[17:28:27.559]                   NAME <- NAMES[[kk]]
[17:28:27.559]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.559]                     next
[17:28:27.559]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.559]                 }
[17:28:27.559]                 if (length(args) > 0) 
[17:28:27.559]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.559]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.559]             }
[17:28:27.559]             else {
[17:28:27.559]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.559]             }
[17:28:27.559]             {
[17:28:27.559]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.559]                   0L) {
[17:28:27.559]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.559]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.559]                   base::options(opts)
[17:28:27.559]                 }
[17:28:27.559]                 {
[17:28:27.559]                   {
[17:28:27.559]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.559]                     NULL
[17:28:27.559]                   }
[17:28:27.559]                   options(future.plan = NULL)
[17:28:27.559]                   if (is.na(NA_character_)) 
[17:28:27.559]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.559]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.559]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.559]                     .init = FALSE)
[17:28:27.559]                 }
[17:28:27.559]             }
[17:28:27.559]         }
[17:28:27.559]     })
[17:28:27.559]     if (TRUE) {
[17:28:27.559]         base::sink(type = "output", split = FALSE)
[17:28:27.559]         if (TRUE) {
[17:28:27.559]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.559]         }
[17:28:27.559]         else {
[17:28:27.559]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.559]         }
[17:28:27.559]         base::close(...future.stdout)
[17:28:27.559]         ...future.stdout <- NULL
[17:28:27.559]     }
[17:28:27.559]     ...future.result$conditions <- ...future.conditions
[17:28:27.559]     ...future.result$finished <- base::Sys.time()
[17:28:27.559]     ...future.result
[17:28:27.559] }
[17:28:27.565] MultisessionFuture started
[17:28:27.565] - Launch lazy future ... done
[17:28:27.565] run() for 'MultisessionFuture' ... done
[17:28:27.568] result() for ClusterFuture ...
[17:28:27.568] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.568] - Validating connection of MultisessionFuture
[17:28:27.587] - received message: FutureResult
[17:28:27.587] - Received FutureResult
[17:28:27.588] - Erased future from FutureRegistry
[17:28:27.588] result() for ClusterFuture ...
[17:28:27.588] - result already collected: FutureResult
[17:28:27.588] result() for ClusterFuture ... done
[17:28:27.588] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:27.588] result() for ClusterFuture ... done
[17:28:27.589] result() for ClusterFuture ...
[17:28:27.589] - result already collected: FutureResult
[17:28:27.589] 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:28:27.590] getGlobalsAndPackages() ...
[17:28:27.590] Searching for globals...
[17:28:27.590] - globals found: [1] 'print'
[17:28:27.590] Searching for globals ... DONE
[17:28:27.591] Resolving globals: FALSE
[17:28:27.591] 
[17:28:27.591] 
[17:28:27.591] getGlobalsAndPackages() ... DONE
[17:28:27.592] run() for 'Future' ...
[17:28:27.592] - state: 'created'
[17:28:27.592] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:27.606] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:27.606] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:27.606]   - Field: 'node'
[17:28:27.607]   - Field: 'label'
[17:28:27.607]   - Field: 'local'
[17:28:27.607]   - Field: 'owner'
[17:28:27.607]   - Field: 'envir'
[17:28:27.607]   - Field: 'workers'
[17:28:27.608]   - Field: 'packages'
[17:28:27.608]   - Field: 'gc'
[17:28:27.608]   - Field: 'conditions'
[17:28:27.608]   - Field: 'persistent'
[17:28:27.608]   - Field: 'expr'
[17:28:27.608]   - Field: 'uuid'
[17:28:27.609]   - Field: 'seed'
[17:28:27.609]   - Field: 'version'
[17:28:27.609]   - Field: 'result'
[17:28:27.609]   - Field: 'asynchronous'
[17:28:27.609]   - Field: 'calls'
[17:28:27.609]   - Field: 'globals'
[17:28:27.610]   - Field: 'stdout'
[17:28:27.610]   - Field: 'earlySignal'
[17:28:27.610]   - Field: 'lazy'
[17:28:27.610]   - Field: 'state'
[17:28:27.610] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:27.611] - Launch lazy future ...
[17:28:27.611] Packages needed by the future expression (n = 0): <none>
[17:28:27.611] Packages needed by future strategies (n = 0): <none>
[17:28:27.612] {
[17:28:27.612]     {
[17:28:27.612]         {
[17:28:27.612]             ...future.startTime <- base::Sys.time()
[17:28:27.612]             {
[17:28:27.612]                 {
[17:28:27.612]                   {
[17:28:27.612]                     {
[17:28:27.612]                       base::local({
[17:28:27.612]                         has_future <- base::requireNamespace("future", 
[17:28:27.612]                           quietly = TRUE)
[17:28:27.612]                         if (has_future) {
[17:28:27.612]                           ns <- base::getNamespace("future")
[17:28:27.612]                           version <- ns[[".package"]][["version"]]
[17:28:27.612]                           if (is.null(version)) 
[17:28:27.612]                             version <- utils::packageVersion("future")
[17:28:27.612]                         }
[17:28:27.612]                         else {
[17:28:27.612]                           version <- NULL
[17:28:27.612]                         }
[17:28:27.612]                         if (!has_future || version < "1.8.0") {
[17:28:27.612]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.612]                             "", base::R.version$version.string), 
[17:28:27.612]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:27.612]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:27.612]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.612]                               "release", "version")], collapse = " "), 
[17:28:27.612]                             hostname = base::Sys.info()[["nodename"]])
[17:28:27.612]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.612]                             info)
[17:28:27.612]                           info <- base::paste(info, collapse = "; ")
[17:28:27.612]                           if (!has_future) {
[17:28:27.612]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.612]                               info)
[17:28:27.612]                           }
[17:28:27.612]                           else {
[17:28:27.612]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.612]                               info, version)
[17:28:27.612]                           }
[17:28:27.612]                           base::stop(msg)
[17:28:27.612]                         }
[17:28:27.612]                       })
[17:28:27.612]                     }
[17:28:27.612]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.612]                     base::options(mc.cores = 1L)
[17:28:27.612]                   }
[17:28:27.612]                   ...future.strategy.old <- future::plan("list")
[17:28:27.612]                   options(future.plan = NULL)
[17:28:27.612]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.612]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.612]                 }
[17:28:27.612]                 ...future.workdir <- getwd()
[17:28:27.612]             }
[17:28:27.612]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.612]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.612]         }
[17:28:27.612]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.612]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.612]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.612]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.612]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.612]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.612]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.612]             base::names(...future.oldOptions))
[17:28:27.612]     }
[17:28:27.612]     if (FALSE) {
[17:28:27.612]     }
[17:28:27.612]     else {
[17:28:27.612]         if (TRUE) {
[17:28:27.612]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.612]                 open = "w")
[17:28:27.612]         }
[17:28:27.612]         else {
[17:28:27.612]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.612]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.612]         }
[17:28:27.612]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.612]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.612]             base::sink(type = "output", split = FALSE)
[17:28:27.612]             base::close(...future.stdout)
[17:28:27.612]         }, add = TRUE)
[17:28:27.612]     }
[17:28:27.612]     ...future.frame <- base::sys.nframe()
[17:28:27.612]     ...future.conditions <- base::list()
[17:28:27.612]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.612]     if (FALSE) {
[17:28:27.612]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.612]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.612]     }
[17:28:27.612]     ...future.result <- base::tryCatch({
[17:28:27.612]         base::withCallingHandlers({
[17:28:27.612]             ...future.value <- base::withVisible(base::local({
[17:28:27.612]                 ...future.makeSendCondition <- base::local({
[17:28:27.612]                   sendCondition <- NULL
[17:28:27.612]                   function(frame = 1L) {
[17:28:27.612]                     if (is.function(sendCondition)) 
[17:28:27.612]                       return(sendCondition)
[17:28:27.612]                     ns <- getNamespace("parallel")
[17:28:27.612]                     if (exists("sendData", mode = "function", 
[17:28:27.612]                       envir = ns)) {
[17:28:27.612]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.612]                         envir = ns)
[17:28:27.612]                       envir <- sys.frame(frame)
[17:28:27.612]                       master <- NULL
[17:28:27.612]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.612]                         !identical(envir, emptyenv())) {
[17:28:27.612]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.612]                           inherits = FALSE)) {
[17:28:27.612]                           master <- get("master", mode = "list", 
[17:28:27.612]                             envir = envir, inherits = FALSE)
[17:28:27.612]                           if (inherits(master, c("SOCKnode", 
[17:28:27.612]                             "SOCK0node"))) {
[17:28:27.612]                             sendCondition <<- function(cond) {
[17:28:27.612]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.612]                                 success = TRUE)
[17:28:27.612]                               parallel_sendData(master, data)
[17:28:27.612]                             }
[17:28:27.612]                             return(sendCondition)
[17:28:27.612]                           }
[17:28:27.612]                         }
[17:28:27.612]                         frame <- frame + 1L
[17:28:27.612]                         envir <- sys.frame(frame)
[17:28:27.612]                       }
[17:28:27.612]                     }
[17:28:27.612]                     sendCondition <<- function(cond) NULL
[17:28:27.612]                   }
[17:28:27.612]                 })
[17:28:27.612]                 withCallingHandlers({
[17:28:27.612]                   print(42)
[17:28:27.612]                 }, immediateCondition = function(cond) {
[17:28:27.612]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.612]                   sendCondition(cond)
[17:28:27.612]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.612]                   {
[17:28:27.612]                     inherits <- base::inherits
[17:28:27.612]                     invokeRestart <- base::invokeRestart
[17:28:27.612]                     is.null <- base::is.null
[17:28:27.612]                     muffled <- FALSE
[17:28:27.612]                     if (inherits(cond, "message")) {
[17:28:27.612]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.612]                       if (muffled) 
[17:28:27.612]                         invokeRestart("muffleMessage")
[17:28:27.612]                     }
[17:28:27.612]                     else if (inherits(cond, "warning")) {
[17:28:27.612]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.612]                       if (muffled) 
[17:28:27.612]                         invokeRestart("muffleWarning")
[17:28:27.612]                     }
[17:28:27.612]                     else if (inherits(cond, "condition")) {
[17:28:27.612]                       if (!is.null(pattern)) {
[17:28:27.612]                         computeRestarts <- base::computeRestarts
[17:28:27.612]                         grepl <- base::grepl
[17:28:27.612]                         restarts <- computeRestarts(cond)
[17:28:27.612]                         for (restart in restarts) {
[17:28:27.612]                           name <- restart$name
[17:28:27.612]                           if (is.null(name)) 
[17:28:27.612]                             next
[17:28:27.612]                           if (!grepl(pattern, name)) 
[17:28:27.612]                             next
[17:28:27.612]                           invokeRestart(restart)
[17:28:27.612]                           muffled <- TRUE
[17:28:27.612]                           break
[17:28:27.612]                         }
[17:28:27.612]                       }
[17:28:27.612]                     }
[17:28:27.612]                     invisible(muffled)
[17:28:27.612]                   }
[17:28:27.612]                   muffleCondition(cond)
[17:28:27.612]                 })
[17:28:27.612]             }))
[17:28:27.612]             future::FutureResult(value = ...future.value$value, 
[17:28:27.612]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.612]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.612]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.612]                     ...future.globalenv.names))
[17:28:27.612]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.612]         }, condition = base::local({
[17:28:27.612]             c <- base::c
[17:28:27.612]             inherits <- base::inherits
[17:28:27.612]             invokeRestart <- base::invokeRestart
[17:28:27.612]             length <- base::length
[17:28:27.612]             list <- base::list
[17:28:27.612]             seq.int <- base::seq.int
[17:28:27.612]             signalCondition <- base::signalCondition
[17:28:27.612]             sys.calls <- base::sys.calls
[17:28:27.612]             `[[` <- base::`[[`
[17:28:27.612]             `+` <- base::`+`
[17:28:27.612]             `<<-` <- base::`<<-`
[17:28:27.612]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.612]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.612]                   3L)]
[17:28:27.612]             }
[17:28:27.612]             function(cond) {
[17:28:27.612]                 is_error <- inherits(cond, "error")
[17:28:27.612]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.612]                   NULL)
[17:28:27.612]                 if (is_error) {
[17:28:27.612]                   sessionInformation <- function() {
[17:28:27.612]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.612]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.612]                       search = base::search(), system = base::Sys.info())
[17:28:27.612]                   }
[17:28:27.612]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.612]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.612]                     cond$call), session = sessionInformation(), 
[17:28:27.612]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.612]                   signalCondition(cond)
[17:28:27.612]                 }
[17:28:27.612]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.612]                 "immediateCondition"))) {
[17:28:27.612]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.612]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.612]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.612]                   if (TRUE && !signal) {
[17:28:27.612]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.612]                     {
[17:28:27.612]                       inherits <- base::inherits
[17:28:27.612]                       invokeRestart <- base::invokeRestart
[17:28:27.612]                       is.null <- base::is.null
[17:28:27.612]                       muffled <- FALSE
[17:28:27.612]                       if (inherits(cond, "message")) {
[17:28:27.612]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.612]                         if (muffled) 
[17:28:27.612]                           invokeRestart("muffleMessage")
[17:28:27.612]                       }
[17:28:27.612]                       else if (inherits(cond, "warning")) {
[17:28:27.612]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.612]                         if (muffled) 
[17:28:27.612]                           invokeRestart("muffleWarning")
[17:28:27.612]                       }
[17:28:27.612]                       else if (inherits(cond, "condition")) {
[17:28:27.612]                         if (!is.null(pattern)) {
[17:28:27.612]                           computeRestarts <- base::computeRestarts
[17:28:27.612]                           grepl <- base::grepl
[17:28:27.612]                           restarts <- computeRestarts(cond)
[17:28:27.612]                           for (restart in restarts) {
[17:28:27.612]                             name <- restart$name
[17:28:27.612]                             if (is.null(name)) 
[17:28:27.612]                               next
[17:28:27.612]                             if (!grepl(pattern, name)) 
[17:28:27.612]                               next
[17:28:27.612]                             invokeRestart(restart)
[17:28:27.612]                             muffled <- TRUE
[17:28:27.612]                             break
[17:28:27.612]                           }
[17:28:27.612]                         }
[17:28:27.612]                       }
[17:28:27.612]                       invisible(muffled)
[17:28:27.612]                     }
[17:28:27.612]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.612]                   }
[17:28:27.612]                 }
[17:28:27.612]                 else {
[17:28:27.612]                   if (TRUE) {
[17:28:27.612]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.612]                     {
[17:28:27.612]                       inherits <- base::inherits
[17:28:27.612]                       invokeRestart <- base::invokeRestart
[17:28:27.612]                       is.null <- base::is.null
[17:28:27.612]                       muffled <- FALSE
[17:28:27.612]                       if (inherits(cond, "message")) {
[17:28:27.612]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.612]                         if (muffled) 
[17:28:27.612]                           invokeRestart("muffleMessage")
[17:28:27.612]                       }
[17:28:27.612]                       else if (inherits(cond, "warning")) {
[17:28:27.612]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.612]                         if (muffled) 
[17:28:27.612]                           invokeRestart("muffleWarning")
[17:28:27.612]                       }
[17:28:27.612]                       else if (inherits(cond, "condition")) {
[17:28:27.612]                         if (!is.null(pattern)) {
[17:28:27.612]                           computeRestarts <- base::computeRestarts
[17:28:27.612]                           grepl <- base::grepl
[17:28:27.612]                           restarts <- computeRestarts(cond)
[17:28:27.612]                           for (restart in restarts) {
[17:28:27.612]                             name <- restart$name
[17:28:27.612]                             if (is.null(name)) 
[17:28:27.612]                               next
[17:28:27.612]                             if (!grepl(pattern, name)) 
[17:28:27.612]                               next
[17:28:27.612]                             invokeRestart(restart)
[17:28:27.612]                             muffled <- TRUE
[17:28:27.612]                             break
[17:28:27.612]                           }
[17:28:27.612]                         }
[17:28:27.612]                       }
[17:28:27.612]                       invisible(muffled)
[17:28:27.612]                     }
[17:28:27.612]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.612]                   }
[17:28:27.612]                 }
[17:28:27.612]             }
[17:28:27.612]         }))
[17:28:27.612]     }, error = function(ex) {
[17:28:27.612]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.612]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.612]                 ...future.rng), started = ...future.startTime, 
[17:28:27.612]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.612]             version = "1.8"), class = "FutureResult")
[17:28:27.612]     }, finally = {
[17:28:27.612]         if (!identical(...future.workdir, getwd())) 
[17:28:27.612]             setwd(...future.workdir)
[17:28:27.612]         {
[17:28:27.612]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.612]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.612]             }
[17:28:27.612]             base::options(...future.oldOptions)
[17:28:27.612]             if (.Platform$OS.type == "windows") {
[17:28:27.612]                 old_names <- names(...future.oldEnvVars)
[17:28:27.612]                 envs <- base::Sys.getenv()
[17:28:27.612]                 names <- names(envs)
[17:28:27.612]                 common <- intersect(names, old_names)
[17:28:27.612]                 added <- setdiff(names, old_names)
[17:28:27.612]                 removed <- setdiff(old_names, names)
[17:28:27.612]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.612]                   envs[common]]
[17:28:27.612]                 NAMES <- toupper(changed)
[17:28:27.612]                 args <- list()
[17:28:27.612]                 for (kk in seq_along(NAMES)) {
[17:28:27.612]                   name <- changed[[kk]]
[17:28:27.612]                   NAME <- NAMES[[kk]]
[17:28:27.612]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.612]                     next
[17:28:27.612]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.612]                 }
[17:28:27.612]                 NAMES <- toupper(added)
[17:28:27.612]                 for (kk in seq_along(NAMES)) {
[17:28:27.612]                   name <- added[[kk]]
[17:28:27.612]                   NAME <- NAMES[[kk]]
[17:28:27.612]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.612]                     next
[17:28:27.612]                   args[[name]] <- ""
[17:28:27.612]                 }
[17:28:27.612]                 NAMES <- toupper(removed)
[17:28:27.612]                 for (kk in seq_along(NAMES)) {
[17:28:27.612]                   name <- removed[[kk]]
[17:28:27.612]                   NAME <- NAMES[[kk]]
[17:28:27.612]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.612]                     next
[17:28:27.612]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.612]                 }
[17:28:27.612]                 if (length(args) > 0) 
[17:28:27.612]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.612]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.612]             }
[17:28:27.612]             else {
[17:28:27.612]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.612]             }
[17:28:27.612]             {
[17:28:27.612]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.612]                   0L) {
[17:28:27.612]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.612]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.612]                   base::options(opts)
[17:28:27.612]                 }
[17:28:27.612]                 {
[17:28:27.612]                   {
[17:28:27.612]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.612]                     NULL
[17:28:27.612]                   }
[17:28:27.612]                   options(future.plan = NULL)
[17:28:27.612]                   if (is.na(NA_character_)) 
[17:28:27.612]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.612]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.612]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.612]                     .init = FALSE)
[17:28:27.612]                 }
[17:28:27.612]             }
[17:28:27.612]         }
[17:28:27.612]     })
[17:28:27.612]     if (TRUE) {
[17:28:27.612]         base::sink(type = "output", split = FALSE)
[17:28:27.612]         if (TRUE) {
[17:28:27.612]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.612]         }
[17:28:27.612]         else {
[17:28:27.612]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.612]         }
[17:28:27.612]         base::close(...future.stdout)
[17:28:27.612]         ...future.stdout <- NULL
[17:28:27.612]     }
[17:28:27.612]     ...future.result$conditions <- ...future.conditions
[17:28:27.612]     ...future.result$finished <- base::Sys.time()
[17:28:27.612]     ...future.result
[17:28:27.612] }
[17:28:27.617] MultisessionFuture started
[17:28:27.617] - Launch lazy future ... done
[17:28:27.617] run() for 'MultisessionFuture' ... done
[17:28:27.618] result() for ClusterFuture ...
[17:28:27.618] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.618] - Validating connection of MultisessionFuture
[17:28:27.637] - received message: FutureResult
[17:28:27.638] - Received FutureResult
[17:28:27.638] - Erased future from FutureRegistry
[17:28:27.638] result() for ClusterFuture ...
[17:28:27.638] - result already collected: FutureResult
[17:28:27.638] result() for ClusterFuture ... done
[17:28:27.638] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:27.639] result() for ClusterFuture ... done
[17:28:27.639] result() for ClusterFuture ...
[17:28:27.639] - result already collected: FutureResult
[17:28:27.639] result() for ClusterFuture ... done
[17:28:27.639] result() for ClusterFuture ...
[17:28:27.639] - result already collected: FutureResult
[17:28:27.639] result() for ClusterFuture ... done
[1] 42
[17:28:27.640] result() for ClusterFuture ...
[17:28:27.640] - result already collected: FutureResult
[17:28:27.640] result() for ClusterFuture ... done
- stdout = FALSE
[17:28:27.640] getGlobalsAndPackages() ...
[17:28:27.640] Searching for globals...
[17:28:27.644] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:28:27.644] Searching for globals ... DONE
[17:28:27.644] Resolving globals: FALSE
[17:28:27.645] 
[17:28:27.645] - packages: [1] 'utils'
[17:28:27.645] getGlobalsAndPackages() ... DONE
[17:28:27.646] run() for 'Future' ...
[17:28:27.646] - state: 'created'
[17:28:27.646] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:27.660] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:27.660] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:27.661]   - Field: 'node'
[17:28:27.661]   - Field: 'label'
[17:28:27.661]   - Field: 'local'
[17:28:27.661]   - Field: 'owner'
[17:28:27.661]   - Field: 'envir'
[17:28:27.661]   - Field: 'workers'
[17:28:27.662]   - Field: 'packages'
[17:28:27.662]   - Field: 'gc'
[17:28:27.662]   - Field: 'conditions'
[17:28:27.662]   - Field: 'persistent'
[17:28:27.662]   - Field: 'expr'
[17:28:27.663]   - Field: 'uuid'
[17:28:27.663]   - Field: 'seed'
[17:28:27.663]   - Field: 'version'
[17:28:27.663]   - Field: 'result'
[17:28:27.663]   - Field: 'asynchronous'
[17:28:27.663]   - Field: 'calls'
[17:28:27.664]   - Field: 'globals'
[17:28:27.664]   - Field: 'stdout'
[17:28:27.664]   - Field: 'earlySignal'
[17:28:27.664]   - Field: 'lazy'
[17:28:27.664]   - Field: 'state'
[17:28:27.664] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:27.665] - Launch lazy future ...
[17:28:27.665] Packages needed by the future expression (n = 1): 'utils'
[17:28:27.665] Packages needed by future strategies (n = 0): <none>
[17:28:27.666] {
[17:28:27.666]     {
[17:28:27.666]         {
[17:28:27.666]             ...future.startTime <- base::Sys.time()
[17:28:27.666]             {
[17:28:27.666]                 {
[17:28:27.666]                   {
[17:28:27.666]                     {
[17:28:27.666]                       {
[17:28:27.666]                         base::local({
[17:28:27.666]                           has_future <- base::requireNamespace("future", 
[17:28:27.666]                             quietly = TRUE)
[17:28:27.666]                           if (has_future) {
[17:28:27.666]                             ns <- base::getNamespace("future")
[17:28:27.666]                             version <- ns[[".package"]][["version"]]
[17:28:27.666]                             if (is.null(version)) 
[17:28:27.666]                               version <- utils::packageVersion("future")
[17:28:27.666]                           }
[17:28:27.666]                           else {
[17:28:27.666]                             version <- NULL
[17:28:27.666]                           }
[17:28:27.666]                           if (!has_future || version < "1.8.0") {
[17:28:27.666]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.666]                               "", base::R.version$version.string), 
[17:28:27.666]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:27.666]                                 base::R.version$platform, 8 * 
[17:28:27.666]                                   base::.Machine$sizeof.pointer), 
[17:28:27.666]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.666]                                 "release", "version")], collapse = " "), 
[17:28:27.666]                               hostname = base::Sys.info()[["nodename"]])
[17:28:27.666]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.666]                               info)
[17:28:27.666]                             info <- base::paste(info, collapse = "; ")
[17:28:27.666]                             if (!has_future) {
[17:28:27.666]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.666]                                 info)
[17:28:27.666]                             }
[17:28:27.666]                             else {
[17:28:27.666]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.666]                                 info, version)
[17:28:27.666]                             }
[17:28:27.666]                             base::stop(msg)
[17:28:27.666]                           }
[17:28:27.666]                         })
[17:28:27.666]                       }
[17:28:27.666]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.666]                       base::options(mc.cores = 1L)
[17:28:27.666]                     }
[17:28:27.666]                     base::local({
[17:28:27.666]                       for (pkg in "utils") {
[17:28:27.666]                         base::loadNamespace(pkg)
[17:28:27.666]                         base::library(pkg, character.only = TRUE)
[17:28:27.666]                       }
[17:28:27.666]                     })
[17:28:27.666]                   }
[17:28:27.666]                   ...future.strategy.old <- future::plan("list")
[17:28:27.666]                   options(future.plan = NULL)
[17:28:27.666]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.666]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.666]                 }
[17:28:27.666]                 ...future.workdir <- getwd()
[17:28:27.666]             }
[17:28:27.666]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.666]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.666]         }
[17:28:27.666]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.666]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.666]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.666]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.666]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.666]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.666]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.666]             base::names(...future.oldOptions))
[17:28:27.666]     }
[17:28:27.666]     if (FALSE) {
[17:28:27.666]     }
[17:28:27.666]     else {
[17:28:27.666]         if (FALSE) {
[17:28:27.666]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.666]                 open = "w")
[17:28:27.666]         }
[17:28:27.666]         else {
[17:28:27.666]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.666]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.666]         }
[17:28:27.666]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.666]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.666]             base::sink(type = "output", split = FALSE)
[17:28:27.666]             base::close(...future.stdout)
[17:28:27.666]         }, add = TRUE)
[17:28:27.666]     }
[17:28:27.666]     ...future.frame <- base::sys.nframe()
[17:28:27.666]     ...future.conditions <- base::list()
[17:28:27.666]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.666]     if (FALSE) {
[17:28:27.666]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.666]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.666]     }
[17:28:27.666]     ...future.result <- base::tryCatch({
[17:28:27.666]         base::withCallingHandlers({
[17:28:27.666]             ...future.value <- base::withVisible(base::local({
[17:28:27.666]                 ...future.makeSendCondition <- base::local({
[17:28:27.666]                   sendCondition <- NULL
[17:28:27.666]                   function(frame = 1L) {
[17:28:27.666]                     if (is.function(sendCondition)) 
[17:28:27.666]                       return(sendCondition)
[17:28:27.666]                     ns <- getNamespace("parallel")
[17:28:27.666]                     if (exists("sendData", mode = "function", 
[17:28:27.666]                       envir = ns)) {
[17:28:27.666]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.666]                         envir = ns)
[17:28:27.666]                       envir <- sys.frame(frame)
[17:28:27.666]                       master <- NULL
[17:28:27.666]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.666]                         !identical(envir, emptyenv())) {
[17:28:27.666]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.666]                           inherits = FALSE)) {
[17:28:27.666]                           master <- get("master", mode = "list", 
[17:28:27.666]                             envir = envir, inherits = FALSE)
[17:28:27.666]                           if (inherits(master, c("SOCKnode", 
[17:28:27.666]                             "SOCK0node"))) {
[17:28:27.666]                             sendCondition <<- function(cond) {
[17:28:27.666]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.666]                                 success = TRUE)
[17:28:27.666]                               parallel_sendData(master, data)
[17:28:27.666]                             }
[17:28:27.666]                             return(sendCondition)
[17:28:27.666]                           }
[17:28:27.666]                         }
[17:28:27.666]                         frame <- frame + 1L
[17:28:27.666]                         envir <- sys.frame(frame)
[17:28:27.666]                       }
[17:28:27.666]                     }
[17:28:27.666]                     sendCondition <<- function(cond) NULL
[17:28:27.666]                   }
[17:28:27.666]                 })
[17:28:27.666]                 withCallingHandlers({
[17:28:27.666]                   {
[17:28:27.666]                     print(1:50)
[17:28:27.666]                     str(1:50)
[17:28:27.666]                     cat(letters, sep = "-")
[17:28:27.666]                     cat(1:6, collapse = "\n")
[17:28:27.666]                     write.table(datasets::iris[1:10, ], sep = "\t")
[17:28:27.666]                     42L
[17:28:27.666]                   }
[17:28:27.666]                 }, immediateCondition = function(cond) {
[17:28:27.666]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.666]                   sendCondition(cond)
[17:28:27.666]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.666]                   {
[17:28:27.666]                     inherits <- base::inherits
[17:28:27.666]                     invokeRestart <- base::invokeRestart
[17:28:27.666]                     is.null <- base::is.null
[17:28:27.666]                     muffled <- FALSE
[17:28:27.666]                     if (inherits(cond, "message")) {
[17:28:27.666]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.666]                       if (muffled) 
[17:28:27.666]                         invokeRestart("muffleMessage")
[17:28:27.666]                     }
[17:28:27.666]                     else if (inherits(cond, "warning")) {
[17:28:27.666]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.666]                       if (muffled) 
[17:28:27.666]                         invokeRestart("muffleWarning")
[17:28:27.666]                     }
[17:28:27.666]                     else if (inherits(cond, "condition")) {
[17:28:27.666]                       if (!is.null(pattern)) {
[17:28:27.666]                         computeRestarts <- base::computeRestarts
[17:28:27.666]                         grepl <- base::grepl
[17:28:27.666]                         restarts <- computeRestarts(cond)
[17:28:27.666]                         for (restart in restarts) {
[17:28:27.666]                           name <- restart$name
[17:28:27.666]                           if (is.null(name)) 
[17:28:27.666]                             next
[17:28:27.666]                           if (!grepl(pattern, name)) 
[17:28:27.666]                             next
[17:28:27.666]                           invokeRestart(restart)
[17:28:27.666]                           muffled <- TRUE
[17:28:27.666]                           break
[17:28:27.666]                         }
[17:28:27.666]                       }
[17:28:27.666]                     }
[17:28:27.666]                     invisible(muffled)
[17:28:27.666]                   }
[17:28:27.666]                   muffleCondition(cond)
[17:28:27.666]                 })
[17:28:27.666]             }))
[17:28:27.666]             future::FutureResult(value = ...future.value$value, 
[17:28:27.666]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.666]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.666]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.666]                     ...future.globalenv.names))
[17:28:27.666]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.666]         }, condition = base::local({
[17:28:27.666]             c <- base::c
[17:28:27.666]             inherits <- base::inherits
[17:28:27.666]             invokeRestart <- base::invokeRestart
[17:28:27.666]             length <- base::length
[17:28:27.666]             list <- base::list
[17:28:27.666]             seq.int <- base::seq.int
[17:28:27.666]             signalCondition <- base::signalCondition
[17:28:27.666]             sys.calls <- base::sys.calls
[17:28:27.666]             `[[` <- base::`[[`
[17:28:27.666]             `+` <- base::`+`
[17:28:27.666]             `<<-` <- base::`<<-`
[17:28:27.666]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.666]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.666]                   3L)]
[17:28:27.666]             }
[17:28:27.666]             function(cond) {
[17:28:27.666]                 is_error <- inherits(cond, "error")
[17:28:27.666]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.666]                   NULL)
[17:28:27.666]                 if (is_error) {
[17:28:27.666]                   sessionInformation <- function() {
[17:28:27.666]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.666]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.666]                       search = base::search(), system = base::Sys.info())
[17:28:27.666]                   }
[17:28:27.666]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.666]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.666]                     cond$call), session = sessionInformation(), 
[17:28:27.666]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.666]                   signalCondition(cond)
[17:28:27.666]                 }
[17:28:27.666]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.666]                 "immediateCondition"))) {
[17:28:27.666]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.666]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.666]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.666]                   if (TRUE && !signal) {
[17:28:27.666]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.666]                     {
[17:28:27.666]                       inherits <- base::inherits
[17:28:27.666]                       invokeRestart <- base::invokeRestart
[17:28:27.666]                       is.null <- base::is.null
[17:28:27.666]                       muffled <- FALSE
[17:28:27.666]                       if (inherits(cond, "message")) {
[17:28:27.666]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.666]                         if (muffled) 
[17:28:27.666]                           invokeRestart("muffleMessage")
[17:28:27.666]                       }
[17:28:27.666]                       else if (inherits(cond, "warning")) {
[17:28:27.666]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.666]                         if (muffled) 
[17:28:27.666]                           invokeRestart("muffleWarning")
[17:28:27.666]                       }
[17:28:27.666]                       else if (inherits(cond, "condition")) {
[17:28:27.666]                         if (!is.null(pattern)) {
[17:28:27.666]                           computeRestarts <- base::computeRestarts
[17:28:27.666]                           grepl <- base::grepl
[17:28:27.666]                           restarts <- computeRestarts(cond)
[17:28:27.666]                           for (restart in restarts) {
[17:28:27.666]                             name <- restart$name
[17:28:27.666]                             if (is.null(name)) 
[17:28:27.666]                               next
[17:28:27.666]                             if (!grepl(pattern, name)) 
[17:28:27.666]                               next
[17:28:27.666]                             invokeRestart(restart)
[17:28:27.666]                             muffled <- TRUE
[17:28:27.666]                             break
[17:28:27.666]                           }
[17:28:27.666]                         }
[17:28:27.666]                       }
[17:28:27.666]                       invisible(muffled)
[17:28:27.666]                     }
[17:28:27.666]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.666]                   }
[17:28:27.666]                 }
[17:28:27.666]                 else {
[17:28:27.666]                   if (TRUE) {
[17:28:27.666]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.666]                     {
[17:28:27.666]                       inherits <- base::inherits
[17:28:27.666]                       invokeRestart <- base::invokeRestart
[17:28:27.666]                       is.null <- base::is.null
[17:28:27.666]                       muffled <- FALSE
[17:28:27.666]                       if (inherits(cond, "message")) {
[17:28:27.666]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.666]                         if (muffled) 
[17:28:27.666]                           invokeRestart("muffleMessage")
[17:28:27.666]                       }
[17:28:27.666]                       else if (inherits(cond, "warning")) {
[17:28:27.666]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.666]                         if (muffled) 
[17:28:27.666]                           invokeRestart("muffleWarning")
[17:28:27.666]                       }
[17:28:27.666]                       else if (inherits(cond, "condition")) {
[17:28:27.666]                         if (!is.null(pattern)) {
[17:28:27.666]                           computeRestarts <- base::computeRestarts
[17:28:27.666]                           grepl <- base::grepl
[17:28:27.666]                           restarts <- computeRestarts(cond)
[17:28:27.666]                           for (restart in restarts) {
[17:28:27.666]                             name <- restart$name
[17:28:27.666]                             if (is.null(name)) 
[17:28:27.666]                               next
[17:28:27.666]                             if (!grepl(pattern, name)) 
[17:28:27.666]                               next
[17:28:27.666]                             invokeRestart(restart)
[17:28:27.666]                             muffled <- TRUE
[17:28:27.666]                             break
[17:28:27.666]                           }
[17:28:27.666]                         }
[17:28:27.666]                       }
[17:28:27.666]                       invisible(muffled)
[17:28:27.666]                     }
[17:28:27.666]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.666]                   }
[17:28:27.666]                 }
[17:28:27.666]             }
[17:28:27.666]         }))
[17:28:27.666]     }, error = function(ex) {
[17:28:27.666]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.666]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.666]                 ...future.rng), started = ...future.startTime, 
[17:28:27.666]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.666]             version = "1.8"), class = "FutureResult")
[17:28:27.666]     }, finally = {
[17:28:27.666]         if (!identical(...future.workdir, getwd())) 
[17:28:27.666]             setwd(...future.workdir)
[17:28:27.666]         {
[17:28:27.666]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.666]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.666]             }
[17:28:27.666]             base::options(...future.oldOptions)
[17:28:27.666]             if (.Platform$OS.type == "windows") {
[17:28:27.666]                 old_names <- names(...future.oldEnvVars)
[17:28:27.666]                 envs <- base::Sys.getenv()
[17:28:27.666]                 names <- names(envs)
[17:28:27.666]                 common <- intersect(names, old_names)
[17:28:27.666]                 added <- setdiff(names, old_names)
[17:28:27.666]                 removed <- setdiff(old_names, names)
[17:28:27.666]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.666]                   envs[common]]
[17:28:27.666]                 NAMES <- toupper(changed)
[17:28:27.666]                 args <- list()
[17:28:27.666]                 for (kk in seq_along(NAMES)) {
[17:28:27.666]                   name <- changed[[kk]]
[17:28:27.666]                   NAME <- NAMES[[kk]]
[17:28:27.666]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.666]                     next
[17:28:27.666]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.666]                 }
[17:28:27.666]                 NAMES <- toupper(added)
[17:28:27.666]                 for (kk in seq_along(NAMES)) {
[17:28:27.666]                   name <- added[[kk]]
[17:28:27.666]                   NAME <- NAMES[[kk]]
[17:28:27.666]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.666]                     next
[17:28:27.666]                   args[[name]] <- ""
[17:28:27.666]                 }
[17:28:27.666]                 NAMES <- toupper(removed)
[17:28:27.666]                 for (kk in seq_along(NAMES)) {
[17:28:27.666]                   name <- removed[[kk]]
[17:28:27.666]                   NAME <- NAMES[[kk]]
[17:28:27.666]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.666]                     next
[17:28:27.666]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.666]                 }
[17:28:27.666]                 if (length(args) > 0) 
[17:28:27.666]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.666]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.666]             }
[17:28:27.666]             else {
[17:28:27.666]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.666]             }
[17:28:27.666]             {
[17:28:27.666]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.666]                   0L) {
[17:28:27.666]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.666]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.666]                   base::options(opts)
[17:28:27.666]                 }
[17:28:27.666]                 {
[17:28:27.666]                   {
[17:28:27.666]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.666]                     NULL
[17:28:27.666]                   }
[17:28:27.666]                   options(future.plan = NULL)
[17:28:27.666]                   if (is.na(NA_character_)) 
[17:28:27.666]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.666]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.666]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.666]                     .init = FALSE)
[17:28:27.666]                 }
[17:28:27.666]             }
[17:28:27.666]         }
[17:28:27.666]     })
[17:28:27.666]     if (TRUE) {
[17:28:27.666]         base::sink(type = "output", split = FALSE)
[17:28:27.666]         if (FALSE) {
[17:28:27.666]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.666]         }
[17:28:27.666]         else {
[17:28:27.666]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.666]         }
[17:28:27.666]         base::close(...future.stdout)
[17:28:27.666]         ...future.stdout <- NULL
[17:28:27.666]     }
[17:28:27.666]     ...future.result$conditions <- ...future.conditions
[17:28:27.666]     ...future.result$finished <- base::Sys.time()
[17:28:27.666]     ...future.result
[17:28:27.666] }
[17:28:27.671] MultisessionFuture started
[17:28:27.672] - Launch lazy future ... done
[17:28:27.672] run() for 'MultisessionFuture' ... done
[17:28:27.672] result() for ClusterFuture ...
[17:28:27.672] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.672] - Validating connection of MultisessionFuture
[17:28:27.692] - received message: FutureResult
[17:28:27.693] - Received FutureResult
[17:28:27.693] - Erased future from FutureRegistry
[17:28:27.693] result() for ClusterFuture ...
[17:28:27.693] - result already collected: FutureResult
[17:28:27.693] result() for ClusterFuture ... done
[17:28:27.693] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:27.694] 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-03-26 17:28:27"
 $ finished    : POSIXct[1:1], format: "2024-03-26 17:28:27"
 $ session_uuid: chr "dd8dfb13-f506-00c3-2691-0463fe0fa50c"
  ..- 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 139024
  .. ..$ time  : POSIXct[1:1], format: "2024-03-26 17:28:27"
  .. ..$ random: int 2147483647
 $ r_info      :List of 4
  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1
  .. ..$ : int [1:3] 4 4 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[17:28:27.703] result() for ClusterFuture ...
[17:28:27.703] - result already collected: FutureResult
[17:28:27.703] result() for ClusterFuture ... done
[17:28:27.703] result() for ClusterFuture ...
[17:28:27.703] - result already collected: FutureResult
[17:28:27.704] result() for ClusterFuture ... done
[17:28:27.704] getGlobalsAndPackages() ...
[17:28:27.704] Searching for globals...
[17:28:27.708] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:28:27.708] Searching for globals ... DONE
[17:28:27.708] Resolving globals: FALSE
[17:28:27.709] 
[17:28:27.709] - packages: [1] 'utils'
[17:28:27.709] getGlobalsAndPackages() ... DONE
[17:28:27.709] run() for 'Future' ...
[17:28:27.710] - state: 'created'
[17:28:27.710] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:27.723] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:27.723] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:27.724]   - Field: 'node'
[17:28:27.724]   - Field: 'label'
[17:28:27.724]   - Field: 'local'
[17:28:27.724]   - Field: 'owner'
[17:28:27.724]   - Field: 'envir'
[17:28:27.724]   - Field: 'workers'
[17:28:27.725]   - Field: 'packages'
[17:28:27.725]   - Field: 'gc'
[17:28:27.725]   - Field: 'conditions'
[17:28:27.725]   - Field: 'persistent'
[17:28:27.725]   - Field: 'expr'
[17:28:27.726]   - Field: 'uuid'
[17:28:27.726]   - Field: 'seed'
[17:28:27.726]   - Field: 'version'
[17:28:27.726]   - Field: 'result'
[17:28:27.726]   - Field: 'asynchronous'
[17:28:27.726]   - Field: 'calls'
[17:28:27.727]   - Field: 'globals'
[17:28:27.727]   - Field: 'stdout'
[17:28:27.727]   - Field: 'earlySignal'
[17:28:27.727]   - Field: 'lazy'
[17:28:27.727]   - Field: 'state'
[17:28:27.727] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:27.728] - Launch lazy future ...
[17:28:27.728] Packages needed by the future expression (n = 1): 'utils'
[17:28:27.728] Packages needed by future strategies (n = 0): <none>
[17:28:27.729] {
[17:28:27.729]     {
[17:28:27.729]         {
[17:28:27.729]             ...future.startTime <- base::Sys.time()
[17:28:27.729]             {
[17:28:27.729]                 {
[17:28:27.729]                   {
[17:28:27.729]                     {
[17:28:27.729]                       {
[17:28:27.729]                         base::local({
[17:28:27.729]                           has_future <- base::requireNamespace("future", 
[17:28:27.729]                             quietly = TRUE)
[17:28:27.729]                           if (has_future) {
[17:28:27.729]                             ns <- base::getNamespace("future")
[17:28:27.729]                             version <- ns[[".package"]][["version"]]
[17:28:27.729]                             if (is.null(version)) 
[17:28:27.729]                               version <- utils::packageVersion("future")
[17:28:27.729]                           }
[17:28:27.729]                           else {
[17:28:27.729]                             version <- NULL
[17:28:27.729]                           }
[17:28:27.729]                           if (!has_future || version < "1.8.0") {
[17:28:27.729]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.729]                               "", base::R.version$version.string), 
[17:28:27.729]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:27.729]                                 base::R.version$platform, 8 * 
[17:28:27.729]                                   base::.Machine$sizeof.pointer), 
[17:28:27.729]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.729]                                 "release", "version")], collapse = " "), 
[17:28:27.729]                               hostname = base::Sys.info()[["nodename"]])
[17:28:27.729]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.729]                               info)
[17:28:27.729]                             info <- base::paste(info, collapse = "; ")
[17:28:27.729]                             if (!has_future) {
[17:28:27.729]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.729]                                 info)
[17:28:27.729]                             }
[17:28:27.729]                             else {
[17:28:27.729]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.729]                                 info, version)
[17:28:27.729]                             }
[17:28:27.729]                             base::stop(msg)
[17:28:27.729]                           }
[17:28:27.729]                         })
[17:28:27.729]                       }
[17:28:27.729]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.729]                       base::options(mc.cores = 1L)
[17:28:27.729]                     }
[17:28:27.729]                     base::local({
[17:28:27.729]                       for (pkg in "utils") {
[17:28:27.729]                         base::loadNamespace(pkg)
[17:28:27.729]                         base::library(pkg, character.only = TRUE)
[17:28:27.729]                       }
[17:28:27.729]                     })
[17:28:27.729]                   }
[17:28:27.729]                   ...future.strategy.old <- future::plan("list")
[17:28:27.729]                   options(future.plan = NULL)
[17:28:27.729]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.729]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.729]                 }
[17:28:27.729]                 ...future.workdir <- getwd()
[17:28:27.729]             }
[17:28:27.729]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.729]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.729]         }
[17:28:27.729]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.729]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.729]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.729]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.729]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.729]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.729]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.729]             base::names(...future.oldOptions))
[17:28:27.729]     }
[17:28:27.729]     if (FALSE) {
[17:28:27.729]     }
[17:28:27.729]     else {
[17:28:27.729]         if (FALSE) {
[17:28:27.729]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.729]                 open = "w")
[17:28:27.729]         }
[17:28:27.729]         else {
[17:28:27.729]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.729]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.729]         }
[17:28:27.729]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.729]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.729]             base::sink(type = "output", split = FALSE)
[17:28:27.729]             base::close(...future.stdout)
[17:28:27.729]         }, add = TRUE)
[17:28:27.729]     }
[17:28:27.729]     ...future.frame <- base::sys.nframe()
[17:28:27.729]     ...future.conditions <- base::list()
[17:28:27.729]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.729]     if (FALSE) {
[17:28:27.729]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.729]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.729]     }
[17:28:27.729]     ...future.result <- base::tryCatch({
[17:28:27.729]         base::withCallingHandlers({
[17:28:27.729]             ...future.value <- base::withVisible(base::local({
[17:28:27.729]                 ...future.makeSendCondition <- base::local({
[17:28:27.729]                   sendCondition <- NULL
[17:28:27.729]                   function(frame = 1L) {
[17:28:27.729]                     if (is.function(sendCondition)) 
[17:28:27.729]                       return(sendCondition)
[17:28:27.729]                     ns <- getNamespace("parallel")
[17:28:27.729]                     if (exists("sendData", mode = "function", 
[17:28:27.729]                       envir = ns)) {
[17:28:27.729]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.729]                         envir = ns)
[17:28:27.729]                       envir <- sys.frame(frame)
[17:28:27.729]                       master <- NULL
[17:28:27.729]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.729]                         !identical(envir, emptyenv())) {
[17:28:27.729]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.729]                           inherits = FALSE)) {
[17:28:27.729]                           master <- get("master", mode = "list", 
[17:28:27.729]                             envir = envir, inherits = FALSE)
[17:28:27.729]                           if (inherits(master, c("SOCKnode", 
[17:28:27.729]                             "SOCK0node"))) {
[17:28:27.729]                             sendCondition <<- function(cond) {
[17:28:27.729]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.729]                                 success = TRUE)
[17:28:27.729]                               parallel_sendData(master, data)
[17:28:27.729]                             }
[17:28:27.729]                             return(sendCondition)
[17:28:27.729]                           }
[17:28:27.729]                         }
[17:28:27.729]                         frame <- frame + 1L
[17:28:27.729]                         envir <- sys.frame(frame)
[17:28:27.729]                       }
[17:28:27.729]                     }
[17:28:27.729]                     sendCondition <<- function(cond) NULL
[17:28:27.729]                   }
[17:28:27.729]                 })
[17:28:27.729]                 withCallingHandlers({
[17:28:27.729]                   {
[17:28:27.729]                     print(1:50)
[17:28:27.729]                     str(1:50)
[17:28:27.729]                     cat(letters, sep = "-")
[17:28:27.729]                     cat(1:6, collapse = "\n")
[17:28:27.729]                     write.table(datasets::iris[1:10, ], sep = "\t")
[17:28:27.729]                     42L
[17:28:27.729]                   }
[17:28:27.729]                 }, immediateCondition = function(cond) {
[17:28:27.729]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.729]                   sendCondition(cond)
[17:28:27.729]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.729]                   {
[17:28:27.729]                     inherits <- base::inherits
[17:28:27.729]                     invokeRestart <- base::invokeRestart
[17:28:27.729]                     is.null <- base::is.null
[17:28:27.729]                     muffled <- FALSE
[17:28:27.729]                     if (inherits(cond, "message")) {
[17:28:27.729]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.729]                       if (muffled) 
[17:28:27.729]                         invokeRestart("muffleMessage")
[17:28:27.729]                     }
[17:28:27.729]                     else if (inherits(cond, "warning")) {
[17:28:27.729]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.729]                       if (muffled) 
[17:28:27.729]                         invokeRestart("muffleWarning")
[17:28:27.729]                     }
[17:28:27.729]                     else if (inherits(cond, "condition")) {
[17:28:27.729]                       if (!is.null(pattern)) {
[17:28:27.729]                         computeRestarts <- base::computeRestarts
[17:28:27.729]                         grepl <- base::grepl
[17:28:27.729]                         restarts <- computeRestarts(cond)
[17:28:27.729]                         for (restart in restarts) {
[17:28:27.729]                           name <- restart$name
[17:28:27.729]                           if (is.null(name)) 
[17:28:27.729]                             next
[17:28:27.729]                           if (!grepl(pattern, name)) 
[17:28:27.729]                             next
[17:28:27.729]                           invokeRestart(restart)
[17:28:27.729]                           muffled <- TRUE
[17:28:27.729]                           break
[17:28:27.729]                         }
[17:28:27.729]                       }
[17:28:27.729]                     }
[17:28:27.729]                     invisible(muffled)
[17:28:27.729]                   }
[17:28:27.729]                   muffleCondition(cond)
[17:28:27.729]                 })
[17:28:27.729]             }))
[17:28:27.729]             future::FutureResult(value = ...future.value$value, 
[17:28:27.729]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.729]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.729]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.729]                     ...future.globalenv.names))
[17:28:27.729]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.729]         }, condition = base::local({
[17:28:27.729]             c <- base::c
[17:28:27.729]             inherits <- base::inherits
[17:28:27.729]             invokeRestart <- base::invokeRestart
[17:28:27.729]             length <- base::length
[17:28:27.729]             list <- base::list
[17:28:27.729]             seq.int <- base::seq.int
[17:28:27.729]             signalCondition <- base::signalCondition
[17:28:27.729]             sys.calls <- base::sys.calls
[17:28:27.729]             `[[` <- base::`[[`
[17:28:27.729]             `+` <- base::`+`
[17:28:27.729]             `<<-` <- base::`<<-`
[17:28:27.729]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.729]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.729]                   3L)]
[17:28:27.729]             }
[17:28:27.729]             function(cond) {
[17:28:27.729]                 is_error <- inherits(cond, "error")
[17:28:27.729]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.729]                   NULL)
[17:28:27.729]                 if (is_error) {
[17:28:27.729]                   sessionInformation <- function() {
[17:28:27.729]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.729]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.729]                       search = base::search(), system = base::Sys.info())
[17:28:27.729]                   }
[17:28:27.729]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.729]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.729]                     cond$call), session = sessionInformation(), 
[17:28:27.729]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.729]                   signalCondition(cond)
[17:28:27.729]                 }
[17:28:27.729]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.729]                 "immediateCondition"))) {
[17:28:27.729]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.729]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.729]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.729]                   if (TRUE && !signal) {
[17:28:27.729]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.729]                     {
[17:28:27.729]                       inherits <- base::inherits
[17:28:27.729]                       invokeRestart <- base::invokeRestart
[17:28:27.729]                       is.null <- base::is.null
[17:28:27.729]                       muffled <- FALSE
[17:28:27.729]                       if (inherits(cond, "message")) {
[17:28:27.729]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.729]                         if (muffled) 
[17:28:27.729]                           invokeRestart("muffleMessage")
[17:28:27.729]                       }
[17:28:27.729]                       else if (inherits(cond, "warning")) {
[17:28:27.729]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.729]                         if (muffled) 
[17:28:27.729]                           invokeRestart("muffleWarning")
[17:28:27.729]                       }
[17:28:27.729]                       else if (inherits(cond, "condition")) {
[17:28:27.729]                         if (!is.null(pattern)) {
[17:28:27.729]                           computeRestarts <- base::computeRestarts
[17:28:27.729]                           grepl <- base::grepl
[17:28:27.729]                           restarts <- computeRestarts(cond)
[17:28:27.729]                           for (restart in restarts) {
[17:28:27.729]                             name <- restart$name
[17:28:27.729]                             if (is.null(name)) 
[17:28:27.729]                               next
[17:28:27.729]                             if (!grepl(pattern, name)) 
[17:28:27.729]                               next
[17:28:27.729]                             invokeRestart(restart)
[17:28:27.729]                             muffled <- TRUE
[17:28:27.729]                             break
[17:28:27.729]                           }
[17:28:27.729]                         }
[17:28:27.729]                       }
[17:28:27.729]                       invisible(muffled)
[17:28:27.729]                     }
[17:28:27.729]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.729]                   }
[17:28:27.729]                 }
[17:28:27.729]                 else {
[17:28:27.729]                   if (TRUE) {
[17:28:27.729]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.729]                     {
[17:28:27.729]                       inherits <- base::inherits
[17:28:27.729]                       invokeRestart <- base::invokeRestart
[17:28:27.729]                       is.null <- base::is.null
[17:28:27.729]                       muffled <- FALSE
[17:28:27.729]                       if (inherits(cond, "message")) {
[17:28:27.729]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.729]                         if (muffled) 
[17:28:27.729]                           invokeRestart("muffleMessage")
[17:28:27.729]                       }
[17:28:27.729]                       else if (inherits(cond, "warning")) {
[17:28:27.729]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.729]                         if (muffled) 
[17:28:27.729]                           invokeRestart("muffleWarning")
[17:28:27.729]                       }
[17:28:27.729]                       else if (inherits(cond, "condition")) {
[17:28:27.729]                         if (!is.null(pattern)) {
[17:28:27.729]                           computeRestarts <- base::computeRestarts
[17:28:27.729]                           grepl <- base::grepl
[17:28:27.729]                           restarts <- computeRestarts(cond)
[17:28:27.729]                           for (restart in restarts) {
[17:28:27.729]                             name <- restart$name
[17:28:27.729]                             if (is.null(name)) 
[17:28:27.729]                               next
[17:28:27.729]                             if (!grepl(pattern, name)) 
[17:28:27.729]                               next
[17:28:27.729]                             invokeRestart(restart)
[17:28:27.729]                             muffled <- TRUE
[17:28:27.729]                             break
[17:28:27.729]                           }
[17:28:27.729]                         }
[17:28:27.729]                       }
[17:28:27.729]                       invisible(muffled)
[17:28:27.729]                     }
[17:28:27.729]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.729]                   }
[17:28:27.729]                 }
[17:28:27.729]             }
[17:28:27.729]         }))
[17:28:27.729]     }, error = function(ex) {
[17:28:27.729]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.729]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.729]                 ...future.rng), started = ...future.startTime, 
[17:28:27.729]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.729]             version = "1.8"), class = "FutureResult")
[17:28:27.729]     }, finally = {
[17:28:27.729]         if (!identical(...future.workdir, getwd())) 
[17:28:27.729]             setwd(...future.workdir)
[17:28:27.729]         {
[17:28:27.729]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.729]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.729]             }
[17:28:27.729]             base::options(...future.oldOptions)
[17:28:27.729]             if (.Platform$OS.type == "windows") {
[17:28:27.729]                 old_names <- names(...future.oldEnvVars)
[17:28:27.729]                 envs <- base::Sys.getenv()
[17:28:27.729]                 names <- names(envs)
[17:28:27.729]                 common <- intersect(names, old_names)
[17:28:27.729]                 added <- setdiff(names, old_names)
[17:28:27.729]                 removed <- setdiff(old_names, names)
[17:28:27.729]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.729]                   envs[common]]
[17:28:27.729]                 NAMES <- toupper(changed)
[17:28:27.729]                 args <- list()
[17:28:27.729]                 for (kk in seq_along(NAMES)) {
[17:28:27.729]                   name <- changed[[kk]]
[17:28:27.729]                   NAME <- NAMES[[kk]]
[17:28:27.729]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.729]                     next
[17:28:27.729]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.729]                 }
[17:28:27.729]                 NAMES <- toupper(added)
[17:28:27.729]                 for (kk in seq_along(NAMES)) {
[17:28:27.729]                   name <- added[[kk]]
[17:28:27.729]                   NAME <- NAMES[[kk]]
[17:28:27.729]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.729]                     next
[17:28:27.729]                   args[[name]] <- ""
[17:28:27.729]                 }
[17:28:27.729]                 NAMES <- toupper(removed)
[17:28:27.729]                 for (kk in seq_along(NAMES)) {
[17:28:27.729]                   name <- removed[[kk]]
[17:28:27.729]                   NAME <- NAMES[[kk]]
[17:28:27.729]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.729]                     next
[17:28:27.729]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.729]                 }
[17:28:27.729]                 if (length(args) > 0) 
[17:28:27.729]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.729]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.729]             }
[17:28:27.729]             else {
[17:28:27.729]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.729]             }
[17:28:27.729]             {
[17:28:27.729]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.729]                   0L) {
[17:28:27.729]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.729]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.729]                   base::options(opts)
[17:28:27.729]                 }
[17:28:27.729]                 {
[17:28:27.729]                   {
[17:28:27.729]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.729]                     NULL
[17:28:27.729]                   }
[17:28:27.729]                   options(future.plan = NULL)
[17:28:27.729]                   if (is.na(NA_character_)) 
[17:28:27.729]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.729]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.729]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.729]                     .init = FALSE)
[17:28:27.729]                 }
[17:28:27.729]             }
[17:28:27.729]         }
[17:28:27.729]     })
[17:28:27.729]     if (TRUE) {
[17:28:27.729]         base::sink(type = "output", split = FALSE)
[17:28:27.729]         if (FALSE) {
[17:28:27.729]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.729]         }
[17:28:27.729]         else {
[17:28:27.729]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.729]         }
[17:28:27.729]         base::close(...future.stdout)
[17:28:27.729]         ...future.stdout <- NULL
[17:28:27.729]     }
[17:28:27.729]     ...future.result$conditions <- ...future.conditions
[17:28:27.729]     ...future.result$finished <- base::Sys.time()
[17:28:27.729]     ...future.result
[17:28:27.729] }
[17:28:27.734] MultisessionFuture started
[17:28:27.735] - Launch lazy future ... done
[17:28:27.735] run() for 'MultisessionFuture' ... done
[17:28:27.735] result() for ClusterFuture ...
[17:28:27.735] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.735] - Validating connection of MultisessionFuture
[17:28:27.752] - received message: FutureResult
[17:28:27.752] - Received FutureResult
[17:28:27.752] - Erased future from FutureRegistry
[17:28:27.752] result() for ClusterFuture ...
[17:28:27.752] - result already collected: FutureResult
[17:28:27.752] result() for ClusterFuture ... done
[17:28:27.753] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:27.753] result() for ClusterFuture ... done
[17:28:27.753] result() for ClusterFuture ...
[17:28:27.753] - result already collected: FutureResult
[17:28:27.753] result() for ClusterFuture ... done
- stdout = structure(TRUE, drop = TRUE)
[17:28:27.754] getGlobalsAndPackages() ...
[17:28:27.754] Searching for globals...
[17:28:27.754] - globals found: [1] 'print'
[17:28:27.755] Searching for globals ... DONE
[17:28:27.755] Resolving globals: FALSE
[17:28:27.755] 
[17:28:27.755] 
[17:28:27.755] getGlobalsAndPackages() ... DONE
[17:28:27.756] run() for 'Future' ...
[17:28:27.756] - state: 'created'
[17:28:27.756] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:27.769] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:27.770] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:27.770]   - Field: 'node'
[17:28:27.770]   - Field: 'label'
[17:28:27.770]   - Field: 'local'
[17:28:27.770]   - Field: 'owner'
[17:28:27.771]   - Field: 'envir'
[17:28:27.771]   - Field: 'workers'
[17:28:27.771]   - Field: 'packages'
[17:28:27.771]   - Field: 'gc'
[17:28:27.771]   - Field: 'conditions'
[17:28:27.771]   - Field: 'persistent'
[17:28:27.772]   - Field: 'expr'
[17:28:27.772]   - Field: 'uuid'
[17:28:27.772]   - Field: 'seed'
[17:28:27.772]   - Field: 'version'
[17:28:27.772]   - Field: 'result'
[17:28:27.773]   - Field: 'asynchronous'
[17:28:27.773]   - Field: 'calls'
[17:28:27.773]   - Field: 'globals'
[17:28:27.773]   - Field: 'stdout'
[17:28:27.773]   - Field: 'earlySignal'
[17:28:27.773]   - Field: 'lazy'
[17:28:27.774]   - Field: 'state'
[17:28:27.774] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:27.774] - Launch lazy future ...
[17:28:27.774] Packages needed by the future expression (n = 0): <none>
[17:28:27.774] Packages needed by future strategies (n = 0): <none>
[17:28:27.775] {
[17:28:27.775]     {
[17:28:27.775]         {
[17:28:27.775]             ...future.startTime <- base::Sys.time()
[17:28:27.775]             {
[17:28:27.775]                 {
[17:28:27.775]                   {
[17:28:27.775]                     {
[17:28:27.775]                       base::local({
[17:28:27.775]                         has_future <- base::requireNamespace("future", 
[17:28:27.775]                           quietly = TRUE)
[17:28:27.775]                         if (has_future) {
[17:28:27.775]                           ns <- base::getNamespace("future")
[17:28:27.775]                           version <- ns[[".package"]][["version"]]
[17:28:27.775]                           if (is.null(version)) 
[17:28:27.775]                             version <- utils::packageVersion("future")
[17:28:27.775]                         }
[17:28:27.775]                         else {
[17:28:27.775]                           version <- NULL
[17:28:27.775]                         }
[17:28:27.775]                         if (!has_future || version < "1.8.0") {
[17:28:27.775]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.775]                             "", base::R.version$version.string), 
[17:28:27.775]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:27.775]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:27.775]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.775]                               "release", "version")], collapse = " "), 
[17:28:27.775]                             hostname = base::Sys.info()[["nodename"]])
[17:28:27.775]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.775]                             info)
[17:28:27.775]                           info <- base::paste(info, collapse = "; ")
[17:28:27.775]                           if (!has_future) {
[17:28:27.775]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.775]                               info)
[17:28:27.775]                           }
[17:28:27.775]                           else {
[17:28:27.775]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.775]                               info, version)
[17:28:27.775]                           }
[17:28:27.775]                           base::stop(msg)
[17:28:27.775]                         }
[17:28:27.775]                       })
[17:28:27.775]                     }
[17:28:27.775]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.775]                     base::options(mc.cores = 1L)
[17:28:27.775]                   }
[17:28:27.775]                   ...future.strategy.old <- future::plan("list")
[17:28:27.775]                   options(future.plan = NULL)
[17:28:27.775]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.775]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.775]                 }
[17:28:27.775]                 ...future.workdir <- getwd()
[17:28:27.775]             }
[17:28:27.775]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.775]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.775]         }
[17:28:27.775]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.775]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.775]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.775]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.775]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.775]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.775]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.775]             base::names(...future.oldOptions))
[17:28:27.775]     }
[17:28:27.775]     if (FALSE) {
[17:28:27.775]     }
[17:28:27.775]     else {
[17:28:27.775]         if (TRUE) {
[17:28:27.775]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.775]                 open = "w")
[17:28:27.775]         }
[17:28:27.775]         else {
[17:28:27.775]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.775]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.775]         }
[17:28:27.775]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.775]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.775]             base::sink(type = "output", split = FALSE)
[17:28:27.775]             base::close(...future.stdout)
[17:28:27.775]         }, add = TRUE)
[17:28:27.775]     }
[17:28:27.775]     ...future.frame <- base::sys.nframe()
[17:28:27.775]     ...future.conditions <- base::list()
[17:28:27.775]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.775]     if (FALSE) {
[17:28:27.775]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.775]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.775]     }
[17:28:27.775]     ...future.result <- base::tryCatch({
[17:28:27.775]         base::withCallingHandlers({
[17:28:27.775]             ...future.value <- base::withVisible(base::local({
[17:28:27.775]                 ...future.makeSendCondition <- base::local({
[17:28:27.775]                   sendCondition <- NULL
[17:28:27.775]                   function(frame = 1L) {
[17:28:27.775]                     if (is.function(sendCondition)) 
[17:28:27.775]                       return(sendCondition)
[17:28:27.775]                     ns <- getNamespace("parallel")
[17:28:27.775]                     if (exists("sendData", mode = "function", 
[17:28:27.775]                       envir = ns)) {
[17:28:27.775]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.775]                         envir = ns)
[17:28:27.775]                       envir <- sys.frame(frame)
[17:28:27.775]                       master <- NULL
[17:28:27.775]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.775]                         !identical(envir, emptyenv())) {
[17:28:27.775]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.775]                           inherits = FALSE)) {
[17:28:27.775]                           master <- get("master", mode = "list", 
[17:28:27.775]                             envir = envir, inherits = FALSE)
[17:28:27.775]                           if (inherits(master, c("SOCKnode", 
[17:28:27.775]                             "SOCK0node"))) {
[17:28:27.775]                             sendCondition <<- function(cond) {
[17:28:27.775]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.775]                                 success = TRUE)
[17:28:27.775]                               parallel_sendData(master, data)
[17:28:27.775]                             }
[17:28:27.775]                             return(sendCondition)
[17:28:27.775]                           }
[17:28:27.775]                         }
[17:28:27.775]                         frame <- frame + 1L
[17:28:27.775]                         envir <- sys.frame(frame)
[17:28:27.775]                       }
[17:28:27.775]                     }
[17:28:27.775]                     sendCondition <<- function(cond) NULL
[17:28:27.775]                   }
[17:28:27.775]                 })
[17:28:27.775]                 withCallingHandlers({
[17:28:27.775]                   print(42)
[17:28:27.775]                 }, immediateCondition = function(cond) {
[17:28:27.775]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.775]                   sendCondition(cond)
[17:28:27.775]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.775]                   {
[17:28:27.775]                     inherits <- base::inherits
[17:28:27.775]                     invokeRestart <- base::invokeRestart
[17:28:27.775]                     is.null <- base::is.null
[17:28:27.775]                     muffled <- FALSE
[17:28:27.775]                     if (inherits(cond, "message")) {
[17:28:27.775]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.775]                       if (muffled) 
[17:28:27.775]                         invokeRestart("muffleMessage")
[17:28:27.775]                     }
[17:28:27.775]                     else if (inherits(cond, "warning")) {
[17:28:27.775]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.775]                       if (muffled) 
[17:28:27.775]                         invokeRestart("muffleWarning")
[17:28:27.775]                     }
[17:28:27.775]                     else if (inherits(cond, "condition")) {
[17:28:27.775]                       if (!is.null(pattern)) {
[17:28:27.775]                         computeRestarts <- base::computeRestarts
[17:28:27.775]                         grepl <- base::grepl
[17:28:27.775]                         restarts <- computeRestarts(cond)
[17:28:27.775]                         for (restart in restarts) {
[17:28:27.775]                           name <- restart$name
[17:28:27.775]                           if (is.null(name)) 
[17:28:27.775]                             next
[17:28:27.775]                           if (!grepl(pattern, name)) 
[17:28:27.775]                             next
[17:28:27.775]                           invokeRestart(restart)
[17:28:27.775]                           muffled <- TRUE
[17:28:27.775]                           break
[17:28:27.775]                         }
[17:28:27.775]                       }
[17:28:27.775]                     }
[17:28:27.775]                     invisible(muffled)
[17:28:27.775]                   }
[17:28:27.775]                   muffleCondition(cond)
[17:28:27.775]                 })
[17:28:27.775]             }))
[17:28:27.775]             future::FutureResult(value = ...future.value$value, 
[17:28:27.775]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.775]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.775]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.775]                     ...future.globalenv.names))
[17:28:27.775]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.775]         }, condition = base::local({
[17:28:27.775]             c <- base::c
[17:28:27.775]             inherits <- base::inherits
[17:28:27.775]             invokeRestart <- base::invokeRestart
[17:28:27.775]             length <- base::length
[17:28:27.775]             list <- base::list
[17:28:27.775]             seq.int <- base::seq.int
[17:28:27.775]             signalCondition <- base::signalCondition
[17:28:27.775]             sys.calls <- base::sys.calls
[17:28:27.775]             `[[` <- base::`[[`
[17:28:27.775]             `+` <- base::`+`
[17:28:27.775]             `<<-` <- base::`<<-`
[17:28:27.775]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.775]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.775]                   3L)]
[17:28:27.775]             }
[17:28:27.775]             function(cond) {
[17:28:27.775]                 is_error <- inherits(cond, "error")
[17:28:27.775]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.775]                   NULL)
[17:28:27.775]                 if (is_error) {
[17:28:27.775]                   sessionInformation <- function() {
[17:28:27.775]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.775]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.775]                       search = base::search(), system = base::Sys.info())
[17:28:27.775]                   }
[17:28:27.775]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.775]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.775]                     cond$call), session = sessionInformation(), 
[17:28:27.775]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.775]                   signalCondition(cond)
[17:28:27.775]                 }
[17:28:27.775]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.775]                 "immediateCondition"))) {
[17:28:27.775]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.775]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.775]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.775]                   if (TRUE && !signal) {
[17:28:27.775]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.775]                     {
[17:28:27.775]                       inherits <- base::inherits
[17:28:27.775]                       invokeRestart <- base::invokeRestart
[17:28:27.775]                       is.null <- base::is.null
[17:28:27.775]                       muffled <- FALSE
[17:28:27.775]                       if (inherits(cond, "message")) {
[17:28:27.775]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.775]                         if (muffled) 
[17:28:27.775]                           invokeRestart("muffleMessage")
[17:28:27.775]                       }
[17:28:27.775]                       else if (inherits(cond, "warning")) {
[17:28:27.775]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.775]                         if (muffled) 
[17:28:27.775]                           invokeRestart("muffleWarning")
[17:28:27.775]                       }
[17:28:27.775]                       else if (inherits(cond, "condition")) {
[17:28:27.775]                         if (!is.null(pattern)) {
[17:28:27.775]                           computeRestarts <- base::computeRestarts
[17:28:27.775]                           grepl <- base::grepl
[17:28:27.775]                           restarts <- computeRestarts(cond)
[17:28:27.775]                           for (restart in restarts) {
[17:28:27.775]                             name <- restart$name
[17:28:27.775]                             if (is.null(name)) 
[17:28:27.775]                               next
[17:28:27.775]                             if (!grepl(pattern, name)) 
[17:28:27.775]                               next
[17:28:27.775]                             invokeRestart(restart)
[17:28:27.775]                             muffled <- TRUE
[17:28:27.775]                             break
[17:28:27.775]                           }
[17:28:27.775]                         }
[17:28:27.775]                       }
[17:28:27.775]                       invisible(muffled)
[17:28:27.775]                     }
[17:28:27.775]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.775]                   }
[17:28:27.775]                 }
[17:28:27.775]                 else {
[17:28:27.775]                   if (TRUE) {
[17:28:27.775]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.775]                     {
[17:28:27.775]                       inherits <- base::inherits
[17:28:27.775]                       invokeRestart <- base::invokeRestart
[17:28:27.775]                       is.null <- base::is.null
[17:28:27.775]                       muffled <- FALSE
[17:28:27.775]                       if (inherits(cond, "message")) {
[17:28:27.775]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.775]                         if (muffled) 
[17:28:27.775]                           invokeRestart("muffleMessage")
[17:28:27.775]                       }
[17:28:27.775]                       else if (inherits(cond, "warning")) {
[17:28:27.775]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.775]                         if (muffled) 
[17:28:27.775]                           invokeRestart("muffleWarning")
[17:28:27.775]                       }
[17:28:27.775]                       else if (inherits(cond, "condition")) {
[17:28:27.775]                         if (!is.null(pattern)) {
[17:28:27.775]                           computeRestarts <- base::computeRestarts
[17:28:27.775]                           grepl <- base::grepl
[17:28:27.775]                           restarts <- computeRestarts(cond)
[17:28:27.775]                           for (restart in restarts) {
[17:28:27.775]                             name <- restart$name
[17:28:27.775]                             if (is.null(name)) 
[17:28:27.775]                               next
[17:28:27.775]                             if (!grepl(pattern, name)) 
[17:28:27.775]                               next
[17:28:27.775]                             invokeRestart(restart)
[17:28:27.775]                             muffled <- TRUE
[17:28:27.775]                             break
[17:28:27.775]                           }
[17:28:27.775]                         }
[17:28:27.775]                       }
[17:28:27.775]                       invisible(muffled)
[17:28:27.775]                     }
[17:28:27.775]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.775]                   }
[17:28:27.775]                 }
[17:28:27.775]             }
[17:28:27.775]         }))
[17:28:27.775]     }, error = function(ex) {
[17:28:27.775]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.775]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.775]                 ...future.rng), started = ...future.startTime, 
[17:28:27.775]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.775]             version = "1.8"), class = "FutureResult")
[17:28:27.775]     }, finally = {
[17:28:27.775]         if (!identical(...future.workdir, getwd())) 
[17:28:27.775]             setwd(...future.workdir)
[17:28:27.775]         {
[17:28:27.775]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.775]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.775]             }
[17:28:27.775]             base::options(...future.oldOptions)
[17:28:27.775]             if (.Platform$OS.type == "windows") {
[17:28:27.775]                 old_names <- names(...future.oldEnvVars)
[17:28:27.775]                 envs <- base::Sys.getenv()
[17:28:27.775]                 names <- names(envs)
[17:28:27.775]                 common <- intersect(names, old_names)
[17:28:27.775]                 added <- setdiff(names, old_names)
[17:28:27.775]                 removed <- setdiff(old_names, names)
[17:28:27.775]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.775]                   envs[common]]
[17:28:27.775]                 NAMES <- toupper(changed)
[17:28:27.775]                 args <- list()
[17:28:27.775]                 for (kk in seq_along(NAMES)) {
[17:28:27.775]                   name <- changed[[kk]]
[17:28:27.775]                   NAME <- NAMES[[kk]]
[17:28:27.775]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.775]                     next
[17:28:27.775]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.775]                 }
[17:28:27.775]                 NAMES <- toupper(added)
[17:28:27.775]                 for (kk in seq_along(NAMES)) {
[17:28:27.775]                   name <- added[[kk]]
[17:28:27.775]                   NAME <- NAMES[[kk]]
[17:28:27.775]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.775]                     next
[17:28:27.775]                   args[[name]] <- ""
[17:28:27.775]                 }
[17:28:27.775]                 NAMES <- toupper(removed)
[17:28:27.775]                 for (kk in seq_along(NAMES)) {
[17:28:27.775]                   name <- removed[[kk]]
[17:28:27.775]                   NAME <- NAMES[[kk]]
[17:28:27.775]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.775]                     next
[17:28:27.775]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.775]                 }
[17:28:27.775]                 if (length(args) > 0) 
[17:28:27.775]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.775]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.775]             }
[17:28:27.775]             else {
[17:28:27.775]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.775]             }
[17:28:27.775]             {
[17:28:27.775]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.775]                   0L) {
[17:28:27.775]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.775]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.775]                   base::options(opts)
[17:28:27.775]                 }
[17:28:27.775]                 {
[17:28:27.775]                   {
[17:28:27.775]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.775]                     NULL
[17:28:27.775]                   }
[17:28:27.775]                   options(future.plan = NULL)
[17:28:27.775]                   if (is.na(NA_character_)) 
[17:28:27.775]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.775]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.775]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.775]                     .init = FALSE)
[17:28:27.775]                 }
[17:28:27.775]             }
[17:28:27.775]         }
[17:28:27.775]     })
[17:28:27.775]     if (TRUE) {
[17:28:27.775]         base::sink(type = "output", split = FALSE)
[17:28:27.775]         if (TRUE) {
[17:28:27.775]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.775]         }
[17:28:27.775]         else {
[17:28:27.775]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.775]         }
[17:28:27.775]         base::close(...future.stdout)
[17:28:27.775]         ...future.stdout <- NULL
[17:28:27.775]     }
[17:28:27.775]     ...future.result$conditions <- ...future.conditions
[17:28:27.775]     ...future.result$finished <- base::Sys.time()
[17:28:27.775]     ...future.result
[17:28:27.775] }
[17:28:27.780] MultisessionFuture started
[17:28:27.781] - Launch lazy future ... done
[17:28:27.781] run() for 'MultisessionFuture' ... done
[17:28:27.781] result() for ClusterFuture ...
[17:28:27.781] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.781] - Validating connection of MultisessionFuture
[17:28:27.795] - received message: FutureResult
[17:28:27.795] - Received FutureResult
[17:28:27.795] - Erased future from FutureRegistry
[17:28:27.795] result() for ClusterFuture ...
[17:28:27.796] - result already collected: FutureResult
[17:28:27.796] result() for ClusterFuture ... done
[17:28:27.796] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:27.796] result() for ClusterFuture ... done
[17:28:27.796] result() for ClusterFuture ...
[17:28:27.796] - result already collected: FutureResult
[17:28:27.797] result() for ClusterFuture ... done
[17:28:27.797] result() for ClusterFuture ...
[17:28:27.797] - result already collected: FutureResult
[17:28:27.797] result() for ClusterFuture ... done
[1] 42
[17:28:27.797] result() for ClusterFuture ...
[17:28:27.797] - result already collected: FutureResult
[17:28:27.798] result() for ClusterFuture ... done
- stdout = NA
[17:28:27.798] getGlobalsAndPackages() ...
[17:28:27.798] Searching for globals...
[17:28:27.801] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:28:27.802] Searching for globals ... DONE
[17:28:27.802] Resolving globals: FALSE
[17:28:27.802] 
[17:28:27.803] - packages: [1] 'utils'
[17:28:27.803] getGlobalsAndPackages() ... DONE
[17:28:27.803] run() for 'Future' ...
[17:28:27.803] - state: 'created'
[17:28:27.804] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:27.817] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:27.817] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:27.818]   - Field: 'node'
[17:28:27.818]   - Field: 'label'
[17:28:27.818]   - Field: 'local'
[17:28:27.818]   - Field: 'owner'
[17:28:27.818]   - Field: 'envir'
[17:28:27.818]   - Field: 'workers'
[17:28:27.819]   - Field: 'packages'
[17:28:27.819]   - Field: 'gc'
[17:28:27.819]   - Field: 'conditions'
[17:28:27.819]   - Field: 'persistent'
[17:28:27.819]   - Field: 'expr'
[17:28:27.820]   - Field: 'uuid'
[17:28:27.820]   - Field: 'seed'
[17:28:27.820]   - Field: 'version'
[17:28:27.820]   - Field: 'result'
[17:28:27.820]   - Field: 'asynchronous'
[17:28:27.820]   - Field: 'calls'
[17:28:27.821]   - Field: 'globals'
[17:28:27.821]   - Field: 'stdout'
[17:28:27.821]   - Field: 'earlySignal'
[17:28:27.821]   - Field: 'lazy'
[17:28:27.821]   - Field: 'state'
[17:28:27.822] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:27.822] - Launch lazy future ...
[17:28:27.824] Packages needed by the future expression (n = 1): 'utils'
[17:28:27.824] Packages needed by future strategies (n = 0): <none>
[17:28:27.825] {
[17:28:27.825]     {
[17:28:27.825]         {
[17:28:27.825]             ...future.startTime <- base::Sys.time()
[17:28:27.825]             {
[17:28:27.825]                 {
[17:28:27.825]                   {
[17:28:27.825]                     {
[17:28:27.825]                       {
[17:28:27.825]                         base::local({
[17:28:27.825]                           has_future <- base::requireNamespace("future", 
[17:28:27.825]                             quietly = TRUE)
[17:28:27.825]                           if (has_future) {
[17:28:27.825]                             ns <- base::getNamespace("future")
[17:28:27.825]                             version <- ns[[".package"]][["version"]]
[17:28:27.825]                             if (is.null(version)) 
[17:28:27.825]                               version <- utils::packageVersion("future")
[17:28:27.825]                           }
[17:28:27.825]                           else {
[17:28:27.825]                             version <- NULL
[17:28:27.825]                           }
[17:28:27.825]                           if (!has_future || version < "1.8.0") {
[17:28:27.825]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.825]                               "", base::R.version$version.string), 
[17:28:27.825]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:27.825]                                 base::R.version$platform, 8 * 
[17:28:27.825]                                   base::.Machine$sizeof.pointer), 
[17:28:27.825]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.825]                                 "release", "version")], collapse = " "), 
[17:28:27.825]                               hostname = base::Sys.info()[["nodename"]])
[17:28:27.825]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.825]                               info)
[17:28:27.825]                             info <- base::paste(info, collapse = "; ")
[17:28:27.825]                             if (!has_future) {
[17:28:27.825]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.825]                                 info)
[17:28:27.825]                             }
[17:28:27.825]                             else {
[17:28:27.825]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.825]                                 info, version)
[17:28:27.825]                             }
[17:28:27.825]                             base::stop(msg)
[17:28:27.825]                           }
[17:28:27.825]                         })
[17:28:27.825]                       }
[17:28:27.825]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.825]                       base::options(mc.cores = 1L)
[17:28:27.825]                     }
[17:28:27.825]                     base::local({
[17:28:27.825]                       for (pkg in "utils") {
[17:28:27.825]                         base::loadNamespace(pkg)
[17:28:27.825]                         base::library(pkg, character.only = TRUE)
[17:28:27.825]                       }
[17:28:27.825]                     })
[17:28:27.825]                   }
[17:28:27.825]                   ...future.strategy.old <- future::plan("list")
[17:28:27.825]                   options(future.plan = NULL)
[17:28:27.825]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.825]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.825]                 }
[17:28:27.825]                 ...future.workdir <- getwd()
[17:28:27.825]             }
[17:28:27.825]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.825]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.825]         }
[17:28:27.825]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.825]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.825]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.825]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.825]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.825]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.825]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.825]             base::names(...future.oldOptions))
[17:28:27.825]     }
[17:28:27.825]     if (TRUE) {
[17:28:27.825]     }
[17:28:27.825]     else {
[17:28:27.825]         if (NA) {
[17:28:27.825]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.825]                 open = "w")
[17:28:27.825]         }
[17:28:27.825]         else {
[17:28:27.825]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.825]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.825]         }
[17:28:27.825]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.825]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.825]             base::sink(type = "output", split = FALSE)
[17:28:27.825]             base::close(...future.stdout)
[17:28:27.825]         }, add = TRUE)
[17:28:27.825]     }
[17:28:27.825]     ...future.frame <- base::sys.nframe()
[17:28:27.825]     ...future.conditions <- base::list()
[17:28:27.825]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.825]     if (FALSE) {
[17:28:27.825]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.825]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.825]     }
[17:28:27.825]     ...future.result <- base::tryCatch({
[17:28:27.825]         base::withCallingHandlers({
[17:28:27.825]             ...future.value <- base::withVisible(base::local({
[17:28:27.825]                 ...future.makeSendCondition <- base::local({
[17:28:27.825]                   sendCondition <- NULL
[17:28:27.825]                   function(frame = 1L) {
[17:28:27.825]                     if (is.function(sendCondition)) 
[17:28:27.825]                       return(sendCondition)
[17:28:27.825]                     ns <- getNamespace("parallel")
[17:28:27.825]                     if (exists("sendData", mode = "function", 
[17:28:27.825]                       envir = ns)) {
[17:28:27.825]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.825]                         envir = ns)
[17:28:27.825]                       envir <- sys.frame(frame)
[17:28:27.825]                       master <- NULL
[17:28:27.825]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.825]                         !identical(envir, emptyenv())) {
[17:28:27.825]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.825]                           inherits = FALSE)) {
[17:28:27.825]                           master <- get("master", mode = "list", 
[17:28:27.825]                             envir = envir, inherits = FALSE)
[17:28:27.825]                           if (inherits(master, c("SOCKnode", 
[17:28:27.825]                             "SOCK0node"))) {
[17:28:27.825]                             sendCondition <<- function(cond) {
[17:28:27.825]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.825]                                 success = TRUE)
[17:28:27.825]                               parallel_sendData(master, data)
[17:28:27.825]                             }
[17:28:27.825]                             return(sendCondition)
[17:28:27.825]                           }
[17:28:27.825]                         }
[17:28:27.825]                         frame <- frame + 1L
[17:28:27.825]                         envir <- sys.frame(frame)
[17:28:27.825]                       }
[17:28:27.825]                     }
[17:28:27.825]                     sendCondition <<- function(cond) NULL
[17:28:27.825]                   }
[17:28:27.825]                 })
[17:28:27.825]                 withCallingHandlers({
[17:28:27.825]                   {
[17:28:27.825]                     print(1:50)
[17:28:27.825]                     str(1:50)
[17:28:27.825]                     cat(letters, sep = "-")
[17:28:27.825]                     cat(1:6, collapse = "\n")
[17:28:27.825]                     write.table(datasets::iris[1:10, ], sep = "\t")
[17:28:27.825]                     42L
[17:28:27.825]                   }
[17:28:27.825]                 }, immediateCondition = function(cond) {
[17:28:27.825]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.825]                   sendCondition(cond)
[17:28:27.825]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.825]                   {
[17:28:27.825]                     inherits <- base::inherits
[17:28:27.825]                     invokeRestart <- base::invokeRestart
[17:28:27.825]                     is.null <- base::is.null
[17:28:27.825]                     muffled <- FALSE
[17:28:27.825]                     if (inherits(cond, "message")) {
[17:28:27.825]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.825]                       if (muffled) 
[17:28:27.825]                         invokeRestart("muffleMessage")
[17:28:27.825]                     }
[17:28:27.825]                     else if (inherits(cond, "warning")) {
[17:28:27.825]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.825]                       if (muffled) 
[17:28:27.825]                         invokeRestart("muffleWarning")
[17:28:27.825]                     }
[17:28:27.825]                     else if (inherits(cond, "condition")) {
[17:28:27.825]                       if (!is.null(pattern)) {
[17:28:27.825]                         computeRestarts <- base::computeRestarts
[17:28:27.825]                         grepl <- base::grepl
[17:28:27.825]                         restarts <- computeRestarts(cond)
[17:28:27.825]                         for (restart in restarts) {
[17:28:27.825]                           name <- restart$name
[17:28:27.825]                           if (is.null(name)) 
[17:28:27.825]                             next
[17:28:27.825]                           if (!grepl(pattern, name)) 
[17:28:27.825]                             next
[17:28:27.825]                           invokeRestart(restart)
[17:28:27.825]                           muffled <- TRUE
[17:28:27.825]                           break
[17:28:27.825]                         }
[17:28:27.825]                       }
[17:28:27.825]                     }
[17:28:27.825]                     invisible(muffled)
[17:28:27.825]                   }
[17:28:27.825]                   muffleCondition(cond)
[17:28:27.825]                 })
[17:28:27.825]             }))
[17:28:27.825]             future::FutureResult(value = ...future.value$value, 
[17:28:27.825]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.825]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.825]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.825]                     ...future.globalenv.names))
[17:28:27.825]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.825]         }, condition = base::local({
[17:28:27.825]             c <- base::c
[17:28:27.825]             inherits <- base::inherits
[17:28:27.825]             invokeRestart <- base::invokeRestart
[17:28:27.825]             length <- base::length
[17:28:27.825]             list <- base::list
[17:28:27.825]             seq.int <- base::seq.int
[17:28:27.825]             signalCondition <- base::signalCondition
[17:28:27.825]             sys.calls <- base::sys.calls
[17:28:27.825]             `[[` <- base::`[[`
[17:28:27.825]             `+` <- base::`+`
[17:28:27.825]             `<<-` <- base::`<<-`
[17:28:27.825]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.825]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.825]                   3L)]
[17:28:27.825]             }
[17:28:27.825]             function(cond) {
[17:28:27.825]                 is_error <- inherits(cond, "error")
[17:28:27.825]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.825]                   NULL)
[17:28:27.825]                 if (is_error) {
[17:28:27.825]                   sessionInformation <- function() {
[17:28:27.825]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.825]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.825]                       search = base::search(), system = base::Sys.info())
[17:28:27.825]                   }
[17:28:27.825]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.825]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.825]                     cond$call), session = sessionInformation(), 
[17:28:27.825]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.825]                   signalCondition(cond)
[17:28:27.825]                 }
[17:28:27.825]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.825]                 "immediateCondition"))) {
[17:28:27.825]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.825]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.825]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.825]                   if (TRUE && !signal) {
[17:28:27.825]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.825]                     {
[17:28:27.825]                       inherits <- base::inherits
[17:28:27.825]                       invokeRestart <- base::invokeRestart
[17:28:27.825]                       is.null <- base::is.null
[17:28:27.825]                       muffled <- FALSE
[17:28:27.825]                       if (inherits(cond, "message")) {
[17:28:27.825]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.825]                         if (muffled) 
[17:28:27.825]                           invokeRestart("muffleMessage")
[17:28:27.825]                       }
[17:28:27.825]                       else if (inherits(cond, "warning")) {
[17:28:27.825]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.825]                         if (muffled) 
[17:28:27.825]                           invokeRestart("muffleWarning")
[17:28:27.825]                       }
[17:28:27.825]                       else if (inherits(cond, "condition")) {
[17:28:27.825]                         if (!is.null(pattern)) {
[17:28:27.825]                           computeRestarts <- base::computeRestarts
[17:28:27.825]                           grepl <- base::grepl
[17:28:27.825]                           restarts <- computeRestarts(cond)
[17:28:27.825]                           for (restart in restarts) {
[17:28:27.825]                             name <- restart$name
[17:28:27.825]                             if (is.null(name)) 
[17:28:27.825]                               next
[17:28:27.825]                             if (!grepl(pattern, name)) 
[17:28:27.825]                               next
[17:28:27.825]                             invokeRestart(restart)
[17:28:27.825]                             muffled <- TRUE
[17:28:27.825]                             break
[17:28:27.825]                           }
[17:28:27.825]                         }
[17:28:27.825]                       }
[17:28:27.825]                       invisible(muffled)
[17:28:27.825]                     }
[17:28:27.825]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.825]                   }
[17:28:27.825]                 }
[17:28:27.825]                 else {
[17:28:27.825]                   if (TRUE) {
[17:28:27.825]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.825]                     {
[17:28:27.825]                       inherits <- base::inherits
[17:28:27.825]                       invokeRestart <- base::invokeRestart
[17:28:27.825]                       is.null <- base::is.null
[17:28:27.825]                       muffled <- FALSE
[17:28:27.825]                       if (inherits(cond, "message")) {
[17:28:27.825]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.825]                         if (muffled) 
[17:28:27.825]                           invokeRestart("muffleMessage")
[17:28:27.825]                       }
[17:28:27.825]                       else if (inherits(cond, "warning")) {
[17:28:27.825]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.825]                         if (muffled) 
[17:28:27.825]                           invokeRestart("muffleWarning")
[17:28:27.825]                       }
[17:28:27.825]                       else if (inherits(cond, "condition")) {
[17:28:27.825]                         if (!is.null(pattern)) {
[17:28:27.825]                           computeRestarts <- base::computeRestarts
[17:28:27.825]                           grepl <- base::grepl
[17:28:27.825]                           restarts <- computeRestarts(cond)
[17:28:27.825]                           for (restart in restarts) {
[17:28:27.825]                             name <- restart$name
[17:28:27.825]                             if (is.null(name)) 
[17:28:27.825]                               next
[17:28:27.825]                             if (!grepl(pattern, name)) 
[17:28:27.825]                               next
[17:28:27.825]                             invokeRestart(restart)
[17:28:27.825]                             muffled <- TRUE
[17:28:27.825]                             break
[17:28:27.825]                           }
[17:28:27.825]                         }
[17:28:27.825]                       }
[17:28:27.825]                       invisible(muffled)
[17:28:27.825]                     }
[17:28:27.825]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.825]                   }
[17:28:27.825]                 }
[17:28:27.825]             }
[17:28:27.825]         }))
[17:28:27.825]     }, error = function(ex) {
[17:28:27.825]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.825]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.825]                 ...future.rng), started = ...future.startTime, 
[17:28:27.825]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.825]             version = "1.8"), class = "FutureResult")
[17:28:27.825]     }, finally = {
[17:28:27.825]         if (!identical(...future.workdir, getwd())) 
[17:28:27.825]             setwd(...future.workdir)
[17:28:27.825]         {
[17:28:27.825]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.825]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.825]             }
[17:28:27.825]             base::options(...future.oldOptions)
[17:28:27.825]             if (.Platform$OS.type == "windows") {
[17:28:27.825]                 old_names <- names(...future.oldEnvVars)
[17:28:27.825]                 envs <- base::Sys.getenv()
[17:28:27.825]                 names <- names(envs)
[17:28:27.825]                 common <- intersect(names, old_names)
[17:28:27.825]                 added <- setdiff(names, old_names)
[17:28:27.825]                 removed <- setdiff(old_names, names)
[17:28:27.825]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.825]                   envs[common]]
[17:28:27.825]                 NAMES <- toupper(changed)
[17:28:27.825]                 args <- list()
[17:28:27.825]                 for (kk in seq_along(NAMES)) {
[17:28:27.825]                   name <- changed[[kk]]
[17:28:27.825]                   NAME <- NAMES[[kk]]
[17:28:27.825]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.825]                     next
[17:28:27.825]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.825]                 }
[17:28:27.825]                 NAMES <- toupper(added)
[17:28:27.825]                 for (kk in seq_along(NAMES)) {
[17:28:27.825]                   name <- added[[kk]]
[17:28:27.825]                   NAME <- NAMES[[kk]]
[17:28:27.825]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.825]                     next
[17:28:27.825]                   args[[name]] <- ""
[17:28:27.825]                 }
[17:28:27.825]                 NAMES <- toupper(removed)
[17:28:27.825]                 for (kk in seq_along(NAMES)) {
[17:28:27.825]                   name <- removed[[kk]]
[17:28:27.825]                   NAME <- NAMES[[kk]]
[17:28:27.825]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.825]                     next
[17:28:27.825]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.825]                 }
[17:28:27.825]                 if (length(args) > 0) 
[17:28:27.825]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.825]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.825]             }
[17:28:27.825]             else {
[17:28:27.825]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.825]             }
[17:28:27.825]             {
[17:28:27.825]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.825]                   0L) {
[17:28:27.825]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.825]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.825]                   base::options(opts)
[17:28:27.825]                 }
[17:28:27.825]                 {
[17:28:27.825]                   {
[17:28:27.825]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.825]                     NULL
[17:28:27.825]                   }
[17:28:27.825]                   options(future.plan = NULL)
[17:28:27.825]                   if (is.na(NA_character_)) 
[17:28:27.825]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.825]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.825]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.825]                     .init = FALSE)
[17:28:27.825]                 }
[17:28:27.825]             }
[17:28:27.825]         }
[17:28:27.825]     })
[17:28:27.825]     if (FALSE) {
[17:28:27.825]         base::sink(type = "output", split = FALSE)
[17:28:27.825]         if (NA) {
[17:28:27.825]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.825]         }
[17:28:27.825]         else {
[17:28:27.825]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.825]         }
[17:28:27.825]         base::close(...future.stdout)
[17:28:27.825]         ...future.stdout <- NULL
[17:28:27.825]     }
[17:28:27.825]     ...future.result$conditions <- ...future.conditions
[17:28:27.825]     ...future.result$finished <- base::Sys.time()
[17:28:27.825]     ...future.result
[17:28:27.825] }
[17:28:27.830] MultisessionFuture started
[17:28:27.830] - Launch lazy future ... done
[17:28:27.830] run() for 'MultisessionFuture' ... done
[17:28:27.831] result() for ClusterFuture ...
[17:28:27.831] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.831] - Validating connection of MultisessionFuture
[17:28:27.847] - received message: FutureResult
[17:28:27.847] - Received FutureResult
[17:28:27.847] - Erased future from FutureRegistry
[17:28:27.847] result() for ClusterFuture ...
[17:28:27.847] - result already collected: FutureResult
[17:28:27.848] result() for ClusterFuture ... done
[17:28:27.848] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:27.848] 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-03-26 17:28:27"
 $ finished    : POSIXct[1:1], format: "2024-03-26 17:28:27"
 $ session_uuid: chr "dd8dfb13-f506-00c3-2691-0463fe0fa50c"
  ..- 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 139024
  .. ..$ time  : POSIXct[1:1], format: "2024-03-26 17:28:27"
  .. ..$ random: int 2147483647
 $ r_info      :List of 4
  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1
  .. ..$ : int [1:3] 4 4 0
  ..$ os           : chr "windows"
  ..$ os_name      : chr "Windows"
  ..$ captures_utf8: logi TRUE
 $ version     : chr "1.8"
 - attr(*, "class")= chr "FutureResult"
[17:28:27.857] result() for ClusterFuture ...
[17:28:27.857] - result already collected: FutureResult
[17:28:27.857] result() for ClusterFuture ... done
[17:28:27.857] result() for ClusterFuture ...
[17:28:27.858] - result already collected: FutureResult
[17:28:27.858] result() for ClusterFuture ... done
[17:28:27.858] getGlobalsAndPackages() ...
[17:28:27.858] Searching for globals...
[17:28:27.862] - globals found: [9] '{', 'print', ':', 'str', 'cat', 'letters', 'write.table', '[', '::'
[17:28:27.862] Searching for globals ... DONE
[17:28:27.862] Resolving globals: FALSE
[17:28:27.863] 
[17:28:27.863] - packages: [1] 'utils'
[17:28:27.863] getGlobalsAndPackages() ... DONE
[17:28:27.863] run() for 'Future' ...
[17:28:27.864] - state: 'created'
[17:28:27.864] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:27.878] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:27.878] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:27.878]   - Field: 'node'
[17:28:27.879]   - Field: 'label'
[17:28:27.879]   - Field: 'local'
[17:28:27.879]   - Field: 'owner'
[17:28:27.879]   - Field: 'envir'
[17:28:27.879]   - Field: 'workers'
[17:28:27.879]   - Field: 'packages'
[17:28:27.880]   - Field: 'gc'
[17:28:27.880]   - Field: 'conditions'
[17:28:27.880]   - Field: 'persistent'
[17:28:27.880]   - Field: 'expr'
[17:28:27.880]   - Field: 'uuid'
[17:28:27.880]   - Field: 'seed'
[17:28:27.881]   - Field: 'version'
[17:28:27.881]   - Field: 'result'
[17:28:27.881]   - Field: 'asynchronous'
[17:28:27.881]   - Field: 'calls'
[17:28:27.881]   - Field: 'globals'
[17:28:27.882]   - Field: 'stdout'
[17:28:27.882]   - Field: 'earlySignal'
[17:28:27.882]   - Field: 'lazy'
[17:28:27.882]   - Field: 'state'
[17:28:27.882] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:27.882] - Launch lazy future ...
[17:28:27.883] Packages needed by the future expression (n = 1): 'utils'
[17:28:27.883] Packages needed by future strategies (n = 0): <none>
[17:28:27.884] {
[17:28:27.884]     {
[17:28:27.884]         {
[17:28:27.884]             ...future.startTime <- base::Sys.time()
[17:28:27.884]             {
[17:28:27.884]                 {
[17:28:27.884]                   {
[17:28:27.884]                     {
[17:28:27.884]                       {
[17:28:27.884]                         base::local({
[17:28:27.884]                           has_future <- base::requireNamespace("future", 
[17:28:27.884]                             quietly = TRUE)
[17:28:27.884]                           if (has_future) {
[17:28:27.884]                             ns <- base::getNamespace("future")
[17:28:27.884]                             version <- ns[[".package"]][["version"]]
[17:28:27.884]                             if (is.null(version)) 
[17:28:27.884]                               version <- utils::packageVersion("future")
[17:28:27.884]                           }
[17:28:27.884]                           else {
[17:28:27.884]                             version <- NULL
[17:28:27.884]                           }
[17:28:27.884]                           if (!has_future || version < "1.8.0") {
[17:28:27.884]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.884]                               "", base::R.version$version.string), 
[17:28:27.884]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:27.884]                                 base::R.version$platform, 8 * 
[17:28:27.884]                                   base::.Machine$sizeof.pointer), 
[17:28:27.884]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.884]                                 "release", "version")], collapse = " "), 
[17:28:27.884]                               hostname = base::Sys.info()[["nodename"]])
[17:28:27.884]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.884]                               info)
[17:28:27.884]                             info <- base::paste(info, collapse = "; ")
[17:28:27.884]                             if (!has_future) {
[17:28:27.884]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.884]                                 info)
[17:28:27.884]                             }
[17:28:27.884]                             else {
[17:28:27.884]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.884]                                 info, version)
[17:28:27.884]                             }
[17:28:27.884]                             base::stop(msg)
[17:28:27.884]                           }
[17:28:27.884]                         })
[17:28:27.884]                       }
[17:28:27.884]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.884]                       base::options(mc.cores = 1L)
[17:28:27.884]                     }
[17:28:27.884]                     base::local({
[17:28:27.884]                       for (pkg in "utils") {
[17:28:27.884]                         base::loadNamespace(pkg)
[17:28:27.884]                         base::library(pkg, character.only = TRUE)
[17:28:27.884]                       }
[17:28:27.884]                     })
[17:28:27.884]                   }
[17:28:27.884]                   ...future.strategy.old <- future::plan("list")
[17:28:27.884]                   options(future.plan = NULL)
[17:28:27.884]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.884]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.884]                 }
[17:28:27.884]                 ...future.workdir <- getwd()
[17:28:27.884]             }
[17:28:27.884]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.884]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.884]         }
[17:28:27.884]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.884]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.884]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.884]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.884]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.884]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.884]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.884]             base::names(...future.oldOptions))
[17:28:27.884]     }
[17:28:27.884]     if (TRUE) {
[17:28:27.884]     }
[17:28:27.884]     else {
[17:28:27.884]         if (NA) {
[17:28:27.884]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.884]                 open = "w")
[17:28:27.884]         }
[17:28:27.884]         else {
[17:28:27.884]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.884]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.884]         }
[17:28:27.884]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.884]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.884]             base::sink(type = "output", split = FALSE)
[17:28:27.884]             base::close(...future.stdout)
[17:28:27.884]         }, add = TRUE)
[17:28:27.884]     }
[17:28:27.884]     ...future.frame <- base::sys.nframe()
[17:28:27.884]     ...future.conditions <- base::list()
[17:28:27.884]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.884]     if (FALSE) {
[17:28:27.884]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.884]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.884]     }
[17:28:27.884]     ...future.result <- base::tryCatch({
[17:28:27.884]         base::withCallingHandlers({
[17:28:27.884]             ...future.value <- base::withVisible(base::local({
[17:28:27.884]                 ...future.makeSendCondition <- base::local({
[17:28:27.884]                   sendCondition <- NULL
[17:28:27.884]                   function(frame = 1L) {
[17:28:27.884]                     if (is.function(sendCondition)) 
[17:28:27.884]                       return(sendCondition)
[17:28:27.884]                     ns <- getNamespace("parallel")
[17:28:27.884]                     if (exists("sendData", mode = "function", 
[17:28:27.884]                       envir = ns)) {
[17:28:27.884]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.884]                         envir = ns)
[17:28:27.884]                       envir <- sys.frame(frame)
[17:28:27.884]                       master <- NULL
[17:28:27.884]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.884]                         !identical(envir, emptyenv())) {
[17:28:27.884]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.884]                           inherits = FALSE)) {
[17:28:27.884]                           master <- get("master", mode = "list", 
[17:28:27.884]                             envir = envir, inherits = FALSE)
[17:28:27.884]                           if (inherits(master, c("SOCKnode", 
[17:28:27.884]                             "SOCK0node"))) {
[17:28:27.884]                             sendCondition <<- function(cond) {
[17:28:27.884]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.884]                                 success = TRUE)
[17:28:27.884]                               parallel_sendData(master, data)
[17:28:27.884]                             }
[17:28:27.884]                             return(sendCondition)
[17:28:27.884]                           }
[17:28:27.884]                         }
[17:28:27.884]                         frame <- frame + 1L
[17:28:27.884]                         envir <- sys.frame(frame)
[17:28:27.884]                       }
[17:28:27.884]                     }
[17:28:27.884]                     sendCondition <<- function(cond) NULL
[17:28:27.884]                   }
[17:28:27.884]                 })
[17:28:27.884]                 withCallingHandlers({
[17:28:27.884]                   {
[17:28:27.884]                     print(1:50)
[17:28:27.884]                     str(1:50)
[17:28:27.884]                     cat(letters, sep = "-")
[17:28:27.884]                     cat(1:6, collapse = "\n")
[17:28:27.884]                     write.table(datasets::iris[1:10, ], sep = "\t")
[17:28:27.884]                     42L
[17:28:27.884]                   }
[17:28:27.884]                 }, immediateCondition = function(cond) {
[17:28:27.884]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.884]                   sendCondition(cond)
[17:28:27.884]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.884]                   {
[17:28:27.884]                     inherits <- base::inherits
[17:28:27.884]                     invokeRestart <- base::invokeRestart
[17:28:27.884]                     is.null <- base::is.null
[17:28:27.884]                     muffled <- FALSE
[17:28:27.884]                     if (inherits(cond, "message")) {
[17:28:27.884]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.884]                       if (muffled) 
[17:28:27.884]                         invokeRestart("muffleMessage")
[17:28:27.884]                     }
[17:28:27.884]                     else if (inherits(cond, "warning")) {
[17:28:27.884]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.884]                       if (muffled) 
[17:28:27.884]                         invokeRestart("muffleWarning")
[17:28:27.884]                     }
[17:28:27.884]                     else if (inherits(cond, "condition")) {
[17:28:27.884]                       if (!is.null(pattern)) {
[17:28:27.884]                         computeRestarts <- base::computeRestarts
[17:28:27.884]                         grepl <- base::grepl
[17:28:27.884]                         restarts <- computeRestarts(cond)
[17:28:27.884]                         for (restart in restarts) {
[17:28:27.884]                           name <- restart$name
[17:28:27.884]                           if (is.null(name)) 
[17:28:27.884]                             next
[17:28:27.884]                           if (!grepl(pattern, name)) 
[17:28:27.884]                             next
[17:28:27.884]                           invokeRestart(restart)
[17:28:27.884]                           muffled <- TRUE
[17:28:27.884]                           break
[17:28:27.884]                         }
[17:28:27.884]                       }
[17:28:27.884]                     }
[17:28:27.884]                     invisible(muffled)
[17:28:27.884]                   }
[17:28:27.884]                   muffleCondition(cond)
[17:28:27.884]                 })
[17:28:27.884]             }))
[17:28:27.884]             future::FutureResult(value = ...future.value$value, 
[17:28:27.884]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.884]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.884]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.884]                     ...future.globalenv.names))
[17:28:27.884]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.884]         }, condition = base::local({
[17:28:27.884]             c <- base::c
[17:28:27.884]             inherits <- base::inherits
[17:28:27.884]             invokeRestart <- base::invokeRestart
[17:28:27.884]             length <- base::length
[17:28:27.884]             list <- base::list
[17:28:27.884]             seq.int <- base::seq.int
[17:28:27.884]             signalCondition <- base::signalCondition
[17:28:27.884]             sys.calls <- base::sys.calls
[17:28:27.884]             `[[` <- base::`[[`
[17:28:27.884]             `+` <- base::`+`
[17:28:27.884]             `<<-` <- base::`<<-`
[17:28:27.884]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.884]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.884]                   3L)]
[17:28:27.884]             }
[17:28:27.884]             function(cond) {
[17:28:27.884]                 is_error <- inherits(cond, "error")
[17:28:27.884]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.884]                   NULL)
[17:28:27.884]                 if (is_error) {
[17:28:27.884]                   sessionInformation <- function() {
[17:28:27.884]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.884]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.884]                       search = base::search(), system = base::Sys.info())
[17:28:27.884]                   }
[17:28:27.884]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.884]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.884]                     cond$call), session = sessionInformation(), 
[17:28:27.884]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.884]                   signalCondition(cond)
[17:28:27.884]                 }
[17:28:27.884]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.884]                 "immediateCondition"))) {
[17:28:27.884]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.884]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.884]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.884]                   if (TRUE && !signal) {
[17:28:27.884]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.884]                     {
[17:28:27.884]                       inherits <- base::inherits
[17:28:27.884]                       invokeRestart <- base::invokeRestart
[17:28:27.884]                       is.null <- base::is.null
[17:28:27.884]                       muffled <- FALSE
[17:28:27.884]                       if (inherits(cond, "message")) {
[17:28:27.884]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.884]                         if (muffled) 
[17:28:27.884]                           invokeRestart("muffleMessage")
[17:28:27.884]                       }
[17:28:27.884]                       else if (inherits(cond, "warning")) {
[17:28:27.884]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.884]                         if (muffled) 
[17:28:27.884]                           invokeRestart("muffleWarning")
[17:28:27.884]                       }
[17:28:27.884]                       else if (inherits(cond, "condition")) {
[17:28:27.884]                         if (!is.null(pattern)) {
[17:28:27.884]                           computeRestarts <- base::computeRestarts
[17:28:27.884]                           grepl <- base::grepl
[17:28:27.884]                           restarts <- computeRestarts(cond)
[17:28:27.884]                           for (restart in restarts) {
[17:28:27.884]                             name <- restart$name
[17:28:27.884]                             if (is.null(name)) 
[17:28:27.884]                               next
[17:28:27.884]                             if (!grepl(pattern, name)) 
[17:28:27.884]                               next
[17:28:27.884]                             invokeRestart(restart)
[17:28:27.884]                             muffled <- TRUE
[17:28:27.884]                             break
[17:28:27.884]                           }
[17:28:27.884]                         }
[17:28:27.884]                       }
[17:28:27.884]                       invisible(muffled)
[17:28:27.884]                     }
[17:28:27.884]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.884]                   }
[17:28:27.884]                 }
[17:28:27.884]                 else {
[17:28:27.884]                   if (TRUE) {
[17:28:27.884]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.884]                     {
[17:28:27.884]                       inherits <- base::inherits
[17:28:27.884]                       invokeRestart <- base::invokeRestart
[17:28:27.884]                       is.null <- base::is.null
[17:28:27.884]                       muffled <- FALSE
[17:28:27.884]                       if (inherits(cond, "message")) {
[17:28:27.884]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.884]                         if (muffled) 
[17:28:27.884]                           invokeRestart("muffleMessage")
[17:28:27.884]                       }
[17:28:27.884]                       else if (inherits(cond, "warning")) {
[17:28:27.884]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.884]                         if (muffled) 
[17:28:27.884]                           invokeRestart("muffleWarning")
[17:28:27.884]                       }
[17:28:27.884]                       else if (inherits(cond, "condition")) {
[17:28:27.884]                         if (!is.null(pattern)) {
[17:28:27.884]                           computeRestarts <- base::computeRestarts
[17:28:27.884]                           grepl <- base::grepl
[17:28:27.884]                           restarts <- computeRestarts(cond)
[17:28:27.884]                           for (restart in restarts) {
[17:28:27.884]                             name <- restart$name
[17:28:27.884]                             if (is.null(name)) 
[17:28:27.884]                               next
[17:28:27.884]                             if (!grepl(pattern, name)) 
[17:28:27.884]                               next
[17:28:27.884]                             invokeRestart(restart)
[17:28:27.884]                             muffled <- TRUE
[17:28:27.884]                             break
[17:28:27.884]                           }
[17:28:27.884]                         }
[17:28:27.884]                       }
[17:28:27.884]                       invisible(muffled)
[17:28:27.884]                     }
[17:28:27.884]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.884]                   }
[17:28:27.884]                 }
[17:28:27.884]             }
[17:28:27.884]         }))
[17:28:27.884]     }, error = function(ex) {
[17:28:27.884]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.884]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.884]                 ...future.rng), started = ...future.startTime, 
[17:28:27.884]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.884]             version = "1.8"), class = "FutureResult")
[17:28:27.884]     }, finally = {
[17:28:27.884]         if (!identical(...future.workdir, getwd())) 
[17:28:27.884]             setwd(...future.workdir)
[17:28:27.884]         {
[17:28:27.884]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.884]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.884]             }
[17:28:27.884]             base::options(...future.oldOptions)
[17:28:27.884]             if (.Platform$OS.type == "windows") {
[17:28:27.884]                 old_names <- names(...future.oldEnvVars)
[17:28:27.884]                 envs <- base::Sys.getenv()
[17:28:27.884]                 names <- names(envs)
[17:28:27.884]                 common <- intersect(names, old_names)
[17:28:27.884]                 added <- setdiff(names, old_names)
[17:28:27.884]                 removed <- setdiff(old_names, names)
[17:28:27.884]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.884]                   envs[common]]
[17:28:27.884]                 NAMES <- toupper(changed)
[17:28:27.884]                 args <- list()
[17:28:27.884]                 for (kk in seq_along(NAMES)) {
[17:28:27.884]                   name <- changed[[kk]]
[17:28:27.884]                   NAME <- NAMES[[kk]]
[17:28:27.884]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.884]                     next
[17:28:27.884]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.884]                 }
[17:28:27.884]                 NAMES <- toupper(added)
[17:28:27.884]                 for (kk in seq_along(NAMES)) {
[17:28:27.884]                   name <- added[[kk]]
[17:28:27.884]                   NAME <- NAMES[[kk]]
[17:28:27.884]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.884]                     next
[17:28:27.884]                   args[[name]] <- ""
[17:28:27.884]                 }
[17:28:27.884]                 NAMES <- toupper(removed)
[17:28:27.884]                 for (kk in seq_along(NAMES)) {
[17:28:27.884]                   name <- removed[[kk]]
[17:28:27.884]                   NAME <- NAMES[[kk]]
[17:28:27.884]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.884]                     next
[17:28:27.884]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.884]                 }
[17:28:27.884]                 if (length(args) > 0) 
[17:28:27.884]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.884]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.884]             }
[17:28:27.884]             else {
[17:28:27.884]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.884]             }
[17:28:27.884]             {
[17:28:27.884]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.884]                   0L) {
[17:28:27.884]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.884]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.884]                   base::options(opts)
[17:28:27.884]                 }
[17:28:27.884]                 {
[17:28:27.884]                   {
[17:28:27.884]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.884]                     NULL
[17:28:27.884]                   }
[17:28:27.884]                   options(future.plan = NULL)
[17:28:27.884]                   if (is.na(NA_character_)) 
[17:28:27.884]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.884]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.884]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.884]                     .init = FALSE)
[17:28:27.884]                 }
[17:28:27.884]             }
[17:28:27.884]         }
[17:28:27.884]     })
[17:28:27.884]     if (FALSE) {
[17:28:27.884]         base::sink(type = "output", split = FALSE)
[17:28:27.884]         if (NA) {
[17:28:27.884]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.884]         }
[17:28:27.884]         else {
[17:28:27.884]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.884]         }
[17:28:27.884]         base::close(...future.stdout)
[17:28:27.884]         ...future.stdout <- NULL
[17:28:27.884]     }
[17:28:27.884]     ...future.result$conditions <- ...future.conditions
[17:28:27.884]     ...future.result$finished <- base::Sys.time()
[17:28:27.884]     ...future.result
[17:28:27.884] }
[17:28:27.889] MultisessionFuture started
[17:28:27.889] - Launch lazy future ... done
[17:28:27.889] run() for 'MultisessionFuture' ... done
[17:28:27.890] result() for ClusterFuture ...
[17:28:27.890] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.890] - Validating connection of MultisessionFuture
[17:28:27.905] - received message: FutureResult
[17:28:27.905] - Received FutureResult
[17:28:27.905] - Erased future from FutureRegistry
[17:28:27.906] result() for ClusterFuture ...
[17:28:27.906] - result already collected: FutureResult
[17:28:27.906] result() for ClusterFuture ... done
[17:28:27.906] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:27.906] result() for ClusterFuture ... done
[17:28:27.906] result() for ClusterFuture ...
[17:28:27.906] - result already collected: FutureResult
[17:28:27.907] result() for ClusterFuture ... done
- stdout = structure(TRUE, drop = TRUE)
[17:28:27.907] getGlobalsAndPackages() ...
[17:28:27.907] Searching for globals...
[17:28:27.908] - globals found: [1] 'print'
[17:28:27.908] Searching for globals ... DONE
[17:28:27.908] Resolving globals: FALSE
[17:28:27.908] 
[17:28:27.909] 
[17:28:27.909] getGlobalsAndPackages() ... DONE
[17:28:27.909] run() for 'Future' ...
[17:28:27.909] - state: 'created'
[17:28:27.909] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:27.923] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:27.923] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:27.923]   - Field: 'node'
[17:28:27.923]   - Field: 'label'
[17:28:27.923]   - Field: 'local'
[17:28:27.924]   - Field: 'owner'
[17:28:27.924]   - Field: 'envir'
[17:28:27.924]   - Field: 'workers'
[17:28:27.924]   - Field: 'packages'
[17:28:27.924]   - Field: 'gc'
[17:28:27.924]   - Field: 'conditions'
[17:28:27.925]   - Field: 'persistent'
[17:28:27.925]   - Field: 'expr'
[17:28:27.925]   - Field: 'uuid'
[17:28:27.925]   - Field: 'seed'
[17:28:27.925]   - Field: 'version'
[17:28:27.926]   - Field: 'result'
[17:28:27.926]   - Field: 'asynchronous'
[17:28:27.926]   - Field: 'calls'
[17:28:27.926]   - Field: 'globals'
[17:28:27.926]   - Field: 'stdout'
[17:28:27.926]   - Field: 'earlySignal'
[17:28:27.927]   - Field: 'lazy'
[17:28:27.927]   - Field: 'state'
[17:28:27.927] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:27.927] - Launch lazy future ...
[17:28:27.927] Packages needed by the future expression (n = 0): <none>
[17:28:27.928] Packages needed by future strategies (n = 0): <none>
[17:28:27.928] {
[17:28:27.928]     {
[17:28:27.928]         {
[17:28:27.928]             ...future.startTime <- base::Sys.time()
[17:28:27.928]             {
[17:28:27.928]                 {
[17:28:27.928]                   {
[17:28:27.928]                     {
[17:28:27.928]                       base::local({
[17:28:27.928]                         has_future <- base::requireNamespace("future", 
[17:28:27.928]                           quietly = TRUE)
[17:28:27.928]                         if (has_future) {
[17:28:27.928]                           ns <- base::getNamespace("future")
[17:28:27.928]                           version <- ns[[".package"]][["version"]]
[17:28:27.928]                           if (is.null(version)) 
[17:28:27.928]                             version <- utils::packageVersion("future")
[17:28:27.928]                         }
[17:28:27.928]                         else {
[17:28:27.928]                           version <- NULL
[17:28:27.928]                         }
[17:28:27.928]                         if (!has_future || version < "1.8.0") {
[17:28:27.928]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.928]                             "", base::R.version$version.string), 
[17:28:27.928]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:27.928]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:27.928]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.928]                               "release", "version")], collapse = " "), 
[17:28:27.928]                             hostname = base::Sys.info()[["nodename"]])
[17:28:27.928]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.928]                             info)
[17:28:27.928]                           info <- base::paste(info, collapse = "; ")
[17:28:27.928]                           if (!has_future) {
[17:28:27.928]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.928]                               info)
[17:28:27.928]                           }
[17:28:27.928]                           else {
[17:28:27.928]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.928]                               info, version)
[17:28:27.928]                           }
[17:28:27.928]                           base::stop(msg)
[17:28:27.928]                         }
[17:28:27.928]                       })
[17:28:27.928]                     }
[17:28:27.928]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.928]                     base::options(mc.cores = 1L)
[17:28:27.928]                   }
[17:28:27.928]                   ...future.strategy.old <- future::plan("list")
[17:28:27.928]                   options(future.plan = NULL)
[17:28:27.928]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.928]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.928]                 }
[17:28:27.928]                 ...future.workdir <- getwd()
[17:28:27.928]             }
[17:28:27.928]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.928]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.928]         }
[17:28:27.928]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.928]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.928]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.928]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.928]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.928]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.928]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.928]             base::names(...future.oldOptions))
[17:28:27.928]     }
[17:28:27.928]     if (FALSE) {
[17:28:27.928]     }
[17:28:27.928]     else {
[17:28:27.928]         if (TRUE) {
[17:28:27.928]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.928]                 open = "w")
[17:28:27.928]         }
[17:28:27.928]         else {
[17:28:27.928]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.928]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.928]         }
[17:28:27.928]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.928]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.928]             base::sink(type = "output", split = FALSE)
[17:28:27.928]             base::close(...future.stdout)
[17:28:27.928]         }, add = TRUE)
[17:28:27.928]     }
[17:28:27.928]     ...future.frame <- base::sys.nframe()
[17:28:27.928]     ...future.conditions <- base::list()
[17:28:27.928]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.928]     if (FALSE) {
[17:28:27.928]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.928]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.928]     }
[17:28:27.928]     ...future.result <- base::tryCatch({
[17:28:27.928]         base::withCallingHandlers({
[17:28:27.928]             ...future.value <- base::withVisible(base::local({
[17:28:27.928]                 ...future.makeSendCondition <- base::local({
[17:28:27.928]                   sendCondition <- NULL
[17:28:27.928]                   function(frame = 1L) {
[17:28:27.928]                     if (is.function(sendCondition)) 
[17:28:27.928]                       return(sendCondition)
[17:28:27.928]                     ns <- getNamespace("parallel")
[17:28:27.928]                     if (exists("sendData", mode = "function", 
[17:28:27.928]                       envir = ns)) {
[17:28:27.928]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.928]                         envir = ns)
[17:28:27.928]                       envir <- sys.frame(frame)
[17:28:27.928]                       master <- NULL
[17:28:27.928]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.928]                         !identical(envir, emptyenv())) {
[17:28:27.928]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.928]                           inherits = FALSE)) {
[17:28:27.928]                           master <- get("master", mode = "list", 
[17:28:27.928]                             envir = envir, inherits = FALSE)
[17:28:27.928]                           if (inherits(master, c("SOCKnode", 
[17:28:27.928]                             "SOCK0node"))) {
[17:28:27.928]                             sendCondition <<- function(cond) {
[17:28:27.928]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.928]                                 success = TRUE)
[17:28:27.928]                               parallel_sendData(master, data)
[17:28:27.928]                             }
[17:28:27.928]                             return(sendCondition)
[17:28:27.928]                           }
[17:28:27.928]                         }
[17:28:27.928]                         frame <- frame + 1L
[17:28:27.928]                         envir <- sys.frame(frame)
[17:28:27.928]                       }
[17:28:27.928]                     }
[17:28:27.928]                     sendCondition <<- function(cond) NULL
[17:28:27.928]                   }
[17:28:27.928]                 })
[17:28:27.928]                 withCallingHandlers({
[17:28:27.928]                   print(42)
[17:28:27.928]                 }, immediateCondition = function(cond) {
[17:28:27.928]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.928]                   sendCondition(cond)
[17:28:27.928]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.928]                   {
[17:28:27.928]                     inherits <- base::inherits
[17:28:27.928]                     invokeRestart <- base::invokeRestart
[17:28:27.928]                     is.null <- base::is.null
[17:28:27.928]                     muffled <- FALSE
[17:28:27.928]                     if (inherits(cond, "message")) {
[17:28:27.928]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.928]                       if (muffled) 
[17:28:27.928]                         invokeRestart("muffleMessage")
[17:28:27.928]                     }
[17:28:27.928]                     else if (inherits(cond, "warning")) {
[17:28:27.928]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.928]                       if (muffled) 
[17:28:27.928]                         invokeRestart("muffleWarning")
[17:28:27.928]                     }
[17:28:27.928]                     else if (inherits(cond, "condition")) {
[17:28:27.928]                       if (!is.null(pattern)) {
[17:28:27.928]                         computeRestarts <- base::computeRestarts
[17:28:27.928]                         grepl <- base::grepl
[17:28:27.928]                         restarts <- computeRestarts(cond)
[17:28:27.928]                         for (restart in restarts) {
[17:28:27.928]                           name <- restart$name
[17:28:27.928]                           if (is.null(name)) 
[17:28:27.928]                             next
[17:28:27.928]                           if (!grepl(pattern, name)) 
[17:28:27.928]                             next
[17:28:27.928]                           invokeRestart(restart)
[17:28:27.928]                           muffled <- TRUE
[17:28:27.928]                           break
[17:28:27.928]                         }
[17:28:27.928]                       }
[17:28:27.928]                     }
[17:28:27.928]                     invisible(muffled)
[17:28:27.928]                   }
[17:28:27.928]                   muffleCondition(cond)
[17:28:27.928]                 })
[17:28:27.928]             }))
[17:28:27.928]             future::FutureResult(value = ...future.value$value, 
[17:28:27.928]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.928]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.928]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.928]                     ...future.globalenv.names))
[17:28:27.928]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.928]         }, condition = base::local({
[17:28:27.928]             c <- base::c
[17:28:27.928]             inherits <- base::inherits
[17:28:27.928]             invokeRestart <- base::invokeRestart
[17:28:27.928]             length <- base::length
[17:28:27.928]             list <- base::list
[17:28:27.928]             seq.int <- base::seq.int
[17:28:27.928]             signalCondition <- base::signalCondition
[17:28:27.928]             sys.calls <- base::sys.calls
[17:28:27.928]             `[[` <- base::`[[`
[17:28:27.928]             `+` <- base::`+`
[17:28:27.928]             `<<-` <- base::`<<-`
[17:28:27.928]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.928]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.928]                   3L)]
[17:28:27.928]             }
[17:28:27.928]             function(cond) {
[17:28:27.928]                 is_error <- inherits(cond, "error")
[17:28:27.928]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.928]                   NULL)
[17:28:27.928]                 if (is_error) {
[17:28:27.928]                   sessionInformation <- function() {
[17:28:27.928]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.928]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.928]                       search = base::search(), system = base::Sys.info())
[17:28:27.928]                   }
[17:28:27.928]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.928]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.928]                     cond$call), session = sessionInformation(), 
[17:28:27.928]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.928]                   signalCondition(cond)
[17:28:27.928]                 }
[17:28:27.928]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.928]                 "immediateCondition"))) {
[17:28:27.928]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.928]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.928]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.928]                   if (TRUE && !signal) {
[17:28:27.928]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.928]                     {
[17:28:27.928]                       inherits <- base::inherits
[17:28:27.928]                       invokeRestart <- base::invokeRestart
[17:28:27.928]                       is.null <- base::is.null
[17:28:27.928]                       muffled <- FALSE
[17:28:27.928]                       if (inherits(cond, "message")) {
[17:28:27.928]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.928]                         if (muffled) 
[17:28:27.928]                           invokeRestart("muffleMessage")
[17:28:27.928]                       }
[17:28:27.928]                       else if (inherits(cond, "warning")) {
[17:28:27.928]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.928]                         if (muffled) 
[17:28:27.928]                           invokeRestart("muffleWarning")
[17:28:27.928]                       }
[17:28:27.928]                       else if (inherits(cond, "condition")) {
[17:28:27.928]                         if (!is.null(pattern)) {
[17:28:27.928]                           computeRestarts <- base::computeRestarts
[17:28:27.928]                           grepl <- base::grepl
[17:28:27.928]                           restarts <- computeRestarts(cond)
[17:28:27.928]                           for (restart in restarts) {
[17:28:27.928]                             name <- restart$name
[17:28:27.928]                             if (is.null(name)) 
[17:28:27.928]                               next
[17:28:27.928]                             if (!grepl(pattern, name)) 
[17:28:27.928]                               next
[17:28:27.928]                             invokeRestart(restart)
[17:28:27.928]                             muffled <- TRUE
[17:28:27.928]                             break
[17:28:27.928]                           }
[17:28:27.928]                         }
[17:28:27.928]                       }
[17:28:27.928]                       invisible(muffled)
[17:28:27.928]                     }
[17:28:27.928]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.928]                   }
[17:28:27.928]                 }
[17:28:27.928]                 else {
[17:28:27.928]                   if (TRUE) {
[17:28:27.928]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.928]                     {
[17:28:27.928]                       inherits <- base::inherits
[17:28:27.928]                       invokeRestart <- base::invokeRestart
[17:28:27.928]                       is.null <- base::is.null
[17:28:27.928]                       muffled <- FALSE
[17:28:27.928]                       if (inherits(cond, "message")) {
[17:28:27.928]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.928]                         if (muffled) 
[17:28:27.928]                           invokeRestart("muffleMessage")
[17:28:27.928]                       }
[17:28:27.928]                       else if (inherits(cond, "warning")) {
[17:28:27.928]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.928]                         if (muffled) 
[17:28:27.928]                           invokeRestart("muffleWarning")
[17:28:27.928]                       }
[17:28:27.928]                       else if (inherits(cond, "condition")) {
[17:28:27.928]                         if (!is.null(pattern)) {
[17:28:27.928]                           computeRestarts <- base::computeRestarts
[17:28:27.928]                           grepl <- base::grepl
[17:28:27.928]                           restarts <- computeRestarts(cond)
[17:28:27.928]                           for (restart in restarts) {
[17:28:27.928]                             name <- restart$name
[17:28:27.928]                             if (is.null(name)) 
[17:28:27.928]                               next
[17:28:27.928]                             if (!grepl(pattern, name)) 
[17:28:27.928]                               next
[17:28:27.928]                             invokeRestart(restart)
[17:28:27.928]                             muffled <- TRUE
[17:28:27.928]                             break
[17:28:27.928]                           }
[17:28:27.928]                         }
[17:28:27.928]                       }
[17:28:27.928]                       invisible(muffled)
[17:28:27.928]                     }
[17:28:27.928]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.928]                   }
[17:28:27.928]                 }
[17:28:27.928]             }
[17:28:27.928]         }))
[17:28:27.928]     }, error = function(ex) {
[17:28:27.928]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.928]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.928]                 ...future.rng), started = ...future.startTime, 
[17:28:27.928]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.928]             version = "1.8"), class = "FutureResult")
[17:28:27.928]     }, finally = {
[17:28:27.928]         if (!identical(...future.workdir, getwd())) 
[17:28:27.928]             setwd(...future.workdir)
[17:28:27.928]         {
[17:28:27.928]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.928]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.928]             }
[17:28:27.928]             base::options(...future.oldOptions)
[17:28:27.928]             if (.Platform$OS.type == "windows") {
[17:28:27.928]                 old_names <- names(...future.oldEnvVars)
[17:28:27.928]                 envs <- base::Sys.getenv()
[17:28:27.928]                 names <- names(envs)
[17:28:27.928]                 common <- intersect(names, old_names)
[17:28:27.928]                 added <- setdiff(names, old_names)
[17:28:27.928]                 removed <- setdiff(old_names, names)
[17:28:27.928]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.928]                   envs[common]]
[17:28:27.928]                 NAMES <- toupper(changed)
[17:28:27.928]                 args <- list()
[17:28:27.928]                 for (kk in seq_along(NAMES)) {
[17:28:27.928]                   name <- changed[[kk]]
[17:28:27.928]                   NAME <- NAMES[[kk]]
[17:28:27.928]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.928]                     next
[17:28:27.928]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.928]                 }
[17:28:27.928]                 NAMES <- toupper(added)
[17:28:27.928]                 for (kk in seq_along(NAMES)) {
[17:28:27.928]                   name <- added[[kk]]
[17:28:27.928]                   NAME <- NAMES[[kk]]
[17:28:27.928]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.928]                     next
[17:28:27.928]                   args[[name]] <- ""
[17:28:27.928]                 }
[17:28:27.928]                 NAMES <- toupper(removed)
[17:28:27.928]                 for (kk in seq_along(NAMES)) {
[17:28:27.928]                   name <- removed[[kk]]
[17:28:27.928]                   NAME <- NAMES[[kk]]
[17:28:27.928]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.928]                     next
[17:28:27.928]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.928]                 }
[17:28:27.928]                 if (length(args) > 0) 
[17:28:27.928]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.928]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.928]             }
[17:28:27.928]             else {
[17:28:27.928]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.928]             }
[17:28:27.928]             {
[17:28:27.928]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.928]                   0L) {
[17:28:27.928]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.928]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.928]                   base::options(opts)
[17:28:27.928]                 }
[17:28:27.928]                 {
[17:28:27.928]                   {
[17:28:27.928]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.928]                     NULL
[17:28:27.928]                   }
[17:28:27.928]                   options(future.plan = NULL)
[17:28:27.928]                   if (is.na(NA_character_)) 
[17:28:27.928]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.928]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.928]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.928]                     .init = FALSE)
[17:28:27.928]                 }
[17:28:27.928]             }
[17:28:27.928]         }
[17:28:27.928]     })
[17:28:27.928]     if (TRUE) {
[17:28:27.928]         base::sink(type = "output", split = FALSE)
[17:28:27.928]         if (TRUE) {
[17:28:27.928]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.928]         }
[17:28:27.928]         else {
[17:28:27.928]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.928]         }
[17:28:27.928]         base::close(...future.stdout)
[17:28:27.928]         ...future.stdout <- NULL
[17:28:27.928]     }
[17:28:27.928]     ...future.result$conditions <- ...future.conditions
[17:28:27.928]     ...future.result$finished <- base::Sys.time()
[17:28:27.928]     ...future.result
[17:28:27.928] }
[17:28:27.934] MultisessionFuture started
[17:28:27.934] - Launch lazy future ... done
[17:28:27.934] run() for 'MultisessionFuture' ... done
[17:28:27.934] result() for ClusterFuture ...
[17:28:27.934] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.934] - Validating connection of MultisessionFuture
[17:28:27.948] - received message: FutureResult
[17:28:27.948] - Received FutureResult
[17:28:27.948] - Erased future from FutureRegistry
[17:28:27.948] result() for ClusterFuture ...
[17:28:27.948] - result already collected: FutureResult
[17:28:27.948] result() for ClusterFuture ... done
[17:28:27.949] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:27.949] result() for ClusterFuture ... done
[17:28:27.949] result() for ClusterFuture ...
[17:28:27.949] - result already collected: FutureResult
[17:28:27.949] result() for ClusterFuture ... done
[17:28:27.949] result() for ClusterFuture ...
[17:28:27.949] - result already collected: FutureResult
[17:28:27.950] result() for ClusterFuture ... done
[1] 42
[17:28:27.950] result() for ClusterFuture ...
[17:28:27.950] - result already collected: FutureResult
[17:28:27.950] result() for ClusterFuture ... done
multisession ... done
Testing with 2 cores ... done
> 
> message("*** Standard output ... DONE")
*** Standard output ... DONE
> 
> source("incl/end.R")
[17:28:27.951] plan(): Setting new future strategy stack:
[17:28:27.951] List of future strategies:
[17:28:27.951] 1. FutureStrategy:
[17:28:27.951]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:27.951]    - tweaked: FALSE
[17:28:27.951]    - call: future::plan(oplan)
[17:28:27.952] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=204] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', '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_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 
   0.87    0.21    1.81