Section 1
Preview this deck
min(enumerable, fallback)
Front
| 5 | 0 | ||
| 4 | 0 | ||
| 3 | 0 | ||
| 2 | 0 | ||
| 1 | 0 |
Active users
0
All-time users
0
Favorites
0
Last updated
6 years ago
Date created
Mar 1, 2020
Cards (52)
Section 1
(50 cards)
min(enumerable, fallback)
Similar to max/2 but returns the minimal element.
map(enumerable, fn)
Returns a list where each item is the result of invoking fn on each corresponding item of enumerable.
drop(enumerable, amount)
Drops the amount of items from the enumerable from the start of the enumerable. A negative amount will drop from the end.
min_max_by(enumerable, fn, fallback)
Returns a tuple with the minimal and maximal element as determined by the return value of fn.
What are the three data types in Elixir which are most commonly used as enumerables?
List, Map, Range
filter(enumerable, fn)
Returns only the elements for which fn returns a truthy value.
map_every(enumerable, nth, fn)
Similar to map/2 except fn is only invoked on every nth element of the enumerable starting with the first element.
dedup(enumerable)
Returns a list where all the consecutive duplicated elements are collapsed into a single element.
sort(enumerable)
Sorts the enumerable according to Erlang's term ordering.
drop_while(enumerable, fn)
Drops every item starting from the beginning of the enumerable while fn returns a truthy value.
slice(enumerable, start, amount)
Returns a subset list of the given enumerable, from start with amount of elements if available.
sort(enumerable, fn)
Sorts the enumerable by the given function.
slice(enumerable, arg)
Returns a subset list of the given enumerable, from start position to index of arg.
min_by(enumerable, fn, fallback)
Similar to max_by/3 but returns the minimal element.
join(enumerable, joiner \\ "")
Joins the elements in a given enumerable into a binary (String) using joiner as a separator.
chunk_by(enumerable, callback)
Returns a nested list where every element is grouped together until the function returns a new value.
reverse_slice(enumerable, start, count)
Reverses the enumerable in the range from initial position start through count elements.
concat(left, right)
Concatenates the enumerable on the right with the enumerable on the left.
member?(enumerable, element)
Returns true if element is found in the enumerable.
max_by(enumerable, fn, fallback)
Returns the maximal element as determined by the return value of fn.
all?(enumerable, callback \\ fn x -> x end)
Returns true if the given function evaluates to true on all of the items in the enumerable.
find_index(enumerable, fn)
similar to find/3, but returns the index of the element instead of the element itself.
reverse(enumerable)
Returns a list of a element in enumerable in reverse order.
empty?(enumerable)
Determines if the enumerable is empty.
drop_every(enumerable, nth)
Drops every nth item from the enumerable starting from the first element.
count(enumerable)
Returns the size of the enumerable.
scan(enumerable, acc, fn)
Applies the given function to each element in the enumerable, storing the value in a list and then passing that value as the accumulator for the next computation.
True/False: Enum module is useful for dealing with potentially infinite enumerables.
False
random(enumerable)
Returns a random element of an enumerable.
map_join(enumerable, joiner \\ "", mapper)
maps and joins the given enumerable in one pass.
reduce(enumerable, fn)
Invokes fn for each element in the enumerable with the accumulator. Accumulator is defaulted to the first element in the enumerable.
reduce(enumerable, acc, fn)
Invokes fn for each element in the enumerable with the accumulator.
into(enumerable, collectable)
Inserts the elements from enumerable into a collectable which is another enumerable.
scan(enumerable, fn)
Similar to scan/3 but uses the first element in the enumerable as the starting accumulator.
find(enumerable, default \\ nil, fn)
Returns the first item for which fn returns a truthy value. If no such item is found, returns default.
What is the time complexity of functions in the Enum module?
O(n)
fetch!(enumerable, index)
Finds the element at the given index and returns it. Throws error if index is out of bounds.
min_max(enumerable, fallback)
Returns a tuple with the minimal and maximal element from the enumerable as determined by Erlangs term ordering.
shuffle(enumerator)
Returns a list with the elements of the enumerable shuffled.
at(enumerable, index, default \\ nil)
Returns the element at the given index or a default value if the given index is out of range.
max(enumerable, fallback)
Returns the maximal element in the enumerable according to Erlang's term ordering. If the enumerable is empty, returns the value that is returned by the fallback function.
reverse(enumerable, tail)
Reverses the elements in enumerable, then appends the tail and returns it as a list.
concat(enumerables)
Given an enumerable of enumerables, concatenates the enumerables into a single list.
any?(enumerable, callback \\ fn x -> x end
Returns true if the given function evaluates to true on any of the items in the enumerable.
fetch(enumerable, index)
Finds the element at the given index and returns it in { :ok, elem } tuple. Returns { :error } if index is out of bounds.
find_value(enumerable, default \
il, fn)
Similar to find/3 but returns the value of the function invocation instead of the element itself.
split(enumerable, count)
Returns a tuple with the enumerable split into two enumerables, leaving count elements in the first one.
into(enumerable, collectable, transform)
Inserts the elements from enumerable into a collectable according to the return value of the function passed into transform.
flat_map(enumerable, fn)
Maps the given fn over the enumerables and flattens the result one level deep.
each(enumerable, fn)
Invokes the given fn for each item in the enumerable.
Section 2
(2 cards)