evalFuture(): Remove argument 'immediateConditions'

Author: HenrikBengtsson

DESCRIPTION

@@ -1,5 +1,5 @@
 Package: future
-Version: 1.34.0-9101
+Version: 1.34.0-9102
 Title: Unified Parallel and Distributed Processing in R for Everyone
 Imports:
     digest,

R/Future-class.R

@@ -659,7 +659,7 @@ getExpression <- function(future, ...) UseMethod("getExpression")
 getExpression.Future <- local({
   tmpl_expr_evaluate2 <- bquote_compile({
     ## Evaluate future
-    future:::evalFuture(core = .(core), local = .(local), stdout = .(stdout), conditionClasses = .(conditionClasses), split = .(split), immediateConditions = .(immediateConditions), immediateConditionClasses = .(immediateConditionClasses), strategiesR = .(strategiesR), forwardOptions = .(forwardOptions), threads = .(threads), cleanup = .(cleanup))
+    future:::evalFuture(core = .(core), local = .(local), stdout = .(stdout), conditionClasses = .(conditionClasses), split = .(split), immediateConditionClasses = .(immediateConditionClasses), strategiesR = .(strategiesR), forwardOptions = .(forwardOptions), threads = .(threads), cleanup = .(cleanup))
   })
 
   function(future, expr = future$expr, conditionClasses = future$conditions, immediateConditions = FALSE, mc.cores = NULL, threads = NA_integer_, cleanup = TRUE, ...) {
@@ -679,9 +679,6 @@ getExpression.Future <- local({
                             sQuote(version)))
     }
 
-    ## Globals needed by the future
-    globals <- globals(future)
-  
     ## Packages needed by the future
     pkgs <- packages(future)
     if (length(pkgs) > 0) {
@@ -716,21 +713,25 @@ getExpression.Future <- local({
     ## Create a future core
     core <- list(
       expr     = expr,
-      globals  = globals,
+      globals  = globals(future),
       packages = pkgs,
       seed     = future$seed
     )
 
-    if (immediateConditions && !is.null(conditionClasses)) {
+    ## Does the backend support immediate relaying of conditions?
+    if (immediateConditions) {
       immediateConditionClasses <- getOption("future.relay.immediate", "immediateCondition")
-      conditionClassesExclude <- attr(conditionClasses, "exclude", exact = TRUE)
+    } else {
+      immediateConditionClasses <- character(0L)
+    }
+    
+    if (length(immediateConditionClasses) > 0 && !is.null(conditionClasses)) {
+      exclude <- attr(conditionClasses, "exclude", exact = TRUE)
       muffleInclude <- attr(conditionClasses, "muffleInclude", exact = TRUE)
       if (is.null(muffleInclude)) muffleInclude <- "^muffle"
       conditionClasses <- unique(c(conditionClasses, immediateConditionClasses))
-      attr(conditionClasses, "exclude") <- conditionClassesExclude
+      attr(conditionClasses, "exclude") <- exclude
       attr(conditionClasses, "muffleInclude") <- muffleInclude
-    } else {
-      immediateConditionClasses <- character(0L)
     }
 
     forwardOptions <- list(

R/expressions.R

@@ -4,7 +4,7 @@ FutureEvalError <- function(...) {
   ex
 }
 
-evalFuture <- function(core, local = FALSE, stdout = TRUE, conditionClasses = character(0L), split = FALSE, immediateConditions = NULL, immediateConditionClasses = character(0L), forwardOptions = NULL, strategiesR = NULL, threads = NA_integer_, envir = parent.frame(), cleanup = TRUE) {
+evalFuture <- function(core, local = FALSE, stdout = TRUE, conditionClasses = character(0L), split = FALSE, immediateConditionClasses = character(0L), forwardOptions = NULL, strategiesR = NULL, threads = NA_integer_, envir = parent.frame(), cleanup = TRUE) {
   expr <- core$expr
   globals <- core$globals
   packages <- core$packages
@@ -15,17 +15,12 @@ evalFuture <- function(core, local = FALSE, stdout = TRUE, conditionClasses = ch
     length(stdout) == 1L && is.logical(stdout),
     length(split) == 1L && is.logical(split) && !is.na(split),
     is.null(conditionClasses) || (is.character(conditionClasses) && !anyNA(conditionClasses) && all(nzchar(conditionClasses))),
-    length(immediateConditions) == 1L && is.logical(immediateConditions) && !is.na(immediateConditions),
     is.character(immediateConditionClasses) && !anyNA(immediateConditionClasses) && all(nzchar(immediateConditionClasses)),
     is.null(seed) || is_lecyer_cmrg_seed(seed) || (is.logical(seed) && !is.na(seed) || !seed),
     length(threads) == 1L && is.integer(threads) && (is.na(threads) || threads >= 1L),
     length(cleanup) == 1L && is.logical(cleanup) && !is.na(cleanup)
   )
 
-  if (!immediateConditions) {
-    immediateConditionClasses <- character(0L)
-  }
-
   ## Is it possible to force single-threaded processing?
   if (!is.na(threads)) {
     ## Setting other than single-threaded processing is currently not