Transpose a list.

Transpose turns a list-of-lists "inside-out"; it turns a pair of lists into a list of pairs, or a list of pairs into pair of lists. For example, if you had a list of length n where each component had values a and b, transpose() would make a list with elements a and b that contained lists of length n. It's called transpose because x[[1]][[2]] is equivalent to transpose(x)[[2]][[1]].

transpose(.l, .names = NULL)

Arguments

.l	A list of vectors to transpose. The first element is used as the template; you'll get a warning if a subsequent element has a different length.
.names	For efficiency, transpose() bases the return structure on the first component of .l by default. Specify .names to override this.

Value

A list with indexing transposed compared to .l.

Details

Note that transpose() is its own inverse, much like the transpose operation on a matrix. You can get back the original input by transposing it twice.

Examples

x <- rerun(5, x = runif(1), y = runif(5))
x %>% str()
#> List of 5
#>  $ :List of 2
#>   ..$ x: num 0.554
#>   ..$ y: num [1:5] 0.113 0.0391 0.9627 0.7334 0.5532
#>  $ :List of 2
#>   ..$ x: num 0.402
#>   ..$ y: num [1:5] 0.656 0.537 0.49 0.509 0.794
#>  $ :List of 2
#>   ..$ x: num 0.119
#>   ..$ y: num [1:5] 0.13 0.528 0.191 0.716 0.267
#>  $ :List of 2
#>   ..$ x: num 0.953
#>   ..$ y: num [1:5] 0.781 0.789 0.4591 0.196 0.0605
#>  $ :List of 2
#>   ..$ x: num 0.518
#>   ..$ y: num [1:5] 0.6462 0.4103 0.0575 0.0914 0.8357
x %>% transpose() %>% str()
#> List of 2
#>  $ x:List of 5
#>   ..$ : num 0.554
#>   ..$ : num 0.402
#>   ..$ : num 0.119
#>   ..$ : num 0.953
#>   ..$ : num 0.518
#>  $ y:List of 5
#>   ..$ : num [1:5] 0.113 0.0391 0.9627 0.7334 0.5532
#>   ..$ : num [1:5] 0.656 0.537 0.49 0.509 0.794
#>   ..$ : num [1:5] 0.13 0.528 0.191 0.716 0.267
#>   ..$ : num [1:5] 0.781 0.789 0.4591 0.196 0.0605
#>   ..$ : num [1:5] 0.6462 0.4103 0.0575 0.0914 0.8357
# Back to where we started
x %>% transpose() %>% transpose() %>% str()
#> List of 5
#>  $ :List of 2
#>   ..$ x: num 0.554
#>   ..$ y: num [1:5] 0.113 0.0391 0.9627 0.7334 0.5532
#>  $ :List of 2
#>   ..$ x: num 0.402
#>   ..$ y: num [1:5] 0.656 0.537 0.49 0.509 0.794
#>  $ :List of 2
#>   ..$ x: num 0.119
#>   ..$ y: num [1:5] 0.13 0.528 0.191 0.716 0.267
#>  $ :List of 2
#>   ..$ x: num 0.953
#>   ..$ y: num [1:5] 0.781 0.789 0.4591 0.196 0.0605
#>  $ :List of 2
#>   ..$ x: num 0.518
#>   ..$ y: num [1:5] 0.6462 0.4103 0.0575 0.0914 0.8357

# transpose() is useful in conjunction with safely() & quietly()
x <- list("a", 1, 2)
y <- x %>% map(safely(log))
y %>% str()
#> List of 3
#>  $ :List of 2
#>   ..$ result: NULL
#>   ..$ error :List of 2
#>   .. ..$ message: chr "non-numeric argument to mathematical function"
#>   .. ..$ call   : language .Primitive("log")(x, base)
#>   .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
#>  $ :List of 2
#>   ..$ result: num 0
#>   ..$ error : NULL
#>  $ :List of 2
#>   ..$ result: num 0.693
#>   ..$ error : NULL
y %>% transpose() %>% str()
#> List of 2
#>  $ result:List of 3
#>   ..$ : NULL
#>   ..$ : num 0
#>   ..$ : num 0.693
#>  $ error :List of 3
#>   ..$ :List of 2
#>   .. ..$ message: chr "non-numeric argument to mathematical function"
#>   .. ..$ call   : language .Primitive("log")(x, base)
#>   .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
#>   ..$ : NULL
#>   ..$ : NULL

# Use simplify_all() to reduce to atomic vectors where possible
x <- list(list(a = 1, b = 2), list(a = 3, b = 4), list(a = 5, b = 6))
x %>% transpose()
#> $a
#> $a[[1]]
#> [1] 1
#> 
#> $a[[2]]
#> [1] 3
#> 
#> $a[[3]]
#> [1] 5
#> 
#> 
#> $b
#> $b[[1]]
#> [1] 2
#> 
#> $b[[2]]
#> [1] 4
#> 
#> $b[[3]]
#> [1] 6
#> 
#> 
x %>% transpose() %>% simplify_all()
#> $a
#> [1] 1 3 5
#> 
#> $b
#> [1] 2 4 6
#> 

# Provide explicit component names to prevent loss of those that don't
# appear in first component
ll <- list(
  list(x = 1, y = "one"),
  list(z = "deux", x = 2)
)
ll %>% transpose()
#> $x
#> $x[[1]]
#> [1] 1
#> 
#> $x[[2]]
#> [1] 2
#> 
#> 
#> $y
#> $y[[1]]
#> [1] "one"
#> 
#> $y[[2]]
#> NULL
#> 
#> 
nms <- ll %>% map(names) %>% reduce(union)
ll %>% transpose(.names = nms)
#> $x
#> $x[[1]]
#> [1] 1
#> 
#> $x[[2]]
#> [1] 2
#> 
#> 
#> $y
#> $y[[1]]
#> [1] "one"
#> 
#> $y[[2]]
#> NULL
#> 
#> 
#> $z
#> $z[[1]]
#> NULL
#> 
#> $z[[2]]
#> [1] "deux"
#> 
#>