Search results for enum take
Enum.take/2 (function)
Takes an `amount` of elements from the beginning or the end of the `enumerable`. If ...
Enum.take_while/2 (function)
Takes the elements from the beginning of the `enumerable` while `fun` returns a truth...
Enum.take_random/2 (function)
Takes `count` random elements from `enumerable`. Note that this function will traver...
Splitting (drop and take) - Enum cheatsheet (extras)
...ck: ```elixir iex> Enum.take(cart, -1) [%{fruit: "orange", count: 6}] ``` ### [`take_every(enum, nth)`](`Enum.take_every/2`) ```elixir iex> Enum.take_every(cart, 2) [ %{frui...
Enum.take_every/2 (function)
Returns a list of every `nth` element in the `enumerable`, starting with the first element. The first element is always included, unless `nth` is 0. The secon...
Enum (module)
...sed as if it was an enumerable. For a general overview of all functions in the `Enum` module, see [the `Enum` cheatsheet](enum-cheat.cheatmd). The functions in this...
Examples - Enum.take/2 (function)
iex> Enum.take([1, 2, 3], 2) [1, 2] iex> Enum.take([1, 2, 3], 10) [1, 2, 3] iex> Enum.take([1, 2, 3], 0) [] iex> Enum.take([1, 2, 3],...
Keyword.take/2 (function)
Takes all entries corresponding to the given `keys` and returns them as a new keyword...
Stream.take_while/2 (function)
Lazily takes elements of the enumerable while the given function returns a truthy value.
Stream.take/2 (function)
Lazily takes the next `count` elements from the enumerable and stops enumeration. If a nega...
Examples - Enum.take_every/2 (function)
iex> Enum.take_every(1..10, 2) [1, 3, 5, 7, 9] iex> Enum.take_every(1..10, 0) [] iex> Enum.take_every([1, 2, 3], 1) [1, 2, 3]
Examples - Enum.take_random/2 (function)
# Although not necessary, let's seed the random algorithm iex> :rand.seed(:exsss, {1, 2, 3}) iex> Enum.take_random(1..10, 2) [6, 1] iex> Enum.ta...
Examples - Enum.take_while/2 (function)
iex> Enum.take_while([1, 2, 3], fn x -> x < 3 end) [1, 2]
Stream.take_every/2 (function)
Creates a stream that takes every `nth` element from the enumerable. The first element is always included,...
Enum cheatsheet (extras)
# Enum cheatsheet A quick reference into the `Enum` module, a module for working with...
Enum.slice/2 (function)
...`enumerable`, it drops elements before `index_range.first` (zero-base), then it takes elements until element `index_range.last` (inclusively). Indexes are normalize...
Enum.unzip/1 (function)
...ts two-element tuples from the given `enumerable` and groups them together. It takes an `enumerable` with elements being two-element tuples and returns a tuple with...
Enum.product/1 (function)
...non-numeric value. If you need to apply a transformation first, consider using `Enum.product_by/2` instead.
Enum.sum/1 (function)
...non-numeric value. If you need to apply a transformation first, consider using `Enum.sum_by/2` instead.
Sorting - Enum cheatsheet (extras)
...> Enum.sort(:desc) ["orange", "banana", "apple"] ``` When sorting structs, use `Enum.sort/2` with a module as sorter. ### [`sort_by(enum, mapper, sorter \\ :asc)`](`Enum.s...
Enum.slice/3 (function)
...an `enumerable`, it drops elements right before element `start_index`; then, it takes `amount` of elements, returning as many elements as possible if there are not e...
Random - Enum cheatsheet (extras)
...y call: ```elixir iex> Enum.random(cart) %{fruit: "orange", count: 6} ``` ### [`take_random(enum, count)`](`Enum.take_random/2`) Results will vary on every call: ```elixir iex...
Enum.zip_with/2 (function)
...hem with the `zip_fun` function as it goes. The first element from each of the enums in `enumerables` will be put into a list which is then passed to the one-arity ...
Map.take/2 (function)
Returns a new map with all the key-value pairs in `map` where the key is in `keys`. If `keys` contains keys that are not in `map`, they're simply ignored.
Zipping - Enum cheatsheet (extras)
... Enum.zip(fruits, counts) [{"apple", 3}, {"banana", 1}, {"orange", 6}] ``` See `Enum.zip/1` for zipping many collections at once. ### [`zip_with(enum1, enum2, fun)`](`Enu...
Side-effects - Enum cheatsheet (extras)
...```elixir iex> Enum.each(cart, &IO.puts(&1.fruit)) apple banana orange :ok ``` `Enum.each/2` is used exclusively for side-effects.
Aggregations - Enum cheatsheet (extras)
...### [`count(enum)`](`Enum.count/1`) ```elixir iex> Enum.count(cart) 3 ``` See `Enum.count_until/2` to count until a limit. ### [`frequencies(enum)`](`Enum.frequencies/1`) ```el...
Enum.zip_reduce/3 (function)
...e is empty. The reducer will receive 2 args: a list of elements (one from each enum) and the accumulator. In practice, the behavior provided by this function can b...
Examples - Enum.slice/3 (function)
....slice(1..100, 5, 10) [6, 7, 8, 9, 10, 11, 12, 13, 14, 15] # amount to take is greater than the number of elements iex> Enum.slice(1..10, 5, 100) [...
Predicates - Enum cheatsheet (extras)
...", count: 3}) true iex> Enum.member?(cart, :something_else) false ``` `item in enum` is equivalent to `Enum.member?(enum, item)`: ```elixir iex> %{fruit: "apple", ...
Chunking - Enum cheatsheet (extras)
... %{fruit: "banana", count: 1}, %{fruit: "orange", count: 6} ] ] ``` See `Enum.chunk_while/4` for custom chunking.
Examples - Enum.zip_reduce/3 (function)
iex> enums = [[1, 1], [2, 2], [3, 3]] ...> Enum.zip_reduce(enums, [], fn elements, ac...
Examples - Enum.all?/2 (function)
...e iex> Enum.all?([], fn _ -> nil end) true As the last example shows, `Enum.all?/2` returns `true` if `enumerable` is empty, regardless of `fun`. In an empty enume...
Examples - Keyword.take/2 (function)
iex> Keyword.take([a: 1, b: 2, c: 3], [:a, :c, :e]) [a: 1, c: 3] iex> Keyword.take([a: 1, b: 2, c: 3, a: 5], [:a, :c, :e]) [a: 1, c: 3, a: 5]
Examples - Map.take/2 (function)
iex> Map.take(%{a: 1, b: 2, c: 3}, [:a, :c, :e]) %{a: 1, c: 3}
Examples - Stream.take/2 (function)
iex> stream = Stream.take(1..100, 5) iex> Enum.to_list(stream) [1, 2, 3, 4, 5] iex> stream = Stream.take(1..100, -5) iex> Enum.to_list(stream) ...
Reduce as a building block - Enum.reduce/3 (function)
...ic building block in functional programming. Almost all of the functions in the `Enum` module can be implemented on top of reduce. Those functions often rely on other...
Attention: unbound async + take - Task.async_stream/5 (function)
...at the cost of reducing concurrency. You can also set the number of elements to take to be a multiple of `:max_concurrency`. For instance, setting `max_concurrency:...
Enum.all?/1 (function)
Returns `true` if all elements in `enumerable` are truthy. When an element has a falsy value (`false` or `nil`) iteration stops immediately and `false` is retu...
Enum.all?/2 (function)
Returns `true` if `fun.(element)` is truthy for all elements in `enumerable`. Iterates over `enumerable` and invokes `fun` on each element. If `fun` ever retur...
Enum.any?/1 (function)
Returns `true` if at least one element in `enumerable` is truthy. When an element has a truthy value (neither `false` nor `nil`) iteration stops immediately an...
Enum.any?/2 (function)
Returns `true` if `fun.(element)` is truthy for at least one element in `enumerable`. Iterates over the `enumerable` and invokes `fun` on each element. When an...
Enum.at/3 (function)
Finds the element at the given `index` (zero-based). Returns `default` if `index` is out of bounds. A negative `index` can be passed, which means the `enumera...
Enum.concat/1 (function)
Given an enumerable of enumerables, concatenates the `enumerables` into a single list.
Enum.concat/2 (function)
Concatenates the enumerable on the `right` with the enumerable on the `left`. This function produces the same result as the `++/2` operator for lists.
Enum.count/1 (function)
Returns the size of the `enumerable`.
Enum.count/2 (function)
Returns the count of elements in the `enumerable` for which `fun` returns a truthy value.
Enum.dedup/1 (function)
Enumerates the `enumerable`, returning a list where all consecutive duplicate elements are collapsed to a single element. Elements are compared using `===/2`. ...
Enum.drop/2 (function)
Drops the `amount` of elements from the `enumerable`. If a negative `amount` is given, the `amount` of last values will be dropped. The `enumerable` will be en...
Enum.each/2 (function)
Invokes the given `fun` for each element in the `enumerable`. Returns `:ok`.
Enum.empty?/1 (function)
Determines if the `enumerable` is empty. Returns `true` if `enumerable` is empty, otherwise `false`.
Enum.fetch/2 (function)
Finds the element at the given `index` (zero-based). Returns `{:ok, element}` if found, otherwise `:error`. A negative `index` can be passed, which means the ...
Enum.fetch!/2 (function)
Finds the element at the given `index` (zero-based). Raises `OutOfBoundsError` if the given `index` is outside the range of the `enumerable`.
Enum.filter/2 (function)
Filters the `enumerable`, i.e. returns only those elements for which `fun` returns a truthy value. See also `reject/2` which discards all elements where the fu...
Enum.find/3 (function)
Returns the first element for which `fun` returns a truthy value. If no such element is found, returns `default`.
Enum.frequencies/1 (function)
Returns a map with keys as unique elements of `enumerable` and values as the count of every element.
Enum.index/0 (type)
Zero-based index. It can also be a negative integer.
Enum.intersperse/2 (function)
Intersperses `separator` between each element of the enumeration.
Enum.into/2 (function)
Inserts the given `enumerable` into a `collectable`. Note that passing a non-empty list as the `collectable` is deprecated. If you're collecting into a non-emp...
Enum.into/3 (function)
Inserts the given `enumerable` into a `collectable` according to the transformation function.
Enum.join/2 (function)
Joins the given `enumerable` into a string using `joiner` as a separator. If `joiner` is not passed at all, it defaults to an empty string. All elements in th...
Enum.map/2 (function)
Returns a list where each element is the result of invoking `fun` on each corresponding element of `enumerable`. For maps, the function expects a key-value tup...
Enum.max/3 (function)
Returns the maximal element in the `enumerable` according to Erlang's term ordering. By default, the comparison is done with the `>=` sorter function. If multi...
Enum.member?/2 (function)
Checks if `element` exists within the `enumerable`. Membership is tested with the match (`===/2`) operator.
Enum.min/3 (function)
Returns the minimal element in the `enumerable` according to Erlang's term ordering. By default, the comparison is done with the `<=` sorter function. If multi...
Enum.random/1 (function)
Returns a random element of an `enumerable`. Raises `Enum.EmptyError` if `enumerable` is empty. This function uses Erlang's [`:rand` module](`:rand`) to calcu...
Enum.reduce/2 (function)
Invokes `fun` for each element in the `enumerable` with the accumulator. Raises `Enum.EmptyError` if `enumerable` is empty. The first element of the `enumerab...
Enum.reduce/3 (function)
Invokes `fun` for each element in the `enumerable` with the accumulator. The initial value of the accumulator is `acc`. The function is invoked for each elemen...
Enum.reject/2 (function)
Returns a list of elements in `enumerable` excluding those for which the function `fun` returns a truthy value. See also `filter/2`.
Enum.reverse/1 (function)
Returns a list of elements in `enumerable` in reverse order.
Enum.reverse/2 (function)
Reverses the elements in `enumerable`, appends the `tail`, and returns it as a list. This is an optimization for `enumerable |> Enum.reverse() |> Enum.concat(t...
Enum.scan/2 (function)
Applies the given function to each element in the `enumerable`, storing the result in a list and passing it as the accumulator for the next computation. Uses th...
Enum.scan/3 (function)
Applies the given function to each element in the `enumerable`, storing the result in a list and passing it as the accumulator for the next computation. Uses th...
Enum.shuffle/1 (function)
Returns a list with the elements of `enumerable` shuffled. This function uses Erlang's [`:rand` module](`:rand`) to calculate the random value. Check its docum...
Enum.slide/3 (function)
Slides a single or multiple elements given by `range_or_single_index` from `enumerable` to `insertion_index`. The semantics of the range to be moved match the ...
Enum.sort/1 (function)
Sorts the `enumerable` according to Erlang's term ordering. This function uses the merge sort algorithm. Do not use this function to sort structs, see `sort/2`...
Enum.sort/2 (function)
Sorts the `enumerable` by the given function. This function uses the merge sort algorithm. The given function should compare two arguments, and return `true` i...
Enum.split/2 (function)
Splits the `enumerable` into two enumerables, leaving `count` elements in the first one. If `count` is a negative number, it starts counting from the back to t...
Enum.uniq/1 (function)
Enumerates the `enumerable`, removing all duplicate elements. The first occurrence of each element is kept and all following duplicates are removed. The overal...
Enum.zip/1 (function)
Zips corresponding elements from a finite collection of enumerables into a list of tuples. The zipping finishes as soon as any enumerable in the given collecti...
Enum.zip/2 (function)
Zips corresponding elements from two enumerables into a list of tuples. Because a list of two-element tuples with atoms as the first tuple element is a keyword...
Examples - Stream.take_every/2 (function)
iex> stream = Stream.take_every(1..10, 2) iex> Enum.to_list(stream) [1, 3, 5, 7, 9] iex> stream = Stream.take_every([1, 2, 3, 4, 5], 1) iex> En...
Examples - Stream.take_while/2 (function)
iex> stream = Stream.take_while(1..100, &(&1 <= 5)) iex> Enum.to_list(stream) [1, 2, 3, 4, 5]
Filtering - Enum cheatsheet (extras)
{: .col-2} ### [`filter(enum, fun)`](`Enum.filter/2`) ```elixir iex> Enum.filter(cart, &(&1.fruit =~ "o")) [%{fruit: "orange", count: 6}] iex> Enum.filter(car...
Mapping - Enum cheatsheet (extras)
{: .col-2} ### [`map(enum, fun)`](`Enum.map/2`) ```elixir iex> Enum.map(cart, & &1.fruit) ["apple", "banana", "orange"] iex> Enum.map(cart, fn item -> ...> ...
Accumulating - Enum cheatsheet (extras)
{: .col-2} ### [`reduce(enum, acc, fun)`](`Enum.reduce/3`) ```elixir iex> Enum.reduce(cart, 0, fn item, acc -> ...> item.count + acc ...> end) 10 ``` ### [...
Conversion - Enum cheatsheet (extras)
{: .col-2} ### [`into(enum, collectable)`](`Enum.into/2`) ```elixir iex> pairs = [{"apple", 3}, {"banana", 1}, {"orange", 6}] iex> Enum.into(pairs, %{}) %{"ap...
Indexing - Enum cheatsheet (extras)
{: .col-2} ### [`at(enum, index, default \\ nil)`](`Enum.at/2`) ```elixir iex> Enum.at(cart, 0) %{fruit: "apple", count: 3} iex> Enum.at(cart, 10) nil iex> En...
Finding - Enum cheatsheet (extras)
{: .col-2} ### [`find(enum, default \\ nil, fun)`](`Enum.find/2`) ```elixir iex> Enum.find(cart, &(&1.fruit =~ "o")) %{fruit: "orange", count: 6} iex> Enum.fi...
Grouping - Enum cheatsheet (extras)
{: .col-2} ### [`group_by(enum, key_fun)`](`Enum.group_by/2`) Group by the last letter of the fruit: ```elixir iex> Enum.group_by(cart, &String.last(&1.fruit...
Slicing - Enum cheatsheet (extras)
{: .col-2} ### [`slice(enum, index_range)`](`Enum.slice/2`) ```elixir iex> Enum.slice(cart, 0..1) [ %{fruit: "apple", count: 3}, %{fruit: "banana", count:...
Reversing - Enum cheatsheet (extras)
{: .col-2} ### [`reverse(enum)`](`Enum.reverse/1`) ```elixir iex> Enum.reverse(cart) [ %{fruit: "orange", count: 6}, %{fruit: "banana", count: 1}, %{fru...
Splitting - Enum cheatsheet (extras)
{: .col-2} ### [`split(enum, amount)`](`Enum.split/2`) ```elixir iex> Enum.split(cart, 1) {[%{fruit: "apple", count: 3}], [ %{fruit: "banana", count: 1}, ...
Examples - Enum.sort_by/3 (function)
...r"] Sorting by multiple properties - first by size, then by first letter (this takes advantage of the fact that tuples are compared element-by-element): iex> E...
Enum.chunk_by/2 (function)
Splits enumerable on every element for which `fun` returns a new value. Returns a list of lists.
Enum.chunk_every/2 (function)
Shortcut to `chunk_every(enumerable, count, count)`.
Enum.chunk_every/4 (function)
Returns list of lists containing `count` elements each, where each new chunk starts `step` elements into the `enumerable`. `step` is optional and, if not passe...
Enum.chunk_while/4 (function)
Chunks the `enumerable` with fine grained control when every chunk is emitted. `chunk_fun` receives the current element and the accumulator and must return: ...
Enum.count_until/2 (function)
Counts the enumerable stopping at `limit`. This is useful for checking certain properties of the count of an enumerable without having to actually count the en...
Enum.count_until/3 (function)
Counts the elements in the enumerable for which `fun` returns a truthy value, stopping at `limit`. See `count/2` and `count_until/2` for more information.
Enum.dedup_by/2 (function)
Enumerates the `enumerable`, returning a list where all consecutive duplicate elements are collapsed to a single element. The function `fun` maps every element...
Enum.drop_every/2 (function)
Returns a list of every `nth` element in the `enumerable` dropped, starting with the first element. The first element is always dropped, unless `nth` is 0. Th...
Enum.drop_while/2 (function)
Drops elements at the beginning of the `enumerable` while `fun` returns a truthy value.
Enum.find_index/2 (function)
Similar to `find/3`, but returns the index (zero-based) of the element instead of the element itself.
Enum.find_value/3 (function)
Similar to `find/3`, but returns the value of the function invocation instead of the element itself. The return value is considered to be found when the result...
Enum.flat_map/2 (function)
Maps the given `fun` over `enumerable` and flattens the result. This function returns a new enumerable built by appending the result of invoking `fun` on each ...
Enum.frequencies_by/2 (function)
Returns a map with keys as unique elements given by `key_fun` and values as the count of every element.
Enum.group_by/3 (function)
Splits the `enumerable` into groups based on `key_fun`. The result is a map where each key is given by `key_fun` and each value is a list of elements given by ...
Enum.map_every/3 (function)
Returns a list of results of invoking `fun` on every `nth` element of `enumerable`, starting with the first element. The first element is always passed to the ...
Enum.map_intersperse/3 (function)
Maps and intersperses the given enumerable in one pass.
Enum.map_join/3 (function)
Maps and joins the given `enumerable` in one pass. If `joiner` is not passed at all, it defaults to an empty string. All elements returned from invoking the `...
Enum.map_reduce/3 (function)
Invokes the given function to each element in the `enumerable` to reduce it to a single element, while keeping an accumulator. Returns a tuple where the first ...
Enum.max_by/4 (function)
Returns the maximal element in the `enumerable` as calculated by the given `fun`. By default, the comparison is done with the `>=` sorter function. If multiple...
Enum.min_by/4 (function)
Returns the minimal element in the `enumerable` as calculated by the given `fun`. By default, the comparison is done with the `<=` sorter function. If multiple...
Enum.min_max/2 (function)
Returns a tuple with the minimal and the maximal elements in the enumerable according to Erlang's term ordering. If multiple elements are considered maximal or...
Enum.product_by/2 (function)
Maps and computes the product of the given `enumerable` in one pass. Raises `ArithmeticError` if `mapper` returns a non-numeric value.
Enum.reduce_while/3 (function)
Reduces `enumerable` until `fun` returns `{:halt, term}`. The return value for `fun` is expected to be * `{:cont, acc}` to continue the reduction with `acc`...
Enum.reverse_slice/3 (function)
Reverses the `enumerable` in the range from initial `start_index` through `count` elements. If `count` is greater than the size of the rest of the `enumerable`...
Enum.sort_by/3 (function)
Sorts the mapped results of the `enumerable` according to the provided `sorter` function. This function maps each element of the `enumerable` using the provide...
Enum.split_while/2 (function)
Splits enumerable in two at the position of the element for which `fun` returns a falsy value (`false` or `nil`) for the first time. It returns a two-element t...
Enum.split_with/2 (function)
Splits the `enumerable` in two lists according to the given function `fun`. Splits the given `enumerable` in two lists by calling `fun` with each element in th...
Enum.sum_by/2 (function)
Maps and sums the given `enumerable` in one pass. Raises `ArithmeticError` if `mapper` returns a non-numeric value.
Enum.to_list/1 (function)
Converts `enumerable` to a list.
Enum.uniq_by/2 (function)
Enumerates the `enumerable`, by removing the elements for which function `fun` returned duplicate elements. The function `fun` maps every element to a term. Tw...
Enum.with_index/2 (function)
Returns the `enumerable` with each element wrapped in a tuple alongside its index or according to a given function. If an integer offset is given as `fun_or_of...
Enum.zip_reduce/4 (function)
Reduces over two enumerables halting as soon as either enumerable is empty. In practice, the behavior provided by this function can be achieved with: Enum...
Enum.zip_with/3 (function)
Zips corresponding elements from two enumerables into a list, transforming them with the `zip_fun` function as it goes. The corresponding elements from each co...
Enum.flat_map_reduce/3 (function)
Maps and reduces an `enumerable`, flattening the given results (only one level deep). It expects an accumulator and a function that receives each enumerable el...
Enum.min_max_by/4 (function)
Returns a tuple with the minimal and the maximal elements in the enumerable as calculated by the given function. If multiple elements are considered maximal or...
Concatenating & flattening - Enum cheatsheet (extras)
{: .col-2} ### [`concat(enums)`](`Enum.concat/1`) ```elixir iex> Enum.concat([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) [1, 2, 3, 4, 5, 6, 7, 8, 9] ``` ### [`concat(...
Duplicates & uniques - Enum cheatsheet (extras)
{: .col-2} ### [`dedup(enum)`](`Enum.dedup/1`) `dedup` only removes contiguous duplicates: ```elixir iex> Enum.dedup([1, 2, 2, 3, 3, 3, 1, 2, 3]) [1, 2, 3, 1...
Joining & interspersing - Enum cheatsheet (extras)
{: .col-2} ### [`join(enum, joiner \\ "")`](`Enum.join/2`) ```elixir iex> Enum.join(["apple", "banana", "orange"], ", ") "apple, banana, orange" ``` ### [`ma...
Access.at/1 (function)
...index-based operations are generally avoided in favor of other functions in the `Enum` module. The returned function is typically passed as an accessor to `Kernel.ge...
Examples - Enum.all?/1 (function)
iex> Enum.all?([1, 2, 3]) true iex> Enum.all?([1, nil, 3]) false iex> Enum.all?([]) true
Examples - Enum.any?/1 (function)
iex> Enum.any?([false, false, false]) false iex> Enum.any?([false, true, false]) true iex> Enum.any?([]) false
Examples - Enum.any?/2 (function)
iex> Enum.any?([2, 4, 6], fn x -> rem(x, 2) == 1 end) false iex> Enum.any?([2, 3, 4], fn x -> rem(x, 2) == 1 end) true iex> Enum.any?([], fn x...
Examples - Enum.at/3 (function)
iex> Enum.at([2, 4, 6], 0) 2 iex> Enum.at([2, 4, 6], 2) 6 iex> Enum.at([2, 4, 6], 4) nil iex> Enum.at([2, 4, 6], 4, :none) :none
Examples - Enum.concat/1 (function)
iex> Enum.concat([1..3, 4..6, 7..9]) [1, 2, 3, 4, 5, 6, 7, 8, 9] iex> Enum.concat([[1, [2], 3], [4], [5, 6]]) [1, [2], 3, 4, 5, 6]
Examples - Enum.concat/2 (function)
iex> Enum.concat(1..3, 4..6) [1, 2, 3, 4, 5, 6] iex> Enum.concat([1, 2, 3], [4, 5, 6]) [1, 2, 3, 4, 5, 6]
Examples - Enum.count/1 (function)
iex> Enum.count([1, 2, 3]) 3
Examples - Enum.count/2 (function)
iex> Enum.count([1, 2, 3, 4, 5], fn x -> rem(x, 2) == 0 end) 2
Examples - Enum.dedup/1 (function)
iex> Enum.dedup([1, 2, 3, 3, 2, 1]) [1, 2, 3, 2, 1] iex> Enum.dedup([1, 1, 2, 2.0, :three, :three]) [1, 2, 2.0, :three]
Examples - Enum.drop/2 (function)
iex> Enum.drop([1, 2, 3], 2) [3] iex> Enum.drop([1, 2, 3], 10) [] iex> Enum.drop([1, 2, 3], 0) [1, 2, 3] iex> Enum.drop([1, 2, 3], -1...
Examples - Enum.each/2 (function)
Enum.each(["some", "example"], fn x -> IO.puts(x) end) "some" "example" #=> :ok
Examples - Enum.empty?/1 (function)
iex> Enum.empty?([]) true iex> Enum.empty?([1, 2, 3]) false
Examples - Enum.fetch/2 (function)
iex> Enum.fetch([2, 4, 6], 0) {:ok, 2} iex> Enum.fetch([2, 4, 6], -3) {:ok, 2} iex> Enum.fetch([2, 4, 6], 2) {:ok, 6} iex> Enum.fetch...
Examples - Enum.fetch!/2 (function)
iex> Enum.fetch!([2, 4, 6], 0) 2 iex> Enum.fetch!([2, 4, 6], 2) 6 iex> Enum.fetch!([2, 4, 6], 4) ** (Enum.OutOfBoundsError) out of bounds ...
Examples - Enum.filter/2 (function)
iex> Enum.filter([1, 2, 3], fn x -> rem(x, 2) == 0 end) [2] iex> Enum.filter(["apple", "pear", "banana"], fn fruit -> String.contains?(fruit, "a") end) ...
Examples - Enum.find/3 (function)
iex> Enum.find([2, 3, 4], fn x -> rem(x, 2) == 1 end) 3 iex> Enum.find([2, 4, 6], fn x -> rem(x, 2) == 1 end) nil iex> Enum.find([2, 4, 6], 0, ...
Examples - Enum.frequencies/1 (function)
iex> Enum.frequencies(~w{ant buffalo ant ant buffalo dingo}) %{"ant" => 3, "buffalo" => 2, "dingo" => 1}
Examples - Enum.intersperse/2 (function)
iex> Enum.intersperse([1, 2, 3], 0) [1, 0, 2, 0, 3] iex> Enum.intersperse([1], 0) [1] iex> Enum.intersperse([], 0) []
Examples - Enum.into/2 (function)
iex> Enum.into([1, 2], []) [1, 2] iex> Enum.into([a: 1, b: 2], %{}) %{a: 1, b: 2} iex> Enum.into(%{a: 1}, %{b: 2}) %{a: 1, b: 2} iex>...
Examples - Enum.into/3 (function)
iex> Enum.into([1, 2, 3], [], fn x -> x * 3 end) [3, 6, 9] iex> Enum.into(%{a: 1, b: 2}, %{c: 3}, fn {k, v} -> {k, v * 2} end) %{a: 2, b: 4, c: 3}
Examples - Enum.join/2 (function)
iex> Enum.join([1, 2, 3]) "123" iex> Enum.join([1, 2, 3], " = ") "1 = 2 = 3" iex> Enum.join([["a", "b"], ["c", "d", "e", ["f", "g"]], "h", "i"...
Examples - Enum.map/2 (function)
iex> Enum.map([1, 2, 3], fn x -> x * 2 end) [2, 4, 6] iex> Enum.map([a: 1, b: 2], fn {k, v} -> {k, -v} end) [a: -1, b: -2]
Examples - Enum.max/3 (function)
iex> Enum.max([1, 2, 3]) 3 The fact this function uses Erlang's term ordering means that the comparison is structural and not semantic. For example: i...
Examples - Enum.member?/2 (function)
iex> Enum.member?(1..10, 5) true iex> Enum.member?(1..10, 5.0) false iex> Enum.member?([1.0, 2.0, 3.0], 2) false iex> Enum.member?([1.0...
Examples - Enum.min/3 (function)
iex> Enum.min([1, 2, 3]) 1 The fact this function uses Erlang's term ordering means that the comparison is structural and not semantic. For example: i...
Examples - Enum.product/1 (function)
iex> Enum.product([]) 1 iex> Enum.product([2, 3, 4]) 24 iex> Enum.product([2.0, 3.0, 4.0]) 24.0
Examples - Enum.random/1 (function)
The examples below use the `:exsss` pseudorandom algorithm since it's the default from Erlang/OTP 22: # Although not necessary, let's seed the random algor...
Implementation - Enum.random/1 (function)
The random functions in this module implement reservoir sampling, which allows them to sample infinite collections. In particular, we implement Algorithm L, as ...
Examples - Enum.reduce/2 (function)
iex> Enum.reduce([1, 2, 3, 4], fn x, acc -> x * acc end) 24
Examples - Enum.reduce/3 (function)
iex> Enum.reduce([1, 2, 3], 0, fn x, acc -> x + acc end) 6 iex> Enum.reduce(%{a: 2, b: 3, c: 4}, 0, fn {_key, val}, acc -> acc + val end) 9
Examples - Enum.reject/2 (function)
iex> Enum.reject([1, 2, 3], fn x -> rem(x, 2) == 0 end) [1, 3]
Examples - Enum.reverse/1 (function)
iex> Enum.reverse([1, 2, 3]) [3, 2, 1]
Examples - Enum.reverse/2 (function)
iex> Enum.reverse([1, 2, 3], [4, 5, 6]) [3, 2, 1, 4, 5, 6]
Examples - Enum.scan/2 (function)
iex> Enum.scan(1..5, &(&1 + &2)) [1, 3, 6, 10, 15]
Examples - Enum.scan/3 (function)
iex> Enum.scan(1..5, 0, &(&1 + &2)) [1, 3, 6, 10, 15]
Examples - Enum.shuffle/1 (function)
The examples below use the `:exsss` pseudorandom algorithm since it's the default from Erlang/OTP 22: # Although not necessary, let's seed the random algor...
Examples - Enum.slice/2 (function)
iex> Enum.slice([1, 2, 3, 4, 5], 1..3) [2, 3, 4] iex> Enum.slice([1, 2, 3, 4, 5], 3..10) [4, 5] # Last three elements (negative indexes) i...
Examples - Enum.slide/3 (function)
# Slide a single element iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], 5, 1) [:a, :f, :b, :c, :d, :e, :g] # Slide a range of elements towards the h...
Examples - Enum.sort/1 (function)
iex> Enum.sort([3, 2, 1]) [1, 2, 3]
Examples - Enum.sort/2 (function)
iex> Enum.sort([1, 2, 3], &(&1 >= &2)) [3, 2, 1] The sorting algorithm will be stable as long as the given function returns `true` for values considered eq...
Examples - Enum.split/2 (function)
iex> Enum.split([1, 2, 3], 2) {[1, 2], [3]} iex> Enum.split([1, 2, 3], 10) {[1, 2, 3], []} iex> Enum.split([1, 2, 3], 0) {[], [1, 2, 3]} ...
Examples - Enum.sum/1 (function)
iex> Enum.sum([1, 2, 3]) 6 iex> Enum.sum(1..10) 55 iex> Enum.sum(1..10//2) 25
Examples - Enum.uniq/1 (function)
iex> Enum.uniq([1, 2, 3, 3, 2, 1]) [1, 2, 3]
Examples - Enum.unzip/1 (function)
iex> Enum.unzip([{:a, 1}, {:b, 2}, {:c, 3}]) {[:a, :b, :c], [1, 2, 3]}
Examples - Enum.zip/1 (function)
iex> Enum.zip([[1, 2, 3], [:a, :b, :c], ["foo", "bar", "baz"]]) [{1, :a, "foo"}, {2, :b, "bar"}, {3, :c, "baz"}] iex> Enum.zip([[1, 2, 3, 4, 5], [:a, :...
Examples - Enum.zip/2 (function)
iex> Enum.zip([1, 2, 3], [:a, :b, :c]) [{1, :a}, {2, :b}, {3, :c}] iex> Enum.zip([:a, :b, :c], [1, 2, 3]) [a: 1, b: 2, c: 3] iex> Enum.zip([1,...
Sorting structs - Enum.sort/2 (function)
Do not use `/2`, `>=/2` and friends when sorting structs. That's because the built-in operators above perform structural comparison and not a se...
Enumerable.result/0 (type)
...iven, the `:halted` tuple with the accumulator must be returned. Functions like `Enum.take_while/2` use `:halt` underneath and can be used to test halting enumerables. In case th...
Examples - Enum.chunk_by/2 (function)
iex> Enum.chunk_by([1, 2, 2, 3, 4, 4, 6, 7, 7], &(rem(&1, 2) == 1)) [[1], [2, 2], [3], [4, 4, 6], [7, 7]]
Examples - Enum.chunk_every/4 (function)
iex> Enum.chunk_every([1, 2, 3, 4, 5, 6], 2) [[1, 2], [3, 4], [5, 6]] iex> Enum.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, :discard) [[1, 2, 3], [3, 4, ...
Examples - Enum.chunk_while/4 (function)
iex> chunk_fun = fn element, acc -> ...> if rem(element, 2) == 0 do ...> {:cont, Enum.reverse([element | acc]), []} ...> else ...> {...
Examples - Enum.count_until/2 (function)
iex> Enum.count_until(1..20, 5) 5 iex> Enum.count_until(1..20, 50) 20 iex> Enum.count_until(1..10, 10) == 10 # At least 10 true iex> Enu...
Examples - Enum.count_until/3 (function)
iex> Enum.count_until(1..20, fn x -> rem(x, 2) == 0 end, 7) 7 iex> Enum.count_until(1..20, fn x -> rem(x, 2) == 0 end, 11) 10
Examples - Enum.dedup_by/2 (function)
iex> Enum.dedup_by([{1, :a}, {2, :b}, {2, :c}, {1, :a}], fn {x, _} -> x end) [{1, :a}, {2, :b}, {1, :a}] iex> Enum.dedup_by([5, 1, 2, 3, 2, 1], fn x ->...
Examples - Enum.drop_every/2 (function)
iex> Enum.drop_every(1..10, 2) [2, 4, 6, 8, 10] iex> Enum.drop_every(1..10, 0) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] iex> Enum.drop_every([1, 2, 3],...
Examples - Enum.drop_while/2 (function)
iex> Enum.drop_while([1, 2, 3, 2, 1], fn x -> x < 3 end) [3, 2, 1]
Examples - Enum.find_index/2 (function)
iex> Enum.find_index([2, 4, 6], fn x -> rem(x, 2) == 1 end) nil iex> Enum.find_index([2, 3, 4], fn x -> rem(x, 2) == 1 end) 1
Examples - Enum.find_value/3 (function)
iex> Enum.find_value([2, 3, 4], fn x -> ...> if x > 2, do: x * x ...> end) 9 iex> Enum.find_value([2, 4, 6], fn x -> rem(x, 2) == 1 end) ...
Examples - Enum.flat_map/2 (function)
iex> Enum.flat_map([:a, :b, :c], fn x -> [x, x] end) [:a, :a, :b, :b, :c, :c] iex> Enum.flat_map([{1, 3}, {4, 6}], fn {x, y} -> x..y end) [1, 2, 3,...
Examples - Enum.frequencies_by/2 (function)
iex> Enum.frequencies_by(~w{aa aA bb cc}, &String.downcase/1) %{"aa" => 2, "bb" => 1, "cc" => 1} iex> Enum.frequencies_by(~w{aaa aA bbb cc c}, &String....
Examples - Enum.group_by/3 (function)
iex> Enum.group_by(~w{ant buffalo cat dingo}, &String.length/1) %{3 => ["ant", "cat"], 5 => ["dingo"], 7 => ["buffalo"]} iex> Enum.group_by(~w{ant buff...
Examples - Enum.map_every/3 (function)
iex> Enum.map_every(1..10, 2, fn x -> x + 1000 end) [1001, 2, 1003, 4, 1005, 6, 1007, 8, 1009, 10] iex> Enum.map_every(1..10, 3, fn x -> x + 1000 end) ...
Examples - Enum.map_intersperse/3 (function)
iex> Enum.map_intersperse([1, 2, 3], :a, &(&1 * 2)) [2, :a, 4, :a, 6]
Examples - Enum.map_join/3 (function)
iex> Enum.map_join([1, 2, 3], &(&1 * 2)) "246" iex> Enum.map_join([1, 2, 3], " = ", &(&1 * 2)) "2 = 4 = 6"
Examples - Enum.map_reduce/3 (function)
iex> Enum.map_reduce([1, 2, 3], 0, fn x, acc -> {x * 2, x + acc} end) {[2, 4, 6], 6}
Examples - Enum.max_by/4 (function)
iex> Enum.max_by(["a", "aa", "aaa"], fn x -> String.length(x) end) "aaa" iex> Enum.max_by(["a", "aa", "aaa", "b", "bbb"], &String.length/1) "aaa" ...
Examples - Enum.min_by/4 (function)
iex> Enum.min_by(["a", "aa", "aaa"], fn x -> String.length(x) end) "a" iex> Enum.min_by(["a", "aa", "aaa", "b", "bbb"], &String.length/1) "a" The ...
Examples - Enum.min_max/2 (function)
iex> Enum.min_max([2, 3, 1]) {1, 3} iex> Enum.min_max([], fn -> {nil, nil} end) {nil, nil}
Examples - Enum.product_by/2 (function)
iex> Enum.product_by([%{count: 2}, %{count: 4}, %{count: 3}], fn x -> x.count end) 24 iex> Enum.product_by(1..3, fn x -> x ** 2 end) 36 iex> E...
Examples - Enum.reduce_while/3 (function)
iex> Enum.reduce_while(1..100, 0, fn x, acc -> ...> if x < 5 do ...> {:cont, acc + x} ...> else ...> {:halt, acc} ...> end ...
Examples - Enum.reverse_slice/3 (function)
iex> Enum.reverse_slice([1, 2, 3, 4, 5, 6], 2, 4) [1, 2, 6, 5, 4, 3]
Examples - Enum.split_while/2 (function)
iex> Enum.split_while([1, 2, 3, 4], fn x -> x < 3 end) {[1, 2], [3, 4]} iex> Enum.split_while([1, 2, 3, 4], fn x -> x < 0 end) {[], [1, 2, 3, 4]} ...
Examples - Enum.split_with/2 (function)
iex> Enum.split_with([5, 4, 3, 2, 1, 0], fn x -> rem(x, 2) == 0 end) {[4, 2, 0], [5, 3, 1]} iex> Enum.split_with([a: 1, b: -2, c: 1, d: -3], fn {_k, v}...
Examples - Enum.sum_by/2 (function)
iex> Enum.sum_by([%{count: 1}, %{count: 2}, %{count: 3}], fn x -> x.count end) 6 iex> Enum.sum_by(1..3, fn x -> x ** 2 end) 14 iex> Enum.sum_b...
Examples - Enum.to_list/1 (function)
iex> Enum.to_list(1..3) [1, 2, 3]
Example - Enum.uniq_by/2 (function)
iex> Enum.uniq_by([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end) [{1, :x}, {2, :y}] iex> Enum.uniq_by([a: {:tea, 2}, b: {:tea, 2}, c: {:coffee, 1}], ...
Examples - Enum.with_index/2 (function)
iex> Enum.with_index([:a, :b, :c]) [a: 0, b: 1, c: 2] iex> Enum.with_index([:a, :b, :c], 3) [a: 3, b: 4, c: 5] iex> Enum.with_index([:a, :b, :...
Examples - Enum.zip_reduce/4 (function)
iex> Enum.zip_reduce([1, 2], [3, 4], 0, fn x, y, acc -> x + y + acc end) 10 iex> Enum.zip_reduce([1, 2], [3, 4], [], fn x, y, acc -> [x + y | acc] end)...
Examples - Enum.zip_with/2 (function)
iex> Enum.zip_with([[1, 2], [3, 4], [5, 6]], fn [x, y, z] -> x + y + z end) [9, 12] iex> Enum.zip_with([[1, 2], [3, 4]], fn [x, y] -> x + y end) [4...
Examples - Enum.zip_with/3 (function)
iex> Enum.zip_with([1, 2], [3, 4], fn x, y -> x + y end) [4, 6] iex> Enum.zip_with([1, 2], [3, 4, 5, 6], fn x, y -> x + y end) [4, 6] iex> Enu...
Examples - Enum.flat_map_reduce/3 (function)
iex> enumerable = 1..100 iex> n = 3 iex> Enum.flat_map_reduce(enumerable, 0, fn x, acc -> ...> if acc end) {[1, 2, 3], 3} iex> Enum.fla...
Examples - Enum.min_max_by/4 (function)
iex> Enum.min_max_by(["aaa", "bb", "c"], fn x -> String.length(x) end) {"c", "aaa"} iex> Enum.min_max_by(["aaa", "a", "bb", "c", "ccc"], &String.length...
Performance characteristics - Enum.sort_by/3 (function)
As detailed in the initial section, `sort_by/3` calculates the comparison value for each element in the enumerable once instead of once for each element in each...
Zipping Maps - Enum.zip_with/3 (function)
It's important to remember that zipping inherently relies on order. If you zip two lists you get the element at the index from each list in turn. If we zip two ...
Ascending and descending (since v1.10.0) - Enum.sort/2 (function)
`sort/2` allows a developer to pass `:asc` or `:desc` as the sorter, which is a convenience for [`&<=/2`](`<=/2`) and [`&>=/2`](`>=/2`) respectively. iex> ...
Why Collectable? - Collectable (protocol)
...d by the `Enumerable` protocol do not keep shape. For example, passing a map to `Enum.map/2` always returns a list. This design is intentional. `Enumerable` was designed t...
Ascending and descending (since v1.10.0) - Enum.sort_by/3 (function)
`sort_by/3` allows a developer to pass `:asc` or `:desc` as the sorter, which is a convenience for [`&<=/2`](`<=/2`) and [`&>=/2`](`>=/2`) respectively: iex...
String.to_charlist/1 (function)
Converts a string into a charlist. Specifically, this function takes a UTF-8 encoded binary and returns a list of its integer code points. It is sim...
Stream (module)
...s are composable, lazy enumerables (for an introduction on enumerables, see the `Enum` module). Any enumerable that generates elements one by one during enumeration i...
Types - OptionParser.parse/2 (function)
Switches parsed by `OptionParser` may take zero or one arguments. The following switches types take no arguments: * `:...
String.printable?/2 (function)
Checks if a string contains only printable characters up to `character_limit`. Takes an optional `character_limit` as a second argument. If `character_limit` is `0`...
Stream.chunk_by/2 (function)
Chunks the `enum` by buffering elements for which `fun` returns the same value. Elements are onl...
Examples - Kernel.defdelegate/2 (macro)
defmodule MyList do defdelegate reverse(list), to: Enum defdelegate other_reverse(list), to: Enum, as: :reverse end MyLi...
Calendar.TimeZoneDatabase.time_zone_period_from_utc_iso_days/2 (callback)
Time zone period for a point in time in UTC for a specific time zone. Takes a time zone name and a point in time for UTC and returns a `time_zone_period` f...
Kernel.**/2 (function)
Power operator. It takes two numbers for input. If both are integers and the right-hand side (the `expon...
Map.split/2 (function)
Takes all entries corresponding to the given `keys` in `map` and extracts them into a...
length and size - Naming conventions (extras)
...ing.length/1` In other words, functions using the word "size" in its name will take the same amount of time whether the data structure is tiny or huge. Conversely,...
Comparing times - Time (module)
...ion. The existence of the `compare/2` function in this module also allows using `Enum.min/2` and `Enum.max/2` functions to get the minimum and maximum time of an `Enum`. Fo...
Comparing dates - Date (module)
...ion. The existence of the `compare/2` function in this module also allows using `Enum.min/2` and `Enum.max/2` functions to get the minimum and maximum date of an `Enum`. Fo...
Tuple (module)
... multiple elements. To manipulate a collection of elements, use a list instead. `Enum` functions do not work on tuples. Tuples are denoted with curly braces: ie...
Comparing naive date times - NaiveDateTime (module)
...ion. The existence of the `compare/2` function in this module also allows using `Enum.min/2` and `Enum.max/2` functions to get the minimum and maximum naive datetime of an ...
Inspect.Algebra.format/2 (function)
Formats a given document for a given width. Takes the maximum width and a document to print as its arguments and returns an IO da...
Keyword.split/2 (function)
Takes all entries corresponding to the given `keys` and extracts them into a separate...
Stream.zip_with/2 (function)
...hem with the `zip_fun` function as it goes. The first element from each of the enums in `enumerables` will be put into a list which is then passed to the one-arity ...
Exception.normalize/3 (function)
Normalizes an exception, converting Erlang exceptions to Elixir exceptions. It takes the `kind` spilled by `catch` as an argument and normalizes only `:error`, retu...
Enumerables - Enumerables and Streams (extras)
Elixir provides the concept of enumerables and the `Enum` module to work with them. We have already learned two enumerables: lists and ma...
DO NOT DO THIS - System (module)
...he system clock changes, some code that executed in 1 second may be reported as taking over 1 hour! To address such concerns, the VM provides a monotonic time via `Sy...
Quote and unquote (extras)
...e structures and the associated `quote/2` and `unquote/1` constructs, so we can take a look at macros in the next guide, and finally build our own domain specific l...
Reduce and map algorithms - Recursion (extras)
...ming in Elixir you will rarely use recursion as above to manipulate lists. The `Enum` module, which we're going to see in the next chapter already provides many conv...
Enumerables and Streams (extras)
...ve code, most operations we perform on collections is done with the help of the `Enum` and `Stream` modules. Let's learn how.
Collectable (protocol)
A protocol to traverse data structures. The `Enum.into/2` function uses this protocol to insert an enumerable into a collection: iex...
Differences to `count/1` - Enumerable.slice/1 (function)
... returns `:ok` if retrieving the `size` of the `enumerable` is cheap, fast, and takes constant time. Otherwise the simplest of operations, such as `Enum.at(enumerabl...
Throws - try, catch, and rescue (extras)
...with libraries that do not provide a proper API. For example, let's imagine the `Enum` module did not provide any API for finding a value and that we needed to find t...
MapSet.filter/2 (function)
.../2` > and `MapSet.reject/2` in a pipeline, it is likely more efficient > to use `Enum.map/2` and `Enum.filter/2` instead and convert to > a map at the end using `MapSet.new...
Anonymous functions - Kernel.SpecialForms.&/1 (macro)
...* 2 end`. We can partially apply a remote function with placeholder: iex> take_five = &Enum.take(&1, 5) iex> take_five.(1..10) [1, 2, 3, 4, 5] Another exa...
Map.filter/2 (function)
...ter/2` > and `Map.reject/2` in a pipeline, it is likely more efficient > to use `Enum.map/2` and `Enum.filter/2` instead and convert to > a map at the end using `Map.new/1`...
Examples - Stream.run/1 (function)
...le")) |> Stream.run() No computation will be done until we call one of the `Enum` functions or `run/1`.
Maps - Typespecs reference (extras)
| %{} # empty map | %{key: value_type} # map with required key :key of value_type | %{key_t...
The pipe operator - Enumerables and Streams (extras)
The `|>` symbol used in the snippet above is the **pipe operator**: it takes the output from the expression on its left side and passes it as the first argu...
DateTime (module)
...ion. The existence of the `compare/2` function in this module also allows using `Enum.min/2` and `Enum.max/2` functions to get the minimum and maximum datetime of an `Enum`...
A simple example - Typespecs reference (extras)
...n the generated documentation. * We specify that the `long_word?/1` function takes an argument of type `word()` and returns a boolean (`boolean()`), that is, ...
Stream.drop/2 (function)
... emission of any element until `n` additional elements have been emitted by the enum.
Streams - Enumerables and Streams (extras)
As an alternative to `Enum`, Elixir provides the `Stream` module which supports lazy operations: ```elixir ...
Identifying functions and documentation - Anonymous functions (extras)
...ty. The arity of a function describes the number of arguments that the function takes. From this point on we will use both the function name and its arity to describe...
String.pad_leading/3 (function)
...de of elements from the `padding`. Passing a list of strings as `padding` will take one element of the list for every missing entry. If the list is shorter than th...
String.pad_trailing/3 (function)
...de of elements from the `padding`. Passing a list of strings as `padding` will take one element of the list for every missing entry. If the list is shorter than th...
Policy - Compatibility and deprecations (extras)
...proposed alternative MUST exist for AT LEAST THREE minor versions. For example, `Enum.uniq/2` was soft-deprecated in favor of `Enum.uniq_by/2` in Elixir v1.1. This means a d...
Example - Kernel.defguard/1 (macro)
...e." import Integer.Guards @doc "Determines the number of steps `n` takes to reach `1`." # If this function never converges, please let me know wha...
System.put_env/1 (function)
...alue for each environment variable corresponding to each `{key, value}` pair in `enum`. Keys and non-nil values are automatically converted to charlists. `nil` values ...
compare - Naming conventions (extras)
.../2` Note that this specific convention is important due to the expectations of `Enum.sort/2`
Eager vs Lazy - Enumerables and Streams (extras)
All the functions in the `Enum` module are eager. Many functions expect an enumerable and return a list back: ...
Enumerable.reduce/3 (function)
Reduces the `enumerable` into an element. Most of the operations in `Enum` are implemented in terms of reduce. This function should apply the given `t:red...
List.myers_difference/2 (function)
... 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`,...
Stream.chunk_while/4 (function)
Chunks the `enum` with fine grained control when every chunk is emitted. `chunk_fun` receives th...
The `Path` module - IO and the file system (extras)
...s opposed to directly manipulating strings is preferred since the `Path` module takes care of different operating systems transparently. Finally, keep in mind that E...
Module.__info__/1 (callback)
...le. Each module gets an `__info__/1` function when it's compiled. The function takes one of the following items: * `:attributes` - a keyword list with all persis...
Enumerable (protocol)
Enumerable protocol used by `Enum` and `Stream` modules. When you invoke a function in the `Enum` module, the fir...
Examples - Stream.transform/3 (function)
...ule. For example, we can implement `Stream.take(enum, n)` as follows: iex> enum = 1001..9999 iex> n = 3 iex> stream = Stream.transform(enum, 0, fn i, a...
Hot code swapping - Agent (module)
...can be done with the following instruction: {:update, :sample, {:advanced, {Enum, :into, [%{}]}}} The agent's state will be added to the given list of arguments...
Examples - String.contains?/2 (function)
...that this function can match within or across grapheme boundaries. For example, take the grapheme "é" which is made of the characters "e" and the acute accent. The ...
List.ascii_printable?/2 (function)
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 ...
Defining structs - Structs (extras)
...fines what fields the struct will have along with their default values. Structs take the name of the module they're defined in. In the example above, we defined a s...
Spawning processes - Processes (extras)
...1` function: ```elixir iex> spawn(fn -> 1 + 2 end) #PID<0.43.0> ``` `spawn/1` takes a function which it will execute in another process. Notice `spawn/1` returns ...
Examples - Date.range/2 (function)
...nge of dates implements the `Enumerable` protocol, which means functions in the `Enum` module can be used to work with ranges: iex> range = Date.range(~D[2001-01...
Ranges as collections - Range (module)
Ranges in Elixir are enumerables and therefore can be used with the `Enum` module: iex> Enum.to_list(1..3) [1, 2, 3] iex> Enum.to_list(3..1//...
Examples - Module attributes (extras)
...g/ex_doc) which is used to generate HTML pages from the documentation. You can take a look at the docs for `Module` for a complete list of supported attributes. El...
Inspect.Algebra.flex_break/1 (function)
...break/1`, but it is re-evaluated when the documented is rendered. For example, take a group document represented as `[1, 2, 3]` where the space after every comma i...
Timeouts - GenServer (behaviour)
... a timeout of `0` milliseconds is not guaranteed to execute (if you want to take another action immediately and unconditionally, use a `:continue` instructi...
Reraise - try, catch, and rescue (extras)
... exception as is, without changing value or its origin. Generally speaking, we take errors in Elixir literally: they are reserved for unexpected and/or exceptional...
Configuring releases - Configuration and releases (extras)
...er hand, `rel/env.sh.eex` and `rel/vm.args.eex` are specific to releases. Let's take a look.
Long parameter list - Code-related anti-patterns (extras)
...ors during use. #### Example In the following example, the `loan/6` functions takes too many arguments, causing its interface to be confusing and potentially leadi...
Compile callbacks - Module (behaviour)
...a module or a `{module, function_or_macro_name}` tuple. The function/macro must take one argument: the module environment. If it's a macro, its returned value will ...
Tasks are processes - Task (module)
Tasks are processes and so data will need to be completely copied to them. Take the following code as an example: large_data = fetch_large_data() task...
Options - Kernel.ParallelCompiler.compile/2 (function)
...allback passing the file * `:each_long_compilation` - for each file that takes more than a given timeout (see the `:long_compilation_threshold` option) to...
Doctests - Doctests, patterns, and with (extras)
... concept many times throughout this guide, be it via `mix help` or by typing `h Enum` or another module in an IEx console. In this section, we will implement the pa...
List (module)
...he `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...
URI.encode_query/2 (function)
Encodes `enumerable` into a query string using `encoding`. Takes an enumerable that enumerates as a list of two-element tuples (for instance, a ...
Protocols - Kernel (module)
...cts data into a data type * `Enumerable` - handles collections in Elixir. The `Enum` module provides eager functions for working with collections, the `Stream` ...
Starting applications - Application (behaviour)
...ndency not started is an error condition. Functions like `ensure_all_started/1` takes care of starting an application and all of its dependencies for you. If the ap...
Learning Erlang - Erlang libraries (extras)
...to-concurrency) chapter, that's where the real fun starts. Our last step is to take a look at existing Elixir (and Erlang) libraries you might use while debugging.
Options - Task.async_stream/5 (function)
...ss asynchronously. If you need to process elements in order, consider using `Enum.map/2` or `Enum.each/2` instead. Defaults to `true`. * `:timeout` - the maximum amo...
Running the formatter - Code.format_string!/2 (function)
...he fact the formatter does not generate elegant code as a hint for refactoring. Take this code: def board?(board_id, %User{} = user, available_permissions, req...
Our first project - Introduction to Mix (extras)
...ing test * creating test/test_helper.exs * creating test/kv_test.exs ``` Let's take a brief look at those generated files. > #### Executables in the `PATH` {: .in...
Examples - Kernel.|>/2 (macro)
...ten/1` function, then the flattened list is passed as the first argument to the `Enum.map/2` function which doubles each element of the list. In other words, the expressio...
Errors in guards - Patterns and guards (extras)
... _anything_else -> ...> :failed ...> end :failed ``` In many cases, we can take advantage of this. In the code above, we used `tuple_size/1` to both check that...
First async tasks to complete - Task.async_stream/5 (function)
...ter/2` to restrict ourselves only to successfully completed tasks, and then use `Enum.take/2` to retrieve N items. Note it is important to set both `ordered: false` and `max...
Project compilation - Introduction to Mix (extras)
...ct folder (`kv`) and its main responsibility is to configure our project. Let's take a look at it: ```elixir defmodule KV.MixProject do use Mix.Project def pr...
Table of deprecations - Compatibility and deprecations (extras)
...pp APP` (v1.14) [v1.18] | `List.zip/1` | `Enum.zip/1` (v1.0) [v1.18] | `Module.eval_quoted/3` | `Code.ev...
Summing up - Distributed tasks and tags (extras)
...connected to said node and started a new process. However, you may also want to take a more explicit approach to connections, by using `Node.connect/1` and `Node.di...
Keeping user's formatting - Code.format_string!/2 (function)
...ines inside blocks are kept as in the input except for: 1) expressions that take multiple lines will always have an empty line before and after and 2) empty...
Quoted expression - Kernel.SpecialForms../2 (macro)
When `.` is used, the quoted expression may take two distinct forms. When the right side starts with a lowercase letter (or unde...
Examples - Task.Supervisor.async_nolink/3 (function)
...re is a reasonable expectation that the task may fail, and you don't want it to take down the caller. Let's see an example where a `GenServer` is meant to run a sin...
Beware! - Kernel.SpecialForms.with/1 (macro)
...that all failure clauses are flattened into a single `else` block. For example, take this code that checks if a given path points to an Elixir file and that it exis...
Routing layer - Distributed tasks and tags (extras)
...o find an entry in the table() or raise entry = Enum.find(table(), fn {enum, _node} -> first in enum end) || no_entry_error(bucket) # If ...
Kernel.@/1 (macro)
...ver.second_data() #=> 13 It is important to note that reading an attribute takes a snapshot of its current value. In other words, the value is read at compilati...
Examples - Kernel.dbg/2 (macro)
Let's take this call to `dbg/2`: dbg(Atom.to_string(:debugging)) #=> "debugging" ...
Examples - String.replace/4 (function)
...at this function can replace within or across grapheme boundaries. For example, take the grapheme "é" which is made of the characters "e" and the acute accent. The ...
Code.Fragment.container_cursor_to_quoted/2 (function)
...nting the cursor position within its container (i.e. its parent). For example, take this code, which would be given as input: max(some_value, This function w...
Creating Streams - Stream (module)
...ssertive code that assumes you have an enumerable, using the functions > in the `Enum` or `Stream` module accordingly.
Examples - String.split/3 (function)
...that this function can split within or across grapheme boundaries. For example, take the grapheme "é" which is made of the characters "e" and the acute accent. The ...
Duplicate keys and ordering - Keyword (module)
...f the functions in this module work in linear time. This means that the time it takes to perform an operation grows at the same rate as the length of the list.
Custom patterns and guards expressions - Patterns and guards (extras)
...structs listed in this page are allowed in patterns and guards. However, we can take advantage of macros to write custom patterns guards that can simplify our progr...
Strings - Basic types (extras)
...at string is 6, even though it has 5 graphemes. That's because the grapheme "ö" takes 2 bytes to be represented in UTF-8. We can get the actual length of the string,...
String and binary operations - String (module)
...onsidering the proper Unicode code points. For example, `String.length/1` will take longer as the input grows. On the other hand, `Kernel.byte_size/1` always runs ...
Maps and structs - Access (behaviour)
...rying to access the field `.age` on `nil` would raise. The `get_in/2` function takes one step further by allowing different accessors to be mixed in. For example, g...
As temporary storage - Module attributes (extras)
...ot yet been defined. Every time we read an attribute inside a function, Elixir takes a snapshot of its current value. Therefore if you read the same attribute multi...
Walk-through - Optional syntax sheet (extras)
Take the following code: ```elixir if variable? do Call.this() else Call.that()...
Why releases? - Configuration and releases (extras)
... time. The first time your application calls `Enum.map/2`, the VM will find the `Enum` module and load it. There's a downside. When you start a new server in producti...
Domain-Specific Languages (DSLs) (extras)
...rator. The third approach uses macros, and is by far the most complex. It will take more lines of code to implement, it is hard and expensive to test (compared to ...
Links - Processes (extras)
...ng can also be done manually by calling `Process.link/1`. We recommend that you take a look at the `Process` module for other functionality provided by processes. ...
4. Hard deprecations - Changelog for Elixir v1.18 (extras)
...ction in `Enumerable.slice/1` * [List] `List.zip/1` is deprecated in favor of `Enum.zip/1` * [Module] Deprecate `Module.eval_quoted/3` in favor of `Code.eval_quoted/3` ...
Map (module)
...the `Enumerable` protocol, so many functions to work with maps are found in the `Enum` module. Additionally, the following functions for maps are found in `Kernel`: ...
Built-in types - Typespecs reference (extras)
...false` will be evaluated as `false` and everything else is `true`. For example, `Enum.filter/2` has the following specification: `filter(t, (element -> as_boolean(term))) :: l...
The application callback module - Application (behaviour)
...plications can be loaded, started, and stopped. Generally, build tools like Mix take care of starting an application and all of its dependencies for you, but you ca...
Agents 101 - Simple state management with agents (extras)
...he head of the list. The second argument of `Agent.update/3` is a function that takes the agent's current state as input and returns its desired new state. Finally, ...
Built-in protocols - Protocols (extras)
...ships with some built-in protocols. In previous chapters, we have discussed the `Enum` module which provides many functions that work with any data structure that imp...
Datetimes as snapshots - DateTime (module)
...", which occurs after it. Applications that are date and time sensitive need to take these scenarios into account and correctly communicate them to users. The good...
Macro hygiene - Macros (extras)
...:yellow]) [red, green, yellow] end end > Sample.run() #=> [3, 5, 6] ``` Take note of the second argument to `Macro.var/2`. This is the **context** being use...
File.open/2 (function)
... it does not exist. Every write operation to a file opened with append will take place at the end of the file. * `:exclusive` - the file, when opened for wri...
Set operations - Gradual set-theoretic types (extras)
...th sets. At this point, you may ask, why not a union? As a real-world example, take a t-shirt with green and yellow stripes. We can say the t-shirt belongs to the ...
Generators and filters - Comprehensions (extras)
...a much more concise representation than using the equivalent functions from the `Enum` and `Stream` modules. Furthermore, comprehensions also allow multiple generator...
The `:reduce` option - Kernel.SpecialForms.for/1 (macro)
...use comprehensions for the mapping and filtering of letters, and then we invoke `Enum.reduce/3` to build a map, for example: iex> letters = for < >, x in ?a..?z, do: < > ...
Compile-time dependencies - Meta-programming anti-patterns (extras)
...nging a single file causes several files to be recompiled. #### Example Let's take the [`Plug`](https://github.com/elixir-plug/plug) library as an example. The `P...
Unrelated multi-clause function - Design-related anti-patterns (extras)
...behavior is clear and consistent for all inputs, then the anti-pattern does not take place.
Supervision trees and applications (extras)
...manage buckets. At some point, we started monitoring buckets so we were able to take action whenever a `KV.Bucket` crashed. Although the change was relatively small...
Errors - try, catch, and rescue (extras)
...}` tuples and another function (`foo!`, same name but with a trailing `!`) that takes the same arguments as `foo` but which raises an exception if there's an error. ...
Structural comparison - Kernel (module)
...3-31], ~D[2017-04-01]) :lt Alternatively, you can use the functions in the `Enum` module to sort or compute a maximum/minimum: iex> Enum.sort([~D[2017-03-31...
Client API - Client-server communication with GenServer (extras)
... a list of options. `start_link/1` calls out to `GenServer.start_link/3`, which takes three arguments: 1. The module where the server callbacks are implemented, in ...
Our first supervisor - Supervision trees and applications (extras)
...or our current specification, it will call `KV.Registry.start_link([])`. Let's take the supervisor for a spin: ```elixir iex> {:ok, sup} = KV.Supervisor.start_lin...
Umbrella projects - Dependencies and umbrella projects (extras)
...fewer files are generated. The generated `mix.exs` file is different too. Let's take a look (comments have been removed): ```elixir defmodule KvUmbrella.MixProject...
Keyword lists - Keyword lists and maps (extras)
...ame linear performance characteristics: the longer the list, the longer it will take to find a key, to count the number of items, and so on. If you need to store a ...
Processes - IO and the file system (extras)
...te to disk separated by commas. How can you achieve this? One option is to use `Enum.join/2` and convert the values to a string: ```elixir iex> Enum.join(["apple", "banana...
Module attributes - Module (behaviour)
...ions. Accepts a module or a `{module, function_name}` tuple. The function must take 6 arguments: * the module environment * the kind of the function/macro: `:...