How to sum a numeric list elements

I'm wondering about an elegant way allowing to sum (or calculate a mean) a numeric values of a list. e.g.

x <- list( a = matrix(c(1,2,3,4), nc=2), b = matrix(1, nc=2, nr=2))

and want to get

x[[1]]+x[[2]] 

or a mean:

(x[[1]]+x[[2]])/2

You can use Reduce to successively apply a binary function to elements in a list.

Reduce("+",x)
     [,1] [,2]
[1,]    2    4
[2,]    3    5

Reduce("+",x)/length(x)
     [,1] [,2]
[1,]  1.0  2.0
[2,]  1.5  2.5

Even if Reduce() is the standard answer to the question of summing list of matrices and it has been pointed out many times, I collected some of the most prominent ways to achieve this goal in the following code. The main purpose is to show if there is any choice which is clearly better than others for speed and "precision".

# load libraries
library(microbenchmark)
library(ggplot2)

# generate the data with ten matrices to sum
mat_list <- lapply(1:10, function(x) matrix(rnorm(100), nrow = 10, ncol = 10))
# larger and longer test set
mat_list_large <- lapply(1:1000, function(x) matrix(rnorm(100000), nrow = 1000, ncol = 100))

# function with reduce @james
f1 <- function(mat_list){
  Reduce(`+`, mat_list)
}
# function with apply @Jilber Urbina
f2 <- function(mat_list){
  apply(simplify2array(mat_list), c(1:2), sum)
}
# function with do.call @Tyler Rinker
f3 <- function(mat_list){
  x <- mat_list[[1]]
  lapply(seq_along(mat_list)[-1], function(i){
    x <<- do.call("+", list(x, mat_list[[i]]))
  })
  return(x)
}
# function with loop modified from @Carl Witthoft
f4 <- function(mat_list){
  out_mat <- mat_list[[1]]
  for (i in 2:length(mat_list)) out_mat <- out_mat + mat_list[[i]]
  return(out_mat)
}

# test to see if they are all equal
all.equal(f1(mat_list), f2(mat_list), f3(mat_list), f4(mat_list), tolerance = 1.5e-8) # TRUE 
# ps: the second method seems to differ slightly from the others

# run 100 times all the functions for having a statistic on their speed
mb <- microbenchmark("Reduce" = f1(mat_list),
                     "apply" = f2(mat_list),
                     "do.call" = f3(mat_list),
                     "loop" = f4(mat_list), 
                     times = 100)
mb2 <- microbenchmark("Reduce" = f1(mat_list_large),
                 "apply" = f2(mat_list_large),
                 "do.call" = f3(mat_list_large),
                 "loop" = f4(mat_list_large), 
                 times = 100)

# see output using a violin plot
autoplot(mb)

autoplot(mb2) # longer version for bigger datasets

Therefore, it is probably better to use Reduce() as for median speed and clearness of code.