This is just a list, but is documentation that a return value will never be null, or an argument should never be null. This is for cases where NonEmpty is too annoying to work with.

Total variants of unsafe list operations.

List initial and final element, if any.

Get xs !! n, but return Nothing if the index is out of range.

Insert x into xs at index i. If i is out of range, insert at the beginning or end of the list.

Remove the element at the given index. Do nothing if the index is out of range.

Like removeAt but return the removed element as well.

Modify element at an index by applying a function to it. If the index is out of range, nothing happens.

Find an element, then change it. Return Nothing if the element wasn't found.

Similar to modifyAt, but will insert an element for an out of range positive index. The list will be extended with deflt, and the modify function passed a Nothing.

Move an element from one index to another, or Nothing if the from index was out of range.

Enumerate an inclusive range. Uses multiplication instead of successive addition to avoid loss of precision.

Also it doesn't require an Enum instance.

Enumerate a half-open range.

Like range, but always includes the end, even if it doesn't line up on a step.

Infinite range.

Apply a function to the first and last elements. Middle elements are unchanged. A null or singleton list is also unchanged.

Filter on the fst values returning Just.

Filter on the snd values returning Just.

This is like scanl, but you can scan with a key function. E.g. to accumulate line lengths: scanlOn length (+) 0.

Stable sort on a cheap key function. Different from List.sortOn, which is for an expensive key function.

Like sortOn, but sort highest-to-lowest.

Merge sorted lists. If two elements compare equal, the one from the left list comes first.

If the heads of the sublists are also sorted I can be lazy in the list of sublists too. This version is optimized for minimal overlap.

This is just List.groupBy except with a key function.

Like groupAdjacent, but include the key.

Group the unsorted list into (key x, xs) where all xs compare equal after key is applied to them.

Similar to keyedGroupSort, but key on the fst element, and strip the key out of the groups.

Like groupFst, but group on the snd element.

Like List.groupBy, but the list doesn't need to be sorted, and use a key function instead of equality. The list is sorted by the key, and the groups appear in their original order in the input list.

Group each element with all the other elements that compare equal to it. The heads of the groups appear in their original order.

groupStableWith but with a key function.

Pair each element with the following element. The last element is paired with Nothing. Like zip xs (drop 1 xs ++ [Nothing]) but only traverses xs once.

Like zipNext but with both preceding and following elements.

This is like zip, but it returns the remainder of the longer argument instead of discarding it.

Return the reversed inits paired with the tails. This is like a zipper moving focus along the input list.

Like zip, but emit Firsts or Seconds if the list lengths are unequal.

Like zip, but the first list is padded with Nothings.

Like zip, but the second list is padded with Nothings.

Perform a Meyes diff.

Left if the val was in the left list but not the right, Right for the converse.

This is like diff, except that the index of each pair in the right list is included. So the index is where you should delete or add the element to turn as into bs:

• (i, Second b), i is the position of b in bs.
• (i, First a), i is where a was deleted from bs.

Pair up two lists of sorted pairs by their first element.

Like pairSorted, but use a key function, and omit the extracted key.

Like pairSorted, but use a key function, and omit the extracted key.

Like pairOn, but when the lists have the same type.

Like List.partition, but partition by two functions consecutively.

Partition and transform at the same time.

Split into groups of a certain size.

Take a list of rows to a list of columns. This is like a zip except for variable-length lists. Similar to zip, the result is trimmed to the length of the shortest row.

List.transpose is similar, but it skips missing elements, instead of truncating all to the shortest. Skipping means you lose what column the element came from.

Similar to rotate, except that the result is the length of the longest row and missing columns are Nothing. Analogous to zip_padded.

Drop until the last element before or equal to the given element.

If the list doesn't have the given prefix, return the original list and False. Otherwise, strip it off and return True. List.stripPrefix is an alternate version.

The cartesian product of a list of lists. E.g. [[1, 2], [3, 4]] -> [[1, 3], [1, 4], [2, 3], [2, 4]].

Like List.mapAccumL, but monadic. Strict in the accumulator.

Split xs on sep, dropping sep from the result.

Interspense a separator and concat.

Split before places where the function matches.

> splitBefore (==1) [1, 2, 1]
[[], [1, 2], [1]]

Split the list on the points where the given function returns true.

This is similar to groupBy, except this is defined to compare adjacent elements. groupBy actually compares to the first element of each group. E.g. you can't group numeric runs with groupBy (a b -> b > a+1).

Like span, but it can transform the spanned sublist.

Drop adjacent elts if they are equal after applying the key function. The first elt is kept.

Filter out elts when the predicate is true for adjacent elts. The first elt is kept, and the later ones are dropped. This is like dropDups except it can compare two elements. E.g. dropWith (>=) will ensure the sequence is increasing.

Sort the input by the key, extract unique values, and also return the duplicates.

Find duplicate values. There are always at least 2 of each output.

Like dropDups, but keep the last adjacent equal elt instead of the first.

This is like dropDups, except that it's not limited to just adjacent elts. The output list is in the same order as the input.

Like unique, but sort the list, and should be more efficient.

Replace sublist from with to in the given list.

Replace occurrances of an element with zero or more other elements.