# Elixir v1.10.3 List View Source

Linked lists hold zero, one, or more elements in the choosen order.

Lists in Elixir are specified between square brackets:

    iex> [1, "two", 3, :four]
    [1, "two", 3, :four]

Two lists can be concatenated and subtracted using the `Kernel.++/2` and `Kernel.--/2` operators:

    iex> [1, 2, 3] ++ [4, 5, 6]
    [1, 2, 3, 4, 5, 6]
    iex> [1, true, 2, false, 3, true] -- [true, false]
    [1, 2, 3, true]

Lists in Elixir are effectively linked lists, which means they are internally represented in pairs containing the head and the tail of a list:

    iex> [head | tail] = [1, 2, 3]
    iex> head
    1
    iex> tail
    [2, 3]

Similarly, we could write the list `[1, 2, 3]` using only such pairs (called cons cells):

    iex> [1 | [2 | [3 | []]]]
    [1, 2, 3]

Some lists, called improper lists, do not have an empty list as the second element in the last cons cell:

    iex> [1 | [2 | [3 | 4]]]
    [1, 2, 3 | 4]

Although improper lists are generally avoided, they are used in some special circumstances like iodata and chardata entities (see the `IO` module).

Due to their cons cell based representation, prepending an element to a list is always fast (constant time), while appending becomes slower as the list grows in size (linear time):

    iex> list = [1, 2, 3]
    iex> [0 | list] # fast
    [0, 1, 2, 3]
    iex> list ++ [4] # slow
    [1, 2, 3, 4]

Most of the functions in this module work in linear time. This means that, that the time it takes to perform an operation grows at the same rate as the length of the list. For example `length/1` and `last/1` will run in linear time because they need to iterate through every element of the list, but `first/1` will run in constant time because it only needs the first element.

Lists also implement the `Enumerable` protocol, so many functions to work with lists are found in the `Enum` module. Additionally, the following functions and operators for lists are found in `Kernel`:

- `++/2`
- `--/2`
- `hd/1`
- `tl/1`
- `in/2`
- `length/1`

## Charlists

If a list is made of non-negative integers, where each integer represents a Unicode code point, the list can also be called a charlist. These integers must:

- be within the range `0..0x10FFFF` (`0..1_114_111`);
- and be out of the range `0xD800..0xDFFF` (`55_296..57_343`), which is reserved in Unicode for UTF-16 surrogate pairs.

Elixir uses single quotes to define charlists:

    iex> 'héllo'
    [104, 233, 108, 108, 111]

In particular, charlists will be printed back by default in single quotes if they contain only printable ASCII characters:

    iex> 'abc'
    'abc'

Even though the representation changed, the raw data does remain a list of numbers, which can be handled as such:

    iex> inspect('abc', charlists: :as_list)
    "[97, 98, 99]"
    iex> Enum.map('abc', fn num -> 1000 + num end)
    [1097, 1098, 1099]

You can use the `IEx.Helpers.i/1` helper to get a condensed rundown on charlists in IEx when you encounter them, which shows you the type, description and also the raw representation in one single summary.

The rationale behind this behaviour is to better support Erlang libraries which may return text as charlists instead of Elixir strings. In Erlang, charlists are the default way of handling strings, while in Elixir it's binaries. One example of such functions is `Application.loaded_applications/0`:

    Application.loaded_applications()
    #=>  [
    #=>    {:stdlib, 'ERTS  CXC 138 10', '2.6'},
    #=>    {:compiler, 'ERTS  CXC 138 10', '6.0.1'},
    #=>    {:elixir, 'elixir', '1.0.0'},
    #=>    {:kernel, 'ERTS  CXC 138 10', '4.1'},
    #=>    {:logger, 'logger', '1.0.0'}
    #=>  ]

A list can be checked if it is made of only printable ASCII characters with `ascii_printable?/2`.

Improper lists are never deemed as charlists.

# Link to this section Summary

## Functions

ascii_printable?(list, limit \\ :infinity)

Checks if `list` is a charlist made only of printable ASCII characters.

delete(list, element)

Deletes the given `element` from the `list`. Returns a new list without the element.

delete_at(list, index)

Produces a new list by removing the value at the specified `index`.

duplicate(elem, n)

Duplicates the given element `n` times in a list.

first(list)

Returns the first element in `list` or `nil` if `list` is empty.

flatten(list)

Flattens the given `list` of nested lists.

flatten(list, tail)

Flattens the given `list` of nested lists. The list `tail` will be added at the end of the flattened list.

foldl(list, acc, fun)

Folds (reduces) the given list from the left with a function. Requires an accumulator.

foldr(list, acc, fun)

Folds (reduces) the given list from the right with a function. Requires an accumulator.

improper?(list)

Returns `true` if `list` is an improper list. Otherwise returns `false`.

insert_at(list, index, value)

Returns a list with `value` inserted at the specified `index`.

keydelete(list, key, position)

Receives a `list` of tuples and deletes the first tuple where the element at `position` matches the given `key`. Returns the new list.

keyfind(list, key, position, default \\ nil)

Receives a list of tuples and returns the first tuple where the element at `position` in the tuple matches the given `key`.

keymember?(list, key, position)

Receives a list of tuples and returns `true` if there is a tuple where the element at `position` in the tuple matches the given `key`.

keyreplace(list, key, position, new_tuple)

Receives a list of tuples and if the identified element by `key` at `position` exists, it is replaced with `new_tuple`.

keysort(list, position)

Receives a list of tuples and sorts the elements at `position` of the tuples. The sort is stable.

keystore(list, key, position, new_tuple)

Receives a `list` of tuples and replaces the element identified by `key` at `position` with `new_tuple`.

keytake(list, key, position)

Receives a `list` of tuples and returns the first tuple where the element at `position` in the tuple matches the given `key`, as well as the `list` without found tuple.

last(list)

Returns the last element in `list` or `nil` if `list` is empty.

myers_difference(list1, list2)

Returns a keyword list that represents an edit script.

myers_difference(list1, list2, diff_script)

Returns a keyword list that represents an edit script with nested diffs.

pop_at(list, index, default \\ nil)

Returns and removes the value at the specified `index` in the `list`.

replace_at(list, index, value)

Returns a list with a replaced value at the specified `index`.

starts_with?(list, prefix)

Returns `true` if `list` starts with the given `prefix` list; otherwise returns `false`.

to_atom(charlist)

Converts a charlist to an atom.

to_charlist(list)

Converts a list of integers representing Unicode code points, lists or strings into a charlist.

to_existing_atom(charlist)

Converts a charlist to an existing atom. Raises an `ArgumentError` if the atom does not exist.

to_float(charlist)

Returns the float whose text representation is `charlist`.

to_integer(charlist)

Returns an integer whose text representation is `charlist`.

to_integer(charlist, base)

Returns an integer whose text representation is `charlist` in base `base`.

to_string(list)

Converts a list of integers representing code points, lists or strings into a string.

to_tuple(list)

Converts a list to a tuple.

update_at(list, index, fun)

Returns a list with an updated value at the specified `index`.

wrap(term)

Wraps `term` in a list if this is not list.

zip(list_of_lists)

Zips corresponding elements from each list in `list_of_lists`.

# Link to this section Functions

Link to this function

# ascii_printable?(list, limit \\ :infinity)

View Source (since 1.6.0)

## Specs

    ascii_printable?(list(), 0) :: true

    ascii_printable?([], limit) :: true when limit: :infinity | pos_integer()

    ascii_printable?([...], limit) :: boolean()
    when limit: :infinity | pos_integer()

Checks if `list` is a charlist made only of printable ASCII characters.

Takes an optional `limit` as a second argument. `ascii_printable?/2` only checks the printability of the list up to the `limit`.

A printable charlist in Elixir contains only the printable characters in the standard seven-bit ASCII character encoding, which are characters ranging from 32 to 126 in decimal notation, plus the following control characters:

- `?\a` - Bell
- `?\b` - Backspace
- `?\t` - Horizontal tab
- `?\n` - Line feed
- `?\v` - Vertical tab
- `?\f` - Form feed
- `?\r` - Carriage return
- `?\e` - Escape

For more information read the Character groups section in the Wikipedia article of the ASCII standard.

## Examples

    iex> List.ascii_printable?('abc')
    true

    iex> List.ascii_printable?('abc' ++ [0])
    false

    iex> List.ascii_printable?('abc' ++ [0], 2)
    true

Improper lists are not printable, even if made only of ASCII characters:

    iex> List.ascii_printable?('abc' ++ ?d)
    false

Link to this function

# delete(list, element)

View Source

## Specs

    delete([], any()) :: []

    delete([...], any()) :: list()

Deletes the given `element` from the `list`. Returns a new list without the element.

If the `element` occurs more than once in the `list`, just the first occurrence is removed.

## Examples

    iex> List.delete([:a, :b, :c], :a)
    [:b, :c]

    iex> List.delete([:a, :b, :c], :d)
    [:a, :b, :c]

    iex> List.delete([:a, :b, :b, :c], :b)
    [:a, :b, :c]

    iex> List.delete([], :b)
    []

Link to this function

# delete_at(list, index)

View Source

## Specs

    delete_at(list(), integer()) :: list()

Produces a new list by removing the value at the specified `index`.

Negative indices indicate an offset from the end of the `list`. If `index` is out of bounds, the original `list` is returned.

## Examples

    iex> List.delete_at([1, 2, 3], 0)
    [2, 3]

    iex> List.delete_at([1, 2, 3], 10)
    [1, 2, 3]

    iex> List.delete_at([1, 2, 3], -1)
    [1, 2]

Link to this function

# duplicate(elem, n)

View Source

## Specs

    duplicate(any(), 0) :: []

    duplicate(elem, pos_integer()) :: [elem, ...] when elem: var

Duplicates the given element `n` times in a list.

`n` is an integer greater than or equal to `0`.

If `n` is `0`, an empty list is returned.

## Examples

    iex> List.duplicate("hello", 0)
    []

    iex> List.duplicate("hi", 1)
    ["hi"]

    iex> List.duplicate("bye", 2)
    ["bye", "bye"]

    iex> List.duplicate([1, 2], 3)
    [[1, 2], [1, 2], [1, 2]]

Link to this function

# first(list)

View Source

## Specs

    first([]) :: nil

    first([elem, ...]) :: elem when elem: var

Returns the first element in `list` or `nil` if `list` is empty.

## Examples

    iex> List.first([])
    nil

    iex> List.first([1])
    1

    iex> List.first([1, 2, 3])
    1

Link to this function

# flatten(list)

View Source

## Specs

    flatten(deep_list) :: list() when deep_list: [any() | deep_list]

Flattens the given `list` of nested lists.

Empty list elements are discarded.

## Examples

    iex> List.flatten([1, [[2], 3]])
    [1, 2, 3]

    iex> List.flatten([[], [[], []]])
    []

Link to this function

# flatten(list, tail)

View Source

## Specs

    flatten(deep_list, [elem]) :: [elem]
    when deep_list: [elem | deep_list], elem: var

Flattens the given `list` of nested lists. The list `tail` will be added at the end of the flattened list.

Empty list elements from `list` are discarded, but not the ones from `tail`.

## Examples

    iex> List.flatten([1, [[2], 3]], [4, 5])
    [1, 2, 3, 4, 5]

    iex> List.flatten([1, [], 2], [3, [], 4])
    [1, 2, 3, [], 4]

Link to this function

# foldl(list, acc, fun)

View Source

## Specs

    foldl([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var

Folds (reduces) the given list from the left with a function. Requires an accumulator.

## Examples

    iex> List.foldl([5, 5], 10, fn x, acc -> x + acc end)
    20

    iex> List.foldl([1, 2, 3, 4], 0, fn x, acc -> x - acc end)
    2

Link to this function

# foldr(list, acc, fun)

View Source

## Specs

    foldr([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var

Folds (reduces) the given list from the right with a function. Requires an accumulator.

## Examples

    iex> List.foldr([1, 2, 3, 4], 0, fn x, acc -> x - acc end)
    -2

Link to this function

# improper?(list)

View Source (since 1.8.0)

## Specs

    improper?(maybe_improper_list()) :: boolean()

Returns `true` if `list` is an improper list. Otherwise returns `false`.

## Examples

    iex> List.improper?([1, 2 | 3])
    true

    iex> List.improper?([1, 2, 3])
    false

Link to this function

# insert_at(list, index, value)

View Source

## Specs

    insert_at(list(), integer(), any()) :: list()

Returns a list with `value` inserted at the specified `index`.

Note that `index` is capped at the list length. Negative indices indicate an offset from the end of the `list`.

## Examples

    iex> List.insert_at([1, 2, 3, 4], 2, 0)
    [1, 2, 0, 3, 4]

    iex> List.insert_at([1, 2, 3], 10, 0)
    [1, 2, 3, 0]

    iex> List.insert_at([1, 2, 3], -1, 0)
    [1, 2, 3, 0]

    iex> List.insert_at([1, 2, 3], -10, 0)
    [0, 1, 2, 3]

Link to this function

# keydelete(list, key, position)

View Source

## Specs

    keydelete([tuple()], any(), non_neg_integer()) :: [tuple()]

Receives a `list` of tuples and deletes the first tuple where the element at `position` matches the given `key`. Returns the new list.

## Examples

    iex> List.keydelete([a: 1, b: 2], :a, 0)
    [b: 2]

    iex> List.keydelete([a: 1, b: 2], 2, 1)
    [a: 1]

    iex> List.keydelete([a: 1, b: 2], :c, 0)
    [a: 1, b: 2]

Link to this function

# keyfind(list, key, position, default \\ nil)

View Source

## Specs

    keyfind([tuple()], any(), non_neg_integer(), any()) :: any()

Receives a list of tuples and returns the first tuple where the element at `position` in the tuple matches the given `key`.

If no matching tuple is found, `default` is returned.

## Examples

    iex> List.keyfind([a: 1, b: 2], :a, 0)
    {:a, 1}

    iex> List.keyfind([a: 1, b: 2], 2, 1)
    {:b, 2}

    iex> List.keyfind([a: 1, b: 2], :c, 0)
    nil

Link to this function

# keymember?(list, key, position)

View Source

## Specs

    keymember?([tuple()], any(), non_neg_integer()) :: boolean()

Receives a list of tuples and returns `true` if there is a tuple where the element at `position` in the tuple matches the given `key`.

## Examples

    iex> List.keymember?([a: 1, b: 2], :a, 0)
    true

    iex> List.keymember?([a: 1, b: 2], 2, 1)
    true

    iex> List.keymember?([a: 1, b: 2], :c, 0)
    false

Link to this function

# keyreplace(list, key, position, new_tuple)

View Source

## Specs

    keyreplace([tuple()], any(), non_neg_integer(), tuple()) :: [tuple()]

Receives a list of tuples and if the identified element by `key` at `position` exists, it is replaced with `new_tuple`.

## Examples

    iex> List.keyreplace([a: 1, b: 2], :a, 0, {:a, 3})
    [a: 3, b: 2]

    iex> List.keyreplace([a: 1, b: 2], :a, 1, {:a, 3})
    [a: 1, b: 2]

Link to this function

# keysort(list, position)

View Source

## Specs

    keysort([tuple()], non_neg_integer()) :: [tuple()]

Receives a list of tuples and sorts the elements at `position` of the tuples. The sort is stable.

## Examples

    iex> List.keysort([a: 5, b: 1, c: 3], 1)
    [b: 1, c: 3, a: 5]

    iex> List.keysort([a: 5, c: 1, b: 3], 0)
    [a: 5, b: 3, c: 1]

Link to this function

# keystore(list, key, position, new_tuple)

View Source

## Specs

    keystore([tuple()], any(), non_neg_integer(), tuple()) :: [tuple(), ...]

Receives a `list` of tuples and replaces the element identified by `key` at `position` with `new_tuple`.

If the element does not exist, it is added to the end of the `list`.

## Examples

    iex> List.keystore([a: 1, b: 2], :a, 0, {:a, 3})
    [a: 3, b: 2]

    iex> List.keystore([a: 1, b: 2], :c, 0, {:c, 3})
    [a: 1, b: 2, c: 3]

Link to this function

# keytake(list, key, position)

View Source

## Specs

    keytake([tuple()], any(), non_neg_integer()) :: {tuple(), [tuple()]} | nil

Receives a `list` of tuples and returns the first tuple where the element at `position` in the tuple matches the given `key`, as well as the `list` without found tuple.

If such a tuple is not found, `nil` will be returned.

## Examples

    iex> List.keytake([a: 1, b: 2], :a, 0)
    {{:a, 1}, [b: 2]}

    iex> List.keytake([a: 1, b: 2], 2, 1)
    {{:b, 2}, [a: 1]}

    iex> List.keytake([a: 1, b: 2], :c, 0)
    nil

Link to this function

# last(list)

View Source

## Specs

    last([]) :: nil

    last([elem, ...]) :: elem when elem: var

Returns the last element in `list` or `nil` if `list` is empty.

## Examples

    iex> List.last([])
    nil

    iex> List.last([1])
    1

    iex> List.last([1, 2, 3])
    3

Link to this function

# myers_difference(list1, list2)

View Source (since 1.4.0)

## Specs

    myers_difference(list(), list()) :: [{:eq | :ins | :del, list()}]

Returns a keyword list that represents an edit script.

The algorithm is outlined in the "An O(ND) Difference Algorithm and Its Variations" paper by E. Myers.

An edit script is a keyword list. Each key describes the "editing action" to take in order to bring `list1` closer to being equal to `list2`; a key can be `:eq`, `:ins`, or `:del`. Each value is a sublist of either `list1` or `list2` that should be inserted (if the corresponding key `:ins`), deleted (if the corresponding key is `:del`), or left alone (if the corresponding key is `:eq`) in `list1` in order to be closer to `list2`.

See `myers_difference/3` if you want to handle nesting in the diff scripts.

## Examples

    iex> List.myers_difference([1, 4, 2, 3], [1, 2, 3, 4])
    [eq: [1], del: [4], eq: [2, 3], ins: [4]]

Link to this function

# myers_difference(list1, list2, diff_script)

View Source (since 1.8.0)

## Specs

    myers_difference(list(), list(), (term(), term() -> script | nil)) :: script
    when script: [{:eq | :ins | :del | :diff, list()}]

Returns a keyword list that represents an edit script with nested diffs.

This is an extension of `myers_difference/2` where a `diff_script` function can be given in case it is desired to compute nested differences. The function may return a list with the inner edit script or `nil` in case there is no such script. The returned inner edit script will be under the `:diff` key.

## Examples

    iex> List.myers_difference(["a", "db", "c"], ["a", "bc"], &String.myers_difference/2)
    [eq: ["a"], diff: [del: "d", eq: "b", ins: "c"], del: ["c"]]

Link to this function

# pop_at(list, index, default \\ nil)

View Source (since 1.4.0)

## Specs

    pop_at(list(), integer(), any()) :: {any(), list()}

Returns and removes the value at the specified `index` in the `list`.

Negative indices indicate an offset from the end of the `list`. If `index` is out of bounds, the original `list` is returned.

## Examples

    iex> List.pop_at([1, 2, 3], 0)
    {1, [2, 3]}
    iex> List.pop_at([1, 2, 3], 5)
    {nil, [1, 2, 3]}
    iex> List.pop_at([1, 2, 3], 5, 10)
    {10, [1, 2, 3]}
    iex> List.pop_at([1, 2, 3], -1)
    {3, [1, 2]}

Link to this function

# replace_at(list, index, value)

View Source

## Specs

    replace_at(list(), integer(), any()) :: list()

Returns a list with a replaced value at the specified `index`.

Negative indices indicate an offset from the end of the `list`. If `index` is out of bounds, the original `list` is returned.

## Examples

    iex> List.replace_at([1, 2, 3], 0, 0)
    [0, 2, 3]

    iex> List.replace_at([1, 2, 3], 10, 0)
    [1, 2, 3]

    iex> List.replace_at([1, 2, 3], -1, 0)
    [1, 2, 0]

    iex> List.replace_at([1, 2, 3], -10, 0)
    [1, 2, 3]

Link to this function

# starts_with?(list, prefix)

View Source (since 1.5.0)

## Specs

    starts_with?([...], [...]) :: boolean()

    starts_with?(list(), []) :: true

    starts_with?([], [...]) :: false

Returns `true` if `list` starts with the given `prefix` list; otherwise returns `false`.

If `prefix` is an empty list, it returns `true`.

### Examples

    iex> List.starts_with?([1, 2, 3], [1, 2])
    true

    iex> List.starts_with?([1, 2], [1, 2, 3])
    false

    iex> List.starts_with?([:alpha], [])
    true

    iex> List.starts_with?([], [:alpha])
    false

Link to this function

# to_atom(charlist)

View Source

## Specs

    to_atom(charlist()) :: atom()

Converts a charlist to an atom.

Elixir supports conversions from charlists which contains any Unicode code point.

Inlined by the compiler.

## Examples

    iex> List.to_atom('Elixir')
    :Elixir

    iex> List.to_atom('🌢 Elixir')
    :"🌢 Elixir"

Link to this function

# to_charlist(list)

View Source (since 1.8.0)

## Specs

    to_charlist(:unicode.charlist()) :: charlist()

Converts a list of integers representing Unicode code points, lists or strings into a charlist.

Notice that this function expects a list of integers representing Unicode code points. If you have a list of bytes, you must instead use the module`:binary`.

## Examples

    iex> List.to_charlist([0x00E6, 0x00DF])
    'æß'

    iex> List.to_charlist([0x0061, "bc"])
    'abc'

    iex> List.to_charlist([0x0064, "ee", ['p']])
    'deep'

Link to this function

# to_existing_atom(charlist)

View Source

## Specs

    to_existing_atom(charlist()) :: atom()

Converts a charlist to an existing atom. Raises an `ArgumentError` if the atom does not exist.

Elixir supports conversions from charlists which contains any Unicode code point.

Inlined by the compiler.

## Examples

    iex> _ = :my_atom
    iex> List.to_existing_atom('my_atom')
    :my_atom

    iex> _ = :"🌢 Elixir"
    iex> List.to_existing_atom('🌢 Elixir')
    :"🌢 Elixir"

    iex> List.to_existing_atom('this_atom_will_never_exist')
    ** (ArgumentError) argument error

Link to this function

# to_float(charlist)

View Source

## Specs

    to_float(charlist()) :: float()

Returns the float whose text representation is `charlist`.

Inlined by the compiler.

## Examples

    iex> List.to_float('2.2017764e+0')
    2.2017764

Link to this function

# to_integer(charlist)

View Source

## Specs

    to_integer(charlist()) :: integer()

Returns an integer whose text representation is `charlist`.

Inlined by the compiler.

## Examples

    iex> List.to_integer('123')
    123

Link to this function

# to_integer(charlist, base)

View Source

## Specs

    to_integer(charlist(), 2..36) :: integer()

Returns an integer whose text representation is `charlist` in base `base`.

Inlined by the compiler.

The base needs to be between `2` and `36`.

## Examples

    iex> List.to_integer('3FF', 16)
    1023

Link to this function

# to_string(list)

View Source

## Specs

    to_string(:unicode.charlist()) :: String.t()

Converts a list of integers representing code points, lists or strings into a string.

To be converted to a string, a list must either be empty or only contain the following elements:

- strings
- integers representing Unicode code points
- a list containing one of these three elements

Notice that this function expects a list of integers representing Unicode code points. If you have a list of bytes, you must instead use the module`:binary`.

## Examples

    iex> List.to_string([0x00E6, 0x00DF])
    "æß"

    iex> List.to_string([0x0061, "bc"])
    "abc"

    iex> List.to_string([0x0064, "ee", ['p']])
    "deep"

    iex> List.to_string([])
    ""

Link to this function

# to_tuple(list)

View Source

## Specs

    to_tuple(list()) :: tuple()

Converts a list to a tuple.

Inlined by the compiler.

## Examples

    iex> List.to_tuple([:share, [:elixir, 163]])
    {:share, [:elixir, 163]}

Link to this function

# update_at(list, index, fun)

View Source

## Specs

    update_at([elem], integer(), (elem -> any())) :: list() when elem: var

Returns a list with an updated value at the specified `index`.

Negative indices indicate an offset from the end of the `list`. If `index` is out of bounds, the original `list` is returned.

## Examples

    iex> List.update_at([1, 2, 3], 0, &(&1 + 10))
    [11, 2, 3]

    iex> List.update_at([1, 2, 3], 10, &(&1 + 10))
    [1, 2, 3]

    iex> List.update_at([1, 2, 3], -1, &(&1 + 10))
    [1, 2, 13]

    iex> List.update_at([1, 2, 3], -10, &(&1 + 10))
    [1, 2, 3]

Link to this function

# wrap(term)

View Source

## Specs

    wrap(term()) :: maybe_improper_list()

Wraps `term` in a list if this is not list.

If `term` is already a list, it returns the list. If `term` is `nil`, it returns an empty list.

## Examples

    iex> List.wrap("hello")
    ["hello"]

    iex> List.wrap([1, 2, 3])
    [1, 2, 3]

    iex> List.wrap(nil)
    []

Link to this function

# zip(list_of_lists)

View Source

## Specs

    zip([list()]) :: [tuple()]

Zips corresponding elements from each list in `list_of_lists`.

The zipping finishes as soon as any list terminates.

## Examples

    iex> List.zip([[1, 2], [3, 4], [5, 6]])
    [{1, 3, 5}, {2, 4, 6}]

    iex> List.zip([[1, 2], [3], [5, 6]])
    [{1, 3, 5}]