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

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

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

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

> source("incl/start.R")
[17:26:32.751] plan(): Setting new future strategy stack:
[17:26:32.753] List of future strategies:
[17:26:32.753] 1. sequential:
[17:26:32.753]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.753]    - tweaked: FALSE
[17:26:32.753]    - call: future::plan("sequential")
[17:26:32.781] plan(): nbrOfWorkers() = 1
> 
> message("*** backtrace( ) ...")
*** backtrace( ) ...
> 
> message("*** backtrace( ) - explicit future ...")
*** backtrace( ) - explicit future ...
> 
> f <- future({ 42L; stop("Woops") })
[17:26:32.791] getGlobalsAndPackages() ...
[17:26:32.792] Searching for globals...
[17:26:32.803] - globals found: [2] '{', 'stop'
[17:26:32.803] Searching for globals ... DONE
[17:26:32.803] Resolving globals: FALSE
[17:26:32.804] 
[17:26:32.804] 
[17:26:32.805] getGlobalsAndPackages() ... DONE
[17:26:32.806] run() for 'Future' ...
[17:26:32.806] - state: 'created'
[17:26:32.807] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:32.807] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:32.808] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:32.808]   - Field: 'label'
[17:26:32.808]   - Field: 'local'
[17:26:32.809]   - Field: 'owner'
[17:26:32.809]   - Field: 'envir'
[17:26:32.809]   - Field: 'packages'
[17:26:32.809]   - Field: 'gc'
[17:26:32.810]   - Field: 'conditions'
[17:26:32.810]   - Field: 'expr'
[17:26:32.810]   - Field: 'uuid'
[17:26:32.811]   - Field: 'seed'
[17:26:32.811]   - Field: 'version'
[17:26:32.811]   - Field: 'result'
[17:26:32.811]   - Field: 'asynchronous'
[17:26:32.812]   - Field: 'calls'
[17:26:32.812]   - Field: 'globals'
[17:26:32.812]   - Field: 'stdout'
[17:26:32.813]   - Field: 'earlySignal'
[17:26:32.813]   - Field: 'lazy'
[17:26:32.813]   - Field: 'state'
[17:26:32.814] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:32.814] - Launch lazy future ...
[17:26:32.815] Packages needed by the future expression (n = 0): <none>
[17:26:32.815] Packages needed by future strategies (n = 0): <none>
[17:26:32.820] {
[17:26:32.820]     {
[17:26:32.820]         {
[17:26:32.820]             ...future.startTime <- base::Sys.time()
[17:26:32.820]             {
[17:26:32.820]                 {
[17:26:32.820]                   {
[17:26:32.820]                     base::local({
[17:26:32.820]                       has_future <- base::requireNamespace("future", 
[17:26:32.820]                         quietly = TRUE)
[17:26:32.820]                       if (has_future) {
[17:26:32.820]                         ns <- base::getNamespace("future")
[17:26:32.820]                         version <- ns[[".package"]][["version"]]
[17:26:32.820]                         if (is.null(version)) 
[17:26:32.820]                           version <- utils::packageVersion("future")
[17:26:32.820]                       }
[17:26:32.820]                       else {
[17:26:32.820]                         version <- NULL
[17:26:32.820]                       }
[17:26:32.820]                       if (!has_future || version < "1.8.0") {
[17:26:32.820]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:32.820]                           "", base::R.version$version.string), 
[17:26:32.820]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:32.820]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:32.820]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:32.820]                             "release", "version")], collapse = " "), 
[17:26:32.820]                           hostname = base::Sys.info()[["nodename"]])
[17:26:32.820]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:32.820]                           info)
[17:26:32.820]                         info <- base::paste(info, collapse = "; ")
[17:26:32.820]                         if (!has_future) {
[17:26:32.820]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:32.820]                             info)
[17:26:32.820]                         }
[17:26:32.820]                         else {
[17:26:32.820]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:32.820]                             info, version)
[17:26:32.820]                         }
[17:26:32.820]                         base::stop(msg)
[17:26:32.820]                       }
[17:26:32.820]                     })
[17:26:32.820]                   }
[17:26:32.820]                   ...future.strategy.old <- future::plan("list")
[17:26:32.820]                   options(future.plan = NULL)
[17:26:32.820]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:32.820]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:32.820]                 }
[17:26:32.820]                 ...future.workdir <- getwd()
[17:26:32.820]             }
[17:26:32.820]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:32.820]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:32.820]         }
[17:26:32.820]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:32.820]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:32.820]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:32.820]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:32.820]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:32.820]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:32.820]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:32.820]             base::names(...future.oldOptions))
[17:26:32.820]     }
[17:26:32.820]     if (FALSE) {
[17:26:32.820]     }
[17:26:32.820]     else {
[17:26:32.820]         if (TRUE) {
[17:26:32.820]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:32.820]                 open = "w")
[17:26:32.820]         }
[17:26:32.820]         else {
[17:26:32.820]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:32.820]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:32.820]         }
[17:26:32.820]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:32.820]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:32.820]             base::sink(type = "output", split = FALSE)
[17:26:32.820]             base::close(...future.stdout)
[17:26:32.820]         }, add = TRUE)
[17:26:32.820]     }
[17:26:32.820]     ...future.frame <- base::sys.nframe()
[17:26:32.820]     ...future.conditions <- base::list()
[17:26:32.820]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:32.820]     if (FALSE) {
[17:26:32.820]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:32.820]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:32.820]     }
[17:26:32.820]     ...future.result <- base::tryCatch({
[17:26:32.820]         base::withCallingHandlers({
[17:26:32.820]             ...future.value <- base::withVisible(base::local({
[17:26:32.820]                 42L
[17:26:32.820]                 stop("Woops")
[17:26:32.820]             }))
[17:26:32.820]             future::FutureResult(value = ...future.value$value, 
[17:26:32.820]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:32.820]                   ...future.rng), globalenv = if (FALSE) 
[17:26:32.820]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:32.820]                     ...future.globalenv.names))
[17:26:32.820]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:32.820]         }, condition = base::local({
[17:26:32.820]             c <- base::c
[17:26:32.820]             inherits <- base::inherits
[17:26:32.820]             invokeRestart <- base::invokeRestart
[17:26:32.820]             length <- base::length
[17:26:32.820]             list <- base::list
[17:26:32.820]             seq.int <- base::seq.int
[17:26:32.820]             signalCondition <- base::signalCondition
[17:26:32.820]             sys.calls <- base::sys.calls
[17:26:32.820]             `[[` <- base::`[[`
[17:26:32.820]             `+` <- base::`+`
[17:26:32.820]             `<<-` <- base::`<<-`
[17:26:32.820]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:32.820]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:32.820]                   3L)]
[17:26:32.820]             }
[17:26:32.820]             function(cond) {
[17:26:32.820]                 is_error <- inherits(cond, "error")
[17:26:32.820]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:32.820]                   NULL)
[17:26:32.820]                 if (is_error) {
[17:26:32.820]                   sessionInformation <- function() {
[17:26:32.820]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:32.820]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:32.820]                       search = base::search(), system = base::Sys.info())
[17:26:32.820]                   }
[17:26:32.820]                   ...future.conditions[[length(...future.conditions) + 
[17:26:32.820]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:32.820]                     cond$call), session = sessionInformation(), 
[17:26:32.820]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:32.820]                   signalCondition(cond)
[17:26:32.820]                 }
[17:26:32.820]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:32.820]                 "immediateCondition"))) {
[17:26:32.820]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:32.820]                   ...future.conditions[[length(...future.conditions) + 
[17:26:32.820]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:32.820]                   if (TRUE && !signal) {
[17:26:32.820]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:32.820]                     {
[17:26:32.820]                       inherits <- base::inherits
[17:26:32.820]                       invokeRestart <- base::invokeRestart
[17:26:32.820]                       is.null <- base::is.null
[17:26:32.820]                       muffled <- FALSE
[17:26:32.820]                       if (inherits(cond, "message")) {
[17:26:32.820]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:32.820]                         if (muffled) 
[17:26:32.820]                           invokeRestart("muffleMessage")
[17:26:32.820]                       }
[17:26:32.820]                       else if (inherits(cond, "warning")) {
[17:26:32.820]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:32.820]                         if (muffled) 
[17:26:32.820]                           invokeRestart("muffleWarning")
[17:26:32.820]                       }
[17:26:32.820]                       else if (inherits(cond, "condition")) {
[17:26:32.820]                         if (!is.null(pattern)) {
[17:26:32.820]                           computeRestarts <- base::computeRestarts
[17:26:32.820]                           grepl <- base::grepl
[17:26:32.820]                           restarts <- computeRestarts(cond)
[17:26:32.820]                           for (restart in restarts) {
[17:26:32.820]                             name <- restart$name
[17:26:32.820]                             if (is.null(name)) 
[17:26:32.820]                               next
[17:26:32.820]                             if (!grepl(pattern, name)) 
[17:26:32.820]                               next
[17:26:32.820]                             invokeRestart(restart)
[17:26:32.820]                             muffled <- TRUE
[17:26:32.820]                             break
[17:26:32.820]                           }
[17:26:32.820]                         }
[17:26:32.820]                       }
[17:26:32.820]                       invisible(muffled)
[17:26:32.820]                     }
[17:26:32.820]                     muffleCondition(cond, pattern = "^muffle")
[17:26:32.820]                   }
[17:26:32.820]                 }
[17:26:32.820]                 else {
[17:26:32.820]                   if (TRUE) {
[17:26:32.820]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:32.820]                     {
[17:26:32.820]                       inherits <- base::inherits
[17:26:32.820]                       invokeRestart <- base::invokeRestart
[17:26:32.820]                       is.null <- base::is.null
[17:26:32.820]                       muffled <- FALSE
[17:26:32.820]                       if (inherits(cond, "message")) {
[17:26:32.820]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:32.820]                         if (muffled) 
[17:26:32.820]                           invokeRestart("muffleMessage")
[17:26:32.820]                       }
[17:26:32.820]                       else if (inherits(cond, "warning")) {
[17:26:32.820]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:32.820]                         if (muffled) 
[17:26:32.820]                           invokeRestart("muffleWarning")
[17:26:32.820]                       }
[17:26:32.820]                       else if (inherits(cond, "condition")) {
[17:26:32.820]                         if (!is.null(pattern)) {
[17:26:32.820]                           computeRestarts <- base::computeRestarts
[17:26:32.820]                           grepl <- base::grepl
[17:26:32.820]                           restarts <- computeRestarts(cond)
[17:26:32.820]                           for (restart in restarts) {
[17:26:32.820]                             name <- restart$name
[17:26:32.820]                             if (is.null(name)) 
[17:26:32.820]                               next
[17:26:32.820]                             if (!grepl(pattern, name)) 
[17:26:32.820]                               next
[17:26:32.820]                             invokeRestart(restart)
[17:26:32.820]                             muffled <- TRUE
[17:26:32.820]                             break
[17:26:32.820]                           }
[17:26:32.820]                         }
[17:26:32.820]                       }
[17:26:32.820]                       invisible(muffled)
[17:26:32.820]                     }
[17:26:32.820]                     muffleCondition(cond, pattern = "^muffle")
[17:26:32.820]                   }
[17:26:32.820]                 }
[17:26:32.820]             }
[17:26:32.820]         }))
[17:26:32.820]     }, error = function(ex) {
[17:26:32.820]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:32.820]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:32.820]                 ...future.rng), started = ...future.startTime, 
[17:26:32.820]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:32.820]             version = "1.8"), class = "FutureResult")
[17:26:32.820]     }, finally = {
[17:26:32.820]         if (!identical(...future.workdir, getwd())) 
[17:26:32.820]             setwd(...future.workdir)
[17:26:32.820]         {
[17:26:32.820]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:32.820]                 ...future.oldOptions$nwarnings <- NULL
[17:26:32.820]             }
[17:26:32.820]             base::options(...future.oldOptions)
[17:26:32.820]             if (.Platform$OS.type == "windows") {
[17:26:32.820]                 old_names <- names(...future.oldEnvVars)
[17:26:32.820]                 envs <- base::Sys.getenv()
[17:26:32.820]                 names <- names(envs)
[17:26:32.820]                 common <- intersect(names, old_names)
[17:26:32.820]                 added <- setdiff(names, old_names)
[17:26:32.820]                 removed <- setdiff(old_names, names)
[17:26:32.820]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:32.820]                   envs[common]]
[17:26:32.820]                 NAMES <- toupper(changed)
[17:26:32.820]                 args <- list()
[17:26:32.820]                 for (kk in seq_along(NAMES)) {
[17:26:32.820]                   name <- changed[[kk]]
[17:26:32.820]                   NAME <- NAMES[[kk]]
[17:26:32.820]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.820]                     next
[17:26:32.820]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:32.820]                 }
[17:26:32.820]                 NAMES <- toupper(added)
[17:26:32.820]                 for (kk in seq_along(NAMES)) {
[17:26:32.820]                   name <- added[[kk]]
[17:26:32.820]                   NAME <- NAMES[[kk]]
[17:26:32.820]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.820]                     next
[17:26:32.820]                   args[[name]] <- ""
[17:26:32.820]                 }
[17:26:32.820]                 NAMES <- toupper(removed)
[17:26:32.820]                 for (kk in seq_along(NAMES)) {
[17:26:32.820]                   name <- removed[[kk]]
[17:26:32.820]                   NAME <- NAMES[[kk]]
[17:26:32.820]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.820]                     next
[17:26:32.820]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:32.820]                 }
[17:26:32.820]                 if (length(args) > 0) 
[17:26:32.820]                   base::do.call(base::Sys.setenv, args = args)
[17:26:32.820]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:32.820]             }
[17:26:32.820]             else {
[17:26:32.820]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:32.820]             }
[17:26:32.820]             {
[17:26:32.820]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:32.820]                   0L) {
[17:26:32.820]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:32.820]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:32.820]                   base::options(opts)
[17:26:32.820]                 }
[17:26:32.820]                 {
[17:26:32.820]                   {
[17:26:32.820]                     NULL
[17:26:32.820]                     RNGkind("Mersenne-Twister")
[17:26:32.820]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:32.820]                       inherits = FALSE)
[17:26:32.820]                   }
[17:26:32.820]                   options(future.plan = NULL)
[17:26:32.820]                   if (is.na(NA_character_)) 
[17:26:32.820]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:32.820]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:32.820]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:32.820]                     .init = FALSE)
[17:26:32.820]                 }
[17:26:32.820]             }
[17:26:32.820]         }
[17:26:32.820]     })
[17:26:32.820]     if (TRUE) {
[17:26:32.820]         base::sink(type = "output", split = FALSE)
[17:26:32.820]         if (TRUE) {
[17:26:32.820]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:32.820]         }
[17:26:32.820]         else {
[17:26:32.820]             ...future.result["stdout"] <- base::list(NULL)
[17:26:32.820]         }
[17:26:32.820]         base::close(...future.stdout)
[17:26:32.820]         ...future.stdout <- NULL
[17:26:32.820]     }
[17:26:32.820]     ...future.result$conditions <- ...future.conditions
[17:26:32.820]     ...future.result$finished <- base::Sys.time()
[17:26:32.820]     ...future.result
[17:26:32.820] }
[17:26:32.827] plan(): Setting new future strategy stack:
[17:26:32.827] List of future strategies:
[17:26:32.827] 1. sequential:
[17:26:32.827]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.827]    - tweaked: FALSE
[17:26:32.827]    - call: NULL
[17:26:32.828] plan(): nbrOfWorkers() = 1
[17:26:32.830] plan(): Setting new future strategy stack:
[17:26:32.831] List of future strategies:
[17:26:32.831] 1. sequential:
[17:26:32.831]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.831]    - tweaked: FALSE
[17:26:32.831]    - call: future::plan("sequential")
[17:26:32.831] plan(): nbrOfWorkers() = 1
[17:26:32.832] SequentialFuture started (and completed)
[17:26:32.832] signalConditions() ...
[17:26:32.832]  - include = 'immediateCondition'
[17:26:32.833]  - exclude = 
[17:26:32.833]  - resignal = FALSE
[17:26:32.833]  - Number of conditions: 1
[17:26:32.833] signalConditions() ... done
[17:26:32.834] - Launch lazy future ... done
[17:26:32.834] run() for 'SequentialFuture' ... done
> v <- value(f, signal = FALSE)
[17:26:32.835] signalConditions() ...
[17:26:32.835]  - include = 'immediateCondition'
[17:26:32.835]  - exclude = 
[17:26:32.835]  - resignal = FALSE
[17:26:32.835]  - Number of conditions: 1
[17:26:32.836] signalConditions() ... done
> print(v)
<simpleError in eval(quote({    42L    stop("Woops")}), new.env()): Woops>
> calls <- backtrace(f)
[17:26:32.837] resolved() for 'SequentialFuture' ...
[17:26:32.837] - state: 'finished'
[17:26:32.837] - run: TRUE
[17:26:32.838] - result: 'FutureResult'
[17:26:32.838] resolved() for 'SequentialFuture' ... done
> print(calls)
[[1]]
future({
    42L
    stop("Woops")
})

[[2]]
Future(expr, substitute = FALSE, envir = envir, lazy = TRUE, 
    seed = seed, globals = globals, packages = packages, stdout = stdout, 
    conditions = conditions, earlySignal = earlySignal, label = label, 
    gc = gc, ...)

[[3]]
eval(quote({
    42L
    stop("Woops")
}), new.env())

[[4]]
stop("Woops")

[[5]]
eval(quote({
    42L
    stop("Woops")
}), new.env())

> 
> message("*** backtrace( ) - explicit future ... DONE")
*** backtrace( ) - explicit future ... DONE
> 
> 
> message("*** backtrace( ) - implicit future ...")
*** backtrace( ) - implicit future ...
> 
> v %<-% { 42L; stop("Woops") }
[17:26:32.839] getGlobalsAndPackages() ...
[17:26:32.839] Searching for globals...
[17:26:32.840] - globals found: [2] '{', 'stop'
[17:26:32.840] Searching for globals ... DONE
[17:26:32.841] Resolving globals: FALSE
[17:26:32.841] 
[17:26:32.841] 
[17:26:32.841] getGlobalsAndPackages() ... DONE
[17:26:32.842] run() for 'Future' ...
[17:26:32.842] - state: 'created'
[17:26:32.842] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:32.843] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:32.843] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:32.843]   - Field: 'label'
[17:26:32.844]   - Field: 'local'
[17:26:32.844]   - Field: 'owner'
[17:26:32.844]   - Field: 'envir'
[17:26:32.844]   - Field: 'packages'
[17:26:32.845]   - Field: 'gc'
[17:26:32.845]   - Field: 'conditions'
[17:26:32.845]   - Field: 'expr'
[17:26:32.846]   - Field: 'uuid'
[17:26:32.846]   - Field: 'seed'
[17:26:32.846]   - Field: 'version'
[17:26:32.847]   - Field: 'result'
[17:26:32.847]   - Field: 'asynchronous'
[17:26:32.847]   - Field: 'calls'
[17:26:32.848]   - Field: 'globals'
[17:26:32.848]   - Field: 'stdout'
[17:26:32.848]   - Field: 'earlySignal'
[17:26:32.848]   - Field: 'lazy'
[17:26:32.849]   - Field: 'state'
[17:26:32.849] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:32.849] - Launch lazy future ...
[17:26:32.850] Packages needed by the future expression (n = 0): <none>
[17:26:32.850] Packages needed by future strategies (n = 0): <none>
[17:26:32.851] {
[17:26:32.851]     {
[17:26:32.851]         {
[17:26:32.851]             ...future.startTime <- base::Sys.time()
[17:26:32.851]             {
[17:26:32.851]                 {
[17:26:32.851]                   {
[17:26:32.851]                     base::local({
[17:26:32.851]                       has_future <- base::requireNamespace("future", 
[17:26:32.851]                         quietly = TRUE)
[17:26:32.851]                       if (has_future) {
[17:26:32.851]                         ns <- base::getNamespace("future")
[17:26:32.851]                         version <- ns[[".package"]][["version"]]
[17:26:32.851]                         if (is.null(version)) 
[17:26:32.851]                           version <- utils::packageVersion("future")
[17:26:32.851]                       }
[17:26:32.851]                       else {
[17:26:32.851]                         version <- NULL
[17:26:32.851]                       }
[17:26:32.851]                       if (!has_future || version < "1.8.0") {
[17:26:32.851]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:32.851]                           "", base::R.version$version.string), 
[17:26:32.851]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:32.851]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:32.851]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:32.851]                             "release", "version")], collapse = " "), 
[17:26:32.851]                           hostname = base::Sys.info()[["nodename"]])
[17:26:32.851]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:32.851]                           info)
[17:26:32.851]                         info <- base::paste(info, collapse = "; ")
[17:26:32.851]                         if (!has_future) {
[17:26:32.851]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:32.851]                             info)
[17:26:32.851]                         }
[17:26:32.851]                         else {
[17:26:32.851]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:32.851]                             info, version)
[17:26:32.851]                         }
[17:26:32.851]                         base::stop(msg)
[17:26:32.851]                       }
[17:26:32.851]                     })
[17:26:32.851]                   }
[17:26:32.851]                   ...future.strategy.old <- future::plan("list")
[17:26:32.851]                   options(future.plan = NULL)
[17:26:32.851]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:32.851]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:32.851]                 }
[17:26:32.851]                 ...future.workdir <- getwd()
[17:26:32.851]             }
[17:26:32.851]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:32.851]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:32.851]         }
[17:26:32.851]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:32.851]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:32.851]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:32.851]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:32.851]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:32.851]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:32.851]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:32.851]             base::names(...future.oldOptions))
[17:26:32.851]     }
[17:26:32.851]     if (FALSE) {
[17:26:32.851]     }
[17:26:32.851]     else {
[17:26:32.851]         if (TRUE) {
[17:26:32.851]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:32.851]                 open = "w")
[17:26:32.851]         }
[17:26:32.851]         else {
[17:26:32.851]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:32.851]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:32.851]         }
[17:26:32.851]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:32.851]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:32.851]             base::sink(type = "output", split = FALSE)
[17:26:32.851]             base::close(...future.stdout)
[17:26:32.851]         }, add = TRUE)
[17:26:32.851]     }
[17:26:32.851]     ...future.frame <- base::sys.nframe()
[17:26:32.851]     ...future.conditions <- base::list()
[17:26:32.851]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:32.851]     if (FALSE) {
[17:26:32.851]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:32.851]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:32.851]     }
[17:26:32.851]     ...future.result <- base::tryCatch({
[17:26:32.851]         base::withCallingHandlers({
[17:26:32.851]             ...future.value <- base::withVisible(base::local({
[17:26:32.851]                 42L
[17:26:32.851]                 stop("Woops")
[17:26:32.851]             }))
[17:26:32.851]             future::FutureResult(value = ...future.value$value, 
[17:26:32.851]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:32.851]                   ...future.rng), globalenv = if (FALSE) 
[17:26:32.851]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:32.851]                     ...future.globalenv.names))
[17:26:32.851]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:32.851]         }, condition = base::local({
[17:26:32.851]             c <- base::c
[17:26:32.851]             inherits <- base::inherits
[17:26:32.851]             invokeRestart <- base::invokeRestart
[17:26:32.851]             length <- base::length
[17:26:32.851]             list <- base::list
[17:26:32.851]             seq.int <- base::seq.int
[17:26:32.851]             signalCondition <- base::signalCondition
[17:26:32.851]             sys.calls <- base::sys.calls
[17:26:32.851]             `[[` <- base::`[[`
[17:26:32.851]             `+` <- base::`+`
[17:26:32.851]             `<<-` <- base::`<<-`
[17:26:32.851]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:32.851]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:32.851]                   3L)]
[17:26:32.851]             }
[17:26:32.851]             function(cond) {
[17:26:32.851]                 is_error <- inherits(cond, "error")
[17:26:32.851]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:32.851]                   NULL)
[17:26:32.851]                 if (is_error) {
[17:26:32.851]                   sessionInformation <- function() {
[17:26:32.851]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:32.851]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:32.851]                       search = base::search(), system = base::Sys.info())
[17:26:32.851]                   }
[17:26:32.851]                   ...future.conditions[[length(...future.conditions) + 
[17:26:32.851]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:32.851]                     cond$call), session = sessionInformation(), 
[17:26:32.851]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:32.851]                   signalCondition(cond)
[17:26:32.851]                 }
[17:26:32.851]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:32.851]                 "immediateCondition"))) {
[17:26:32.851]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:32.851]                   ...future.conditions[[length(...future.conditions) + 
[17:26:32.851]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:32.851]                   if (TRUE && !signal) {
[17:26:32.851]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:32.851]                     {
[17:26:32.851]                       inherits <- base::inherits
[17:26:32.851]                       invokeRestart <- base::invokeRestart
[17:26:32.851]                       is.null <- base::is.null
[17:26:32.851]                       muffled <- FALSE
[17:26:32.851]                       if (inherits(cond, "message")) {
[17:26:32.851]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:32.851]                         if (muffled) 
[17:26:32.851]                           invokeRestart("muffleMessage")
[17:26:32.851]                       }
[17:26:32.851]                       else if (inherits(cond, "warning")) {
[17:26:32.851]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:32.851]                         if (muffled) 
[17:26:32.851]                           invokeRestart("muffleWarning")
[17:26:32.851]                       }
[17:26:32.851]                       else if (inherits(cond, "condition")) {
[17:26:32.851]                         if (!is.null(pattern)) {
[17:26:32.851]                           computeRestarts <- base::computeRestarts
[17:26:32.851]                           grepl <- base::grepl
[17:26:32.851]                           restarts <- computeRestarts(cond)
[17:26:32.851]                           for (restart in restarts) {
[17:26:32.851]                             name <- restart$name
[17:26:32.851]                             if (is.null(name)) 
[17:26:32.851]                               next
[17:26:32.851]                             if (!grepl(pattern, name)) 
[17:26:32.851]                               next
[17:26:32.851]                             invokeRestart(restart)
[17:26:32.851]                             muffled <- TRUE
[17:26:32.851]                             break
[17:26:32.851]                           }
[17:26:32.851]                         }
[17:26:32.851]                       }
[17:26:32.851]                       invisible(muffled)
[17:26:32.851]                     }
[17:26:32.851]                     muffleCondition(cond, pattern = "^muffle")
[17:26:32.851]                   }
[17:26:32.851]                 }
[17:26:32.851]                 else {
[17:26:32.851]                   if (TRUE) {
[17:26:32.851]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:32.851]                     {
[17:26:32.851]                       inherits <- base::inherits
[17:26:32.851]                       invokeRestart <- base::invokeRestart
[17:26:32.851]                       is.null <- base::is.null
[17:26:32.851]                       muffled <- FALSE
[17:26:32.851]                       if (inherits(cond, "message")) {
[17:26:32.851]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:32.851]                         if (muffled) 
[17:26:32.851]                           invokeRestart("muffleMessage")
[17:26:32.851]                       }
[17:26:32.851]                       else if (inherits(cond, "warning")) {
[17:26:32.851]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:32.851]                         if (muffled) 
[17:26:32.851]                           invokeRestart("muffleWarning")
[17:26:32.851]                       }
[17:26:32.851]                       else if (inherits(cond, "condition")) {
[17:26:32.851]                         if (!is.null(pattern)) {
[17:26:32.851]                           computeRestarts <- base::computeRestarts
[17:26:32.851]                           grepl <- base::grepl
[17:26:32.851]                           restarts <- computeRestarts(cond)
[17:26:32.851]                           for (restart in restarts) {
[17:26:32.851]                             name <- restart$name
[17:26:32.851]                             if (is.null(name)) 
[17:26:32.851]                               next
[17:26:32.851]                             if (!grepl(pattern, name)) 
[17:26:32.851]                               next
[17:26:32.851]                             invokeRestart(restart)
[17:26:32.851]                             muffled <- TRUE
[17:26:32.851]                             break
[17:26:32.851]                           }
[17:26:32.851]                         }
[17:26:32.851]                       }
[17:26:32.851]                       invisible(muffled)
[17:26:32.851]                     }
[17:26:32.851]                     muffleCondition(cond, pattern = "^muffle")
[17:26:32.851]                   }
[17:26:32.851]                 }
[17:26:32.851]             }
[17:26:32.851]         }))
[17:26:32.851]     }, error = function(ex) {
[17:26:32.851]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:32.851]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:32.851]                 ...future.rng), started = ...future.startTime, 
[17:26:32.851]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:32.851]             version = "1.8"), class = "FutureResult")
[17:26:32.851]     }, finally = {
[17:26:32.851]         if (!identical(...future.workdir, getwd())) 
[17:26:32.851]             setwd(...future.workdir)
[17:26:32.851]         {
[17:26:32.851]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:32.851]                 ...future.oldOptions$nwarnings <- NULL
[17:26:32.851]             }
[17:26:32.851]             base::options(...future.oldOptions)
[17:26:32.851]             if (.Platform$OS.type == "windows") {
[17:26:32.851]                 old_names <- names(...future.oldEnvVars)
[17:26:32.851]                 envs <- base::Sys.getenv()
[17:26:32.851]                 names <- names(envs)
[17:26:32.851]                 common <- intersect(names, old_names)
[17:26:32.851]                 added <- setdiff(names, old_names)
[17:26:32.851]                 removed <- setdiff(old_names, names)
[17:26:32.851]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:32.851]                   envs[common]]
[17:26:32.851]                 NAMES <- toupper(changed)
[17:26:32.851]                 args <- list()
[17:26:32.851]                 for (kk in seq_along(NAMES)) {
[17:26:32.851]                   name <- changed[[kk]]
[17:26:32.851]                   NAME <- NAMES[[kk]]
[17:26:32.851]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.851]                     next
[17:26:32.851]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:32.851]                 }
[17:26:32.851]                 NAMES <- toupper(added)
[17:26:32.851]                 for (kk in seq_along(NAMES)) {
[17:26:32.851]                   name <- added[[kk]]
[17:26:32.851]                   NAME <- NAMES[[kk]]
[17:26:32.851]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.851]                     next
[17:26:32.851]                   args[[name]] <- ""
[17:26:32.851]                 }
[17:26:32.851]                 NAMES <- toupper(removed)
[17:26:32.851]                 for (kk in seq_along(NAMES)) {
[17:26:32.851]                   name <- removed[[kk]]
[17:26:32.851]                   NAME <- NAMES[[kk]]
[17:26:32.851]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.851]                     next
[17:26:32.851]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:32.851]                 }
[17:26:32.851]                 if (length(args) > 0) 
[17:26:32.851]                   base::do.call(base::Sys.setenv, args = args)
[17:26:32.851]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:32.851]             }
[17:26:32.851]             else {
[17:26:32.851]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:32.851]             }
[17:26:32.851]             {
[17:26:32.851]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:32.851]                   0L) {
[17:26:32.851]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:32.851]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:32.851]                   base::options(opts)
[17:26:32.851]                 }
[17:26:32.851]                 {
[17:26:32.851]                   {
[17:26:32.851]                     NULL
[17:26:32.851]                     RNGkind("Mersenne-Twister")
[17:26:32.851]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:32.851]                       inherits = FALSE)
[17:26:32.851]                   }
[17:26:32.851]                   options(future.plan = NULL)
[17:26:32.851]                   if (is.na(NA_character_)) 
[17:26:32.851]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:32.851]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:32.851]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:32.851]                     .init = FALSE)
[17:26:32.851]                 }
[17:26:32.851]             }
[17:26:32.851]         }
[17:26:32.851]     })
[17:26:32.851]     if (TRUE) {
[17:26:32.851]         base::sink(type = "output", split = FALSE)
[17:26:32.851]         if (TRUE) {
[17:26:32.851]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:32.851]         }
[17:26:32.851]         else {
[17:26:32.851]             ...future.result["stdout"] <- base::list(NULL)
[17:26:32.851]         }
[17:26:32.851]         base::close(...future.stdout)
[17:26:32.851]         ...future.stdout <- NULL
[17:26:32.851]     }
[17:26:32.851]     ...future.result$conditions <- ...future.conditions
[17:26:32.851]     ...future.result$finished <- base::Sys.time()
[17:26:32.851]     ...future.result
[17:26:32.851] }
[17:26:32.857] plan(): Setting new future strategy stack:
[17:26:32.858] List of future strategies:
[17:26:32.858] 1. sequential:
[17:26:32.858]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.858]    - tweaked: FALSE
[17:26:32.858]    - call: NULL
[17:26:32.859] plan(): nbrOfWorkers() = 1
[17:26:32.861] plan(): Setting new future strategy stack:
[17:26:32.861] List of future strategies:
[17:26:32.861] 1. sequential:
[17:26:32.861]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.861]    - tweaked: FALSE
[17:26:32.861]    - call: future::plan("sequential")
[17:26:32.862] plan(): nbrOfWorkers() = 1
[17:26:32.863] SequentialFuture started (and completed)
[17:26:32.863] signalConditions() ...
[17:26:32.863]  - include = 'immediateCondition'
[17:26:32.864]  - exclude = 
[17:26:32.864]  - resignal = FALSE
[17:26:32.864]  - Number of conditions: 1
[17:26:32.864] signalConditions() ... done
[17:26:32.865] - Launch lazy future ... done
[17:26:32.865] run() for 'SequentialFuture' ... done
> calls <- backtrace(v)
[17:26:32.866] resolved() for 'SequentialFuture' ...
[17:26:32.866] - state: 'finished'
[17:26:32.866] - run: TRUE
[17:26:32.867] - result: 'FutureResult'
[17:26:32.867] resolved() for 'SequentialFuture' ... done
> print(calls)
[[1]]
v %<-% {
    42L
    stop("Woops")
}

[[2]]
futureAssignInternal(target, expr, envir = envir, substitute = FALSE)

[[3]]
futureAssign(name, expr, envir = envir, assign.env = assign.env, 
    substitute = FALSE)

[[4]]
do.call(future::future, args = future.args, envir = assign.env)

[[5]]
(function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, 
    seed = FALSE, globals = TRUE, packages = NULL, stdout = TRUE, 
    conditions = "condition", earlySignal = FALSE, label = NULL, 
    gc = FALSE, ...) 
{
    if (substitute) 
        expr <- substitute(expr)
    t_start <- Sys.time()
    gp <- getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression, 
        globals = globals)
    expr <- gp$expr
    globals <- gp$globals
    if (length(packages) > 0 || length(gp$packages) > 0) {
        packages <- unique(c(gp$packages, packages))
    }
    gp <- NULL
    attr(globals, "already-done") <- TRUE
    future <- Future(expr, substitute = FALSE, envir = envir, 
        lazy = TRUE, seed = seed, globals = globals, packages = packages, 
        stdout = stdout, conditions = conditions, earlySignal = earlySignal, 
        label = label, gc = gc, ...)
    future$.defaultLocal <- !is.element("local", names(list(...)))
    if (getOption("future.journal", FALSE)) {
        future <- makeFutureJournal(future, event = "create", 
            category = "overhead", start = t_start)
    }
    if (!lazy) {
        future <- run(future)
        future$lazy <- FALSE
        stop_if_not(inherits(future, "Future"), !future$lazy)
    }
    future
})({
    42L
    stop("Woops")
}, envir = <environment>, lazy = FALSE, seed = FALSE, globals = TRUE, 
    packages = NULL, stdout = TRUE, conditions = "condition", 
    earlySignal = FALSE, label = NULL, gc = FALSE)

[[6]]
Future(expr, substitute = FALSE, envir = envir, lazy = TRUE, 
    seed = seed, globals = globals, packages = packages, stdout = stdout, 
    conditions = conditions, earlySignal = earlySignal, label = label, 
    gc = gc, ...)

[[7]]
eval(quote({
    42L
    stop("Woops")
}), new.env())

[[8]]
stop("Woops")

[[9]]
eval(quote({
    42L
    stop("Woops")
}), new.env())

> 
> message("*** backtrace( ) - implicit future ... DONE")
*** backtrace( ) - implicit future ... DONE
> 
> 
> message("*** backtrace( ) - subsetting ...")
*** backtrace( ) - subsetting ...
> 
> env <- new.env()
> env[["a"]] %<-% { 42L; stop("Woops") }
[17:26:32.869] getGlobalsAndPackages() ...
[17:26:32.870] Searching for globals...
[17:26:32.872] - globals found: [2] '{', 'stop'
[17:26:32.872] Searching for globals ... DONE
[17:26:32.872] Resolving globals: FALSE
[17:26:32.873] 
[17:26:32.873] 
[17:26:32.873] getGlobalsAndPackages() ... DONE
[17:26:32.874] run() for 'Future' ...
[17:26:32.874] - state: 'created'
[17:26:32.875] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:32.875] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:32.876] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:32.876]   - Field: 'label'
[17:26:32.876]   - Field: 'local'
[17:26:32.877]   - Field: 'owner'
[17:26:32.877]   - Field: 'envir'
[17:26:32.877]   - Field: 'packages'
[17:26:32.878]   - Field: 'gc'
[17:26:32.878]   - Field: 'conditions'
[17:26:32.878]   - Field: 'expr'
[17:26:32.878]   - Field: 'uuid'
[17:26:32.879]   - Field: 'seed'
[17:26:32.879]   - Field: 'version'
[17:26:32.879]   - Field: 'result'
[17:26:32.880]   - Field: 'asynchronous'
[17:26:32.880]   - Field: 'calls'
[17:26:32.880]   - Field: 'globals'
[17:26:32.881]   - Field: 'stdout'
[17:26:32.881]   - Field: 'earlySignal'
[17:26:32.881]   - Field: 'lazy'
[17:26:32.881]   - Field: 'state'
[17:26:32.882] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:32.882] - Launch lazy future ...
[17:26:32.883] Packages needed by the future expression (n = 0): <none>
[17:26:32.883] Packages needed by future strategies (n = 0): <none>
[17:26:32.884] {
[17:26:32.884]     {
[17:26:32.884]         {
[17:26:32.884]             ...future.startTime <- base::Sys.time()
[17:26:32.884]             {
[17:26:32.884]                 {
[17:26:32.884]                   {
[17:26:32.884]                     base::local({
[17:26:32.884]                       has_future <- base::requireNamespace("future", 
[17:26:32.884]                         quietly = TRUE)
[17:26:32.884]                       if (has_future) {
[17:26:32.884]                         ns <- base::getNamespace("future")
[17:26:32.884]                         version <- ns[[".package"]][["version"]]
[17:26:32.884]                         if (is.null(version)) 
[17:26:32.884]                           version <- utils::packageVersion("future")
[17:26:32.884]                       }
[17:26:32.884]                       else {
[17:26:32.884]                         version <- NULL
[17:26:32.884]                       }
[17:26:32.884]                       if (!has_future || version < "1.8.0") {
[17:26:32.884]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:32.884]                           "", base::R.version$version.string), 
[17:26:32.884]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:32.884]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:32.884]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:32.884]                             "release", "version")], collapse = " "), 
[17:26:32.884]                           hostname = base::Sys.info()[["nodename"]])
[17:26:32.884]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:32.884]                           info)
[17:26:32.884]                         info <- base::paste(info, collapse = "; ")
[17:26:32.884]                         if (!has_future) {
[17:26:32.884]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:32.884]                             info)
[17:26:32.884]                         }
[17:26:32.884]                         else {
[17:26:32.884]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:32.884]                             info, version)
[17:26:32.884]                         }
[17:26:32.884]                         base::stop(msg)
[17:26:32.884]                       }
[17:26:32.884]                     })
[17:26:32.884]                   }
[17:26:32.884]                   ...future.strategy.old <- future::plan("list")
[17:26:32.884]                   options(future.plan = NULL)
[17:26:32.884]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:32.884]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:32.884]                 }
[17:26:32.884]                 ...future.workdir <- getwd()
[17:26:32.884]             }
[17:26:32.884]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:32.884]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:32.884]         }
[17:26:32.884]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:32.884]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:32.884]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:32.884]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:32.884]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:32.884]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:32.884]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:32.884]             base::names(...future.oldOptions))
[17:26:32.884]     }
[17:26:32.884]     if (FALSE) {
[17:26:32.884]     }
[17:26:32.884]     else {
[17:26:32.884]         if (TRUE) {
[17:26:32.884]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:32.884]                 open = "w")
[17:26:32.884]         }
[17:26:32.884]         else {
[17:26:32.884]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:32.884]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:32.884]         }
[17:26:32.884]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:32.884]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:32.884]             base::sink(type = "output", split = FALSE)
[17:26:32.884]             base::close(...future.stdout)
[17:26:32.884]         }, add = TRUE)
[17:26:32.884]     }
[17:26:32.884]     ...future.frame <- base::sys.nframe()
[17:26:32.884]     ...future.conditions <- base::list()
[17:26:32.884]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:32.884]     if (FALSE) {
[17:26:32.884]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:32.884]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:32.884]     }
[17:26:32.884]     ...future.result <- base::tryCatch({
[17:26:32.884]         base::withCallingHandlers({
[17:26:32.884]             ...future.value <- base::withVisible(base::local({
[17:26:32.884]                 42L
[17:26:32.884]                 stop("Woops")
[17:26:32.884]             }))
[17:26:32.884]             future::FutureResult(value = ...future.value$value, 
[17:26:32.884]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:32.884]                   ...future.rng), globalenv = if (FALSE) 
[17:26:32.884]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:32.884]                     ...future.globalenv.names))
[17:26:32.884]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:32.884]         }, condition = base::local({
[17:26:32.884]             c <- base::c
[17:26:32.884]             inherits <- base::inherits
[17:26:32.884]             invokeRestart <- base::invokeRestart
[17:26:32.884]             length <- base::length
[17:26:32.884]             list <- base::list
[17:26:32.884]             seq.int <- base::seq.int
[17:26:32.884]             signalCondition <- base::signalCondition
[17:26:32.884]             sys.calls <- base::sys.calls
[17:26:32.884]             `[[` <- base::`[[`
[17:26:32.884]             `+` <- base::`+`
[17:26:32.884]             `<<-` <- base::`<<-`
[17:26:32.884]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:32.884]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:32.884]                   3L)]
[17:26:32.884]             }
[17:26:32.884]             function(cond) {
[17:26:32.884]                 is_error <- inherits(cond, "error")
[17:26:32.884]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:32.884]                   NULL)
[17:26:32.884]                 if (is_error) {
[17:26:32.884]                   sessionInformation <- function() {
[17:26:32.884]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:32.884]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:32.884]                       search = base::search(), system = base::Sys.info())
[17:26:32.884]                   }
[17:26:32.884]                   ...future.conditions[[length(...future.conditions) + 
[17:26:32.884]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:32.884]                     cond$call), session = sessionInformation(), 
[17:26:32.884]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:32.884]                   signalCondition(cond)
[17:26:32.884]                 }
[17:26:32.884]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:32.884]                 "immediateCondition"))) {
[17:26:32.884]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:32.884]                   ...future.conditions[[length(...future.conditions) + 
[17:26:32.884]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:32.884]                   if (TRUE && !signal) {
[17:26:32.884]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:32.884]                     {
[17:26:32.884]                       inherits <- base::inherits
[17:26:32.884]                       invokeRestart <- base::invokeRestart
[17:26:32.884]                       is.null <- base::is.null
[17:26:32.884]                       muffled <- FALSE
[17:26:32.884]                       if (inherits(cond, "message")) {
[17:26:32.884]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:32.884]                         if (muffled) 
[17:26:32.884]                           invokeRestart("muffleMessage")
[17:26:32.884]                       }
[17:26:32.884]                       else if (inherits(cond, "warning")) {
[17:26:32.884]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:32.884]                         if (muffled) 
[17:26:32.884]                           invokeRestart("muffleWarning")
[17:26:32.884]                       }
[17:26:32.884]                       else if (inherits(cond, "condition")) {
[17:26:32.884]                         if (!is.null(pattern)) {
[17:26:32.884]                           computeRestarts <- base::computeRestarts
[17:26:32.884]                           grepl <- base::grepl
[17:26:32.884]                           restarts <- computeRestarts(cond)
[17:26:32.884]                           for (restart in restarts) {
[17:26:32.884]                             name <- restart$name
[17:26:32.884]                             if (is.null(name)) 
[17:26:32.884]                               next
[17:26:32.884]                             if (!grepl(pattern, name)) 
[17:26:32.884]                               next
[17:26:32.884]                             invokeRestart(restart)
[17:26:32.884]                             muffled <- TRUE
[17:26:32.884]                             break
[17:26:32.884]                           }
[17:26:32.884]                         }
[17:26:32.884]                       }
[17:26:32.884]                       invisible(muffled)
[17:26:32.884]                     }
[17:26:32.884]                     muffleCondition(cond, pattern = "^muffle")
[17:26:32.884]                   }
[17:26:32.884]                 }
[17:26:32.884]                 else {
[17:26:32.884]                   if (TRUE) {
[17:26:32.884]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:32.884]                     {
[17:26:32.884]                       inherits <- base::inherits
[17:26:32.884]                       invokeRestart <- base::invokeRestart
[17:26:32.884]                       is.null <- base::is.null
[17:26:32.884]                       muffled <- FALSE
[17:26:32.884]                       if (inherits(cond, "message")) {
[17:26:32.884]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:32.884]                         if (muffled) 
[17:26:32.884]                           invokeRestart("muffleMessage")
[17:26:32.884]                       }
[17:26:32.884]                       else if (inherits(cond, "warning")) {
[17:26:32.884]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:32.884]                         if (muffled) 
[17:26:32.884]                           invokeRestart("muffleWarning")
[17:26:32.884]                       }
[17:26:32.884]                       else if (inherits(cond, "condition")) {
[17:26:32.884]                         if (!is.null(pattern)) {
[17:26:32.884]                           computeRestarts <- base::computeRestarts
[17:26:32.884]                           grepl <- base::grepl
[17:26:32.884]                           restarts <- computeRestarts(cond)
[17:26:32.884]                           for (restart in restarts) {
[17:26:32.884]                             name <- restart$name
[17:26:32.884]                             if (is.null(name)) 
[17:26:32.884]                               next
[17:26:32.884]                             if (!grepl(pattern, name)) 
[17:26:32.884]                               next
[17:26:32.884]                             invokeRestart(restart)
[17:26:32.884]                             muffled <- TRUE
[17:26:32.884]                             break
[17:26:32.884]                           }
[17:26:32.884]                         }
[17:26:32.884]                       }
[17:26:32.884]                       invisible(muffled)
[17:26:32.884]                     }
[17:26:32.884]                     muffleCondition(cond, pattern = "^muffle")
[17:26:32.884]                   }
[17:26:32.884]                 }
[17:26:32.884]             }
[17:26:32.884]         }))
[17:26:32.884]     }, error = function(ex) {
[17:26:32.884]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:32.884]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:32.884]                 ...future.rng), started = ...future.startTime, 
[17:26:32.884]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:32.884]             version = "1.8"), class = "FutureResult")
[17:26:32.884]     }, finally = {
[17:26:32.884]         if (!identical(...future.workdir, getwd())) 
[17:26:32.884]             setwd(...future.workdir)
[17:26:32.884]         {
[17:26:32.884]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:32.884]                 ...future.oldOptions$nwarnings <- NULL
[17:26:32.884]             }
[17:26:32.884]             base::options(...future.oldOptions)
[17:26:32.884]             if (.Platform$OS.type == "windows") {
[17:26:32.884]                 old_names <- names(...future.oldEnvVars)
[17:26:32.884]                 envs <- base::Sys.getenv()
[17:26:32.884]                 names <- names(envs)
[17:26:32.884]                 common <- intersect(names, old_names)
[17:26:32.884]                 added <- setdiff(names, old_names)
[17:26:32.884]                 removed <- setdiff(old_names, names)
[17:26:32.884]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:32.884]                   envs[common]]
[17:26:32.884]                 NAMES <- toupper(changed)
[17:26:32.884]                 args <- list()
[17:26:32.884]                 for (kk in seq_along(NAMES)) {
[17:26:32.884]                   name <- changed[[kk]]
[17:26:32.884]                   NAME <- NAMES[[kk]]
[17:26:32.884]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.884]                     next
[17:26:32.884]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:32.884]                 }
[17:26:32.884]                 NAMES <- toupper(added)
[17:26:32.884]                 for (kk in seq_along(NAMES)) {
[17:26:32.884]                   name <- added[[kk]]
[17:26:32.884]                   NAME <- NAMES[[kk]]
[17:26:32.884]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.884]                     next
[17:26:32.884]                   args[[name]] <- ""
[17:26:32.884]                 }
[17:26:32.884]                 NAMES <- toupper(removed)
[17:26:32.884]                 for (kk in seq_along(NAMES)) {
[17:26:32.884]                   name <- removed[[kk]]
[17:26:32.884]                   NAME <- NAMES[[kk]]
[17:26:32.884]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.884]                     next
[17:26:32.884]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:32.884]                 }
[17:26:32.884]                 if (length(args) > 0) 
[17:26:32.884]                   base::do.call(base::Sys.setenv, args = args)
[17:26:32.884]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:32.884]             }
[17:26:32.884]             else {
[17:26:32.884]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:32.884]             }
[17:26:32.884]             {
[17:26:32.884]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:32.884]                   0L) {
[17:26:32.884]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:32.884]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:32.884]                   base::options(opts)
[17:26:32.884]                 }
[17:26:32.884]                 {
[17:26:32.884]                   {
[17:26:32.884]                     NULL
[17:26:32.884]                     RNGkind("Mersenne-Twister")
[17:26:32.884]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:32.884]                       inherits = FALSE)
[17:26:32.884]                   }
[17:26:32.884]                   options(future.plan = NULL)
[17:26:32.884]                   if (is.na(NA_character_)) 
[17:26:32.884]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:32.884]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:32.884]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:32.884]                     .init = FALSE)
[17:26:32.884]                 }
[17:26:32.884]             }
[17:26:32.884]         }
[17:26:32.884]     })
[17:26:32.884]     if (TRUE) {
[17:26:32.884]         base::sink(type = "output", split = FALSE)
[17:26:32.884]         if (TRUE) {
[17:26:32.884]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:32.884]         }
[17:26:32.884]         else {
[17:26:32.884]             ...future.result["stdout"] <- base::list(NULL)
[17:26:32.884]         }
[17:26:32.884]         base::close(...future.stdout)
[17:26:32.884]         ...future.stdout <- NULL
[17:26:32.884]     }
[17:26:32.884]     ...future.result$conditions <- ...future.conditions
[17:26:32.884]     ...future.result$finished <- base::Sys.time()
[17:26:32.884]     ...future.result
[17:26:32.884] }
[17:26:32.890] plan(): Setting new future strategy stack:
[17:26:32.890] List of future strategies:
[17:26:32.890] 1. sequential:
[17:26:32.890]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.890]    - tweaked: FALSE
[17:26:32.890]    - call: NULL
[17:26:32.894] plan(): nbrOfWorkers() = 1
[17:26:32.896] plan(): Setting new future strategy stack:
[17:26:32.896] List of future strategies:
[17:26:32.896] 1. sequential:
[17:26:32.896]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.896]    - tweaked: FALSE
[17:26:32.896]    - call: future::plan("sequential")
[17:26:32.897] plan(): nbrOfWorkers() = 1
[17:26:32.897] SequentialFuture started (and completed)
[17:26:32.897] signalConditions() ...
[17:26:32.897]  - include = 'immediateCondition'
[17:26:32.898]  - exclude = 
[17:26:32.898]  - resignal = FALSE
[17:26:32.898]  - Number of conditions: 1
[17:26:32.898] signalConditions() ... done
[17:26:32.898] - Launch lazy future ... done
[17:26:32.898] run() for 'SequentialFuture' ... done
> env[["b"]] %<-% { 42L; stop("Woops") }
[17:26:32.899] getGlobalsAndPackages() ...
[17:26:32.899] Searching for globals...
[17:26:32.900] - globals found: [2] '{', 'stop'
[17:26:32.901] Searching for globals ... DONE
[17:26:32.901] Resolving globals: FALSE
[17:26:32.901] 
[17:26:32.901] 
[17:26:32.901] getGlobalsAndPackages() ... DONE
[17:26:32.902] run() for 'Future' ...
[17:26:32.902] - state: 'created'
[17:26:32.902] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:32.903] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:32.903] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:32.903]   - Field: 'label'
[17:26:32.903]   - Field: 'local'
[17:26:32.903]   - Field: 'owner'
[17:26:32.904]   - Field: 'envir'
[17:26:32.904]   - Field: 'packages'
[17:26:32.904]   - Field: 'gc'
[17:26:32.904]   - Field: 'conditions'
[17:26:32.904]   - Field: 'expr'
[17:26:32.904]   - Field: 'uuid'
[17:26:32.905]   - Field: 'seed'
[17:26:32.905]   - Field: 'version'
[17:26:32.905]   - Field: 'result'
[17:26:32.905]   - Field: 'asynchronous'
[17:26:32.905]   - Field: 'calls'
[17:26:32.905]   - Field: 'globals'
[17:26:32.906]   - Field: 'stdout'
[17:26:32.906]   - Field: 'earlySignal'
[17:26:32.906]   - Field: 'lazy'
[17:26:32.906]   - Field: 'state'
[17:26:32.906] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:32.907] - Launch lazy future ...
[17:26:32.907] Packages needed by the future expression (n = 0): <none>
[17:26:32.907] Packages needed by future strategies (n = 0): <none>
[17:26:32.908] {
[17:26:32.908]     {
[17:26:32.908]         {
[17:26:32.908]             ...future.startTime <- base::Sys.time()
[17:26:32.908]             {
[17:26:32.908]                 {
[17:26:32.908]                   {
[17:26:32.908]                     base::local({
[17:26:32.908]                       has_future <- base::requireNamespace("future", 
[17:26:32.908]                         quietly = TRUE)
[17:26:32.908]                       if (has_future) {
[17:26:32.908]                         ns <- base::getNamespace("future")
[17:26:32.908]                         version <- ns[[".package"]][["version"]]
[17:26:32.908]                         if (is.null(version)) 
[17:26:32.908]                           version <- utils::packageVersion("future")
[17:26:32.908]                       }
[17:26:32.908]                       else {
[17:26:32.908]                         version <- NULL
[17:26:32.908]                       }
[17:26:32.908]                       if (!has_future || version < "1.8.0") {
[17:26:32.908]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:32.908]                           "", base::R.version$version.string), 
[17:26:32.908]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:32.908]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:32.908]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:32.908]                             "release", "version")], collapse = " "), 
[17:26:32.908]                           hostname = base::Sys.info()[["nodename"]])
[17:26:32.908]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:32.908]                           info)
[17:26:32.908]                         info <- base::paste(info, collapse = "; ")
[17:26:32.908]                         if (!has_future) {
[17:26:32.908]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:32.908]                             info)
[17:26:32.908]                         }
[17:26:32.908]                         else {
[17:26:32.908]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:32.908]                             info, version)
[17:26:32.908]                         }
[17:26:32.908]                         base::stop(msg)
[17:26:32.908]                       }
[17:26:32.908]                     })
[17:26:32.908]                   }
[17:26:32.908]                   ...future.strategy.old <- future::plan("list")
[17:26:32.908]                   options(future.plan = NULL)
[17:26:32.908]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:32.908]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:32.908]                 }
[17:26:32.908]                 ...future.workdir <- getwd()
[17:26:32.908]             }
[17:26:32.908]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:32.908]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:32.908]         }
[17:26:32.908]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:32.908]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:32.908]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:32.908]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:32.908]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:32.908]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:32.908]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:32.908]             base::names(...future.oldOptions))
[17:26:32.908]     }
[17:26:32.908]     if (FALSE) {
[17:26:32.908]     }
[17:26:32.908]     else {
[17:26:32.908]         if (TRUE) {
[17:26:32.908]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:32.908]                 open = "w")
[17:26:32.908]         }
[17:26:32.908]         else {
[17:26:32.908]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:32.908]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:32.908]         }
[17:26:32.908]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:32.908]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:32.908]             base::sink(type = "output", split = FALSE)
[17:26:32.908]             base::close(...future.stdout)
[17:26:32.908]         }, add = TRUE)
[17:26:32.908]     }
[17:26:32.908]     ...future.frame <- base::sys.nframe()
[17:26:32.908]     ...future.conditions <- base::list()
[17:26:32.908]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:32.908]     if (FALSE) {
[17:26:32.908]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:32.908]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:32.908]     }
[17:26:32.908]     ...future.result <- base::tryCatch({
[17:26:32.908]         base::withCallingHandlers({
[17:26:32.908]             ...future.value <- base::withVisible(base::local({
[17:26:32.908]                 42L
[17:26:32.908]                 stop("Woops")
[17:26:32.908]             }))
[17:26:32.908]             future::FutureResult(value = ...future.value$value, 
[17:26:32.908]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:32.908]                   ...future.rng), globalenv = if (FALSE) 
[17:26:32.908]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:32.908]                     ...future.globalenv.names))
[17:26:32.908]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:32.908]         }, condition = base::local({
[17:26:32.908]             c <- base::c
[17:26:32.908]             inherits <- base::inherits
[17:26:32.908]             invokeRestart <- base::invokeRestart
[17:26:32.908]             length <- base::length
[17:26:32.908]             list <- base::list
[17:26:32.908]             seq.int <- base::seq.int
[17:26:32.908]             signalCondition <- base::signalCondition
[17:26:32.908]             sys.calls <- base::sys.calls
[17:26:32.908]             `[[` <- base::`[[`
[17:26:32.908]             `+` <- base::`+`
[17:26:32.908]             `<<-` <- base::`<<-`
[17:26:32.908]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:32.908]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:32.908]                   3L)]
[17:26:32.908]             }
[17:26:32.908]             function(cond) {
[17:26:32.908]                 is_error <- inherits(cond, "error")
[17:26:32.908]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:32.908]                   NULL)
[17:26:32.908]                 if (is_error) {
[17:26:32.908]                   sessionInformation <- function() {
[17:26:32.908]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:32.908]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:32.908]                       search = base::search(), system = base::Sys.info())
[17:26:32.908]                   }
[17:26:32.908]                   ...future.conditions[[length(...future.conditions) + 
[17:26:32.908]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:32.908]                     cond$call), session = sessionInformation(), 
[17:26:32.908]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:32.908]                   signalCondition(cond)
[17:26:32.908]                 }
[17:26:32.908]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:32.908]                 "immediateCondition"))) {
[17:26:32.908]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:32.908]                   ...future.conditions[[length(...future.conditions) + 
[17:26:32.908]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:32.908]                   if (TRUE && !signal) {
[17:26:32.908]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:32.908]                     {
[17:26:32.908]                       inherits <- base::inherits
[17:26:32.908]                       invokeRestart <- base::invokeRestart
[17:26:32.908]                       is.null <- base::is.null
[17:26:32.908]                       muffled <- FALSE
[17:26:32.908]                       if (inherits(cond, "message")) {
[17:26:32.908]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:32.908]                         if (muffled) 
[17:26:32.908]                           invokeRestart("muffleMessage")
[17:26:32.908]                       }
[17:26:32.908]                       else if (inherits(cond, "warning")) {
[17:26:32.908]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:32.908]                         if (muffled) 
[17:26:32.908]                           invokeRestart("muffleWarning")
[17:26:32.908]                       }
[17:26:32.908]                       else if (inherits(cond, "condition")) {
[17:26:32.908]                         if (!is.null(pattern)) {
[17:26:32.908]                           computeRestarts <- base::computeRestarts
[17:26:32.908]                           grepl <- base::grepl
[17:26:32.908]                           restarts <- computeRestarts(cond)
[17:26:32.908]                           for (restart in restarts) {
[17:26:32.908]                             name <- restart$name
[17:26:32.908]                             if (is.null(name)) 
[17:26:32.908]                               next
[17:26:32.908]                             if (!grepl(pattern, name)) 
[17:26:32.908]                               next
[17:26:32.908]                             invokeRestart(restart)
[17:26:32.908]                             muffled <- TRUE
[17:26:32.908]                             break
[17:26:32.908]                           }
[17:26:32.908]                         }
[17:26:32.908]                       }
[17:26:32.908]                       invisible(muffled)
[17:26:32.908]                     }
[17:26:32.908]                     muffleCondition(cond, pattern = "^muffle")
[17:26:32.908]                   }
[17:26:32.908]                 }
[17:26:32.908]                 else {
[17:26:32.908]                   if (TRUE) {
[17:26:32.908]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:32.908]                     {
[17:26:32.908]                       inherits <- base::inherits
[17:26:32.908]                       invokeRestart <- base::invokeRestart
[17:26:32.908]                       is.null <- base::is.null
[17:26:32.908]                       muffled <- FALSE
[17:26:32.908]                       if (inherits(cond, "message")) {
[17:26:32.908]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:32.908]                         if (muffled) 
[17:26:32.908]                           invokeRestart("muffleMessage")
[17:26:32.908]                       }
[17:26:32.908]                       else if (inherits(cond, "warning")) {
[17:26:32.908]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:32.908]                         if (muffled) 
[17:26:32.908]                           invokeRestart("muffleWarning")
[17:26:32.908]                       }
[17:26:32.908]                       else if (inherits(cond, "condition")) {
[17:26:32.908]                         if (!is.null(pattern)) {
[17:26:32.908]                           computeRestarts <- base::computeRestarts
[17:26:32.908]                           grepl <- base::grepl
[17:26:32.908]                           restarts <- computeRestarts(cond)
[17:26:32.908]                           for (restart in restarts) {
[17:26:32.908]                             name <- restart$name
[17:26:32.908]                             if (is.null(name)) 
[17:26:32.908]                               next
[17:26:32.908]                             if (!grepl(pattern, name)) 
[17:26:32.908]                               next
[17:26:32.908]                             invokeRestart(restart)
[17:26:32.908]                             muffled <- TRUE
[17:26:32.908]                             break
[17:26:32.908]                           }
[17:26:32.908]                         }
[17:26:32.908]                       }
[17:26:32.908]                       invisible(muffled)
[17:26:32.908]                     }
[17:26:32.908]                     muffleCondition(cond, pattern = "^muffle")
[17:26:32.908]                   }
[17:26:32.908]                 }
[17:26:32.908]             }
[17:26:32.908]         }))
[17:26:32.908]     }, error = function(ex) {
[17:26:32.908]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:32.908]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:32.908]                 ...future.rng), started = ...future.startTime, 
[17:26:32.908]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:32.908]             version = "1.8"), class = "FutureResult")
[17:26:32.908]     }, finally = {
[17:26:32.908]         if (!identical(...future.workdir, getwd())) 
[17:26:32.908]             setwd(...future.workdir)
[17:26:32.908]         {
[17:26:32.908]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:32.908]                 ...future.oldOptions$nwarnings <- NULL
[17:26:32.908]             }
[17:26:32.908]             base::options(...future.oldOptions)
[17:26:32.908]             if (.Platform$OS.type == "windows") {
[17:26:32.908]                 old_names <- names(...future.oldEnvVars)
[17:26:32.908]                 envs <- base::Sys.getenv()
[17:26:32.908]                 names <- names(envs)
[17:26:32.908]                 common <- intersect(names, old_names)
[17:26:32.908]                 added <- setdiff(names, old_names)
[17:26:32.908]                 removed <- setdiff(old_names, names)
[17:26:32.908]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:32.908]                   envs[common]]
[17:26:32.908]                 NAMES <- toupper(changed)
[17:26:32.908]                 args <- list()
[17:26:32.908]                 for (kk in seq_along(NAMES)) {
[17:26:32.908]                   name <- changed[[kk]]
[17:26:32.908]                   NAME <- NAMES[[kk]]
[17:26:32.908]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.908]                     next
[17:26:32.908]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:32.908]                 }
[17:26:32.908]                 NAMES <- toupper(added)
[17:26:32.908]                 for (kk in seq_along(NAMES)) {
[17:26:32.908]                   name <- added[[kk]]
[17:26:32.908]                   NAME <- NAMES[[kk]]
[17:26:32.908]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.908]                     next
[17:26:32.908]                   args[[name]] <- ""
[17:26:32.908]                 }
[17:26:32.908]                 NAMES <- toupper(removed)
[17:26:32.908]                 for (kk in seq_along(NAMES)) {
[17:26:32.908]                   name <- removed[[kk]]
[17:26:32.908]                   NAME <- NAMES[[kk]]
[17:26:32.908]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.908]                     next
[17:26:32.908]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:32.908]                 }
[17:26:32.908]                 if (length(args) > 0) 
[17:26:32.908]                   base::do.call(base::Sys.setenv, args = args)
[17:26:32.908]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:32.908]             }
[17:26:32.908]             else {
[17:26:32.908]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:32.908]             }
[17:26:32.908]             {
[17:26:32.908]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:32.908]                   0L) {
[17:26:32.908]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:32.908]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:32.908]                   base::options(opts)
[17:26:32.908]                 }
[17:26:32.908]                 {
[17:26:32.908]                   {
[17:26:32.908]                     NULL
[17:26:32.908]                     RNGkind("Mersenne-Twister")
[17:26:32.908]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:32.908]                       inherits = FALSE)
[17:26:32.908]                   }
[17:26:32.908]                   options(future.plan = NULL)
[17:26:32.908]                   if (is.na(NA_character_)) 
[17:26:32.908]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:32.908]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:32.908]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:32.908]                     .init = FALSE)
[17:26:32.908]                 }
[17:26:32.908]             }
[17:26:32.908]         }
[17:26:32.908]     })
[17:26:32.908]     if (TRUE) {
[17:26:32.908]         base::sink(type = "output", split = FALSE)
[17:26:32.908]         if (TRUE) {
[17:26:32.908]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:32.908]         }
[17:26:32.908]         else {
[17:26:32.908]             ...future.result["stdout"] <- base::list(NULL)
[17:26:32.908]         }
[17:26:32.908]         base::close(...future.stdout)
[17:26:32.908]         ...future.stdout <- NULL
[17:26:32.908]     }
[17:26:32.908]     ...future.result$conditions <- ...future.conditions
[17:26:32.908]     ...future.result$finished <- base::Sys.time()
[17:26:32.908]     ...future.result
[17:26:32.908] }
[17:26:32.913] plan(): Setting new future strategy stack:
[17:26:32.913] List of future strategies:
[17:26:32.913] 1. sequential:
[17:26:32.913]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.913]    - tweaked: FALSE
[17:26:32.913]    - call: NULL
[17:26:32.914] plan(): nbrOfWorkers() = 1
[17:26:32.916] plan(): Setting new future strategy stack:
[17:26:32.916] List of future strategies:
[17:26:32.916] 1. sequential:
[17:26:32.916]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.916]    - tweaked: FALSE
[17:26:32.916]    - call: future::plan("sequential")
[17:26:32.917] plan(): nbrOfWorkers() = 1
[17:26:32.917] SequentialFuture started (and completed)
[17:26:32.917] signalConditions() ...
[17:26:32.917]  - include = 'immediateCondition'
[17:26:32.918]  - exclude = 
[17:26:32.918]  - resignal = FALSE
[17:26:32.918]  - Number of conditions: 1
[17:26:32.918] signalConditions() ... done
[17:26:32.918] - Launch lazy future ... done
[17:26:32.918] run() for 'SequentialFuture' ... done
> calls <- backtrace(env[["b"]])
[17:26:32.919] resolved() for 'SequentialFuture' ...
[17:26:32.919] - state: 'finished'
[17:26:32.919] - run: TRUE
[17:26:32.920] - result: 'FutureResult'
[17:26:32.920] resolved() for 'SequentialFuture' ... done
> print(calls)
[[1]]
env[["b"]] %<-% {
    42L
    stop("Woops")
}

[[2]]
futureAssignInternal(target, expr, envir = envir, substitute = FALSE)

[[3]]
futureAssign(name, expr, envir = envir, assign.env = assign.env, 
    substitute = FALSE)

[[4]]
do.call(future::future, args = future.args, envir = assign.env)

[[5]]
(function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, 
    seed = FALSE, globals = TRUE, packages = NULL, stdout = TRUE, 
    conditions = "condition", earlySignal = FALSE, label = NULL, 
    gc = FALSE, ...) 
{
    if (substitute) 
        expr <- substitute(expr)
    t_start <- Sys.time()
    gp <- getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression, 
        globals = globals)
    expr <- gp$expr
    globals <- gp$globals
    if (length(packages) > 0 || length(gp$packages) > 0) {
        packages <- unique(c(gp$packages, packages))
    }
    gp <- NULL
    attr(globals, "already-done") <- TRUE
    future <- Future(expr, substitute = FALSE, envir = envir, 
        lazy = TRUE, seed = seed, globals = globals, packages = packages, 
        stdout = stdout, conditions = conditions, earlySignal = earlySignal, 
        label = label, gc = gc, ...)
    future$.defaultLocal <- !is.element("local", names(list(...)))
    if (getOption("future.journal", FALSE)) {
        future <- makeFutureJournal(future, event = "create", 
            category = "overhead", start = t_start)
    }
    if (!lazy) {
        future <- run(future)
        future$lazy <- FALSE
        stop_if_not(inherits(future, "Future"), !future$lazy)
    }
    future
})({
    42L
    stop("Woops")
}, envir = <environment>, lazy = FALSE, seed = FALSE, globals = TRUE, 
    packages = NULL, stdout = TRUE, conditions = "condition", 
    earlySignal = FALSE, label = NULL, gc = FALSE)

[[6]]
Future(expr, substitute = FALSE, envir = envir, lazy = TRUE, 
    seed = seed, globals = globals, packages = packages, stdout = stdout, 
    conditions = conditions, earlySignal = earlySignal, label = label, 
    gc = gc, ...)

[[7]]
eval(quote({
    42L
    stop("Woops")
}), new.env())

[[8]]
stop("Woops")

[[9]]
eval(quote({
    42L
    stop("Woops")
}), new.env())

> stopifnot(is.list(calls))
> 
> lenv <- listenv::listenv()
> lenv[[1]] %<-% { 42L; stop("Woops") }
[17:26:32.922] getGlobalsAndPackages() ...
[17:26:32.922] Searching for globals...
[17:26:32.924] - globals found: [2] '{', 'stop'
[17:26:32.925] Searching for globals ... DONE
[17:26:32.925] Resolving globals: FALSE
[17:26:32.926] 
[17:26:32.926] 
[17:26:32.926] getGlobalsAndPackages() ... DONE
[17:26:32.927] run() for 'Future' ...
[17:26:32.927] - state: 'created'
[17:26:32.928] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:32.928] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:32.929] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:32.929]   - Field: 'label'
[17:26:32.929]   - Field: 'local'
[17:26:32.930]   - Field: 'owner'
[17:26:32.930]   - Field: 'envir'
[17:26:32.930]   - Field: 'packages'
[17:26:32.931]   - Field: 'gc'
[17:26:32.931]   - Field: 'conditions'
[17:26:32.931]   - Field: 'expr'
[17:26:32.932]   - Field: 'uuid'
[17:26:32.932]   - Field: 'seed'
[17:26:32.932]   - Field: 'version'
[17:26:32.933]   - Field: 'result'
[17:26:32.933]   - Field: 'asynchronous'
[17:26:32.933]   - Field: 'calls'
[17:26:32.934]   - Field: 'globals'
[17:26:32.934]   - Field: 'stdout'
[17:26:32.934]   - Field: 'earlySignal'
[17:26:32.935]   - Field: 'lazy'
[17:26:32.935]   - Field: 'state'
[17:26:32.935] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:32.936] - Launch lazy future ...
[17:26:32.936] Packages needed by the future expression (n = 0): <none>
[17:26:32.936] Packages needed by future strategies (n = 0): <none>
[17:26:32.938] {
[17:26:32.938]     {
[17:26:32.938]         {
[17:26:32.938]             ...future.startTime <- base::Sys.time()
[17:26:32.938]             {
[17:26:32.938]                 {
[17:26:32.938]                   {
[17:26:32.938]                     base::local({
[17:26:32.938]                       has_future <- base::requireNamespace("future", 
[17:26:32.938]                         quietly = TRUE)
[17:26:32.938]                       if (has_future) {
[17:26:32.938]                         ns <- base::getNamespace("future")
[17:26:32.938]                         version <- ns[[".package"]][["version"]]
[17:26:32.938]                         if (is.null(version)) 
[17:26:32.938]                           version <- utils::packageVersion("future")
[17:26:32.938]                       }
[17:26:32.938]                       else {
[17:26:32.938]                         version <- NULL
[17:26:32.938]                       }
[17:26:32.938]                       if (!has_future || version < "1.8.0") {
[17:26:32.938]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:32.938]                           "", base::R.version$version.string), 
[17:26:32.938]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:32.938]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:32.938]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:32.938]                             "release", "version")], collapse = " "), 
[17:26:32.938]                           hostname = base::Sys.info()[["nodename"]])
[17:26:32.938]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:32.938]                           info)
[17:26:32.938]                         info <- base::paste(info, collapse = "; ")
[17:26:32.938]                         if (!has_future) {
[17:26:32.938]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:32.938]                             info)
[17:26:32.938]                         }
[17:26:32.938]                         else {
[17:26:32.938]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:32.938]                             info, version)
[17:26:32.938]                         }
[17:26:32.938]                         base::stop(msg)
[17:26:32.938]                       }
[17:26:32.938]                     })
[17:26:32.938]                   }
[17:26:32.938]                   ...future.strategy.old <- future::plan("list")
[17:26:32.938]                   options(future.plan = NULL)
[17:26:32.938]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:32.938]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:32.938]                 }
[17:26:32.938]                 ...future.workdir <- getwd()
[17:26:32.938]             }
[17:26:32.938]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:32.938]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:32.938]         }
[17:26:32.938]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:32.938]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:32.938]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:32.938]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:32.938]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:32.938]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:32.938]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:32.938]             base::names(...future.oldOptions))
[17:26:32.938]     }
[17:26:32.938]     if (FALSE) {
[17:26:32.938]     }
[17:26:32.938]     else {
[17:26:32.938]         if (TRUE) {
[17:26:32.938]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:32.938]                 open = "w")
[17:26:32.938]         }
[17:26:32.938]         else {
[17:26:32.938]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:32.938]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:32.938]         }
[17:26:32.938]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:32.938]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:32.938]             base::sink(type = "output", split = FALSE)
[17:26:32.938]             base::close(...future.stdout)
[17:26:32.938]         }, add = TRUE)
[17:26:32.938]     }
[17:26:32.938]     ...future.frame <- base::sys.nframe()
[17:26:32.938]     ...future.conditions <- base::list()
[17:26:32.938]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:32.938]     if (FALSE) {
[17:26:32.938]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:32.938]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:32.938]     }
[17:26:32.938]     ...future.result <- base::tryCatch({
[17:26:32.938]         base::withCallingHandlers({
[17:26:32.938]             ...future.value <- base::withVisible(base::local({
[17:26:32.938]                 42L
[17:26:32.938]                 stop("Woops")
[17:26:32.938]             }))
[17:26:32.938]             future::FutureResult(value = ...future.value$value, 
[17:26:32.938]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:32.938]                   ...future.rng), globalenv = if (FALSE) 
[17:26:32.938]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:32.938]                     ...future.globalenv.names))
[17:26:32.938]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:32.938]         }, condition = base::local({
[17:26:32.938]             c <- base::c
[17:26:32.938]             inherits <- base::inherits
[17:26:32.938]             invokeRestart <- base::invokeRestart
[17:26:32.938]             length <- base::length
[17:26:32.938]             list <- base::list
[17:26:32.938]             seq.int <- base::seq.int
[17:26:32.938]             signalCondition <- base::signalCondition
[17:26:32.938]             sys.calls <- base::sys.calls
[17:26:32.938]             `[[` <- base::`[[`
[17:26:32.938]             `+` <- base::`+`
[17:26:32.938]             `<<-` <- base::`<<-`
[17:26:32.938]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:32.938]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:32.938]                   3L)]
[17:26:32.938]             }
[17:26:32.938]             function(cond) {
[17:26:32.938]                 is_error <- inherits(cond, "error")
[17:26:32.938]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:32.938]                   NULL)
[17:26:32.938]                 if (is_error) {
[17:26:32.938]                   sessionInformation <- function() {
[17:26:32.938]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:32.938]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:32.938]                       search = base::search(), system = base::Sys.info())
[17:26:32.938]                   }
[17:26:32.938]                   ...future.conditions[[length(...future.conditions) + 
[17:26:32.938]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:32.938]                     cond$call), session = sessionInformation(), 
[17:26:32.938]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:32.938]                   signalCondition(cond)
[17:26:32.938]                 }
[17:26:32.938]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:32.938]                 "immediateCondition"))) {
[17:26:32.938]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:32.938]                   ...future.conditions[[length(...future.conditions) + 
[17:26:32.938]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:32.938]                   if (TRUE && !signal) {
[17:26:32.938]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:32.938]                     {
[17:26:32.938]                       inherits <- base::inherits
[17:26:32.938]                       invokeRestart <- base::invokeRestart
[17:26:32.938]                       is.null <- base::is.null
[17:26:32.938]                       muffled <- FALSE
[17:26:32.938]                       if (inherits(cond, "message")) {
[17:26:32.938]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:32.938]                         if (muffled) 
[17:26:32.938]                           invokeRestart("muffleMessage")
[17:26:32.938]                       }
[17:26:32.938]                       else if (inherits(cond, "warning")) {
[17:26:32.938]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:32.938]                         if (muffled) 
[17:26:32.938]                           invokeRestart("muffleWarning")
[17:26:32.938]                       }
[17:26:32.938]                       else if (inherits(cond, "condition")) {
[17:26:32.938]                         if (!is.null(pattern)) {
[17:26:32.938]                           computeRestarts <- base::computeRestarts
[17:26:32.938]                           grepl <- base::grepl
[17:26:32.938]                           restarts <- computeRestarts(cond)
[17:26:32.938]                           for (restart in restarts) {
[17:26:32.938]                             name <- restart$name
[17:26:32.938]                             if (is.null(name)) 
[17:26:32.938]                               next
[17:26:32.938]                             if (!grepl(pattern, name)) 
[17:26:32.938]                               next
[17:26:32.938]                             invokeRestart(restart)
[17:26:32.938]                             muffled <- TRUE
[17:26:32.938]                             break
[17:26:32.938]                           }
[17:26:32.938]                         }
[17:26:32.938]                       }
[17:26:32.938]                       invisible(muffled)
[17:26:32.938]                     }
[17:26:32.938]                     muffleCondition(cond, pattern = "^muffle")
[17:26:32.938]                   }
[17:26:32.938]                 }
[17:26:32.938]                 else {
[17:26:32.938]                   if (TRUE) {
[17:26:32.938]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:32.938]                     {
[17:26:32.938]                       inherits <- base::inherits
[17:26:32.938]                       invokeRestart <- base::invokeRestart
[17:26:32.938]                       is.null <- base::is.null
[17:26:32.938]                       muffled <- FALSE
[17:26:32.938]                       if (inherits(cond, "message")) {
[17:26:32.938]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:32.938]                         if (muffled) 
[17:26:32.938]                           invokeRestart("muffleMessage")
[17:26:32.938]                       }
[17:26:32.938]                       else if (inherits(cond, "warning")) {
[17:26:32.938]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:32.938]                         if (muffled) 
[17:26:32.938]                           invokeRestart("muffleWarning")
[17:26:32.938]                       }
[17:26:32.938]                       else if (inherits(cond, "condition")) {
[17:26:32.938]                         if (!is.null(pattern)) {
[17:26:32.938]                           computeRestarts <- base::computeRestarts
[17:26:32.938]                           grepl <- base::grepl
[17:26:32.938]                           restarts <- computeRestarts(cond)
[17:26:32.938]                           for (restart in restarts) {
[17:26:32.938]                             name <- restart$name
[17:26:32.938]                             if (is.null(name)) 
[17:26:32.938]                               next
[17:26:32.938]                             if (!grepl(pattern, name)) 
[17:26:32.938]                               next
[17:26:32.938]                             invokeRestart(restart)
[17:26:32.938]                             muffled <- TRUE
[17:26:32.938]                             break
[17:26:32.938]                           }
[17:26:32.938]                         }
[17:26:32.938]                       }
[17:26:32.938]                       invisible(muffled)
[17:26:32.938]                     }
[17:26:32.938]                     muffleCondition(cond, pattern = "^muffle")
[17:26:32.938]                   }
[17:26:32.938]                 }
[17:26:32.938]             }
[17:26:32.938]         }))
[17:26:32.938]     }, error = function(ex) {
[17:26:32.938]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:32.938]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:32.938]                 ...future.rng), started = ...future.startTime, 
[17:26:32.938]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:32.938]             version = "1.8"), class = "FutureResult")
[17:26:32.938]     }, finally = {
[17:26:32.938]         if (!identical(...future.workdir, getwd())) 
[17:26:32.938]             setwd(...future.workdir)
[17:26:32.938]         {
[17:26:32.938]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:32.938]                 ...future.oldOptions$nwarnings <- NULL
[17:26:32.938]             }
[17:26:32.938]             base::options(...future.oldOptions)
[17:26:32.938]             if (.Platform$OS.type == "windows") {
[17:26:32.938]                 old_names <- names(...future.oldEnvVars)
[17:26:32.938]                 envs <- base::Sys.getenv()
[17:26:32.938]                 names <- names(envs)
[17:26:32.938]                 common <- intersect(names, old_names)
[17:26:32.938]                 added <- setdiff(names, old_names)
[17:26:32.938]                 removed <- setdiff(old_names, names)
[17:26:32.938]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:32.938]                   envs[common]]
[17:26:32.938]                 NAMES <- toupper(changed)
[17:26:32.938]                 args <- list()
[17:26:32.938]                 for (kk in seq_along(NAMES)) {
[17:26:32.938]                   name <- changed[[kk]]
[17:26:32.938]                   NAME <- NAMES[[kk]]
[17:26:32.938]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.938]                     next
[17:26:32.938]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:32.938]                 }
[17:26:32.938]                 NAMES <- toupper(added)
[17:26:32.938]                 for (kk in seq_along(NAMES)) {
[17:26:32.938]                   name <- added[[kk]]
[17:26:32.938]                   NAME <- NAMES[[kk]]
[17:26:32.938]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.938]                     next
[17:26:32.938]                   args[[name]] <- ""
[17:26:32.938]                 }
[17:26:32.938]                 NAMES <- toupper(removed)
[17:26:32.938]                 for (kk in seq_along(NAMES)) {
[17:26:32.938]                   name <- removed[[kk]]
[17:26:32.938]                   NAME <- NAMES[[kk]]
[17:26:32.938]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.938]                     next
[17:26:32.938]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:32.938]                 }
[17:26:32.938]                 if (length(args) > 0) 
[17:26:32.938]                   base::do.call(base::Sys.setenv, args = args)
[17:26:32.938]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:32.938]             }
[17:26:32.938]             else {
[17:26:32.938]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:32.938]             }
[17:26:32.938]             {
[17:26:32.938]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:32.938]                   0L) {
[17:26:32.938]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:32.938]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:32.938]                   base::options(opts)
[17:26:32.938]                 }
[17:26:32.938]                 {
[17:26:32.938]                   {
[17:26:32.938]                     NULL
[17:26:32.938]                     RNGkind("Mersenne-Twister")
[17:26:32.938]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:32.938]                       inherits = FALSE)
[17:26:32.938]                   }
[17:26:32.938]                   options(future.plan = NULL)
[17:26:32.938]                   if (is.na(NA_character_)) 
[17:26:32.938]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:32.938]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:32.938]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:32.938]                     .init = FALSE)
[17:26:32.938]                 }
[17:26:32.938]             }
[17:26:32.938]         }
[17:26:32.938]     })
[17:26:32.938]     if (TRUE) {
[17:26:32.938]         base::sink(type = "output", split = FALSE)
[17:26:32.938]         if (TRUE) {
[17:26:32.938]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:32.938]         }
[17:26:32.938]         else {
[17:26:32.938]             ...future.result["stdout"] <- base::list(NULL)
[17:26:32.938]         }
[17:26:32.938]         base::close(...future.stdout)
[17:26:32.938]         ...future.stdout <- NULL
[17:26:32.938]     }
[17:26:32.938]     ...future.result$conditions <- ...future.conditions
[17:26:32.938]     ...future.result$finished <- base::Sys.time()
[17:26:32.938]     ...future.result
[17:26:32.938] }
[17:26:32.944] plan(): Setting new future strategy stack:
[17:26:32.944] List of future strategies:
[17:26:32.944] 1. sequential:
[17:26:32.944]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.944]    - tweaked: FALSE
[17:26:32.944]    - call: NULL
[17:26:32.946] plan(): nbrOfWorkers() = 1
[17:26:32.948] plan(): Setting new future strategy stack:
[17:26:32.948] List of future strategies:
[17:26:32.948] 1. sequential:
[17:26:32.948]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.948]    - tweaked: FALSE
[17:26:32.948]    - call: future::plan("sequential")
[17:26:32.949] plan(): nbrOfWorkers() = 1
[17:26:32.949] SequentialFuture started (and completed)
[17:26:32.950] signalConditions() ...
[17:26:32.950]  - include = 'immediateCondition'
[17:26:32.950]  - exclude = 
[17:26:32.951]  - resignal = FALSE
[17:26:32.951]  - Number of conditions: 1
[17:26:32.954] signalConditions() ... done
[17:26:32.954] - Launch lazy future ... done
[17:26:32.954] run() for 'SequentialFuture' ... done
> lenv[[2]] %<-% { 42L; stop("Woops") }
[17:26:32.955] getGlobalsAndPackages() ...
[17:26:32.956] Searching for globals...
[17:26:32.958] - globals found: [2] '{', 'stop'
[17:26:32.958] Searching for globals ... DONE
[17:26:32.958] Resolving globals: FALSE
[17:26:32.959] 
[17:26:32.959] 
[17:26:32.960] getGlobalsAndPackages() ... DONE
[17:26:32.960] run() for 'Future' ...
[17:26:32.961] - state: 'created'
[17:26:32.961] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:32.961] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:32.962] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:32.962]   - Field: 'label'
[17:26:32.962]   - Field: 'local'
[17:26:32.963]   - Field: 'owner'
[17:26:32.963]   - Field: 'envir'
[17:26:32.963]   - Field: 'packages'
[17:26:32.964]   - Field: 'gc'
[17:26:32.964]   - Field: 'conditions'
[17:26:32.964]   - Field: 'expr'
[17:26:32.965]   - Field: 'uuid'
[17:26:32.965]   - Field: 'seed'
[17:26:32.965]   - Field: 'version'
[17:26:32.966]   - Field: 'result'
[17:26:32.966]   - Field: 'asynchronous'
[17:26:32.966]   - Field: 'calls'
[17:26:32.967]   - Field: 'globals'
[17:26:32.967]   - Field: 'stdout'
[17:26:32.967]   - Field: 'earlySignal'
[17:26:32.968]   - Field: 'lazy'
[17:26:32.968]   - Field: 'state'
[17:26:32.968] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:32.969] - Launch lazy future ...
[17:26:32.969] Packages needed by the future expression (n = 0): <none>
[17:26:32.969] Packages needed by future strategies (n = 0): <none>
[17:26:32.970] {
[17:26:32.970]     {
[17:26:32.970]         {
[17:26:32.970]             ...future.startTime <- base::Sys.time()
[17:26:32.970]             {
[17:26:32.970]                 {
[17:26:32.970]                   {
[17:26:32.970]                     base::local({
[17:26:32.970]                       has_future <- base::requireNamespace("future", 
[17:26:32.970]                         quietly = TRUE)
[17:26:32.970]                       if (has_future) {
[17:26:32.970]                         ns <- base::getNamespace("future")
[17:26:32.970]                         version <- ns[[".package"]][["version"]]
[17:26:32.970]                         if (is.null(version)) 
[17:26:32.970]                           version <- utils::packageVersion("future")
[17:26:32.970]                       }
[17:26:32.970]                       else {
[17:26:32.970]                         version <- NULL
[17:26:32.970]                       }
[17:26:32.970]                       if (!has_future || version < "1.8.0") {
[17:26:32.970]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:32.970]                           "", base::R.version$version.string), 
[17:26:32.970]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:32.970]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:32.970]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:32.970]                             "release", "version")], collapse = " "), 
[17:26:32.970]                           hostname = base::Sys.info()[["nodename"]])
[17:26:32.970]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:32.970]                           info)
[17:26:32.970]                         info <- base::paste(info, collapse = "; ")
[17:26:32.970]                         if (!has_future) {
[17:26:32.970]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:32.970]                             info)
[17:26:32.970]                         }
[17:26:32.970]                         else {
[17:26:32.970]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:32.970]                             info, version)
[17:26:32.970]                         }
[17:26:32.970]                         base::stop(msg)
[17:26:32.970]                       }
[17:26:32.970]                     })
[17:26:32.970]                   }
[17:26:32.970]                   ...future.strategy.old <- future::plan("list")
[17:26:32.970]                   options(future.plan = NULL)
[17:26:32.970]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:32.970]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:32.970]                 }
[17:26:32.970]                 ...future.workdir <- getwd()
[17:26:32.970]             }
[17:26:32.970]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:32.970]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:32.970]         }
[17:26:32.970]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:32.970]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:32.970]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:32.970]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:32.970]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:32.970]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:32.970]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:32.970]             base::names(...future.oldOptions))
[17:26:32.970]     }
[17:26:32.970]     if (FALSE) {
[17:26:32.970]     }
[17:26:32.970]     else {
[17:26:32.970]         if (TRUE) {
[17:26:32.970]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:32.970]                 open = "w")
[17:26:32.970]         }
[17:26:32.970]         else {
[17:26:32.970]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:32.970]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:32.970]         }
[17:26:32.970]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:32.970]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:32.970]             base::sink(type = "output", split = FALSE)
[17:26:32.970]             base::close(...future.stdout)
[17:26:32.970]         }, add = TRUE)
[17:26:32.970]     }
[17:26:32.970]     ...future.frame <- base::sys.nframe()
[17:26:32.970]     ...future.conditions <- base::list()
[17:26:32.970]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:32.970]     if (FALSE) {
[17:26:32.970]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:32.970]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:32.970]     }
[17:26:32.970]     ...future.result <- base::tryCatch({
[17:26:32.970]         base::withCallingHandlers({
[17:26:32.970]             ...future.value <- base::withVisible(base::local({
[17:26:32.970]                 42L
[17:26:32.970]                 stop("Woops")
[17:26:32.970]             }))
[17:26:32.970]             future::FutureResult(value = ...future.value$value, 
[17:26:32.970]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:32.970]                   ...future.rng), globalenv = if (FALSE) 
[17:26:32.970]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:32.970]                     ...future.globalenv.names))
[17:26:32.970]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:32.970]         }, condition = base::local({
[17:26:32.970]             c <- base::c
[17:26:32.970]             inherits <- base::inherits
[17:26:32.970]             invokeRestart <- base::invokeRestart
[17:26:32.970]             length <- base::length
[17:26:32.970]             list <- base::list
[17:26:32.970]             seq.int <- base::seq.int
[17:26:32.970]             signalCondition <- base::signalCondition
[17:26:32.970]             sys.calls <- base::sys.calls
[17:26:32.970]             `[[` <- base::`[[`
[17:26:32.970]             `+` <- base::`+`
[17:26:32.970]             `<<-` <- base::`<<-`
[17:26:32.970]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:32.970]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:32.970]                   3L)]
[17:26:32.970]             }
[17:26:32.970]             function(cond) {
[17:26:32.970]                 is_error <- inherits(cond, "error")
[17:26:32.970]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:32.970]                   NULL)
[17:26:32.970]                 if (is_error) {
[17:26:32.970]                   sessionInformation <- function() {
[17:26:32.970]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:32.970]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:32.970]                       search = base::search(), system = base::Sys.info())
[17:26:32.970]                   }
[17:26:32.970]                   ...future.conditions[[length(...future.conditions) + 
[17:26:32.970]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:32.970]                     cond$call), session = sessionInformation(), 
[17:26:32.970]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:32.970]                   signalCondition(cond)
[17:26:32.970]                 }
[17:26:32.970]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:32.970]                 "immediateCondition"))) {
[17:26:32.970]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:32.970]                   ...future.conditions[[length(...future.conditions) + 
[17:26:32.970]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:32.970]                   if (TRUE && !signal) {
[17:26:32.970]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:32.970]                     {
[17:26:32.970]                       inherits <- base::inherits
[17:26:32.970]                       invokeRestart <- base::invokeRestart
[17:26:32.970]                       is.null <- base::is.null
[17:26:32.970]                       muffled <- FALSE
[17:26:32.970]                       if (inherits(cond, "message")) {
[17:26:32.970]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:32.970]                         if (muffled) 
[17:26:32.970]                           invokeRestart("muffleMessage")
[17:26:32.970]                       }
[17:26:32.970]                       else if (inherits(cond, "warning")) {
[17:26:32.970]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:32.970]                         if (muffled) 
[17:26:32.970]                           invokeRestart("muffleWarning")
[17:26:32.970]                       }
[17:26:32.970]                       else if (inherits(cond, "condition")) {
[17:26:32.970]                         if (!is.null(pattern)) {
[17:26:32.970]                           computeRestarts <- base::computeRestarts
[17:26:32.970]                           grepl <- base::grepl
[17:26:32.970]                           restarts <- computeRestarts(cond)
[17:26:32.970]                           for (restart in restarts) {
[17:26:32.970]                             name <- restart$name
[17:26:32.970]                             if (is.null(name)) 
[17:26:32.970]                               next
[17:26:32.970]                             if (!grepl(pattern, name)) 
[17:26:32.970]                               next
[17:26:32.970]                             invokeRestart(restart)
[17:26:32.970]                             muffled <- TRUE
[17:26:32.970]                             break
[17:26:32.970]                           }
[17:26:32.970]                         }
[17:26:32.970]                       }
[17:26:32.970]                       invisible(muffled)
[17:26:32.970]                     }
[17:26:32.970]                     muffleCondition(cond, pattern = "^muffle")
[17:26:32.970]                   }
[17:26:32.970]                 }
[17:26:32.970]                 else {
[17:26:32.970]                   if (TRUE) {
[17:26:32.970]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:32.970]                     {
[17:26:32.970]                       inherits <- base::inherits
[17:26:32.970]                       invokeRestart <- base::invokeRestart
[17:26:32.970]                       is.null <- base::is.null
[17:26:32.970]                       muffled <- FALSE
[17:26:32.970]                       if (inherits(cond, "message")) {
[17:26:32.970]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:32.970]                         if (muffled) 
[17:26:32.970]                           invokeRestart("muffleMessage")
[17:26:32.970]                       }
[17:26:32.970]                       else if (inherits(cond, "warning")) {
[17:26:32.970]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:32.970]                         if (muffled) 
[17:26:32.970]                           invokeRestart("muffleWarning")
[17:26:32.970]                       }
[17:26:32.970]                       else if (inherits(cond, "condition")) {
[17:26:32.970]                         if (!is.null(pattern)) {
[17:26:32.970]                           computeRestarts <- base::computeRestarts
[17:26:32.970]                           grepl <- base::grepl
[17:26:32.970]                           restarts <- computeRestarts(cond)
[17:26:32.970]                           for (restart in restarts) {
[17:26:32.970]                             name <- restart$name
[17:26:32.970]                             if (is.null(name)) 
[17:26:32.970]                               next
[17:26:32.970]                             if (!grepl(pattern, name)) 
[17:26:32.970]                               next
[17:26:32.970]                             invokeRestart(restart)
[17:26:32.970]                             muffled <- TRUE
[17:26:32.970]                             break
[17:26:32.970]                           }
[17:26:32.970]                         }
[17:26:32.970]                       }
[17:26:32.970]                       invisible(muffled)
[17:26:32.970]                     }
[17:26:32.970]                     muffleCondition(cond, pattern = "^muffle")
[17:26:32.970]                   }
[17:26:32.970]                 }
[17:26:32.970]             }
[17:26:32.970]         }))
[17:26:32.970]     }, error = function(ex) {
[17:26:32.970]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:32.970]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:32.970]                 ...future.rng), started = ...future.startTime, 
[17:26:32.970]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:32.970]             version = "1.8"), class = "FutureResult")
[17:26:32.970]     }, finally = {
[17:26:32.970]         if (!identical(...future.workdir, getwd())) 
[17:26:32.970]             setwd(...future.workdir)
[17:26:32.970]         {
[17:26:32.970]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:32.970]                 ...future.oldOptions$nwarnings <- NULL
[17:26:32.970]             }
[17:26:32.970]             base::options(...future.oldOptions)
[17:26:32.970]             if (.Platform$OS.type == "windows") {
[17:26:32.970]                 old_names <- names(...future.oldEnvVars)
[17:26:32.970]                 envs <- base::Sys.getenv()
[17:26:32.970]                 names <- names(envs)
[17:26:32.970]                 common <- intersect(names, old_names)
[17:26:32.970]                 added <- setdiff(names, old_names)
[17:26:32.970]                 removed <- setdiff(old_names, names)
[17:26:32.970]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:32.970]                   envs[common]]
[17:26:32.970]                 NAMES <- toupper(changed)
[17:26:32.970]                 args <- list()
[17:26:32.970]                 for (kk in seq_along(NAMES)) {
[17:26:32.970]                   name <- changed[[kk]]
[17:26:32.970]                   NAME <- NAMES[[kk]]
[17:26:32.970]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.970]                     next
[17:26:32.970]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:32.970]                 }
[17:26:32.970]                 NAMES <- toupper(added)
[17:26:32.970]                 for (kk in seq_along(NAMES)) {
[17:26:32.970]                   name <- added[[kk]]
[17:26:32.970]                   NAME <- NAMES[[kk]]
[17:26:32.970]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.970]                     next
[17:26:32.970]                   args[[name]] <- ""
[17:26:32.970]                 }
[17:26:32.970]                 NAMES <- toupper(removed)
[17:26:32.970]                 for (kk in seq_along(NAMES)) {
[17:26:32.970]                   name <- removed[[kk]]
[17:26:32.970]                   NAME <- NAMES[[kk]]
[17:26:32.970]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:32.970]                     next
[17:26:32.970]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:32.970]                 }
[17:26:32.970]                 if (length(args) > 0) 
[17:26:32.970]                   base::do.call(base::Sys.setenv, args = args)
[17:26:32.970]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:32.970]             }
[17:26:32.970]             else {
[17:26:32.970]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:32.970]             }
[17:26:32.970]             {
[17:26:32.970]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:32.970]                   0L) {
[17:26:32.970]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:32.970]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:32.970]                   base::options(opts)
[17:26:32.970]                 }
[17:26:32.970]                 {
[17:26:32.970]                   {
[17:26:32.970]                     NULL
[17:26:32.970]                     RNGkind("Mersenne-Twister")
[17:26:32.970]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:32.970]                       inherits = FALSE)
[17:26:32.970]                   }
[17:26:32.970]                   options(future.plan = NULL)
[17:26:32.970]                   if (is.na(NA_character_)) 
[17:26:32.970]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:32.970]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:32.970]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:32.970]                     .init = FALSE)
[17:26:32.970]                 }
[17:26:32.970]             }
[17:26:32.970]         }
[17:26:32.970]     })
[17:26:32.970]     if (TRUE) {
[17:26:32.970]         base::sink(type = "output", split = FALSE)
[17:26:32.970]         if (TRUE) {
[17:26:32.970]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:32.970]         }
[17:26:32.970]         else {
[17:26:32.970]             ...future.result["stdout"] <- base::list(NULL)
[17:26:32.970]         }
[17:26:32.970]         base::close(...future.stdout)
[17:26:32.970]         ...future.stdout <- NULL
[17:26:32.970]     }
[17:26:32.970]     ...future.result$conditions <- ...future.conditions
[17:26:32.970]     ...future.result$finished <- base::Sys.time()
[17:26:32.970]     ...future.result
[17:26:32.970] }
[17:26:32.977] plan(): Setting new future strategy stack:
[17:26:32.978] List of future strategies:
[17:26:32.978] 1. sequential:
[17:26:32.978]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.978]    - tweaked: FALSE
[17:26:32.978]    - call: NULL
[17:26:32.979] plan(): nbrOfWorkers() = 1
[17:26:32.981] plan(): Setting new future strategy stack:
[17:26:32.981] List of future strategies:
[17:26:32.981] 1. sequential:
[17:26:32.981]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:32.981]    - tweaked: FALSE
[17:26:32.981]    - call: future::plan("sequential")
[17:26:32.982] plan(): nbrOfWorkers() = 1
[17:26:32.983] SequentialFuture started (and completed)
[17:26:32.983] signalConditions() ...
[17:26:32.983]  - include = 'immediateCondition'
[17:26:32.984]  - exclude = 
[17:26:32.984]  - resignal = FALSE
[17:26:32.984]  - Number of conditions: 1
[17:26:32.985] signalConditions() ... done
[17:26:32.985] - Launch lazy future ... done
[17:26:32.985] run() for 'SequentialFuture' ... done
> calls <- backtrace(lenv[[2]])
[17:26:32.986] resolved() for 'SequentialFuture' ...
[17:26:32.986] - state: 'finished'
[17:26:32.987] - run: TRUE
[17:26:32.987] - result: 'FutureResult'
[17:26:32.987] resolved() for 'SequentialFuture' ... done
> print(calls)
[[1]]
lenv[[2]] %<-% {
    42L
    stop("Woops")
}

[[2]]
futureAssignInternal(target, expr, envir = envir, substitute = FALSE)

[[3]]
futureAssign(name, expr, envir = envir, assign.env = assign.env, 
    substitute = FALSE)

[[4]]
do.call(future::future, args = future.args, envir = assign.env)

[[5]]
(function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, 
    seed = FALSE, globals = TRUE, packages = NULL, stdout = TRUE, 
    conditions = "condition", earlySignal = FALSE, label = NULL, 
    gc = FALSE, ...) 
{
    if (substitute) 
        expr <- substitute(expr)
    t_start <- Sys.time()
    gp <- getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression, 
        globals = globals)
    expr <- gp$expr
    globals <- gp$globals
    if (length(packages) > 0 || length(gp$packages) > 0) {
        packages <- unique(c(gp$packages, packages))
    }
    gp <- NULL
    attr(globals, "already-done") <- TRUE
    future <- Future(expr, substitute = FALSE, envir = envir, 
        lazy = TRUE, seed = seed, globals = globals, packages = packages, 
        stdout = stdout, conditions = conditions, earlySignal = earlySignal, 
        label = label, gc = gc, ...)
    future$.defaultLocal <- !is.element("local", names(list(...)))
    if (getOption("future.journal", FALSE)) {
        future <- makeFutureJournal(future, event = "create", 
            category = "overhead", start = t_start)
    }
    if (!lazy) {
        future <- run(future)
        future$lazy <- FALSE
        stop_if_not(inherits(future, "Future"), !future$lazy)
    }
    future
})({
    42L
    stop("Woops")
}, envir = <environment>, lazy = FALSE, seed = FALSE, globals = TRUE, 
    packages = NULL, stdout = TRUE, conditions = "condition", 
    earlySignal = FALSE, label = NULL, gc = FALSE)

[[6]]
Future(expr, substitute = FALSE, envir = envir, lazy = TRUE, 
    seed = seed, globals = globals, packages = packages, stdout = stdout, 
    conditions = conditions, earlySignal = earlySignal, label = label, 
    gc = gc, ...)

[[7]]
eval(quote({
    42L
    stop("Woops")
}), new.env())

[[8]]
stop("Woops")

[[9]]
eval(quote({
    42L
    stop("Woops")
}), new.env())

> stopifnot(is.list(calls))
> 
> ll <- list()
> ll[[1]] <- future({ 42L; stop("Woops") })
[17:26:32.989] getGlobalsAndPackages() ...
[17:26:32.990] Searching for globals...
[17:26:32.991] - globals found: [2] '{', 'stop'
[17:26:32.992] Searching for globals ... DONE
[17:26:32.992] Resolving globals: FALSE
[17:26:32.993] 
[17:26:32.993] 
[17:26:32.993] getGlobalsAndPackages() ... DONE
[17:26:32.994] run() for 'Future' ...
[17:26:32.994] - state: 'created'
[17:26:32.995] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:32.995] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:32.996] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:32.996]   - Field: 'label'
[17:26:32.996]   - Field: 'local'
[17:26:32.997]   - Field: 'owner'
[17:26:32.997]   - Field: 'envir'
[17:26:32.997]   - Field: 'packages'
[17:26:32.998]   - Field: 'gc'
[17:26:32.998]   - Field: 'conditions'
[17:26:32.998]   - Field: 'expr'
[17:26:32.999]   - Field: 'uuid'
[17:26:32.999]   - Field: 'seed'
[17:26:32.999]   - Field: 'version'
[17:26:33.000]   - Field: 'result'
[17:26:33.000]   - Field: 'asynchronous'
[17:26:33.000]   - Field: 'calls'
[17:26:33.001]   - Field: 'globals'
[17:26:33.001]   - Field: 'stdout'
[17:26:33.001]   - Field: 'earlySignal'
[17:26:33.002]   - Field: 'lazy'
[17:26:33.002]   - Field: 'state'
[17:26:33.002] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:33.002] - Launch lazy future ...
[17:26:33.003] Packages needed by the future expression (n = 0): <none>
[17:26:33.003] Packages needed by future strategies (n = 0): <none>
[17:26:33.004] {
[17:26:33.004]     {
[17:26:33.004]         {
[17:26:33.004]             ...future.startTime <- base::Sys.time()
[17:26:33.004]             {
[17:26:33.004]                 {
[17:26:33.004]                   {
[17:26:33.004]                     base::local({
[17:26:33.004]                       has_future <- base::requireNamespace("future", 
[17:26:33.004]                         quietly = TRUE)
[17:26:33.004]                       if (has_future) {
[17:26:33.004]                         ns <- base::getNamespace("future")
[17:26:33.004]                         version <- ns[[".package"]][["version"]]
[17:26:33.004]                         if (is.null(version)) 
[17:26:33.004]                           version <- utils::packageVersion("future")
[17:26:33.004]                       }
[17:26:33.004]                       else {
[17:26:33.004]                         version <- NULL
[17:26:33.004]                       }
[17:26:33.004]                       if (!has_future || version < "1.8.0") {
[17:26:33.004]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:33.004]                           "", base::R.version$version.string), 
[17:26:33.004]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:33.004]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:33.004]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:33.004]                             "release", "version")], collapse = " "), 
[17:26:33.004]                           hostname = base::Sys.info()[["nodename"]])
[17:26:33.004]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:33.004]                           info)
[17:26:33.004]                         info <- base::paste(info, collapse = "; ")
[17:26:33.004]                         if (!has_future) {
[17:26:33.004]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:33.004]                             info)
[17:26:33.004]                         }
[17:26:33.004]                         else {
[17:26:33.004]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:33.004]                             info, version)
[17:26:33.004]                         }
[17:26:33.004]                         base::stop(msg)
[17:26:33.004]                       }
[17:26:33.004]                     })
[17:26:33.004]                   }
[17:26:33.004]                   ...future.strategy.old <- future::plan("list")
[17:26:33.004]                   options(future.plan = NULL)
[17:26:33.004]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:33.004]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:33.004]                 }
[17:26:33.004]                 ...future.workdir <- getwd()
[17:26:33.004]             }
[17:26:33.004]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:33.004]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:33.004]         }
[17:26:33.004]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:33.004]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:33.004]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:33.004]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:33.004]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:33.004]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:33.004]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:33.004]             base::names(...future.oldOptions))
[17:26:33.004]     }
[17:26:33.004]     if (FALSE) {
[17:26:33.004]     }
[17:26:33.004]     else {
[17:26:33.004]         if (TRUE) {
[17:26:33.004]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:33.004]                 open = "w")
[17:26:33.004]         }
[17:26:33.004]         else {
[17:26:33.004]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:33.004]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:33.004]         }
[17:26:33.004]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:33.004]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:33.004]             base::sink(type = "output", split = FALSE)
[17:26:33.004]             base::close(...future.stdout)
[17:26:33.004]         }, add = TRUE)
[17:26:33.004]     }
[17:26:33.004]     ...future.frame <- base::sys.nframe()
[17:26:33.004]     ...future.conditions <- base::list()
[17:26:33.004]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:33.004]     if (FALSE) {
[17:26:33.004]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:33.004]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:33.004]     }
[17:26:33.004]     ...future.result <- base::tryCatch({
[17:26:33.004]         base::withCallingHandlers({
[17:26:33.004]             ...future.value <- base::withVisible(base::local({
[17:26:33.004]                 42L
[17:26:33.004]                 stop("Woops")
[17:26:33.004]             }))
[17:26:33.004]             future::FutureResult(value = ...future.value$value, 
[17:26:33.004]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:33.004]                   ...future.rng), globalenv = if (FALSE) 
[17:26:33.004]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:33.004]                     ...future.globalenv.names))
[17:26:33.004]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:33.004]         }, condition = base::local({
[17:26:33.004]             c <- base::c
[17:26:33.004]             inherits <- base::inherits
[17:26:33.004]             invokeRestart <- base::invokeRestart
[17:26:33.004]             length <- base::length
[17:26:33.004]             list <- base::list
[17:26:33.004]             seq.int <- base::seq.int
[17:26:33.004]             signalCondition <- base::signalCondition
[17:26:33.004]             sys.calls <- base::sys.calls
[17:26:33.004]             `[[` <- base::`[[`
[17:26:33.004]             `+` <- base::`+`
[17:26:33.004]             `<<-` <- base::`<<-`
[17:26:33.004]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:33.004]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:33.004]                   3L)]
[17:26:33.004]             }
[17:26:33.004]             function(cond) {
[17:26:33.004]                 is_error <- inherits(cond, "error")
[17:26:33.004]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:33.004]                   NULL)
[17:26:33.004]                 if (is_error) {
[17:26:33.004]                   sessionInformation <- function() {
[17:26:33.004]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:33.004]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:33.004]                       search = base::search(), system = base::Sys.info())
[17:26:33.004]                   }
[17:26:33.004]                   ...future.conditions[[length(...future.conditions) + 
[17:26:33.004]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:33.004]                     cond$call), session = sessionInformation(), 
[17:26:33.004]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:33.004]                   signalCondition(cond)
[17:26:33.004]                 }
[17:26:33.004]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:33.004]                 "immediateCondition"))) {
[17:26:33.004]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:33.004]                   ...future.conditions[[length(...future.conditions) + 
[17:26:33.004]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:33.004]                   if (TRUE && !signal) {
[17:26:33.004]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:33.004]                     {
[17:26:33.004]                       inherits <- base::inherits
[17:26:33.004]                       invokeRestart <- base::invokeRestart
[17:26:33.004]                       is.null <- base::is.null
[17:26:33.004]                       muffled <- FALSE
[17:26:33.004]                       if (inherits(cond, "message")) {
[17:26:33.004]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:33.004]                         if (muffled) 
[17:26:33.004]                           invokeRestart("muffleMessage")
[17:26:33.004]                       }
[17:26:33.004]                       else if (inherits(cond, "warning")) {
[17:26:33.004]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:33.004]                         if (muffled) 
[17:26:33.004]                           invokeRestart("muffleWarning")
[17:26:33.004]                       }
[17:26:33.004]                       else if (inherits(cond, "condition")) {
[17:26:33.004]                         if (!is.null(pattern)) {
[17:26:33.004]                           computeRestarts <- base::computeRestarts
[17:26:33.004]                           grepl <- base::grepl
[17:26:33.004]                           restarts <- computeRestarts(cond)
[17:26:33.004]                           for (restart in restarts) {
[17:26:33.004]                             name <- restart$name
[17:26:33.004]                             if (is.null(name)) 
[17:26:33.004]                               next
[17:26:33.004]                             if (!grepl(pattern, name)) 
[17:26:33.004]                               next
[17:26:33.004]                             invokeRestart(restart)
[17:26:33.004]                             muffled <- TRUE
[17:26:33.004]                             break
[17:26:33.004]                           }
[17:26:33.004]                         }
[17:26:33.004]                       }
[17:26:33.004]                       invisible(muffled)
[17:26:33.004]                     }
[17:26:33.004]                     muffleCondition(cond, pattern = "^muffle")
[17:26:33.004]                   }
[17:26:33.004]                 }
[17:26:33.004]                 else {
[17:26:33.004]                   if (TRUE) {
[17:26:33.004]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:33.004]                     {
[17:26:33.004]                       inherits <- base::inherits
[17:26:33.004]                       invokeRestart <- base::invokeRestart
[17:26:33.004]                       is.null <- base::is.null
[17:26:33.004]                       muffled <- FALSE
[17:26:33.004]                       if (inherits(cond, "message")) {
[17:26:33.004]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:33.004]                         if (muffled) 
[17:26:33.004]                           invokeRestart("muffleMessage")
[17:26:33.004]                       }
[17:26:33.004]                       else if (inherits(cond, "warning")) {
[17:26:33.004]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:33.004]                         if (muffled) 
[17:26:33.004]                           invokeRestart("muffleWarning")
[17:26:33.004]                       }
[17:26:33.004]                       else if (inherits(cond, "condition")) {
[17:26:33.004]                         if (!is.null(pattern)) {
[17:26:33.004]                           computeRestarts <- base::computeRestarts
[17:26:33.004]                           grepl <- base::grepl
[17:26:33.004]                           restarts <- computeRestarts(cond)
[17:26:33.004]                           for (restart in restarts) {
[17:26:33.004]                             name <- restart$name
[17:26:33.004]                             if (is.null(name)) 
[17:26:33.004]                               next
[17:26:33.004]                             if (!grepl(pattern, name)) 
[17:26:33.004]                               next
[17:26:33.004]                             invokeRestart(restart)
[17:26:33.004]                             muffled <- TRUE
[17:26:33.004]                             break
[17:26:33.004]                           }
[17:26:33.004]                         }
[17:26:33.004]                       }
[17:26:33.004]                       invisible(muffled)
[17:26:33.004]                     }
[17:26:33.004]                     muffleCondition(cond, pattern = "^muffle")
[17:26:33.004]                   }
[17:26:33.004]                 }
[17:26:33.004]             }
[17:26:33.004]         }))
[17:26:33.004]     }, error = function(ex) {
[17:26:33.004]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:33.004]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:33.004]                 ...future.rng), started = ...future.startTime, 
[17:26:33.004]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:33.004]             version = "1.8"), class = "FutureResult")
[17:26:33.004]     }, finally = {
[17:26:33.004]         if (!identical(...future.workdir, getwd())) 
[17:26:33.004]             setwd(...future.workdir)
[17:26:33.004]         {
[17:26:33.004]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:33.004]                 ...future.oldOptions$nwarnings <- NULL
[17:26:33.004]             }
[17:26:33.004]             base::options(...future.oldOptions)
[17:26:33.004]             if (.Platform$OS.type == "windows") {
[17:26:33.004]                 old_names <- names(...future.oldEnvVars)
[17:26:33.004]                 envs <- base::Sys.getenv()
[17:26:33.004]                 names <- names(envs)
[17:26:33.004]                 common <- intersect(names, old_names)
[17:26:33.004]                 added <- setdiff(names, old_names)
[17:26:33.004]                 removed <- setdiff(old_names, names)
[17:26:33.004]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:33.004]                   envs[common]]
[17:26:33.004]                 NAMES <- toupper(changed)
[17:26:33.004]                 args <- list()
[17:26:33.004]                 for (kk in seq_along(NAMES)) {
[17:26:33.004]                   name <- changed[[kk]]
[17:26:33.004]                   NAME <- NAMES[[kk]]
[17:26:33.004]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:33.004]                     next
[17:26:33.004]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:33.004]                 }
[17:26:33.004]                 NAMES <- toupper(added)
[17:26:33.004]                 for (kk in seq_along(NAMES)) {
[17:26:33.004]                   name <- added[[kk]]
[17:26:33.004]                   NAME <- NAMES[[kk]]
[17:26:33.004]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:33.004]                     next
[17:26:33.004]                   args[[name]] <- ""
[17:26:33.004]                 }
[17:26:33.004]                 NAMES <- toupper(removed)
[17:26:33.004]                 for (kk in seq_along(NAMES)) {
[17:26:33.004]                   name <- removed[[kk]]
[17:26:33.004]                   NAME <- NAMES[[kk]]
[17:26:33.004]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:33.004]                     next
[17:26:33.004]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:33.004]                 }
[17:26:33.004]                 if (length(args) > 0) 
[17:26:33.004]                   base::do.call(base::Sys.setenv, args = args)
[17:26:33.004]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:33.004]             }
[17:26:33.004]             else {
[17:26:33.004]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:33.004]             }
[17:26:33.004]             {
[17:26:33.004]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:33.004]                   0L) {
[17:26:33.004]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:33.004]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:33.004]                   base::options(opts)
[17:26:33.004]                 }
[17:26:33.004]                 {
[17:26:33.004]                   {
[17:26:33.004]                     NULL
[17:26:33.004]                     RNGkind("Mersenne-Twister")
[17:26:33.004]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:33.004]                       inherits = FALSE)
[17:26:33.004]                   }
[17:26:33.004]                   options(future.plan = NULL)
[17:26:33.004]                   if (is.na(NA_character_)) 
[17:26:33.004]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:33.004]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:33.004]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:33.004]                     .init = FALSE)
[17:26:33.004]                 }
[17:26:33.004]             }
[17:26:33.004]         }
[17:26:33.004]     })
[17:26:33.004]     if (TRUE) {
[17:26:33.004]         base::sink(type = "output", split = FALSE)
[17:26:33.004]         if (TRUE) {
[17:26:33.004]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:33.004]         }
[17:26:33.004]         else {
[17:26:33.004]             ...future.result["stdout"] <- base::list(NULL)
[17:26:33.004]         }
[17:26:33.004]         base::close(...future.stdout)
[17:26:33.004]         ...future.stdout <- NULL
[17:26:33.004]     }
[17:26:33.004]     ...future.result$conditions <- ...future.conditions
[17:26:33.004]     ...future.result$finished <- base::Sys.time()
[17:26:33.004]     ...future.result
[17:26:33.004] }
[17:26:33.011] plan(): Setting new future strategy stack:
[17:26:33.011] List of future strategies:
[17:26:33.011] 1. sequential:
[17:26:33.011]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:33.011]    - tweaked: FALSE
[17:26:33.011]    - call: NULL
[17:26:33.012] plan(): nbrOfWorkers() = 1
[17:26:33.014] plan(): Setting new future strategy stack:
[17:26:33.015] List of future strategies:
[17:26:33.015] 1. sequential:
[17:26:33.015]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:33.015]    - tweaked: FALSE
[17:26:33.015]    - call: future::plan("sequential")
[17:26:33.016] plan(): nbrOfWorkers() = 1
[17:26:33.016] SequentialFuture started (and completed)
[17:26:33.017] signalConditions() ...
[17:26:33.017]  - include = 'immediateCondition'
[17:26:33.017]  - exclude = 
[17:26:33.017]  - resignal = FALSE
[17:26:33.018]  - Number of conditions: 1
[17:26:33.018] signalConditions() ... done
[17:26:33.018] - Launch lazy future ... done
[17:26:33.018] run() for 'SequentialFuture' ... done
> ll[[2]] <- future({ 42L; stop("Woops") })
[17:26:33.019] getGlobalsAndPackages() ...
[17:26:33.019] Searching for globals...
[17:26:33.021] - globals found: [2] '{', 'stop'
[17:26:33.021] Searching for globals ... DONE
[17:26:33.021] Resolving globals: FALSE
[17:26:33.024] 
[17:26:33.025] 
[17:26:33.025] getGlobalsAndPackages() ... DONE
[17:26:33.025] run() for 'Future' ...
[17:26:33.026] - state: 'created'
[17:26:33.026] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:33.027] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:33.027] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:33.027]   - Field: 'label'
[17:26:33.028]   - Field: 'local'
[17:26:33.028]   - Field: 'owner'
[17:26:33.028]   - Field: 'envir'
[17:26:33.028]   - Field: 'packages'
[17:26:33.029]   - Field: 'gc'
[17:26:33.029]   - Field: 'conditions'
[17:26:33.029]   - Field: 'expr'
[17:26:33.030]   - Field: 'uuid'
[17:26:33.030]   - Field: 'seed'
[17:26:33.030]   - Field: 'version'
[17:26:33.030]   - Field: 'result'
[17:26:33.031]   - Field: 'asynchronous'
[17:26:33.031]   - Field: 'calls'
[17:26:33.031]   - Field: 'globals'
[17:26:33.032]   - Field: 'stdout'
[17:26:33.032]   - Field: 'earlySignal'
[17:26:33.032]   - Field: 'lazy'
[17:26:33.033]   - Field: 'state'
[17:26:33.033] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:33.033] - Launch lazy future ...
[17:26:33.034] Packages needed by the future expression (n = 0): <none>
[17:26:33.034] Packages needed by future strategies (n = 0): <none>
[17:26:33.035] {
[17:26:33.035]     {
[17:26:33.035]         {
[17:26:33.035]             ...future.startTime <- base::Sys.time()
[17:26:33.035]             {
[17:26:33.035]                 {
[17:26:33.035]                   {
[17:26:33.035]                     base::local({
[17:26:33.035]                       has_future <- base::requireNamespace("future", 
[17:26:33.035]                         quietly = TRUE)
[17:26:33.035]                       if (has_future) {
[17:26:33.035]                         ns <- base::getNamespace("future")
[17:26:33.035]                         version <- ns[[".package"]][["version"]]
[17:26:33.035]                         if (is.null(version)) 
[17:26:33.035]                           version <- utils::packageVersion("future")
[17:26:33.035]                       }
[17:26:33.035]                       else {
[17:26:33.035]                         version <- NULL
[17:26:33.035]                       }
[17:26:33.035]                       if (!has_future || version < "1.8.0") {
[17:26:33.035]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:33.035]                           "", base::R.version$version.string), 
[17:26:33.035]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:33.035]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:33.035]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:33.035]                             "release", "version")], collapse = " "), 
[17:26:33.035]                           hostname = base::Sys.info()[["nodename"]])
[17:26:33.035]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:33.035]                           info)
[17:26:33.035]                         info <- base::paste(info, collapse = "; ")
[17:26:33.035]                         if (!has_future) {
[17:26:33.035]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:33.035]                             info)
[17:26:33.035]                         }
[17:26:33.035]                         else {
[17:26:33.035]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:33.035]                             info, version)
[17:26:33.035]                         }
[17:26:33.035]                         base::stop(msg)
[17:26:33.035]                       }
[17:26:33.035]                     })
[17:26:33.035]                   }
[17:26:33.035]                   ...future.strategy.old <- future::plan("list")
[17:26:33.035]                   options(future.plan = NULL)
[17:26:33.035]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:33.035]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:33.035]                 }
[17:26:33.035]                 ...future.workdir <- getwd()
[17:26:33.035]             }
[17:26:33.035]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:33.035]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:33.035]         }
[17:26:33.035]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:33.035]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:33.035]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:33.035]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:33.035]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:33.035]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:33.035]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:33.035]             base::names(...future.oldOptions))
[17:26:33.035]     }
[17:26:33.035]     if (FALSE) {
[17:26:33.035]     }
[17:26:33.035]     else {
[17:26:33.035]         if (TRUE) {
[17:26:33.035]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:33.035]                 open = "w")
[17:26:33.035]         }
[17:26:33.035]         else {
[17:26:33.035]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:33.035]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:33.035]         }
[17:26:33.035]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:33.035]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:33.035]             base::sink(type = "output", split = FALSE)
[17:26:33.035]             base::close(...future.stdout)
[17:26:33.035]         }, add = TRUE)
[17:26:33.035]     }
[17:26:33.035]     ...future.frame <- base::sys.nframe()
[17:26:33.035]     ...future.conditions <- base::list()
[17:26:33.035]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:33.035]     if (FALSE) {
[17:26:33.035]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:33.035]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:33.035]     }
[17:26:33.035]     ...future.result <- base::tryCatch({
[17:26:33.035]         base::withCallingHandlers({
[17:26:33.035]             ...future.value <- base::withVisible(base::local({
[17:26:33.035]                 42L
[17:26:33.035]                 stop("Woops")
[17:26:33.035]             }))
[17:26:33.035]             future::FutureResult(value = ...future.value$value, 
[17:26:33.035]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:33.035]                   ...future.rng), globalenv = if (FALSE) 
[17:26:33.035]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:33.035]                     ...future.globalenv.names))
[17:26:33.035]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:33.035]         }, condition = base::local({
[17:26:33.035]             c <- base::c
[17:26:33.035]             inherits <- base::inherits
[17:26:33.035]             invokeRestart <- base::invokeRestart
[17:26:33.035]             length <- base::length
[17:26:33.035]             list <- base::list
[17:26:33.035]             seq.int <- base::seq.int
[17:26:33.035]             signalCondition <- base::signalCondition
[17:26:33.035]             sys.calls <- base::sys.calls
[17:26:33.035]             `[[` <- base::`[[`
[17:26:33.035]             `+` <- base::`+`
[17:26:33.035]             `<<-` <- base::`<<-`
[17:26:33.035]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:33.035]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:33.035]                   3L)]
[17:26:33.035]             }
[17:26:33.035]             function(cond) {
[17:26:33.035]                 is_error <- inherits(cond, "error")
[17:26:33.035]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:33.035]                   NULL)
[17:26:33.035]                 if (is_error) {
[17:26:33.035]                   sessionInformation <- function() {
[17:26:33.035]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:33.035]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:33.035]                       search = base::search(), system = base::Sys.info())
[17:26:33.035]                   }
[17:26:33.035]                   ...future.conditions[[length(...future.conditions) + 
[17:26:33.035]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:33.035]                     cond$call), session = sessionInformation(), 
[17:26:33.035]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:33.035]                   signalCondition(cond)
[17:26:33.035]                 }
[17:26:33.035]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:33.035]                 "immediateCondition"))) {
[17:26:33.035]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:33.035]                   ...future.conditions[[length(...future.conditions) + 
[17:26:33.035]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:33.035]                   if (TRUE && !signal) {
[17:26:33.035]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:33.035]                     {
[17:26:33.035]                       inherits <- base::inherits
[17:26:33.035]                       invokeRestart <- base::invokeRestart
[17:26:33.035]                       is.null <- base::is.null
[17:26:33.035]                       muffled <- FALSE
[17:26:33.035]                       if (inherits(cond, "message")) {
[17:26:33.035]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:33.035]                         if (muffled) 
[17:26:33.035]                           invokeRestart("muffleMessage")
[17:26:33.035]                       }
[17:26:33.035]                       else if (inherits(cond, "warning")) {
[17:26:33.035]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:33.035]                         if (muffled) 
[17:26:33.035]                           invokeRestart("muffleWarning")
[17:26:33.035]                       }
[17:26:33.035]                       else if (inherits(cond, "condition")) {
[17:26:33.035]                         if (!is.null(pattern)) {
[17:26:33.035]                           computeRestarts <- base::computeRestarts
[17:26:33.035]                           grepl <- base::grepl
[17:26:33.035]                           restarts <- computeRestarts(cond)
[17:26:33.035]                           for (restart in restarts) {
[17:26:33.035]                             name <- restart$name
[17:26:33.035]                             if (is.null(name)) 
[17:26:33.035]                               next
[17:26:33.035]                             if (!grepl(pattern, name)) 
[17:26:33.035]                               next
[17:26:33.035]                             invokeRestart(restart)
[17:26:33.035]                             muffled <- TRUE
[17:26:33.035]                             break
[17:26:33.035]                           }
[17:26:33.035]                         }
[17:26:33.035]                       }
[17:26:33.035]                       invisible(muffled)
[17:26:33.035]                     }
[17:26:33.035]                     muffleCondition(cond, pattern = "^muffle")
[17:26:33.035]                   }
[17:26:33.035]                 }
[17:26:33.035]                 else {
[17:26:33.035]                   if (TRUE) {
[17:26:33.035]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:33.035]                     {
[17:26:33.035]                       inherits <- base::inherits
[17:26:33.035]                       invokeRestart <- base::invokeRestart
[17:26:33.035]                       is.null <- base::is.null
[17:26:33.035]                       muffled <- FALSE
[17:26:33.035]                       if (inherits(cond, "message")) {
[17:26:33.035]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:33.035]                         if (muffled) 
[17:26:33.035]                           invokeRestart("muffleMessage")
[17:26:33.035]                       }
[17:26:33.035]                       else if (inherits(cond, "warning")) {
[17:26:33.035]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:33.035]                         if (muffled) 
[17:26:33.035]                           invokeRestart("muffleWarning")
[17:26:33.035]                       }
[17:26:33.035]                       else if (inherits(cond, "condition")) {
[17:26:33.035]                         if (!is.null(pattern)) {
[17:26:33.035]                           computeRestarts <- base::computeRestarts
[17:26:33.035]                           grepl <- base::grepl
[17:26:33.035]                           restarts <- computeRestarts(cond)
[17:26:33.035]                           for (restart in restarts) {
[17:26:33.035]                             name <- restart$name
[17:26:33.035]                             if (is.null(name)) 
[17:26:33.035]                               next
[17:26:33.035]                             if (!grepl(pattern, name)) 
[17:26:33.035]                               next
[17:26:33.035]                             invokeRestart(restart)
[17:26:33.035]                             muffled <- TRUE
[17:26:33.035]                             break
[17:26:33.035]                           }
[17:26:33.035]                         }
[17:26:33.035]                       }
[17:26:33.035]                       invisible(muffled)
[17:26:33.035]                     }
[17:26:33.035]                     muffleCondition(cond, pattern = "^muffle")
[17:26:33.035]                   }
[17:26:33.035]                 }
[17:26:33.035]             }
[17:26:33.035]         }))
[17:26:33.035]     }, error = function(ex) {
[17:26:33.035]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:33.035]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:33.035]                 ...future.rng), started = ...future.startTime, 
[17:26:33.035]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:33.035]             version = "1.8"), class = "FutureResult")
[17:26:33.035]     }, finally = {
[17:26:33.035]         if (!identical(...future.workdir, getwd())) 
[17:26:33.035]             setwd(...future.workdir)
[17:26:33.035]         {
[17:26:33.035]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:33.035]                 ...future.oldOptions$nwarnings <- NULL
[17:26:33.035]             }
[17:26:33.035]             base::options(...future.oldOptions)
[17:26:33.035]             if (.Platform$OS.type == "windows") {
[17:26:33.035]                 old_names <- names(...future.oldEnvVars)
[17:26:33.035]                 envs <- base::Sys.getenv()
[17:26:33.035]                 names <- names(envs)
[17:26:33.035]                 common <- intersect(names, old_names)
[17:26:33.035]                 added <- setdiff(names, old_names)
[17:26:33.035]                 removed <- setdiff(old_names, names)
[17:26:33.035]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:33.035]                   envs[common]]
[17:26:33.035]                 NAMES <- toupper(changed)
[17:26:33.035]                 args <- list()
[17:26:33.035]                 for (kk in seq_along(NAMES)) {
[17:26:33.035]                   name <- changed[[kk]]
[17:26:33.035]                   NAME <- NAMES[[kk]]
[17:26:33.035]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:33.035]                     next
[17:26:33.035]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:33.035]                 }
[17:26:33.035]                 NAMES <- toupper(added)
[17:26:33.035]                 for (kk in seq_along(NAMES)) {
[17:26:33.035]                   name <- added[[kk]]
[17:26:33.035]                   NAME <- NAMES[[kk]]
[17:26:33.035]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:33.035]                     next
[17:26:33.035]                   args[[name]] <- ""
[17:26:33.035]                 }
[17:26:33.035]                 NAMES <- toupper(removed)
[17:26:33.035]                 for (kk in seq_along(NAMES)) {
[17:26:33.035]                   name <- removed[[kk]]
[17:26:33.035]                   NAME <- NAMES[[kk]]
[17:26:33.035]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:33.035]                     next
[17:26:33.035]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:33.035]                 }
[17:26:33.035]                 if (length(args) > 0) 
[17:26:33.035]                   base::do.call(base::Sys.setenv, args = args)
[17:26:33.035]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:33.035]             }
[17:26:33.035]             else {
[17:26:33.035]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:33.035]             }
[17:26:33.035]             {
[17:26:33.035]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:33.035]                   0L) {
[17:26:33.035]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:33.035]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:33.035]                   base::options(opts)
[17:26:33.035]                 }
[17:26:33.035]                 {
[17:26:33.035]                   {
[17:26:33.035]                     NULL
[17:26:33.035]                     RNGkind("Mersenne-Twister")
[17:26:33.035]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:33.035]                       inherits = FALSE)
[17:26:33.035]                   }
[17:26:33.035]                   options(future.plan = NULL)
[17:26:33.035]                   if (is.na(NA_character_)) 
[17:26:33.035]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:33.035]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:33.035]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:33.035]                     .init = FALSE)
[17:26:33.035]                 }
[17:26:33.035]             }
[17:26:33.035]         }
[17:26:33.035]     })
[17:26:33.035]     if (TRUE) {
[17:26:33.035]         base::sink(type = "output", split = FALSE)
[17:26:33.035]         if (TRUE) {
[17:26:33.035]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:33.035]         }
[17:26:33.035]         else {
[17:26:33.035]             ...future.result["stdout"] <- base::list(NULL)
[17:26:33.035]         }
[17:26:33.035]         base::close(...future.stdout)
[17:26:33.035]         ...future.stdout <- NULL
[17:26:33.035]     }
[17:26:33.035]     ...future.result$conditions <- ...future.conditions
[17:26:33.035]     ...future.result$finished <- base::Sys.time()
[17:26:33.035]     ...future.result
[17:26:33.035] }
[17:26:33.042] plan(): Setting new future strategy stack:
[17:26:33.042] List of future strategies:
[17:26:33.042] 1. sequential:
[17:26:33.042]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:33.042]    - tweaked: FALSE
[17:26:33.042]    - call: NULL
[17:26:33.043] plan(): nbrOfWorkers() = 1
[17:26:33.045] plan(): Setting new future strategy stack:
[17:26:33.045] List of future strategies:
[17:26:33.045] 1. sequential:
[17:26:33.045]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:33.045]    - tweaked: FALSE
[17:26:33.045]    - call: future::plan("sequential")
[17:26:33.046] plan(): nbrOfWorkers() = 1
[17:26:33.047] SequentialFuture started (and completed)
[17:26:33.047] signalConditions() ...
[17:26:33.047]  - include = 'immediateCondition'
[17:26:33.048]  - exclude = 
[17:26:33.048]  - resignal = FALSE
[17:26:33.048]  - Number of conditions: 1
[17:26:33.048] signalConditions() ... done
[17:26:33.049] - Launch lazy future ... done
[17:26:33.049] run() for 'SequentialFuture' ... done
> vs <- value(ll, signal = FALSE)
[17:26:33.050] resolve() on list ...
[17:26:33.050]  recursive: 0
[17:26:33.051]  length: 2
[17:26:33.051] 
[17:26:33.052] resolved() for 'SequentialFuture' ...
[17:26:33.052] - state: 'finished'
[17:26:33.052] - run: TRUE
[17:26:33.053] - result: 'FutureResult'
[17:26:33.053] resolved() for 'SequentialFuture' ... done
[17:26:33.053] Future #1
[17:26:33.054] signalConditions() ...
[17:26:33.054]  - include = 'immediateCondition'
[17:26:33.054]  - exclude = 
[17:26:33.055]  - resignal = FALSE
[17:26:33.055]  - Number of conditions: 1
[17:26:33.055] signalConditions() ... done
[17:26:33.056] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:26:33.056] - nx: 2
[17:26:33.056] - relay: TRUE
[17:26:33.056] - stdout: TRUE
[17:26:33.057] - signal: FALSE
[17:26:33.057] - resignal: FALSE
[17:26:33.057] - force: TRUE
[17:26:33.058] - relayed: [n=2] FALSE, FALSE
[17:26:33.058] - queued futures: [n=2] FALSE, FALSE
[17:26:33.058]  - until=1
[17:26:33.058]  - relaying element #1
[17:26:33.059] signalConditions() ...
[17:26:33.059]  - include = 'immediateCondition'
[17:26:33.059]  - exclude = 
[17:26:33.060]  - resignal = FALSE
[17:26:33.060]  - Number of conditions: 1
[17:26:33.060] signalConditions() ... done
[17:26:33.061] - relayed: [n=2] TRUE, FALSE
[17:26:33.061] - queued futures: [n=2] TRUE, FALSE
[17:26:33.061] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:26:33.062]  length: 1 (resolved future 1)
[17:26:33.062] resolved() for 'SequentialFuture' ...
[17:26:33.062] - state: 'finished'
[17:26:33.063] - run: TRUE
[17:26:33.063] - result: 'FutureResult'
[17:26:33.063] resolved() for 'SequentialFuture' ... done
[17:26:33.064] Future #2
[17:26:33.064] signalConditions() ...
[17:26:33.064]  - include = 'immediateCondition'
[17:26:33.065]  - exclude = 
[17:26:33.065]  - resignal = FALSE
[17:26:33.065]  - Number of conditions: 1
[17:26:33.066] signalConditions() ... done
[17:26:33.066] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:33.066] - nx: 2
[17:26:33.067] - relay: TRUE
[17:26:33.067] - stdout: TRUE
[17:26:33.067] - signal: FALSE
[17:26:33.067] - resignal: FALSE
[17:26:33.068] - force: TRUE
[17:26:33.068] - relayed: [n=2] TRUE, FALSE
[17:26:33.068] - queued futures: [n=2] TRUE, FALSE
[17:26:33.068]  - until=2
[17:26:33.069]  - relaying element #2
[17:26:33.069] signalConditions() ...
[17:26:33.069]  - include = 'immediateCondition'
[17:26:33.070]  - exclude = 
[17:26:33.070]  - resignal = FALSE
[17:26:33.070]  - Number of conditions: 1
[17:26:33.071] signalConditions() ... done
[17:26:33.071] - relayed: [n=2] TRUE, TRUE
[17:26:33.072] - queued futures: [n=2] TRUE, TRUE
[17:26:33.072] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:33.072]  length: 0 (resolved future 2)
[17:26:33.073] Relaying remaining futures
[17:26:33.073] signalConditionsASAP(NULL, pos=0) ...
[17:26:33.073] - nx: 2
[17:26:33.073] - relay: TRUE
[17:26:33.074] - stdout: TRUE
[17:26:33.074] - signal: FALSE
[17:26:33.074] - resignal: FALSE
[17:26:33.075] - force: TRUE
[17:26:33.075] - relayed: [n=2] TRUE, TRUE
[17:26:33.075] - queued futures: [n=2] TRUE, TRUE
 - flush all
[17:26:33.076] - relayed: [n=2] TRUE, TRUE
[17:26:33.076] - queued futures: [n=2] TRUE, TRUE
[17:26:33.076] signalConditionsASAP(NULL, pos=0) ... done
[17:26:33.077] resolve() on list ... DONE
[17:26:33.077] signalConditions() ...
[17:26:33.077]  - include = 'immediateCondition'
[17:26:33.078]  - exclude = 
[17:26:33.078]  - resignal = FALSE
[17:26:33.078]  - Number of conditions: 1
[17:26:33.078] signalConditions() ... done
[17:26:33.079] signalConditions() ...
[17:26:33.079]  - include = 'immediateCondition'
[17:26:33.079]  - exclude = 
[17:26:33.080]  - resignal = FALSE
[17:26:33.080]  - Number of conditions: 1
[17:26:33.080] signalConditions() ... done
> calls <- backtrace(ll[[2]])
[17:26:33.081] resolved() for 'SequentialFuture' ...
[17:26:33.081] - state: 'finished'
[17:26:33.082] - run: TRUE
[17:26:33.082] - result: 'FutureResult'
[17:26:33.082] resolved() for 'SequentialFuture' ... done
> print(calls)
[[1]]
future({
    42L
    stop("Woops")
})

[[2]]
Future(expr, substitute = FALSE, envir = envir, lazy = TRUE, 
    seed = seed, globals = globals, packages = packages, stdout = stdout, 
    conditions = conditions, earlySignal = earlySignal, label = label, 
    gc = gc, ...)

[[3]]
eval(quote({
    42L
    stop("Woops")
}), new.env())

[[4]]
stop("Woops")

[[5]]
eval(quote({
    42L
    stop("Woops")
}), new.env())

> stopifnot(is.list(calls))
> 
> message("*** backtrace( ) - subsetting ... DONE")
*** backtrace( ) - subsetting ... DONE
> 
> 
> message("*** backtrace( ) - exceptions ...")
*** backtrace( ) - exceptions ...
> 
> message("- No condition ...")
- No condition ...
> f <- future(42L)
[17:26:33.084] getGlobalsAndPackages() ...
[17:26:33.084] Searching for globals...
[17:26:33.085] 
[17:26:33.085] Searching for globals ... DONE
[17:26:33.085] - globals: [0] <none>
[17:26:33.086] getGlobalsAndPackages() ... DONE
[17:26:33.086] run() for 'Future' ...
[17:26:33.086] - state: 'created'
[17:26:33.087] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:33.087] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:33.088] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:33.088]   - Field: 'label'
[17:26:33.088]   - Field: 'local'
[17:26:33.089]   - Field: 'owner'
[17:26:33.089]   - Field: 'envir'
[17:26:33.089]   - Field: 'packages'
[17:26:33.090]   - Field: 'gc'
[17:26:33.090]   - Field: 'conditions'
[17:26:33.093]   - Field: 'expr'
[17:26:33.093]   - Field: 'uuid'
[17:26:33.094]   - Field: 'seed'
[17:26:33.094]   - Field: 'version'
[17:26:33.094]   - Field: 'result'
[17:26:33.094]   - Field: 'asynchronous'
[17:26:33.095]   - Field: 'calls'
[17:26:33.095]   - Field: 'globals'
[17:26:33.095]   - Field: 'stdout'
[17:26:33.096]   - Field: 'earlySignal'
[17:26:33.096]   - Field: 'lazy'
[17:26:33.096]   - Field: 'state'
[17:26:33.097] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:33.097] - Launch lazy future ...
[17:26:33.097] Packages needed by the future expression (n = 0): <none>
[17:26:33.098] Packages needed by future strategies (n = 0): <none>
[17:26:33.099] {
[17:26:33.099]     {
[17:26:33.099]         {
[17:26:33.099]             ...future.startTime <- base::Sys.time()
[17:26:33.099]             {
[17:26:33.099]                 {
[17:26:33.099]                   {
[17:26:33.099]                     base::local({
[17:26:33.099]                       has_future <- base::requireNamespace("future", 
[17:26:33.099]                         quietly = TRUE)
[17:26:33.099]                       if (has_future) {
[17:26:33.099]                         ns <- base::getNamespace("future")
[17:26:33.099]                         version <- ns[[".package"]][["version"]]
[17:26:33.099]                         if (is.null(version)) 
[17:26:33.099]                           version <- utils::packageVersion("future")
[17:26:33.099]                       }
[17:26:33.099]                       else {
[17:26:33.099]                         version <- NULL
[17:26:33.099]                       }
[17:26:33.099]                       if (!has_future || version < "1.8.0") {
[17:26:33.099]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:33.099]                           "", base::R.version$version.string), 
[17:26:33.099]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:33.099]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:33.099]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:33.099]                             "release", "version")], collapse = " "), 
[17:26:33.099]                           hostname = base::Sys.info()[["nodename"]])
[17:26:33.099]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:33.099]                           info)
[17:26:33.099]                         info <- base::paste(info, collapse = "; ")
[17:26:33.099]                         if (!has_future) {
[17:26:33.099]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:33.099]                             info)
[17:26:33.099]                         }
[17:26:33.099]                         else {
[17:26:33.099]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:33.099]                             info, version)
[17:26:33.099]                         }
[17:26:33.099]                         base::stop(msg)
[17:26:33.099]                       }
[17:26:33.099]                     })
[17:26:33.099]                   }
[17:26:33.099]                   ...future.strategy.old <- future::plan("list")
[17:26:33.099]                   options(future.plan = NULL)
[17:26:33.099]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:33.099]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:33.099]                 }
[17:26:33.099]                 ...future.workdir <- getwd()
[17:26:33.099]             }
[17:26:33.099]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:33.099]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:33.099]         }
[17:26:33.099]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:33.099]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:33.099]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:33.099]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:33.099]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:33.099]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:33.099]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:33.099]             base::names(...future.oldOptions))
[17:26:33.099]     }
[17:26:33.099]     if (FALSE) {
[17:26:33.099]     }
[17:26:33.099]     else {
[17:26:33.099]         if (TRUE) {
[17:26:33.099]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:33.099]                 open = "w")
[17:26:33.099]         }
[17:26:33.099]         else {
[17:26:33.099]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:33.099]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:33.099]         }
[17:26:33.099]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:33.099]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:33.099]             base::sink(type = "output", split = FALSE)
[17:26:33.099]             base::close(...future.stdout)
[17:26:33.099]         }, add = TRUE)
[17:26:33.099]     }
[17:26:33.099]     ...future.frame <- base::sys.nframe()
[17:26:33.099]     ...future.conditions <- base::list()
[17:26:33.099]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:33.099]     if (FALSE) {
[17:26:33.099]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:33.099]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:33.099]     }
[17:26:33.099]     ...future.result <- base::tryCatch({
[17:26:33.099]         base::withCallingHandlers({
[17:26:33.099]             ...future.value <- base::withVisible(base::local(42L))
[17:26:33.099]             future::FutureResult(value = ...future.value$value, 
[17:26:33.099]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:33.099]                   ...future.rng), globalenv = if (FALSE) 
[17:26:33.099]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:33.099]                     ...future.globalenv.names))
[17:26:33.099]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:33.099]         }, condition = base::local({
[17:26:33.099]             c <- base::c
[17:26:33.099]             inherits <- base::inherits
[17:26:33.099]             invokeRestart <- base::invokeRestart
[17:26:33.099]             length <- base::length
[17:26:33.099]             list <- base::list
[17:26:33.099]             seq.int <- base::seq.int
[17:26:33.099]             signalCondition <- base::signalCondition
[17:26:33.099]             sys.calls <- base::sys.calls
[17:26:33.099]             `[[` <- base::`[[`
[17:26:33.099]             `+` <- base::`+`
[17:26:33.099]             `<<-` <- base::`<<-`
[17:26:33.099]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:33.099]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:33.099]                   3L)]
[17:26:33.099]             }
[17:26:33.099]             function(cond) {
[17:26:33.099]                 is_error <- inherits(cond, "error")
[17:26:33.099]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:33.099]                   NULL)
[17:26:33.099]                 if (is_error) {
[17:26:33.099]                   sessionInformation <- function() {
[17:26:33.099]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:33.099]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:33.099]                       search = base::search(), system = base::Sys.info())
[17:26:33.099]                   }
[17:26:33.099]                   ...future.conditions[[length(...future.conditions) + 
[17:26:33.099]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:33.099]                     cond$call), session = sessionInformation(), 
[17:26:33.099]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:33.099]                   signalCondition(cond)
[17:26:33.099]                 }
[17:26:33.099]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:33.099]                 "immediateCondition"))) {
[17:26:33.099]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:33.099]                   ...future.conditions[[length(...future.conditions) + 
[17:26:33.099]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:33.099]                   if (TRUE && !signal) {
[17:26:33.099]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:33.099]                     {
[17:26:33.099]                       inherits <- base::inherits
[17:26:33.099]                       invokeRestart <- base::invokeRestart
[17:26:33.099]                       is.null <- base::is.null
[17:26:33.099]                       muffled <- FALSE
[17:26:33.099]                       if (inherits(cond, "message")) {
[17:26:33.099]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:33.099]                         if (muffled) 
[17:26:33.099]                           invokeRestart("muffleMessage")
[17:26:33.099]                       }
[17:26:33.099]                       else if (inherits(cond, "warning")) {
[17:26:33.099]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:33.099]                         if (muffled) 
[17:26:33.099]                           invokeRestart("muffleWarning")
[17:26:33.099]                       }
[17:26:33.099]                       else if (inherits(cond, "condition")) {
[17:26:33.099]                         if (!is.null(pattern)) {
[17:26:33.099]                           computeRestarts <- base::computeRestarts
[17:26:33.099]                           grepl <- base::grepl
[17:26:33.099]                           restarts <- computeRestarts(cond)
[17:26:33.099]                           for (restart in restarts) {
[17:26:33.099]                             name <- restart$name
[17:26:33.099]                             if (is.null(name)) 
[17:26:33.099]                               next
[17:26:33.099]                             if (!grepl(pattern, name)) 
[17:26:33.099]                               next
[17:26:33.099]                             invokeRestart(restart)
[17:26:33.099]                             muffled <- TRUE
[17:26:33.099]                             break
[17:26:33.099]                           }
[17:26:33.099]                         }
[17:26:33.099]                       }
[17:26:33.099]                       invisible(muffled)
[17:26:33.099]                     }
[17:26:33.099]                     muffleCondition(cond, pattern = "^muffle")
[17:26:33.099]                   }
[17:26:33.099]                 }
[17:26:33.099]                 else {
[17:26:33.099]                   if (TRUE) {
[17:26:33.099]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:33.099]                     {
[17:26:33.099]                       inherits <- base::inherits
[17:26:33.099]                       invokeRestart <- base::invokeRestart
[17:26:33.099]                       is.null <- base::is.null
[17:26:33.099]                       muffled <- FALSE
[17:26:33.099]                       if (inherits(cond, "message")) {
[17:26:33.099]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:33.099]                         if (muffled) 
[17:26:33.099]                           invokeRestart("muffleMessage")
[17:26:33.099]                       }
[17:26:33.099]                       else if (inherits(cond, "warning")) {
[17:26:33.099]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:33.099]                         if (muffled) 
[17:26:33.099]                           invokeRestart("muffleWarning")
[17:26:33.099]                       }
[17:26:33.099]                       else if (inherits(cond, "condition")) {
[17:26:33.099]                         if (!is.null(pattern)) {
[17:26:33.099]                           computeRestarts <- base::computeRestarts
[17:26:33.099]                           grepl <- base::grepl
[17:26:33.099]                           restarts <- computeRestarts(cond)
[17:26:33.099]                           for (restart in restarts) {
[17:26:33.099]                             name <- restart$name
[17:26:33.099]                             if (is.null(name)) 
[17:26:33.099]                               next
[17:26:33.099]                             if (!grepl(pattern, name)) 
[17:26:33.099]                               next
[17:26:33.099]                             invokeRestart(restart)
[17:26:33.099]                             muffled <- TRUE
[17:26:33.099]                             break
[17:26:33.099]                           }
[17:26:33.099]                         }
[17:26:33.099]                       }
[17:26:33.099]                       invisible(muffled)
[17:26:33.099]                     }
[17:26:33.099]                     muffleCondition(cond, pattern = "^muffle")
[17:26:33.099]                   }
[17:26:33.099]                 }
[17:26:33.099]             }
[17:26:33.099]         }))
[17:26:33.099]     }, error = function(ex) {
[17:26:33.099]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:33.099]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:33.099]                 ...future.rng), started = ...future.startTime, 
[17:26:33.099]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:33.099]             version = "1.8"), class = "FutureResult")
[17:26:33.099]     }, finally = {
[17:26:33.099]         if (!identical(...future.workdir, getwd())) 
[17:26:33.099]             setwd(...future.workdir)
[17:26:33.099]         {
[17:26:33.099]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:33.099]                 ...future.oldOptions$nwarnings <- NULL
[17:26:33.099]             }
[17:26:33.099]             base::options(...future.oldOptions)
[17:26:33.099]             if (.Platform$OS.type == "windows") {
[17:26:33.099]                 old_names <- names(...future.oldEnvVars)
[17:26:33.099]                 envs <- base::Sys.getenv()
[17:26:33.099]                 names <- names(envs)
[17:26:33.099]                 common <- intersect(names, old_names)
[17:26:33.099]                 added <- setdiff(names, old_names)
[17:26:33.099]                 removed <- setdiff(old_names, names)
[17:26:33.099]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:33.099]                   envs[common]]
[17:26:33.099]                 NAMES <- toupper(changed)
[17:26:33.099]                 args <- list()
[17:26:33.099]                 for (kk in seq_along(NAMES)) {
[17:26:33.099]                   name <- changed[[kk]]
[17:26:33.099]                   NAME <- NAMES[[kk]]
[17:26:33.099]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:33.099]                     next
[17:26:33.099]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:33.099]                 }
[17:26:33.099]                 NAMES <- toupper(added)
[17:26:33.099]                 for (kk in seq_along(NAMES)) {
[17:26:33.099]                   name <- added[[kk]]
[17:26:33.099]                   NAME <- NAMES[[kk]]
[17:26:33.099]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:33.099]                     next
[17:26:33.099]                   args[[name]] <- ""
[17:26:33.099]                 }
[17:26:33.099]                 NAMES <- toupper(removed)
[17:26:33.099]                 for (kk in seq_along(NAMES)) {
[17:26:33.099]                   name <- removed[[kk]]
[17:26:33.099]                   NAME <- NAMES[[kk]]
[17:26:33.099]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:33.099]                     next
[17:26:33.099]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:33.099]                 }
[17:26:33.099]                 if (length(args) > 0) 
[17:26:33.099]                   base::do.call(base::Sys.setenv, args = args)
[17:26:33.099]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:33.099]             }
[17:26:33.099]             else {
[17:26:33.099]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:33.099]             }
[17:26:33.099]             {
[17:26:33.099]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:33.099]                   0L) {
[17:26:33.099]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:33.099]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:33.099]                   base::options(opts)
[17:26:33.099]                 }
[17:26:33.099]                 {
[17:26:33.099]                   {
[17:26:33.099]                     NULL
[17:26:33.099]                     RNGkind("Mersenne-Twister")
[17:26:33.099]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:33.099]                       inherits = FALSE)
[17:26:33.099]                   }
[17:26:33.099]                   options(future.plan = NULL)
[17:26:33.099]                   if (is.na(NA_character_)) 
[17:26:33.099]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:33.099]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:33.099]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:33.099]                     .init = FALSE)
[17:26:33.099]                 }
[17:26:33.099]             }
[17:26:33.099]         }
[17:26:33.099]     })
[17:26:33.099]     if (TRUE) {
[17:26:33.099]         base::sink(type = "output", split = FALSE)
[17:26:33.099]         if (TRUE) {
[17:26:33.099]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:33.099]         }
[17:26:33.099]         else {
[17:26:33.099]             ...future.result["stdout"] <- base::list(NULL)
[17:26:33.099]         }
[17:26:33.099]         base::close(...future.stdout)
[17:26:33.099]         ...future.stdout <- NULL
[17:26:33.099]     }
[17:26:33.099]     ...future.result$conditions <- ...future.conditions
[17:26:33.099]     ...future.result$finished <- base::Sys.time()
[17:26:33.099]     ...future.result
[17:26:33.099] }
[17:26:33.105] plan(): Setting new future strategy stack:
[17:26:33.106] List of future strategies:
[17:26:33.106] 1. sequential:
[17:26:33.106]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:33.106]    - tweaked: FALSE
[17:26:33.106]    - call: NULL
[17:26:33.107] plan(): nbrOfWorkers() = 1
[17:26:33.109] plan(): Setting new future strategy stack:
[17:26:33.110] List of future strategies:
[17:26:33.110] 1. sequential:
[17:26:33.110]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:33.110]    - tweaked: FALSE
[17:26:33.110]    - call: future::plan("sequential")
[17:26:33.111] plan(): nbrOfWorkers() = 1
[17:26:33.111] SequentialFuture started (and completed)
[17:26:33.112] - Launch lazy future ... done
[17:26:33.112] run() for 'SequentialFuture' ... done
> res <- tryCatch(backtrace(f), error = identity)
[17:26:33.113] resolved() for 'SequentialFuture' ...
[17:26:33.113] - state: 'finished'
[17:26:33.114] - run: TRUE
[17:26:33.114] - result: 'FutureResult'
[17:26:33.114] resolved() for 'SequentialFuture' ... done
> print(res)
<simpleError: No error was caught for this future: 'f'>
> stopifnot(inherits(res, "error"))
> 
> message("- No call stack ...")
- No call stack ...
> f <- future({ 42L; stop("Woops") })
[17:26:33.115] getGlobalsAndPackages() ...
[17:26:33.116] Searching for globals...
[17:26:33.117] - globals found: [2] '{', 'stop'
[17:26:33.118] Searching for globals ... DONE
[17:26:33.118] Resolving globals: FALSE
[17:26:33.119] 
[17:26:33.119] 
[17:26:33.119] getGlobalsAndPackages() ... DONE
[17:26:33.120] run() for 'Future' ...
[17:26:33.120] - state: 'created'
[17:26:33.121] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:33.121] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:33.122] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:33.122]   - Field: 'label'
[17:26:33.122]   - Field: 'local'
[17:26:33.123]   - Field: 'owner'
[17:26:33.123]   - Field: 'envir'
[17:26:33.123]   - Field: 'packages'
[17:26:33.124]   - Field: 'gc'
[17:26:33.124]   - Field: 'conditions'
[17:26:33.124]   - Field: 'expr'
[17:26:33.124]   - Field: 'uuid'
[17:26:33.125]   - Field: 'seed'
[17:26:33.125]   - Field: 'version'
[17:26:33.125]   - Field: 'result'
[17:26:33.126]   - Field: 'asynchronous'
[17:26:33.126]   - Field: 'calls'
[17:26:33.126]   - Field: 'globals'
[17:26:33.127]   - Field: 'stdout'
[17:26:33.127]   - Field: 'earlySignal'
[17:26:33.127]   - Field: 'lazy'
[17:26:33.128]   - Field: 'state'
[17:26:33.128] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:33.128] - Launch lazy future ...
[17:26:33.129] Packages needed by the future expression (n = 0): <none>
[17:26:33.129] Packages needed by future strategies (n = 0): <none>
[17:26:33.130] {
[17:26:33.130]     {
[17:26:33.130]         {
[17:26:33.130]             ...future.startTime <- base::Sys.time()
[17:26:33.130]             {
[17:26:33.130]                 {
[17:26:33.130]                   {
[17:26:33.130]                     base::local({
[17:26:33.130]                       has_future <- base::requireNamespace("future", 
[17:26:33.130]                         quietly = TRUE)
[17:26:33.130]                       if (has_future) {
[17:26:33.130]                         ns <- base::getNamespace("future")
[17:26:33.130]                         version <- ns[[".package"]][["version"]]
[17:26:33.130]                         if (is.null(version)) 
[17:26:33.130]                           version <- utils::packageVersion("future")
[17:26:33.130]                       }
[17:26:33.130]                       else {
[17:26:33.130]                         version <- NULL
[17:26:33.130]                       }
[17:26:33.130]                       if (!has_future || version < "1.8.0") {
[17:26:33.130]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:33.130]                           "", base::R.version$version.string), 
[17:26:33.130]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:33.130]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:33.130]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:33.130]                             "release", "version")], collapse = " "), 
[17:26:33.130]                           hostname = base::Sys.info()[["nodename"]])
[17:26:33.130]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:33.130]                           info)
[17:26:33.130]                         info <- base::paste(info, collapse = "; ")
[17:26:33.130]                         if (!has_future) {
[17:26:33.130]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:33.130]                             info)
[17:26:33.130]                         }
[17:26:33.130]                         else {
[17:26:33.130]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:33.130]                             info, version)
[17:26:33.130]                         }
[17:26:33.130]                         base::stop(msg)
[17:26:33.130]                       }
[17:26:33.130]                     })
[17:26:33.130]                   }
[17:26:33.130]                   ...future.strategy.old <- future::plan("list")
[17:26:33.130]                   options(future.plan = NULL)
[17:26:33.130]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:33.130]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:33.130]                 }
[17:26:33.130]                 ...future.workdir <- getwd()
[17:26:33.130]             }
[17:26:33.130]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:33.130]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:33.130]         }
[17:26:33.130]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:33.130]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:33.130]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:33.130]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:33.130]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:33.130]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:33.130]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:33.130]             base::names(...future.oldOptions))
[17:26:33.130]     }
[17:26:33.130]     if (FALSE) {
[17:26:33.130]     }
[17:26:33.130]     else {
[17:26:33.130]         if (TRUE) {
[17:26:33.130]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:33.130]                 open = "w")
[17:26:33.130]         }
[17:26:33.130]         else {
[17:26:33.130]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:33.130]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:33.130]         }
[17:26:33.130]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:33.130]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:33.130]             base::sink(type = "output", split = FALSE)
[17:26:33.130]             base::close(...future.stdout)
[17:26:33.130]         }, add = TRUE)
[17:26:33.130]     }
[17:26:33.130]     ...future.frame <- base::sys.nframe()
[17:26:33.130]     ...future.conditions <- base::list()
[17:26:33.130]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:33.130]     if (FALSE) {
[17:26:33.130]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:33.130]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:33.130]     }
[17:26:33.130]     ...future.result <- base::tryCatch({
[17:26:33.130]         base::withCallingHandlers({
[17:26:33.130]             ...future.value <- base::withVisible(base::local({
[17:26:33.130]                 42L
[17:26:33.130]                 stop("Woops")
[17:26:33.130]             }))
[17:26:33.130]             future::FutureResult(value = ...future.value$value, 
[17:26:33.130]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:33.130]                   ...future.rng), globalenv = if (FALSE) 
[17:26:33.130]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:33.130]                     ...future.globalenv.names))
[17:26:33.130]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:33.130]         }, condition = base::local({
[17:26:33.130]             c <- base::c
[17:26:33.130]             inherits <- base::inherits
[17:26:33.130]             invokeRestart <- base::invokeRestart
[17:26:33.130]             length <- base::length
[17:26:33.130]             list <- base::list
[17:26:33.130]             seq.int <- base::seq.int
[17:26:33.130]             signalCondition <- base::signalCondition
[17:26:33.130]             sys.calls <- base::sys.calls
[17:26:33.130]             `[[` <- base::`[[`
[17:26:33.130]             `+` <- base::`+`
[17:26:33.130]             `<<-` <- base::`<<-`
[17:26:33.130]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:33.130]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:33.130]                   3L)]
[17:26:33.130]             }
[17:26:33.130]             function(cond) {
[17:26:33.130]                 is_error <- inherits(cond, "error")
[17:26:33.130]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:33.130]                   NULL)
[17:26:33.130]                 if (is_error) {
[17:26:33.130]                   sessionInformation <- function() {
[17:26:33.130]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:33.130]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:33.130]                       search = base::search(), system = base::Sys.info())
[17:26:33.130]                   }
[17:26:33.130]                   ...future.conditions[[length(...future.conditions) + 
[17:26:33.130]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:33.130]                     cond$call), session = sessionInformation(), 
[17:26:33.130]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:33.130]                   signalCondition(cond)
[17:26:33.130]                 }
[17:26:33.130]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:33.130]                 "immediateCondition"))) {
[17:26:33.130]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:33.130]                   ...future.conditions[[length(...future.conditions) + 
[17:26:33.130]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:33.130]                   if (TRUE && !signal) {
[17:26:33.130]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:33.130]                     {
[17:26:33.130]                       inherits <- base::inherits
[17:26:33.130]                       invokeRestart <- base::invokeRestart
[17:26:33.130]                       is.null <- base::is.null
[17:26:33.130]                       muffled <- FALSE
[17:26:33.130]                       if (inherits(cond, "message")) {
[17:26:33.130]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:33.130]                         if (muffled) 
[17:26:33.130]                           invokeRestart("muffleMessage")
[17:26:33.130]                       }
[17:26:33.130]                       else if (inherits(cond, "warning")) {
[17:26:33.130]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:33.130]                         if (muffled) 
[17:26:33.130]                           invokeRestart("muffleWarning")
[17:26:33.130]                       }
[17:26:33.130]                       else if (inherits(cond, "condition")) {
[17:26:33.130]                         if (!is.null(pattern)) {
[17:26:33.130]                           computeRestarts <- base::computeRestarts
[17:26:33.130]                           grepl <- base::grepl
[17:26:33.130]                           restarts <- computeRestarts(cond)
[17:26:33.130]                           for (restart in restarts) {
[17:26:33.130]                             name <- restart$name
[17:26:33.130]                             if (is.null(name)) 
[17:26:33.130]                               next
[17:26:33.130]                             if (!grepl(pattern, name)) 
[17:26:33.130]                               next
[17:26:33.130]                             invokeRestart(restart)
[17:26:33.130]                             muffled <- TRUE
[17:26:33.130]                             break
[17:26:33.130]                           }
[17:26:33.130]                         }
[17:26:33.130]                       }
[17:26:33.130]                       invisible(muffled)
[17:26:33.130]                     }
[17:26:33.130]                     muffleCondition(cond, pattern = "^muffle")
[17:26:33.130]                   }
[17:26:33.130]                 }
[17:26:33.130]                 else {
[17:26:33.130]                   if (TRUE) {
[17:26:33.130]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:33.130]                     {
[17:26:33.130]                       inherits <- base::inherits
[17:26:33.130]                       invokeRestart <- base::invokeRestart
[17:26:33.130]                       is.null <- base::is.null
[17:26:33.130]                       muffled <- FALSE
[17:26:33.130]                       if (inherits(cond, "message")) {
[17:26:33.130]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:33.130]                         if (muffled) 
[17:26:33.130]                           invokeRestart("muffleMessage")
[17:26:33.130]                       }
[17:26:33.130]                       else if (inherits(cond, "warning")) {
[17:26:33.130]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:33.130]                         if (muffled) 
[17:26:33.130]                           invokeRestart("muffleWarning")
[17:26:33.130]                       }
[17:26:33.130]                       else if (inherits(cond, "condition")) {
[17:26:33.130]                         if (!is.null(pattern)) {
[17:26:33.130]                           computeRestarts <- base::computeRestarts
[17:26:33.130]                           grepl <- base::grepl
[17:26:33.130]                           restarts <- computeRestarts(cond)
[17:26:33.130]                           for (restart in restarts) {
[17:26:33.130]                             name <- restart$name
[17:26:33.130]                             if (is.null(name)) 
[17:26:33.130]                               next
[17:26:33.130]                             if (!grepl(pattern, name)) 
[17:26:33.130]                               next
[17:26:33.130]                             invokeRestart(restart)
[17:26:33.130]                             muffled <- TRUE
[17:26:33.130]                             break
[17:26:33.130]                           }
[17:26:33.130]                         }
[17:26:33.130]                       }
[17:26:33.130]                       invisible(muffled)
[17:26:33.130]                     }
[17:26:33.130]                     muffleCondition(cond, pattern = "^muffle")
[17:26:33.130]                   }
[17:26:33.130]                 }
[17:26:33.130]             }
[17:26:33.130]         }))
[17:26:33.130]     }, error = function(ex) {
[17:26:33.130]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:33.130]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:33.130]                 ...future.rng), started = ...future.startTime, 
[17:26:33.130]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:33.130]             version = "1.8"), class = "FutureResult")
[17:26:33.130]     }, finally = {
[17:26:33.130]         if (!identical(...future.workdir, getwd())) 
[17:26:33.130]             setwd(...future.workdir)
[17:26:33.130]         {
[17:26:33.130]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:33.130]                 ...future.oldOptions$nwarnings <- NULL
[17:26:33.130]             }
[17:26:33.130]             base::options(...future.oldOptions)
[17:26:33.130]             if (.Platform$OS.type == "windows") {
[17:26:33.130]                 old_names <- names(...future.oldEnvVars)
[17:26:33.130]                 envs <- base::Sys.getenv()
[17:26:33.130]                 names <- names(envs)
[17:26:33.130]                 common <- intersect(names, old_names)
[17:26:33.130]                 added <- setdiff(names, old_names)
[17:26:33.130]                 removed <- setdiff(old_names, names)
[17:26:33.130]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:33.130]                   envs[common]]
[17:26:33.130]                 NAMES <- toupper(changed)
[17:26:33.130]                 args <- list()
[17:26:33.130]                 for (kk in seq_along(NAMES)) {
[17:26:33.130]                   name <- changed[[kk]]
[17:26:33.130]                   NAME <- NAMES[[kk]]
[17:26:33.130]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:33.130]                     next
[17:26:33.130]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:33.130]                 }
[17:26:33.130]                 NAMES <- toupper(added)
[17:26:33.130]                 for (kk in seq_along(NAMES)) {
[17:26:33.130]                   name <- added[[kk]]
[17:26:33.130]                   NAME <- NAMES[[kk]]
[17:26:33.130]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:33.130]                     next
[17:26:33.130]                   args[[name]] <- ""
[17:26:33.130]                 }
[17:26:33.130]                 NAMES <- toupper(removed)
[17:26:33.130]                 for (kk in seq_along(NAMES)) {
[17:26:33.130]                   name <- removed[[kk]]
[17:26:33.130]                   NAME <- NAMES[[kk]]
[17:26:33.130]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:33.130]                     next
[17:26:33.130]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:33.130]                 }
[17:26:33.130]                 if (length(args) > 0) 
[17:26:33.130]                   base::do.call(base::Sys.setenv, args = args)
[17:26:33.130]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:33.130]             }
[17:26:33.130]             else {
[17:26:33.130]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:33.130]             }
[17:26:33.130]             {
[17:26:33.130]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:33.130]                   0L) {
[17:26:33.130]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:33.130]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:33.130]                   base::options(opts)
[17:26:33.130]                 }
[17:26:33.130]                 {
[17:26:33.130]                   {
[17:26:33.130]                     NULL
[17:26:33.130]                     RNGkind("Mersenne-Twister")
[17:26:33.130]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:33.130]                       inherits = FALSE)
[17:26:33.130]                   }
[17:26:33.130]                   options(future.plan = NULL)
[17:26:33.130]                   if (is.na(NA_character_)) 
[17:26:33.130]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:33.130]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:33.130]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:33.130]                     .init = FALSE)
[17:26:33.130]                 }
[17:26:33.130]             }
[17:26:33.130]         }
[17:26:33.130]     })
[17:26:33.130]     if (TRUE) {
[17:26:33.130]         base::sink(type = "output", split = FALSE)
[17:26:33.130]         if (TRUE) {
[17:26:33.130]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:33.130]         }
[17:26:33.130]         else {
[17:26:33.130]             ...future.result["stdout"] <- base::list(NULL)
[17:26:33.130]         }
[17:26:33.130]         base::close(...future.stdout)
[17:26:33.130]         ...future.stdout <- NULL
[17:26:33.130]     }
[17:26:33.130]     ...future.result$conditions <- ...future.conditions
[17:26:33.130]     ...future.result$finished <- base::Sys.time()
[17:26:33.130]     ...future.result
[17:26:33.130] }
[17:26:33.137] plan(): Setting new future strategy stack:
[17:26:33.137] List of future strategies:
[17:26:33.137] 1. sequential:
[17:26:33.137]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:33.137]    - tweaked: FALSE
[17:26:33.137]    - call: NULL
[17:26:33.138] plan(): nbrOfWorkers() = 1
[17:26:33.141] plan(): Setting new future strategy stack:
[17:26:33.141] List of future strategies:
[17:26:33.141] 1. sequential:
[17:26:33.141]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:33.141]    - tweaked: FALSE
[17:26:33.141]    - call: future::plan("sequential")
[17:26:33.142] plan(): nbrOfWorkers() = 1
[17:26:33.142] SequentialFuture started (and completed)
[17:26:33.143] signalConditions() ...
[17:26:33.143]  - include = 'immediateCondition'
[17:26:33.143]  - exclude = 
[17:26:33.144]  - resignal = FALSE
[17:26:33.144]  - Number of conditions: 1
[17:26:33.144] signalConditions() ... done
[17:26:33.144] - Launch lazy future ... done
[17:26:33.145] run() for 'SequentialFuture' ... done
> v <- value(f, signal = FALSE)
[17:26:33.145] signalConditions() ...
[17:26:33.145]  - include = 'immediateCondition'
[17:26:33.146]  - exclude = 
[17:26:33.146]  - resignal = FALSE
[17:26:33.146]  - Number of conditions: 1
[17:26:33.147] signalConditions() ... done
> 
> if (availableCores() >= 2L) {
+   message("- Non-resolved future ...")
+   plan(multisession, workers = 2L)
+   f <- future({ Sys.sleep(3); 42L; stop("Woops") })
+   res <- tryCatch(backtrace(f), error = identity)
+   print(res)
+   stopifnot(inherits(res, "error"))
+   
+   ## If we don't resolve the future, the cluster of workers will not
+   ## be able to shut down naturally. They will eventually time out,
+   ## but that will happen long after 'R CMD check' terminates. Because
+   ## of this, 'R CMD check --as-cran' will report on "detritus in the
+   ## temp directory" when running on MS Windows.  This happens because
+   ## MS Windows doesn't shut down child processes as Linux and macOS
+   ## does when the main R session terminates.
+   resolve(f)
+ }
- Non-resolved future ...
[17:26:33.155] plan(): Setting new future strategy stack:
[17:26:33.155] List of future strategies:
[17:26:33.155] 1. multisession:
[17:26:33.155]    - args: function (..., workers = 2L, envir = parent.frame())
[17:26:33.155]    - tweaked: TRUE
[17:26:33.155]    - call: plan(multisession, workers = 2L)
[17:26:33.181] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:26:33.182] multisession:
[17:26:33.182] - args: function (..., workers = 2L, envir = parent.frame())
[17:26:33.182] - tweaked: TRUE
[17:26:33.182] - call: plan(multisession, workers = 2L)
[17:26:33.183] getGlobalsAndPackages() ...
[17:26:33.183] Not searching for globals
[17:26:33.184] - globals: [0] <none>
[17:26:33.184] getGlobalsAndPackages() ... DONE
[17:26:33.185] [local output] makeClusterPSOCK() ...
[17:26:33.245] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:26:33.254] [local output] Base port: 31743
[17:26:33.254] [local output] Getting setup options for 2 cluster nodes ...
[17:26:33.254] [local output]  - Node #1 of 2 ...
[17:26:33.256] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:33.258] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpI7ZIik/worker.rank=1.parallelly.parent=159976.270e84b4b1f39.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpI7ZIik/worker.rank=1.parallelly.parent=159976.270e84b4b1f39.pid\")"'
[17:26:33.704] - Possible to infer worker's PID: TRUE
[17:26:33.705] [local output] Rscript port: 31743

[17:26:33.706] [local output]  - Node #2 of 2 ...
[17:26:33.707] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:33.709] [local output] Rscript port: 31743

[17:26:33.709] [local output] Getting setup options for 2 cluster nodes ... done
[17:26:33.710] [local output]  - Parallel setup requested for some PSOCK nodes
[17:26:33.711] [local output] Setting up PSOCK nodes in parallel
[17:26:33.711] List of 36
[17:26:33.711]  $ worker          : chr "localhost"
[17:26:33.711]   ..- attr(*, "localhost")= logi TRUE
[17:26:33.711]  $ master          : chr "localhost"
[17:26:33.711]  $ port            : int 31743
[17:26:33.711]  $ connectTimeout  : num 120
[17:26:33.711]  $ timeout         : num 120
[17:26:33.711]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:26:33.711]  $ homogeneous     : logi TRUE
[17:26:33.711]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=backtrace.R:159976:CRANWIN3:CRAN"| __truncated__
[17:26:33.711]  $ rscript_envs    : NULL
[17:26:33.711]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:26:33.711]  $ rscript_startup : NULL
[17:26:33.711]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:26:33.711]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:33.711]  $ methods         : logi TRUE
[17:26:33.711]  $ socketOptions   : chr "no-delay"
[17:26:33.711]  $ useXDR          : logi FALSE
[17:26:33.711]  $ outfile         : chr "/dev/null"
[17:26:33.711]  $ renice          : int NA
[17:26:33.711]  $ rshcmd          : NULL
[17:26:33.711]  $ user            : chr(0) 
[17:26:33.711]  $ revtunnel       : logi FALSE
[17:26:33.711]  $ rshlogfile      : NULL
[17:26:33.711]  $ rshopts         : chr(0) 
[17:26:33.711]  $ rank            : int 1
[17:26:33.711]  $ manual          : logi FALSE
[17:26:33.711]  $ dryrun          : logi FALSE
[17:26:33.711]  $ quiet           : logi FALSE
[17:26:33.711]  $ setup_strategy  : chr "parallel"
[17:26:33.711]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:33.711]  $ pidfile         : chr "D:/temp/RtmpI7ZIik/worker.rank=1.parallelly.parent=159976.270e84b4b1f39.pid"
[17:26:33.711]  $ rshcmd_label    : NULL
[17:26:33.711]  $ rsh_call        : NULL
[17:26:33.711]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:33.711]  $ localMachine    : logi TRUE
[17:26:33.711]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:26:33.711]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:26:33.711]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:26:33.711]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:26:33.711]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:26:33.711]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:26:33.711]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:26:33.711]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:26:33.711]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:26:33.711]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:26:33.711]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:26:33.711]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:26:33.711]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:26:33.711]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:26:33.711]  $ arguments       :List of 28
[17:26:33.711]   ..$ worker          : chr "localhost"
[17:26:33.711]   ..$ master          : NULL
[17:26:33.711]   ..$ port            : int 31743
[17:26:33.711]   ..$ connectTimeout  : num 120
[17:26:33.711]   ..$ timeout         : num 120
[17:26:33.711]   ..$ rscript         : NULL
[17:26:33.711]   ..$ homogeneous     : NULL
[17:26:33.711]   ..$ rscript_args    : NULL
[17:26:33.711]   ..$ rscript_envs    : NULL
[17:26:33.711]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:26:33.711]   ..$ rscript_startup : NULL
[17:26:33.711]   ..$ rscript_sh      : chr "auto"
[17:26:33.711]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:33.711]   ..$ methods         : logi TRUE
[17:26:33.711]   ..$ socketOptions   : chr "no-delay"
[17:26:33.711]   ..$ useXDR          : logi FALSE
[17:26:33.711]   ..$ outfile         : chr "/dev/null"
[17:26:33.711]   ..$ renice          : int NA
[17:26:33.711]   ..$ rshcmd          : NULL
[17:26:33.711]   ..$ user            : NULL
[17:26:33.711]   ..$ revtunnel       : logi NA
[17:26:33.711]   ..$ rshlogfile      : NULL
[17:26:33.711]   ..$ rshopts         : NULL
[17:26:33.711]   ..$ rank            : int 1
[17:26:33.711]   ..$ manual          : logi FALSE
[17:26:33.711]   ..$ dryrun          : logi FALSE
[17:26:33.711]   ..$ quiet           : logi FALSE
[17:26:33.711]   ..$ setup_strategy  : chr "parallel"
[17:26:33.711]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:26:33.752] [local output] System call to launch all workers:
[17:26:33.752] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=backtrace.R:159976:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpI7ZIik/worker.rank=1.parallelly.parent=159976.270e84b4b1f39.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=31743 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:26:33.753] [local output] Starting PSOCK main server
[17:26:33.761] [local output] Workers launched
[17:26:33.761] [local output] Waiting for workers to connect back
[17:26:33.761]  - [local output] 0 workers out of 2 ready
[17:26:34.015]  - [local output] 0 workers out of 2 ready
[17:26:34.016]  - [local output] 1 workers out of 2 ready
[17:26:34.030]  - [local output] 1 workers out of 2 ready
[17:26:34.030]  - [local output] 2 workers out of 2 ready
[17:26:34.031] [local output] Launching of 2 workers completed
[17:26:34.031] [local output] Number of nodes in cluster: 2
[17:26:34.031] [local output] Collecting session information from 2 workers
[17:26:34.033] [local output]  - Worker #1 of 2
[17:26:34.035] [local output]  - Worker #2 of 2
[17:26:34.036] [local output] makeClusterPSOCK() ... done
[17:26:34.057] Packages needed by the future expression (n = 0): <none>
[17:26:34.058] Packages needed by future strategies (n = 0): <none>
[17:26:34.059] {
[17:26:34.059]     {
[17:26:34.059]         {
[17:26:34.059]             ...future.startTime <- base::Sys.time()
[17:26:34.059]             {
[17:26:34.059]                 {
[17:26:34.059]                   {
[17:26:34.059]                     {
[17:26:34.059]                       base::local({
[17:26:34.059]                         has_future <- base::requireNamespace("future", 
[17:26:34.059]                           quietly = TRUE)
[17:26:34.059]                         if (has_future) {
[17:26:34.059]                           ns <- base::getNamespace("future")
[17:26:34.059]                           version <- ns[[".package"]][["version"]]
[17:26:34.059]                           if (is.null(version)) 
[17:26:34.059]                             version <- utils::packageVersion("future")
[17:26:34.059]                         }
[17:26:34.059]                         else {
[17:26:34.059]                           version <- NULL
[17:26:34.059]                         }
[17:26:34.059]                         if (!has_future || version < "1.8.0") {
[17:26:34.059]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.059]                             "", base::R.version$version.string), 
[17:26:34.059]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:34.059]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.059]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.059]                               "release", "version")], collapse = " "), 
[17:26:34.059]                             hostname = base::Sys.info()[["nodename"]])
[17:26:34.059]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.059]                             info)
[17:26:34.059]                           info <- base::paste(info, collapse = "; ")
[17:26:34.059]                           if (!has_future) {
[17:26:34.059]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.059]                               info)
[17:26:34.059]                           }
[17:26:34.059]                           else {
[17:26:34.059]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.059]                               info, version)
[17:26:34.059]                           }
[17:26:34.059]                           base::stop(msg)
[17:26:34.059]                         }
[17:26:34.059]                       })
[17:26:34.059]                     }
[17:26:34.059]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:34.059]                     base::options(mc.cores = 1L)
[17:26:34.059]                   }
[17:26:34.059]                   ...future.strategy.old <- future::plan("list")
[17:26:34.059]                   options(future.plan = NULL)
[17:26:34.059]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.059]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.059]                 }
[17:26:34.059]                 ...future.workdir <- getwd()
[17:26:34.059]             }
[17:26:34.059]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.059]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.059]         }
[17:26:34.059]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.059]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.059]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.059]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.059]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.059]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.059]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.059]             base::names(...future.oldOptions))
[17:26:34.059]     }
[17:26:34.059]     if (FALSE) {
[17:26:34.059]     }
[17:26:34.059]     else {
[17:26:34.059]         if (TRUE) {
[17:26:34.059]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.059]                 open = "w")
[17:26:34.059]         }
[17:26:34.059]         else {
[17:26:34.059]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.059]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.059]         }
[17:26:34.059]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.059]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.059]             base::sink(type = "output", split = FALSE)
[17:26:34.059]             base::close(...future.stdout)
[17:26:34.059]         }, add = TRUE)
[17:26:34.059]     }
[17:26:34.059]     ...future.frame <- base::sys.nframe()
[17:26:34.059]     ...future.conditions <- base::list()
[17:26:34.059]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.059]     if (FALSE) {
[17:26:34.059]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.059]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.059]     }
[17:26:34.059]     ...future.result <- base::tryCatch({
[17:26:34.059]         base::withCallingHandlers({
[17:26:34.059]             ...future.value <- base::withVisible(base::local({
[17:26:34.059]                 ...future.makeSendCondition <- base::local({
[17:26:34.059]                   sendCondition <- NULL
[17:26:34.059]                   function(frame = 1L) {
[17:26:34.059]                     if (is.function(sendCondition)) 
[17:26:34.059]                       return(sendCondition)
[17:26:34.059]                     ns <- getNamespace("parallel")
[17:26:34.059]                     if (exists("sendData", mode = "function", 
[17:26:34.059]                       envir = ns)) {
[17:26:34.059]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:34.059]                         envir = ns)
[17:26:34.059]                       envir <- sys.frame(frame)
[17:26:34.059]                       master <- NULL
[17:26:34.059]                       while (!identical(envir, .GlobalEnv) && 
[17:26:34.059]                         !identical(envir, emptyenv())) {
[17:26:34.059]                         if (exists("master", mode = "list", envir = envir, 
[17:26:34.059]                           inherits = FALSE)) {
[17:26:34.059]                           master <- get("master", mode = "list", 
[17:26:34.059]                             envir = envir, inherits = FALSE)
[17:26:34.059]                           if (inherits(master, c("SOCKnode", 
[17:26:34.059]                             "SOCK0node"))) {
[17:26:34.059]                             sendCondition <<- function(cond) {
[17:26:34.059]                               data <- list(type = "VALUE", value = cond, 
[17:26:34.059]                                 success = TRUE)
[17:26:34.059]                               parallel_sendData(master, data)
[17:26:34.059]                             }
[17:26:34.059]                             return(sendCondition)
[17:26:34.059]                           }
[17:26:34.059]                         }
[17:26:34.059]                         frame <- frame + 1L
[17:26:34.059]                         envir <- sys.frame(frame)
[17:26:34.059]                       }
[17:26:34.059]                     }
[17:26:34.059]                     sendCondition <<- function(cond) NULL
[17:26:34.059]                   }
[17:26:34.059]                 })
[17:26:34.059]                 withCallingHandlers({
[17:26:34.059]                   NA
[17:26:34.059]                 }, immediateCondition = function(cond) {
[17:26:34.059]                   sendCondition <- ...future.makeSendCondition()
[17:26:34.059]                   sendCondition(cond)
[17:26:34.059]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.059]                   {
[17:26:34.059]                     inherits <- base::inherits
[17:26:34.059]                     invokeRestart <- base::invokeRestart
[17:26:34.059]                     is.null <- base::is.null
[17:26:34.059]                     muffled <- FALSE
[17:26:34.059]                     if (inherits(cond, "message")) {
[17:26:34.059]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:34.059]                       if (muffled) 
[17:26:34.059]                         invokeRestart("muffleMessage")
[17:26:34.059]                     }
[17:26:34.059]                     else if (inherits(cond, "warning")) {
[17:26:34.059]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:34.059]                       if (muffled) 
[17:26:34.059]                         invokeRestart("muffleWarning")
[17:26:34.059]                     }
[17:26:34.059]                     else if (inherits(cond, "condition")) {
[17:26:34.059]                       if (!is.null(pattern)) {
[17:26:34.059]                         computeRestarts <- base::computeRestarts
[17:26:34.059]                         grepl <- base::grepl
[17:26:34.059]                         restarts <- computeRestarts(cond)
[17:26:34.059]                         for (restart in restarts) {
[17:26:34.059]                           name <- restart$name
[17:26:34.059]                           if (is.null(name)) 
[17:26:34.059]                             next
[17:26:34.059]                           if (!grepl(pattern, name)) 
[17:26:34.059]                             next
[17:26:34.059]                           invokeRestart(restart)
[17:26:34.059]                           muffled <- TRUE
[17:26:34.059]                           break
[17:26:34.059]                         }
[17:26:34.059]                       }
[17:26:34.059]                     }
[17:26:34.059]                     invisible(muffled)
[17:26:34.059]                   }
[17:26:34.059]                   muffleCondition(cond)
[17:26:34.059]                 })
[17:26:34.059]             }))
[17:26:34.059]             future::FutureResult(value = ...future.value$value, 
[17:26:34.059]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.059]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.059]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.059]                     ...future.globalenv.names))
[17:26:34.059]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.059]         }, condition = base::local({
[17:26:34.059]             c <- base::c
[17:26:34.059]             inherits <- base::inherits
[17:26:34.059]             invokeRestart <- base::invokeRestart
[17:26:34.059]             length <- base::length
[17:26:34.059]             list <- base::list
[17:26:34.059]             seq.int <- base::seq.int
[17:26:34.059]             signalCondition <- base::signalCondition
[17:26:34.059]             sys.calls <- base::sys.calls
[17:26:34.059]             `[[` <- base::`[[`
[17:26:34.059]             `+` <- base::`+`
[17:26:34.059]             `<<-` <- base::`<<-`
[17:26:34.059]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.059]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.059]                   3L)]
[17:26:34.059]             }
[17:26:34.059]             function(cond) {
[17:26:34.059]                 is_error <- inherits(cond, "error")
[17:26:34.059]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.059]                   NULL)
[17:26:34.059]                 if (is_error) {
[17:26:34.059]                   sessionInformation <- function() {
[17:26:34.059]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.059]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.059]                       search = base::search(), system = base::Sys.info())
[17:26:34.059]                   }
[17:26:34.059]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.059]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.059]                     cond$call), session = sessionInformation(), 
[17:26:34.059]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.059]                   signalCondition(cond)
[17:26:34.059]                 }
[17:26:34.059]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.059]                 "immediateCondition"))) {
[17:26:34.059]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.059]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.059]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.059]                   if (TRUE && !signal) {
[17:26:34.059]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.059]                     {
[17:26:34.059]                       inherits <- base::inherits
[17:26:34.059]                       invokeRestart <- base::invokeRestart
[17:26:34.059]                       is.null <- base::is.null
[17:26:34.059]                       muffled <- FALSE
[17:26:34.059]                       if (inherits(cond, "message")) {
[17:26:34.059]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.059]                         if (muffled) 
[17:26:34.059]                           invokeRestart("muffleMessage")
[17:26:34.059]                       }
[17:26:34.059]                       else if (inherits(cond, "warning")) {
[17:26:34.059]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.059]                         if (muffled) 
[17:26:34.059]                           invokeRestart("muffleWarning")
[17:26:34.059]                       }
[17:26:34.059]                       else if (inherits(cond, "condition")) {
[17:26:34.059]                         if (!is.null(pattern)) {
[17:26:34.059]                           computeRestarts <- base::computeRestarts
[17:26:34.059]                           grepl <- base::grepl
[17:26:34.059]                           restarts <- computeRestarts(cond)
[17:26:34.059]                           for (restart in restarts) {
[17:26:34.059]                             name <- restart$name
[17:26:34.059]                             if (is.null(name)) 
[17:26:34.059]                               next
[17:26:34.059]                             if (!grepl(pattern, name)) 
[17:26:34.059]                               next
[17:26:34.059]                             invokeRestart(restart)
[17:26:34.059]                             muffled <- TRUE
[17:26:34.059]                             break
[17:26:34.059]                           }
[17:26:34.059]                         }
[17:26:34.059]                       }
[17:26:34.059]                       invisible(muffled)
[17:26:34.059]                     }
[17:26:34.059]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.059]                   }
[17:26:34.059]                 }
[17:26:34.059]                 else {
[17:26:34.059]                   if (TRUE) {
[17:26:34.059]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.059]                     {
[17:26:34.059]                       inherits <- base::inherits
[17:26:34.059]                       invokeRestart <- base::invokeRestart
[17:26:34.059]                       is.null <- base::is.null
[17:26:34.059]                       muffled <- FALSE
[17:26:34.059]                       if (inherits(cond, "message")) {
[17:26:34.059]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.059]                         if (muffled) 
[17:26:34.059]                           invokeRestart("muffleMessage")
[17:26:34.059]                       }
[17:26:34.059]                       else if (inherits(cond, "warning")) {
[17:26:34.059]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.059]                         if (muffled) 
[17:26:34.059]                           invokeRestart("muffleWarning")
[17:26:34.059]                       }
[17:26:34.059]                       else if (inherits(cond, "condition")) {
[17:26:34.059]                         if (!is.null(pattern)) {
[17:26:34.059]                           computeRestarts <- base::computeRestarts
[17:26:34.059]                           grepl <- base::grepl
[17:26:34.059]                           restarts <- computeRestarts(cond)
[17:26:34.059]                           for (restart in restarts) {
[17:26:34.059]                             name <- restart$name
[17:26:34.059]                             if (is.null(name)) 
[17:26:34.059]                               next
[17:26:34.059]                             if (!grepl(pattern, name)) 
[17:26:34.059]                               next
[17:26:34.059]                             invokeRestart(restart)
[17:26:34.059]                             muffled <- TRUE
[17:26:34.059]                             break
[17:26:34.059]                           }
[17:26:34.059]                         }
[17:26:34.059]                       }
[17:26:34.059]                       invisible(muffled)
[17:26:34.059]                     }
[17:26:34.059]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.059]                   }
[17:26:34.059]                 }
[17:26:34.059]             }
[17:26:34.059]         }))
[17:26:34.059]     }, error = function(ex) {
[17:26:34.059]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.059]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.059]                 ...future.rng), started = ...future.startTime, 
[17:26:34.059]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.059]             version = "1.8"), class = "FutureResult")
[17:26:34.059]     }, finally = {
[17:26:34.059]         if (!identical(...future.workdir, getwd())) 
[17:26:34.059]             setwd(...future.workdir)
[17:26:34.059]         {
[17:26:34.059]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.059]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.059]             }
[17:26:34.059]             base::options(...future.oldOptions)
[17:26:34.059]             if (.Platform$OS.type == "windows") {
[17:26:34.059]                 old_names <- names(...future.oldEnvVars)
[17:26:34.059]                 envs <- base::Sys.getenv()
[17:26:34.059]                 names <- names(envs)
[17:26:34.059]                 common <- intersect(names, old_names)
[17:26:34.059]                 added <- setdiff(names, old_names)
[17:26:34.059]                 removed <- setdiff(old_names, names)
[17:26:34.059]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.059]                   envs[common]]
[17:26:34.059]                 NAMES <- toupper(changed)
[17:26:34.059]                 args <- list()
[17:26:34.059]                 for (kk in seq_along(NAMES)) {
[17:26:34.059]                   name <- changed[[kk]]
[17:26:34.059]                   NAME <- NAMES[[kk]]
[17:26:34.059]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.059]                     next
[17:26:34.059]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.059]                 }
[17:26:34.059]                 NAMES <- toupper(added)
[17:26:34.059]                 for (kk in seq_along(NAMES)) {
[17:26:34.059]                   name <- added[[kk]]
[17:26:34.059]                   NAME <- NAMES[[kk]]
[17:26:34.059]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.059]                     next
[17:26:34.059]                   args[[name]] <- ""
[17:26:34.059]                 }
[17:26:34.059]                 NAMES <- toupper(removed)
[17:26:34.059]                 for (kk in seq_along(NAMES)) {
[17:26:34.059]                   name <- removed[[kk]]
[17:26:34.059]                   NAME <- NAMES[[kk]]
[17:26:34.059]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.059]                     next
[17:26:34.059]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.059]                 }
[17:26:34.059]                 if (length(args) > 0) 
[17:26:34.059]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.059]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.059]             }
[17:26:34.059]             else {
[17:26:34.059]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.059]             }
[17:26:34.059]             {
[17:26:34.059]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.059]                   0L) {
[17:26:34.059]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.059]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.059]                   base::options(opts)
[17:26:34.059]                 }
[17:26:34.059]                 {
[17:26:34.059]                   {
[17:26:34.059]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:34.059]                     NULL
[17:26:34.059]                   }
[17:26:34.059]                   options(future.plan = NULL)
[17:26:34.059]                   if (is.na(NA_character_)) 
[17:26:34.059]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.059]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.059]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.059]                     .init = FALSE)
[17:26:34.059]                 }
[17:26:34.059]             }
[17:26:34.059]         }
[17:26:34.059]     })
[17:26:34.059]     if (TRUE) {
[17:26:34.059]         base::sink(type = "output", split = FALSE)
[17:26:34.059]         if (TRUE) {
[17:26:34.059]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.059]         }
[17:26:34.059]         else {
[17:26:34.059]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.059]         }
[17:26:34.059]         base::close(...future.stdout)
[17:26:34.059]         ...future.stdout <- NULL
[17:26:34.059]     }
[17:26:34.059]     ...future.result$conditions <- ...future.conditions
[17:26:34.059]     ...future.result$finished <- base::Sys.time()
[17:26:34.059]     ...future.result
[17:26:34.059] }
[17:26:34.190] MultisessionFuture started
[17:26:34.190] result() for ClusterFuture ...
[17:26:34.191] receiveMessageFromWorker() for ClusterFuture ...
[17:26:34.191] - Validating connection of MultisessionFuture
[17:26:34.293] - received message: FutureResult
[17:26:34.294] - Received FutureResult
[17:26:34.298] - Erased future from FutureRegistry
[17:26:34.299] result() for ClusterFuture ...
[17:26:34.299] - result already collected: FutureResult
[17:26:34.299] result() for ClusterFuture ... done
[17:26:34.300] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:34.300] result() for ClusterFuture ... done
[17:26:34.300] result() for ClusterFuture ...
[17:26:34.301] - result already collected: FutureResult
[17:26:34.301] result() for ClusterFuture ... done
[17:26:34.301] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:26:34.302] plan(): nbrOfWorkers() = 2
[17:26:34.302] getGlobalsAndPackages() ...
[17:26:34.303] Searching for globals...
[17:26:34.306] - globals found: [3] '{', 'Sys.sleep', 'stop'
[17:26:34.306] Searching for globals ... DONE
[17:26:34.306] Resolving globals: FALSE
[17:26:34.307] 
[17:26:34.307] 
[17:26:34.308] getGlobalsAndPackages() ... DONE
[17:26:34.308] run() for 'Future' ...
[17:26:34.309] - state: 'created'
[17:26:34.309] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:34.326] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:34.327] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:34.327]   - Field: 'node'
[17:26:34.327]   - Field: 'label'
[17:26:34.328]   - Field: 'local'
[17:26:34.328]   - Field: 'owner'
[17:26:34.329]   - Field: 'envir'
[17:26:34.329]   - Field: 'workers'
[17:26:34.329]   - Field: 'packages'
[17:26:34.330]   - Field: 'gc'
[17:26:34.330]   - Field: 'conditions'
[17:26:34.330]   - Field: 'persistent'
[17:26:34.331]   - Field: 'expr'
[17:26:34.331]   - Field: 'uuid'
[17:26:34.331]   - Field: 'seed'
[17:26:34.331]   - Field: 'version'
[17:26:34.332]   - Field: 'result'
[17:26:34.332]   - Field: 'asynchronous'
[17:26:34.332]   - Field: 'calls'
[17:26:34.333]   - Field: 'globals'
[17:26:34.333]   - Field: 'stdout'
[17:26:34.333]   - Field: 'earlySignal'
[17:26:34.334]   - Field: 'lazy'
[17:26:34.334]   - Field: 'state'
[17:26:34.334] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:34.335] - Launch lazy future ...
[17:26:34.335] Packages needed by the future expression (n = 0): <none>
[17:26:34.336] Packages needed by future strategies (n = 0): <none>
[17:26:34.337] {
[17:26:34.337]     {
[17:26:34.337]         {
[17:26:34.337]             ...future.startTime <- base::Sys.time()
[17:26:34.337]             {
[17:26:34.337]                 {
[17:26:34.337]                   {
[17:26:34.337]                     {
[17:26:34.337]                       base::local({
[17:26:34.337]                         has_future <- base::requireNamespace("future", 
[17:26:34.337]                           quietly = TRUE)
[17:26:34.337]                         if (has_future) {
[17:26:34.337]                           ns <- base::getNamespace("future")
[17:26:34.337]                           version <- ns[[".package"]][["version"]]
[17:26:34.337]                           if (is.null(version)) 
[17:26:34.337]                             version <- utils::packageVersion("future")
[17:26:34.337]                         }
[17:26:34.337]                         else {
[17:26:34.337]                           version <- NULL
[17:26:34.337]                         }
[17:26:34.337]                         if (!has_future || version < "1.8.0") {
[17:26:34.337]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.337]                             "", base::R.version$version.string), 
[17:26:34.337]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:34.337]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.337]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.337]                               "release", "version")], collapse = " "), 
[17:26:34.337]                             hostname = base::Sys.info()[["nodename"]])
[17:26:34.337]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.337]                             info)
[17:26:34.337]                           info <- base::paste(info, collapse = "; ")
[17:26:34.337]                           if (!has_future) {
[17:26:34.337]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.337]                               info)
[17:26:34.337]                           }
[17:26:34.337]                           else {
[17:26:34.337]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.337]                               info, version)
[17:26:34.337]                           }
[17:26:34.337]                           base::stop(msg)
[17:26:34.337]                         }
[17:26:34.337]                       })
[17:26:34.337]                     }
[17:26:34.337]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:34.337]                     base::options(mc.cores = 1L)
[17:26:34.337]                   }
[17:26:34.337]                   ...future.strategy.old <- future::plan("list")
[17:26:34.337]                   options(future.plan = NULL)
[17:26:34.337]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.337]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.337]                 }
[17:26:34.337]                 ...future.workdir <- getwd()
[17:26:34.337]             }
[17:26:34.337]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.337]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.337]         }
[17:26:34.337]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.337]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.337]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.337]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.337]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.337]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.337]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.337]             base::names(...future.oldOptions))
[17:26:34.337]     }
[17:26:34.337]     if (FALSE) {
[17:26:34.337]     }
[17:26:34.337]     else {
[17:26:34.337]         if (TRUE) {
[17:26:34.337]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.337]                 open = "w")
[17:26:34.337]         }
[17:26:34.337]         else {
[17:26:34.337]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.337]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.337]         }
[17:26:34.337]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.337]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.337]             base::sink(type = "output", split = FALSE)
[17:26:34.337]             base::close(...future.stdout)
[17:26:34.337]         }, add = TRUE)
[17:26:34.337]     }
[17:26:34.337]     ...future.frame <- base::sys.nframe()
[17:26:34.337]     ...future.conditions <- base::list()
[17:26:34.337]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.337]     if (FALSE) {
[17:26:34.337]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.337]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.337]     }
[17:26:34.337]     ...future.result <- base::tryCatch({
[17:26:34.337]         base::withCallingHandlers({
[17:26:34.337]             ...future.value <- base::withVisible(base::local({
[17:26:34.337]                 ...future.makeSendCondition <- base::local({
[17:26:34.337]                   sendCondition <- NULL
[17:26:34.337]                   function(frame = 1L) {
[17:26:34.337]                     if (is.function(sendCondition)) 
[17:26:34.337]                       return(sendCondition)
[17:26:34.337]                     ns <- getNamespace("parallel")
[17:26:34.337]                     if (exists("sendData", mode = "function", 
[17:26:34.337]                       envir = ns)) {
[17:26:34.337]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:34.337]                         envir = ns)
[17:26:34.337]                       envir <- sys.frame(frame)
[17:26:34.337]                       master <- NULL
[17:26:34.337]                       while (!identical(envir, .GlobalEnv) && 
[17:26:34.337]                         !identical(envir, emptyenv())) {
[17:26:34.337]                         if (exists("master", mode = "list", envir = envir, 
[17:26:34.337]                           inherits = FALSE)) {
[17:26:34.337]                           master <- get("master", mode = "list", 
[17:26:34.337]                             envir = envir, inherits = FALSE)
[17:26:34.337]                           if (inherits(master, c("SOCKnode", 
[17:26:34.337]                             "SOCK0node"))) {
[17:26:34.337]                             sendCondition <<- function(cond) {
[17:26:34.337]                               data <- list(type = "VALUE", value = cond, 
[17:26:34.337]                                 success = TRUE)
[17:26:34.337]                               parallel_sendData(master, data)
[17:26:34.337]                             }
[17:26:34.337]                             return(sendCondition)
[17:26:34.337]                           }
[17:26:34.337]                         }
[17:26:34.337]                         frame <- frame + 1L
[17:26:34.337]                         envir <- sys.frame(frame)
[17:26:34.337]                       }
[17:26:34.337]                     }
[17:26:34.337]                     sendCondition <<- function(cond) NULL
[17:26:34.337]                   }
[17:26:34.337]                 })
[17:26:34.337]                 withCallingHandlers({
[17:26:34.337]                   {
[17:26:34.337]                     Sys.sleep(3)
[17:26:34.337]                     42L
[17:26:34.337]                     stop("Woops")
[17:26:34.337]                   }
[17:26:34.337]                 }, immediateCondition = function(cond) {
[17:26:34.337]                   sendCondition <- ...future.makeSendCondition()
[17:26:34.337]                   sendCondition(cond)
[17:26:34.337]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.337]                   {
[17:26:34.337]                     inherits <- base::inherits
[17:26:34.337]                     invokeRestart <- base::invokeRestart
[17:26:34.337]                     is.null <- base::is.null
[17:26:34.337]                     muffled <- FALSE
[17:26:34.337]                     if (inherits(cond, "message")) {
[17:26:34.337]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:34.337]                       if (muffled) 
[17:26:34.337]                         invokeRestart("muffleMessage")
[17:26:34.337]                     }
[17:26:34.337]                     else if (inherits(cond, "warning")) {
[17:26:34.337]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:34.337]                       if (muffled) 
[17:26:34.337]                         invokeRestart("muffleWarning")
[17:26:34.337]                     }
[17:26:34.337]                     else if (inherits(cond, "condition")) {
[17:26:34.337]                       if (!is.null(pattern)) {
[17:26:34.337]                         computeRestarts <- base::computeRestarts
[17:26:34.337]                         grepl <- base::grepl
[17:26:34.337]                         restarts <- computeRestarts(cond)
[17:26:34.337]                         for (restart in restarts) {
[17:26:34.337]                           name <- restart$name
[17:26:34.337]                           if (is.null(name)) 
[17:26:34.337]                             next
[17:26:34.337]                           if (!grepl(pattern, name)) 
[17:26:34.337]                             next
[17:26:34.337]                           invokeRestart(restart)
[17:26:34.337]                           muffled <- TRUE
[17:26:34.337]                           break
[17:26:34.337]                         }
[17:26:34.337]                       }
[17:26:34.337]                     }
[17:26:34.337]                     invisible(muffled)
[17:26:34.337]                   }
[17:26:34.337]                   muffleCondition(cond)
[17:26:34.337]                 })
[17:26:34.337]             }))
[17:26:34.337]             future::FutureResult(value = ...future.value$value, 
[17:26:34.337]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.337]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.337]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.337]                     ...future.globalenv.names))
[17:26:34.337]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.337]         }, condition = base::local({
[17:26:34.337]             c <- base::c
[17:26:34.337]             inherits <- base::inherits
[17:26:34.337]             invokeRestart <- base::invokeRestart
[17:26:34.337]             length <- base::length
[17:26:34.337]             list <- base::list
[17:26:34.337]             seq.int <- base::seq.int
[17:26:34.337]             signalCondition <- base::signalCondition
[17:26:34.337]             sys.calls <- base::sys.calls
[17:26:34.337]             `[[` <- base::`[[`
[17:26:34.337]             `+` <- base::`+`
[17:26:34.337]             `<<-` <- base::`<<-`
[17:26:34.337]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.337]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.337]                   3L)]
[17:26:34.337]             }
[17:26:34.337]             function(cond) {
[17:26:34.337]                 is_error <- inherits(cond, "error")
[17:26:34.337]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.337]                   NULL)
[17:26:34.337]                 if (is_error) {
[17:26:34.337]                   sessionInformation <- function() {
[17:26:34.337]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.337]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.337]                       search = base::search(), system = base::Sys.info())
[17:26:34.337]                   }
[17:26:34.337]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.337]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.337]                     cond$call), session = sessionInformation(), 
[17:26:34.337]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.337]                   signalCondition(cond)
[17:26:34.337]                 }
[17:26:34.337]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.337]                 "immediateCondition"))) {
[17:26:34.337]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.337]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.337]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.337]                   if (TRUE && !signal) {
[17:26:34.337]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.337]                     {
[17:26:34.337]                       inherits <- base::inherits
[17:26:34.337]                       invokeRestart <- base::invokeRestart
[17:26:34.337]                       is.null <- base::is.null
[17:26:34.337]                       muffled <- FALSE
[17:26:34.337]                       if (inherits(cond, "message")) {
[17:26:34.337]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.337]                         if (muffled) 
[17:26:34.337]                           invokeRestart("muffleMessage")
[17:26:34.337]                       }
[17:26:34.337]                       else if (inherits(cond, "warning")) {
[17:26:34.337]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.337]                         if (muffled) 
[17:26:34.337]                           invokeRestart("muffleWarning")
[17:26:34.337]                       }
[17:26:34.337]                       else if (inherits(cond, "condition")) {
[17:26:34.337]                         if (!is.null(pattern)) {
[17:26:34.337]                           computeRestarts <- base::computeRestarts
[17:26:34.337]                           grepl <- base::grepl
[17:26:34.337]                           restarts <- computeRestarts(cond)
[17:26:34.337]                           for (restart in restarts) {
[17:26:34.337]                             name <- restart$name
[17:26:34.337]                             if (is.null(name)) 
[17:26:34.337]                               next
[17:26:34.337]                             if (!grepl(pattern, name)) 
[17:26:34.337]                               next
[17:26:34.337]                             invokeRestart(restart)
[17:26:34.337]                             muffled <- TRUE
[17:26:34.337]                             break
[17:26:34.337]                           }
[17:26:34.337]                         }
[17:26:34.337]                       }
[17:26:34.337]                       invisible(muffled)
[17:26:34.337]                     }
[17:26:34.337]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.337]                   }
[17:26:34.337]                 }
[17:26:34.337]                 else {
[17:26:34.337]                   if (TRUE) {
[17:26:34.337]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.337]                     {
[17:26:34.337]                       inherits <- base::inherits
[17:26:34.337]                       invokeRestart <- base::invokeRestart
[17:26:34.337]                       is.null <- base::is.null
[17:26:34.337]                       muffled <- FALSE
[17:26:34.337]                       if (inherits(cond, "message")) {
[17:26:34.337]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.337]                         if (muffled) 
[17:26:34.337]                           invokeRestart("muffleMessage")
[17:26:34.337]                       }
[17:26:34.337]                       else if (inherits(cond, "warning")) {
[17:26:34.337]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.337]                         if (muffled) 
[17:26:34.337]                           invokeRestart("muffleWarning")
[17:26:34.337]                       }
[17:26:34.337]                       else if (inherits(cond, "condition")) {
[17:26:34.337]                         if (!is.null(pattern)) {
[17:26:34.337]                           computeRestarts <- base::computeRestarts
[17:26:34.337]                           grepl <- base::grepl
[17:26:34.337]                           restarts <- computeRestarts(cond)
[17:26:34.337]                           for (restart in restarts) {
[17:26:34.337]                             name <- restart$name
[17:26:34.337]                             if (is.null(name)) 
[17:26:34.337]                               next
[17:26:34.337]                             if (!grepl(pattern, name)) 
[17:26:34.337]                               next
[17:26:34.337]                             invokeRestart(restart)
[17:26:34.337]                             muffled <- TRUE
[17:26:34.337]                             break
[17:26:34.337]                           }
[17:26:34.337]                         }
[17:26:34.337]                       }
[17:26:34.337]                       invisible(muffled)
[17:26:34.337]                     }
[17:26:34.337]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.337]                   }
[17:26:34.337]                 }
[17:26:34.337]             }
[17:26:34.337]         }))
[17:26:34.337]     }, error = function(ex) {
[17:26:34.337]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.337]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.337]                 ...future.rng), started = ...future.startTime, 
[17:26:34.337]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.337]             version = "1.8"), class = "FutureResult")
[17:26:34.337]     }, finally = {
[17:26:34.337]         if (!identical(...future.workdir, getwd())) 
[17:26:34.337]             setwd(...future.workdir)
[17:26:34.337]         {
[17:26:34.337]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.337]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.337]             }
[17:26:34.337]             base::options(...future.oldOptions)
[17:26:34.337]             if (.Platform$OS.type == "windows") {
[17:26:34.337]                 old_names <- names(...future.oldEnvVars)
[17:26:34.337]                 envs <- base::Sys.getenv()
[17:26:34.337]                 names <- names(envs)
[17:26:34.337]                 common <- intersect(names, old_names)
[17:26:34.337]                 added <- setdiff(names, old_names)
[17:26:34.337]                 removed <- setdiff(old_names, names)
[17:26:34.337]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.337]                   envs[common]]
[17:26:34.337]                 NAMES <- toupper(changed)
[17:26:34.337]                 args <- list()
[17:26:34.337]                 for (kk in seq_along(NAMES)) {
[17:26:34.337]                   name <- changed[[kk]]
[17:26:34.337]                   NAME <- NAMES[[kk]]
[17:26:34.337]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.337]                     next
[17:26:34.337]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.337]                 }
[17:26:34.337]                 NAMES <- toupper(added)
[17:26:34.337]                 for (kk in seq_along(NAMES)) {
[17:26:34.337]                   name <- added[[kk]]
[17:26:34.337]                   NAME <- NAMES[[kk]]
[17:26:34.337]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.337]                     next
[17:26:34.337]                   args[[name]] <- ""
[17:26:34.337]                 }
[17:26:34.337]                 NAMES <- toupper(removed)
[17:26:34.337]                 for (kk in seq_along(NAMES)) {
[17:26:34.337]                   name <- removed[[kk]]
[17:26:34.337]                   NAME <- NAMES[[kk]]
[17:26:34.337]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.337]                     next
[17:26:34.337]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.337]                 }
[17:26:34.337]                 if (length(args) > 0) 
[17:26:34.337]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.337]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.337]             }
[17:26:34.337]             else {
[17:26:34.337]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.337]             }
[17:26:34.337]             {
[17:26:34.337]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.337]                   0L) {
[17:26:34.337]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.337]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.337]                   base::options(opts)
[17:26:34.337]                 }
[17:26:34.337]                 {
[17:26:34.337]                   {
[17:26:34.337]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:34.337]                     NULL
[17:26:34.337]                   }
[17:26:34.337]                   options(future.plan = NULL)
[17:26:34.337]                   if (is.na(NA_character_)) 
[17:26:34.337]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.337]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.337]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.337]                     .init = FALSE)
[17:26:34.337]                 }
[17:26:34.337]             }
[17:26:34.337]         }
[17:26:34.337]     })
[17:26:34.337]     if (TRUE) {
[17:26:34.337]         base::sink(type = "output", split = FALSE)
[17:26:34.337]         if (TRUE) {
[17:26:34.337]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.337]         }
[17:26:34.337]         else {
[17:26:34.337]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.337]         }
[17:26:34.337]         base::close(...future.stdout)
[17:26:34.337]         ...future.stdout <- NULL
[17:26:34.337]     }
[17:26:34.337]     ...future.result$conditions <- ...future.conditions
[17:26:34.337]     ...future.result$finished <- base::Sys.time()
[17:26:34.337]     ...future.result
[17:26:34.337] }
[17:26:34.346] MultisessionFuture started
[17:26:34.347] - Launch lazy future ... done
[17:26:34.347] run() for 'MultisessionFuture' ... done
<simpleError: No error has been caught because the future is unresolved: 'f'>
[17:26:37.467] receiveMessageFromWorker() for ClusterFuture ...
[17:26:37.468] - Validating connection of MultisessionFuture
[17:26:37.469] - received message: FutureResult
[17:26:37.470] - Received FutureResult
[17:26:37.470] - Erased future from FutureRegistry
[17:26:37.471] result() for ClusterFuture ...
[17:26:37.471] - result already collected: FutureResult
[17:26:37.471] result() for ClusterFuture ... done
[17:26:37.472] signalConditions() ...
[17:26:37.472]  - include = 'immediateCondition'
[17:26:37.473]  - exclude = 
[17:26:37.473]  - resignal = FALSE
[17:26:37.473]  - Number of conditions: 1
[17:26:37.474] signalConditions() ... done
[17:26:37.474] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:37.475] A MultisessionFuture was resolved (result was not collected)
MultisessionFuture:
Label: '<none>'
Expression:
{
    Sys.sleep(3)
    42L
    stop("Woops")
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 27 bytes of class 'NULL'
Conditions captured: [n=1] 'simpleError'
Early signaling: FALSE
Owner process: 24e2e1ec-4d72-5642-5ba1-1fae62cd1be5
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
> 
> message("*** backtrace( ) - exceptions ... DONE")
*** backtrace( ) - exceptions ... DONE
> 
> 
> message("*** backtrace( ) ... DONE")
*** backtrace( ) ... DONE
> 
> source("incl/end.R")
[17:26:37.480] plan(): Setting new future strategy stack:
[17:26:37.480] List of future strategies:
[17:26:37.480] 1. FutureStrategy:
[17:26:37.480]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:37.480]    - tweaked: FALSE
[17:26:37.480]    - call: future::plan(oplan)
[17:26:37.502] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=205] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'RTOOLS44_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS44_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_NOTE_MISSING_PACKAGE_ANCHORS_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_DEPRECATED_IS_R_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   0.93    0.15    5.14