R: Flatten or squash a list of lists into a simpler vector

flatten {rlang} | R Documentation

## Flatten or squash a list of lists into a simpler vector

### Description

`flatten()` removes one level hierarchy from a list, while `squash()` removes all levels. These functions are similar to `unlist()` but they are type-stable so you always know what the type of the output is.

### Usage

    flatten(x)

    flatten_lgl(x)

    flatten_int(x)

    flatten_dbl(x)

    flatten_cpl(x)

    flatten_chr(x)

    flatten_raw(x)

    squash(x)

    squash_lgl(x)

    squash_int(x)

    squash_dbl(x)

    squash_cpl(x)

    squash_chr(x)

    squash_raw(x)

    flatten_if(x, predicate = is_spliced)

    squash_if(x, predicate = is_spliced)

### Arguments

`x` | A list of flatten or squash. The contents of the list can be anything for unsuffixed functions `flatten()` and `squash()` (as a list is returned), but the contents must match the type for the other functions.
`predicate` | A function of one argument returning whether it should be spliced.

### Value

`flatten()` returns a list, `flatten_lgl()` a logical vector, `flatten_int()` an integer vector, `flatten_dbl()` a double vector, and `flatten_chr()` a character vector. Similarly for `squash()` and the typed variants (`squash_lgl()` etc).

### Examples

    x <- replicate(2, sample(4), simplify = FALSE)
    x

    flatten(x)
    flatten_int(x)

    # With flatten(), only one level gets removed at a time:
    deep <- list(1, list(2, list(3)))
    flatten(deep)
    flatten(flatten(deep))

    # But squash() removes all levels:
    squash(deep)
    squash_dbl(deep)

    # The typed flattens remove one level and coerce to an atomic
    # vector at the same time:
    flatten_dbl(list(1, list(2)))

    # Only bare lists are flattened, but you can splice S3 lists
    # explicitly:
    foo <- set_attrs(list("bar"), class = "foo")
    str(flatten(list(1, foo, list(100))))
    str(flatten(list(1, splice(foo), list(100))))

    # Instead of splicing manually, flatten_if() and squash_if() let
    # you specify a predicate function:
    is_foo <- function(x) inherits(x, "foo") || is_bare_list(x)
    str(flatten_if(list(1, foo, list(100)), is_foo))

    # squash_if() does the same with deep lists:
    deep_foo <- list(1, list(foo, list(foo, 100)))
    str(deep_foo)

    str(squash(deep_foo))
    str(squash_if(deep_foo, is_foo))

[Package rlang version 0.2.2 Index]