Why does withCallingHandlers still stops execution?

Question

It seems that withCallingHandlers doesn't actually catch the error the way that tryCatch does and the script still stops executing.

Compare the snippet with tryCatch where both "before" and "after" are printed:

f1 <- function() {
  cat("before tryCatch\n")
  tryCatch({
      stop("this is an error!")
    },
    error = function(cond) {
      print(cond$message)
    }
  )
  cat("after tryCatch\n")
}

With the same snippet with withCallingHandlers that doesn't print "after" and stops execution:

f2 <- function() {
  cat("before tryCatch\n")
  withCallingHandlers({
      stop("this is an error!")
    },
    error = function(cond) {
      print(cond$message)
    }
  )
  cat("after tryCatch\n")
}

What am I doing wrong?

Some context

I'd like to use withCallingHandlers to analyze the call stack at the point where the error occurs using sys.calls().

According to Advanced R that should be possible:

The handlers in withCallingHandlers() are called in the context of the call that generated the condition whereas the handlers in tryCatch() are called in the context of tryCatch().

It seems that wrapping `withCallingHandlers` with `tryCatch` resolves the problem, but it seems a bit ugly. — elifiner, Aug 23 '15 at 14:58
Simply said the error parameter in `withCallingHandlers` is used to as to signal an error to the function but does not establish an error handler that recovers from the error. This can only be achieved by using `tryCatch`. — R Yoda, Nov 04 '16 at 18:16

score 16 · Accepted Answer · answered Aug 24 '15 at 00:01

Calling handlers provide a way of 'touching' a condition on the way through, maybe logging an error to a file before signalling the user in an interactive session.

Calling handlers can be used to 'muffle' warnings, messages, or errors if the calling handler doesn't actually return. You can make a calling handler not return using restarts -- surround the code that you'd like to continue executing in a call to withRestarts(), and invoke the restart in the handler:

f2 <- function() {
  cat("before tryCatch\n")
  withCallingHandlers({
      withRestarts({
          stop("this is an error!")
      }, muffleStop=function() {
          message("'stop' muffled")
      })
    },
    error = function(cond) {
      print(cond$message)
      invokeRestart("muffleStop")
    }
  )
  cat("after tryCatch\n")
}

It's more usual that the restarts are established in one chunk of code (like in the built-in function warning) and invoked in a completely independent chunk of code (like the built-in function suppressWarnings:

> warning
function (..., call. = TRUE, immediate. = FALSE, noBreaks. = FALSE, 
    domain = NULL) 
{
        ##
        ## ...
        ##
        withRestarts({
            .Internal(.signalCondition(cond, message, call))
            .Internal(.dfltWarn(message, call))
        }, muffleWarning = function() NULL)
        ##
        ## ...
        ##
}
<bytecode: 0x51a4730>
<environment: namespace:base>
> suppressWarnings
function (expr) 
{
    ops <- options(warn = -1)
    on.exit(options(ops))
    withCallingHandlers(expr, 
        warning = function(w) invokeRestart("muffleWarning"))
}
<bytecode: 0x35c2a60>
<environment: namespace:base>

Why does withCallingHandlers still stops execution?

1 Answers1

Linked