Specs

ascii_printable?(list(), limit) :: boolean()
when limit: :infinity | non_neg_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

Specs

delete(list(), any()) :: list()

Deletes the given item from the list. Returns a new list without the item.

If the item 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, :b, :c], :b)
[:a, :b, :c]

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]

Specs

duplicate(elem, non_neg_integer()) :: [elem] when elem: var

Duplicates the given element n times in a list.

Examples

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

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

Specs

first([elem]) :: nil | 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

Specs

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

Flattens the given list of nested lists.

Examples

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

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.

Examples

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

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

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

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

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]

Specs

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

Receives a list of tuples and deletes the first tuple where the item 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]

Specs

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

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

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

Specs

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

Receives a list of tuples and returns true if there is a tuple where the item 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

Specs

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

Receives a list of tuples and if the identified item 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]

Specs

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

Receives a list of tuples and sorts the items 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]

Specs

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

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

If the item 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]

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

Specs

last([elem]) :: nil | 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

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]]

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"]]

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]}

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]

Specs

starts_with?(list(), list()) :: 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

Specs

to_atom(charlist()) :: atom()

Converts a charlist to an atom.

Currently Elixir does not support conversions from charlists which contains Unicode codepoints greater than 0xFF.

Inlined by the compiler.

Examples

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

Specs

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

Converts a list of integers representing codepoints, lists or strings into a charlist.

Notice that this function expects a list of integers representing UTF-8 codepoints. If you have a list of bytes, you must instead use the :binary module.

Examples

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

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

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

Specs

to_existing_atom(charlist()) :: atom()

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

Currently Elixir does not support conversions from charlists which contains Unicode codepoints greater than 0xFF.

Inlined by the compiler.

Examples

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

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

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

Specs

to_integer(charlist()) :: integer()

Returns an integer whose text representation is charlist.

Inlined by the compiler.

Examples

iex> List.to_integer('123')
123

Specs

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

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

Inlined by the compiler.

Examples

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

Specs

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

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

Notice that this function expects a list of integers representing UTF-8 codepoints. If you have a list of bytes, you must instead use the :binary module.

Examples

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

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

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

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]}

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]

Specs

wrap(nil) :: []

wrap(list) :: list when list: maybe_improper_list()

wrap(term) :: [term, ...] when term: any()

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)
[]

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}]