You probably have encountered situations similar to this one:

result = vector("list", length(some_numbers))

for(i in seq_along(some_numbers)){
  result[[i]] = some_function(some_numbers[[i]])
}

print(result)

First I initialize result, an empty list of size equal to the length of some_numbers which will contains the results of applying some_function() to each element of some_numbers. Then, using a for loop, I apply the function. This is what I get back:

NaNs producedError in sqrt(x) : non-numeric argument to mathematical function

Let’s take a look at some_numbers and some_function():

print(some_numbers)
## [[1]]
## [1] -1.9
## 
## [[2]]
## [1] 20
## 
## [[3]]
## [1] "-88"
## 
## [[4]]
## [1] -42
some_function
## function(x){
##   if(x == 0) res = 0
##   if(x < 0) res = -sqrt(-x)
##   if(x > 0) res = sqrt(x)
##   return(res)
## }

So the function simply returns the square root of x (or minus the square root of -x if x is negative), but the number in third position of the list some_numbers is actually a character. This type of mistakes can commonly happen. The result list looks like this:

print(result)
[[1]]
[1] -1.378405

[[2]]
[1] 4.472136

[[3]]
NULL

[[4]]
NULL

As you see, even though the fourth element could have been computed, the error made the whole loop stop. In such a simple example, you could correct this and then run your function. But what if the list you want to apply your function to is very long and the computation take a very, very long time? Perhaps you simply want to skip these errors and get back to them later. One way of doing that is using tryCatch():

result = vector("list", length(some_numbers))

for(i in seq_along(some_numbers)){
  result[[i]] = tryCatch(some_function(some_numbers[[i]]), 
                         error = function(e) paste("something wrong here"))
}

print(result)
## [[1]]
## [1] -1.378405
## 
## [[2]]
## [1] 4.472136
## 
## [[3]]
## [1] "something wrong here"
## 
## [[4]]
## [1] -6.480741

This works, but it’s verbose and easy to mess up. My advice here is that if you want to skip errors in loops you don’t write loops! This is quite easy with the purrr package:

library(purrr)

result = map(some_numbers, some_function)

There’s several advantages here already; no need to initialize an empty structure to hold your result, and no need to think about indices, which can sometimes get confusing. This however does not work either; there’s still the problem that we have a character inside some_numbers:

Error in sqrt(x) : non-numeric argument to mathematical function

However, purrr contains some very amazing functions for error handling, safely() and possibly(). Let’s try possibly() first:

possibly_some_function = possibly(some_function, otherwise = "something wrong here")

possibly() takes a function as argument as well as otherwise; this is where you define a return value in case something is wrong. possibly() then returns a new function that skips errors:

result = map(some_numbers, possibly_some_function)

print(result)
## [[1]]
## [1] -1.378405
## 
## [[2]]
## [1] 4.472136
## 
## [[3]]
## [1] "something wrong here"
## 
## [[4]]
## [1] -6.480741

When you use possibly() on a function, you’re politely telling R “would you kindly apply the function wherever possible, and if not, tell me where there was an issue”. What about safely()?

safely_some_function = safely(some_function)


result = map(some_numbers, safely_some_function)

str(result)
## List of 4
##  $ :List of 2
##   ..$ result: num -1.38
##   ..$ error : NULL
##  $ :List of 2
##   ..$ result: num 4.47
##   ..$ error : NULL
##  $ :List of 2
##   ..$ result: NULL
##   ..$ error :List of 2
##   .. ..$ message: chr "invalid argument to unary operator"
##   .. ..$ call   : language -x
##   .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
##  $ :List of 2
##   ..$ result: num -6.48
##   ..$ error : NULL

The major difference with possibly() is that safely() returns a more complex object: it returns a list of lists. There are as many lists as there are elements in some_numbers. Let’s take a look at the first one:

print(result[[1]])
## $result
## [1] -1.378405
## 
## $error
## NULL

result[[1]] is a list with a result and an error. If there was no error, we get a value in result and NULL in error. If there was an error, this is what we see:

print(result[[3]])
## $result
## NULL
## 
## $error
## <simpleError in -x: invalid argument to unary operator>

Because lists of lists are not easy to handle, I like to use possibly(), but if you use safely() you might want to know about transpose(), which is another function from purrr:

result2 = transpose(result)

str(result2)
## List of 2
##  $ result:List of 4
##   ..$ : num -1.38
##   ..$ : num 4.47
##   ..$ : NULL
##   ..$ : num -6.48
##  $ error :List of 4
##   ..$ : NULL
##   ..$ : NULL
##   ..$ :List of 2
##   .. ..$ message: chr "invalid argument to unary operator"
##   .. ..$ call   : language -x
##   .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
##   ..$ : NULL

result2 is now a list of two lists: a result list holding all the results, and an error list holding all the error message. You can get results with:

result2$result
## [[1]]
## [1] -1.378405
## 
## [[2]]
## [1] 4.472136
## 
## [[3]]
## NULL
## 
## [[4]]
## [1] -6.480741

I hope you enjoyed this blog post, and that these functions will make your life easier!

Don’t hesitate to follow us on twitter @rdata_lu and to subscribe to our youtube channel.
You can also contact us if you have any comments or suggestions. See you for the next post!