How to rethrow an error in R? - r

Question

I'll catch an error using tryCatch, and attempt to handle the error. However, how can I rethrow the error if I cannot handle the error locally (i.e. delegate to error handlers of parent functions higher up in the call stack)?
I tried using signalCondition but instead of seeing the rethrown error, all I see is NULL:
> error.can.be.handled <- function(e) F
>
> foo <- function() stop("foo stop!")
> tryCatch(foo(),
+ error = function(e) {
+ if (error.can.be.handled(e)) {
+ # handle error
+ }
+ else
+ signalCondition(e) # Rethrow error
+ }
+ )
NULL # I expected to see 'Error in foo() : foo stop!' here
What's going wrong?

Answer 1

tryCatch(stop("oops"), error=function(e) stop(e))
will re-signal the stop condition, although the context has been lost
> tryCatch(stop("oops"), error=function(e) stop(e))
Error in doTryCatch(return(expr), name, parentenv, handler) : oops
> traceback()
5: stop(e)
4: value[[3L]](cond)
3: tryCatchOne(expr, names, parentenv, handlers[[1L]])
2: tryCatchList(expr, classes, parentenv, handlers)
1: tryCatch(stop("oops"), error = function(e) stop(e))
> tryCatch(stop("oops"))
Error in tryCatchList(expr, classes, parentenv, handlers) : oops
> traceback()
3: stop("oops")
2: tryCatchList(expr, classes, parentenv, handlers)
1: tryCatch(stop("oops"))
Returning just e as #tonytonov suggests does signal that a condition has occurred, but not that an error has occurred.

Answer 2

There's a workaround you can use to avoid having to catch and re-throw the error at all. Basically, use a success flag with an on.exit handler to run a block of code only if the code in question fails:
foo <- function() stop("foo stop!")
runFoo <- function() {
success <- FALSE
on.exit({
if (!success) {
## Handle failure
}
})
result <- foo()
success <- TRUE
result
}
runFoo()
The main disadvantage of this approach is that while you know an error occurred (because success never got set to TRUE), you don't get access to the error object itself, so you will need to use some other method to detect whether you can handle the error or not.
The runFoo wrapper function is needed because the on.exit expression runs when exiting the current function, so it needs to be run inside a function. If the code that you're writing is already inside a function, then you don't need to use this wrapper.

Answer 3

There is no need in signalCondition() whatsoever:
tryCatch(foo(),
error = function(e) {
if (error.can.be.handled(e)) {
# handle error
}
else
e # Rethrow error
}
)
<simpleError in foo(): foo stop!>