lists

(xs.take(i), xs.drop(i)) with i clamped to 0..=xs.len: a negative i gives ([], xs) and an i past the end gives (xs, []).

The longest prefix whose elements all satisfy p, and the rest (Haskell's span). p is called once per element of the prefix, plus once for the first element that fails.

The longest prefix with no element satisfying p, and the rest, which starts with the first element that does (Haskell's break).

Splits xs between every pair of neighbours a, b for which p(a, b) holds; no element is lost. An empty list gives []. split_when([1, 2, 4, 5], (a, b) => b != a + 1) is [[1, 2], [4, 5]].

Splits xs at every element equal to sep, dropping the separators, like Str.split: [] gives [[]], and neighbouring or trailing separators give empty pieces, so the result always has one more piece than there are separators.

split_on with a predicate: splits at every element satisfying p and drops those elements.

Exactly n consecutive parts whose lengths differ by at most one, the longer parts first (more-itertools' divide). With fewer than n elements the last parts are empty.

Windows of size elements starting every step elements (Kotlin's windowed). With partial false only full windows are returned; with partial true the windows that start before the end but run past it are kept, shortened. sliding(xs, n, 1, false) is xs.windows(n) and sliding(xs, n, n, true) is xs.chunks(n).

xs.chunks(n) with the last chunk padded with fill to n elements. An empty list gives [].

Groups runs of consecutive elements with the same key, each with its key (Python's itertools.groupby, Rust's chunk_by). key is called once per element. Equal keys that are not adjacent make separate runs; use group_into to group them all.

Run-length encoding: each run of equal neighbours as (value, length).

The inverse of rle; counts below 1 contribute nothing.

Every suffix of xs, longest first, ending with []: xs.len + 1 lists.

Every prefix of xs, shortest first, starting with []: xs.len + 1 lists.

The last n elements (all of them when n >= xs.len, none when n <= 0).

xs without its last n elements ([] when n >= xs.len, xs when n <= 0).

The longest suffix whose elements all satisfy p, tested from the end.

xs without the longest suffix whose elements all satisfy p (an rstrip for lists).

xs padded at the end with fill to at least n elements; longer lists are unchanged.

xs padded at the front with fill to at least n elements; longer lists are unchanged.

xs with runs of equal neighbours collapsed to their first element (Unix uniq). Use the builtin unique to drop every repeat.

dedup comparing keys: keeps the first element of each run of neighbours with equal keys.

The first element for each distinct key, in input order (lodash's uniqBy). key is called once per element.

The values that occur more than once, each once, in the order of their first occurrence.

Whether every element equals the first (true for an empty list).

Whether no two elements are equal (true for an empty list).

The only element of xs, or none when it has zero or several.

How many times each value occurs (Python's Counter). The builtin counts gives the same numbers as a list in first-seen order.

How many elements have each key (lodash's countBy).

How many elements satisfy p.

A map from each element's key to the element (lodash's keyBy). When several elements share a key the last one wins; use group_into to keep them all.

A map built from the (key, value) pair f gives for each element (Kotlin's associate). When keys repeat the last pair wins.

The elements grouped by key into a map; each group keeps input order. The builtin group_by gives the same groups as a list in first-seen key order.

The sum of f over the elements (0 for an empty list); overflow traps like +.

The sum of f over the elements as floats (0.0 for an empty list), with Kahan-Babuska compensation, so long sums of small terms lose no precision to a large running total.

The first element with the smallest key, or none for an empty list. key is called once per element.

The first element with the largest key, or none for an empty list. key is called once per element.

The smallest and the largest element in one pass (the first of each among equals), or none for an empty list.

min_by and max_by in one pass: the first element with the smallest key and the first with the largest, or none for an empty list.

The k elements with the largest keys, largest first; equal keys keep input order, so the result is stable. k <= 0 gives [] and k >= xs.len sorts the whole list.

The k elements with the smallest keys, smallest first, stable like top_k.

The k largest elements, largest first (Python's heapq.nlargest).

The k smallest elements, smallest first (Python's heapq.nsmallest).

Alternates elements of xs and ys, starting with xs; the rest of the longer list follows.

Round-robin over any number of lists: the first element of each, then the second of each, skipping lists that have run out (more-itertools' interleave_longest).

sep between every two elements: [a, sep, b, sep, c].

The lists of xss joined with sep between every two (join for lists of lists).

Triples of the elements at the same index, as long as the shortest list.

f applied to the elements at the same index, as long as the shorter list.

Pairs as long as the longer list, the shorter one padded with its fill value (Python's zip_longest).

Pairs as long as the longer list, with none where a list has run out.

The firsts and the seconds of a list of pairs.

The three components of a list of triples.

Rows become columns. Ragged input is allowed: column i holds element i of every row that has one, in row order, so it is shorter than the row count when some rows are short, and there are as many columns as the longest row has elements. [] gives [].

Adjacent pairs: [(x0, x1), (x1, x2), ...], empty for fewer than two elements.

The most lists or pairs the combinatoric functions return: 1,000,000. Their pre clauses reject inputs whose output would be larger, so a typo can't ask for a trillion permutations.

Every pair (x, y) with x from xs and y from ys, x varying slowest. At most combinatorics_limit() pairs.

The n-ary cartesian product (Python's itertools.product): every list taking one element from each list of xss, the last varying fastest. [] gives [[]], and any empty list gives []. At most combinatorics_limit() lists.

The k-permutations of xs by position, in lexicographic order of positions (Python's itertools.permutations(xs, k)): n! / (n - k)! lists, [[]] for k == 0 and [] for k > xs.len. Equal elements are treated as distinct. At most combinatorics_limit() lists.

The k-combinations of xs by position, in lexicographic order of positions, each in input order (Python's itertools.combinations): C(n, k) lists, [[]] for k == 0 and [] for k > xs.len. At most combinatorics_limit() lists.

The k-combinations with repetition (Python's combinations_with_replacement): C(n + k - 1, k) lists in lexicographic order of positions; [[]] for k == 0, [] for an empty xs and k > 0. At most combinatorics_limit() lists.

Every sublist of xs (keeping input order), by size and then lexicographically by position: 2 ** xs.len lists, starting with []. At most 20 elements (1,048,576 lists).

The number of k-permutations of n items, n! / (n - k)! (0 when k > n), or none when it doesn't fit in an Int or an argument is negative.

The number of k-combinations of n items, the binomial coefficient (0 when k > n), or none when it doesn't fit in an Int or an argument is negative.

A list of n copies of x ([] when n <= 0).

xs repeated n times ([] when n <= 0).

The first n elements of xs repeated forever ([] when xs is empty or n <= 0).

f(i, x) for each element and its index.

The elements for which p(i, x) holds, with i the index.

The values of f that are some, in order (Rust's filter_map).

The values inside the somes, in order.

The first some that f gives, calling f only until then (Rust's find_map).

The ok values and the err values of f, each in order.

The ok values and the err values, each in order.

some of every value when all are some, else none.

ok of every value when all are ok, else the first err.

The element at i, counting from the end when i is negative (-1 is the last), or none when out of range.

xs with x inserted before index i; i is clamped to 0..=xs.len, so a negative i inserts at the front and one past the end appends.

xs with all of ys inserted before index i, clamped like insert_at.

xs without the element at i; an out-of-range i (negative included) leaves it unchanged.

xs without the first element equal to x (unchanged when there is none). The builtin filter removes them all.

xs with the element at i replaced by x; out of range leaves it unchanged.

xs with the element at i replaced by f of it; out of range leaves it unchanged and doesn't call f.

xs with the elements at i and j exchanged; unchanged when either is out of range.

xs with the element at from moved so that it ends at index to (clamped to the valid range); unchanged when from is out of range.

The last element satisfying p, testing from the end.

The index of the last element satisfying p, testing from the end.

The index of the last element equal to x.

The indexes of every element satisfying p, ascending.

The indexes of every element equal to x, ascending.

The first index at which p is false, for a list that is partitioned (every element satisfying p comes before every one that doesn't); xs.len when p holds everywhere. Binary search: p is called O(log n) times.

The first index whose key is at least target, in a list sorted by key (xs.len if none).

The first index whose key is greater than target, in a list sorted by key (xs.len if none).

The first index whose key equals target in a list sorted by key, or none.

x inserted into the sorted list xs after any equal elements, so the list stays sorted and insertion is stable.

x inserted into xs, sorted by key, after any elements with an equal key.

The first index at which sub occurs in xs as a contiguous run; some(0) for an empty sub. Worst case O(xs.len * sub.len).

The last index at which sub occurs in xs; some(xs.len) for an empty sub.

Whether sub occurs in xs as a contiguous run (always for an empty sub).

Whether xs starts with prefix.

Whether xs ends with suffix.

How many times sub occurs in xs without overlapping, scanning left to right (like Str.count in Python). An empty sub counts xs.len + 1 times.

xs with every non-overlapping occurrence of sub (left to right) replaced by by. An empty sub leaves xs unchanged.

Folds from the right: f(x0, f(x1, ... f(xn, init))).

Folds from the left with the first element as the start, or none for an empty list.

Folds from the right with the last element as the start, or none for an empty list.

The accumulators of fold_right, aligned with the elements: element i of the result is f(xs[i], result[i + 1]), the last one f(xs[n - 1], init). Same length as xs, like the builtin scan.

Whether every element is at most the next one.

Whether every element is less than the next one (sorted, no repeats).

Whether the keys never decrease. key is called once per element.

Whether cmp(a, b) <= 0 for every pair of neighbours, with a comparator like sort_with's.

The indexes that sort xs (stable: equal elements keep input order), NumPy's argsort. argsort(xs).map(i => xs[i]) is xs sorted.

The indexes that sort xs by key, stable. key is called once per element.

The 0-based position of each element in the stable sort (ordinal ranks: ties get consecutive ranks in input order). The inverse permutation of argsort.

Dense ranks: 0 for the smallest value, and one more for each larger distinct value; equal elements share a rank.

Lexicographic comparison by the elements' Ord: -1, 0 or 1. A proper prefix comes first.

The elements of the sorted lists xs and ys in one sorted list, by key; on equal keys elements of xs come first. The builtin merge does this for the elements themselves.

A k-way merge: every element of the lists in one sorted list, stable (on equals, earlier lists first). With sorted inputs this is the merge; any input gives a sorted result.

The distinct elements of xs and then of ys that are not in xs, each once, in first-seen order.

The distinct elements of xs that also occur in ys, in xs order.

The distinct elements of xs that don't occur in ys, in xs order.

The distinct elements in exactly one of the lists: those of xs first, then those of ys.

Whether every element of ys occurs in xs (true for an empty ys).

Whether some element of ys occurs in xs (false for an empty ys).

Whether the lists have no element in common.

The multiset intersection, keeping duplicates: each value as many times as it occurs in both lists (the smaller count), in xs order.

The multiset difference: xs with one occurrence removed for each occurrence in ys, the earliest first (Python's Counter subtraction, keeping order).

The multiset union: all of xs, then the occurrences in ys beyond those in xs (each value as many times as the larger count).

Whether ys is a permutation of xs: the same elements with the same counts.

k distinct positions of xs chosen uniformly at random, in random order (Python's random.sample), as a pure function of seed like the builtin shuffle. k is clamped to 0..=xs.len.

sample, with the chosen elements in their input order.