NonEmptyListModule

Builds a list of exactly one item.

Builds a list of count items from their indices, treating a count below one as one. Total, where List.init 0 yields an empty list.

Builds a list of count copies, treating a count below one as one.

Prepends an item to a standard list.

Prepends an item to an already non-empty list.

Returns the non-empty list, or None when the source is empty.

Returns the non-empty list, or None when the source is empty.

Returns the non-empty list, or None when the source is empty.

Returns a refinement admitting any list with at least one item.

Admits a non-empty list, reporting the same failure the refinement does.

Converts to a non-empty array, preserving order.

Returns the refined value as a standard list.

Returns the refined value as a sequence.

Returns the first item. Total.

Returns every item after the first.

Returns the final item. Total.

Returns the number of items as a plain int, matching List.length.

Applies a mapping to every item. Non-emptiness is preserved.

Applies an index-aware mapping to every item. Non-emptiness is preserved.

Pairs every item with its index. Non-emptiness is preserved.

Concatenates two non-empty lists.

Appends a standard list to a non-empty list.

Maps each item to a non-empty list and concatenates the results.

Concatenates a non-empty list of non-empty lists.

Reverses the order of the items.

Sorts the items in ascending order.

Sorts the items by a projected key.

Sorts the items using an explicit comparison.

Sorts the items in descending order.

Sorts the items by a projected key, descending.

Removes duplicate items, preserving first-seen order. Non-emptiness is preserved.

Removes items sharing a projected key, keeping the first of each. Non-emptiness is preserved.

Every pairing of an item from each list. Non-emptiness is preserved.

Pairs items positionally, truncating to the shorter input. Total — unlike List.zip, which raises when the lengths differ.

Combines items positionally, truncating to the shorter input. Total — unlike List.map2, which raises when the lengths differ.

Splits a non-empty list of pairs into a pair of non-empty lists.

Combines every item with an associative operation. Total — no seed required.

Combines every item from the right. Total — no seed required.

Folds over the items from an explicit seed.

Folds over the items from the right.

Returns the smallest item. Total.

Returns the largest item. Total.

Returns the item with the smallest projected key. Total.

Returns the item with the largest projected key. Total.

Adds every item, matching List.sum.

Adds a projection of every item, matching List.sumBy.

Averages the items. Total — the divisor is the length, which is always at least one, so unlike List.average this cannot raise.

Averages a projection of the items. Total, for the same reason as average.

Counts the items sharing each key. Every count is at least one.

Runs a fold and keeps every intermediate state, including the seed.

Runs a fold from the right and keeps every intermediate state.

Filters the items, returning a standard list because emptiness is possible.

Filters the items, returning None when nothing survives.

Partitions the items into matching and non-matching standard lists.

Returns whether any item satisfies the predicate.

Returns whether every item satisfies the predicate.

Returns whether the list contains the item.

Returns the first matching item, if any.

Returns the last matching item, if any.

Returns the index of the first matching item, if any.

Returns the first item the chooser accepts, if any.

Keeps the chosen items, returning a standard list because a chooser can reject every item.

Keeps the chosen items, returning None when nothing survives.

Returns the item at an index, or None when the index is out of range.

Returns the item at an index, clamping the index into range. Total — index zero is always the head, so there is no empty case to report.

Keeps at most the first count items, treating a count below one as one. Total, and non-emptiness is preserved — where List.truncate 0 empties.

Drops the first count items, returning a standard list because skipping can consume everything. Total — a count past the end yields the empty list rather than raising the way List.skip does.

Pairs each item with its successor, returning a standard list — a single item yields none.

Applies an action to every item.

Applies an index-aware action to every item.

Groups items by a key. Every group is non-empty by construction — a group only exists because something fell into it — so the values keep their type rather than degrading to a list the caller has to re-check.

Splits into consecutive runs of the given size. Total: a size below one is treated as one, where List.chunkBySize raises, and both the outer list and every chunk stay non-empty.

Applies a fallible mapping to every item, accumulating every failure rather than stopping at the first.

Collects a non-empty list of results, accumulating every failure.

Applies a mapping that may yield nothing, succeeding only when every item does.

Collects a non-empty list of options, succeeding only when every item is present.