Capture side effects.

These functions wrap functions so that instead of generating side effects through printed output, messages, warnings, and errors, they return enhanced output. They are all adverbs because they modify the action of a verb (a function).

safely(.f, otherwise = NULL, quiet = TRUE)

quietly(.f)

possibly(.f, otherwise, quiet = TRUE)

auto_browse(.f)

Arguments

.f	A function, formula, or vector (not necessarily atomic). If a function, it is used as is. If a formula, e.g. ~ .x + 2, it is converted to a function. There are three ways to refer to the arguments: For a single argument function, use . For a two argument function, use .x and .y For more arguments, use ..1, ..2, ..3 etc This syntax allows you to create very compact anonymous functions. If character vector, numeric vector, or list, it is converted to an extractor function. Character vectors index by name and numeric vectors index by position; use a list to index by position and name at different levels. If a component is not present, the value of .default will be returned.
otherwise	Default value to use when an error occurs.
quiet	Hide errors (TRUE, the default), or display them as they occur?

Value

safely: wrapped function instead returns a list with components result and error. If an error occurred, error is an error object and result has a default value (otherwise). Else error is NULL.

quietly: wrapped function instead returns a list with components result, output, messages and warnings.

possibly: wrapped function uses a default value (otherwise) whenever an error occurs.

Details

If you would like to include a function created with safely, slowly, or insistently in a package, see faq-adverbs-export.

Examples

safe_log <- safely(log)
safe_log(10)
#> $result
#> [1] 2.302585
#> 
#> $error
#> NULL
#> 
safe_log("a")
#> $result
#> NULL
#> 
#> $error
#> <simpleError in .Primitive("log")(x, base): non-numeric argument to mathematical function>
#> 

list("a", 10, 100) %>%
  map(safe_log) %>%
  transpose()
#> $result
#> $result[[1]]
#> NULL
#> 
#> $result[[2]]
#> [1] 2.302585
#> 
#> $result[[3]]
#> [1] 4.60517
#> 
#> 
#> $error
#> $error[[1]]
#> <simpleError in .Primitive("log")(x, base): non-numeric argument to mathematical function>
#> 
#> $error[[2]]
#> NULL
#> 
#> $error[[3]]
#> NULL
#> 
#> 

# This is a bit easier to work with if you supply a default value
# of the same type and use the simplify argument to transpose():
safe_log <- safely(log, otherwise = NA_real_)
list("a", 10, 100) %>%
  map(safe_log) %>%
  transpose() %>%
  simplify_all()
#> $result
#> [1]       NA 2.302585 4.605170
#> 
#> $error
#> $error[[1]]
#> <simpleError in .Primitive("log")(x, base): non-numeric argument to mathematical function>
#> 
#> $error[[2]]
#> NULL
#> 
#> $error[[3]]
#> NULL
#> 
#> 

# To replace errors with a default value, use possibly().
list("a", 10, 100) %>%
  map_dbl(possibly(log, NA_real_))
#> [1]       NA 2.302585 4.605170

# For interactive usage, auto_browse() is useful because it automatically
# starts a browser() in the right place.
f <- function(x) {
  y <- 20
  if (x > 5) {
    stop("!")
  } else {
    x
  }
}
if (interactive()) {
  map(1:6, auto_browse(f))
}

# It doesn't make sense to use auto_browse with primitive functions,
# because they are implemented in C so there's no useful environment
# for you to interact with.