NonEmptyArrayModule

Builds an array of exactly one item.

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

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

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

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

Returns a refinement admitting a non-empty array from a list, which is the shape structured wire formats use.

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

Returns a copy of the refined value as a standard array.

Returns the refined value as a standard list.

Converts to a non-empty list.

Converts from a non-empty list.

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 Array.length.

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

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

Concatenates two non-empty arrays.

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.

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

Folds over the items from an explicit seed.

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.

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

Filters the items, returning None when nothing survives.

Returns whether any item satisfies the predicate.

Returns whether every item satisfies the predicate.

Applies an action to every item.

Prepends an item to an already non-empty array.

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

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

Concatenates a non-empty array of non-empty arrays.

Sorts the items in descending order.

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

Pairs items positionally, truncating to the shorter input. Total.

Splits a non-empty array of pairs into a pair of non-empty arrays.

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

Folds over the items from the right.

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

Returns whether the array contains the item.

Returns the first matching item, if any.

Returns the refined value as a sequence.

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

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

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

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

Groups items by a key. Every group is non-empty by construction.

Splits into consecutive runs of the given size, treating a size below one as one. Every chunk is non-empty.

Adds every item, matching Array.sum.

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

Averages the items. Total — the divisor is the length, which is always at least one, so unlike Array.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.

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 array 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 Array.truncate 0 empties.

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

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

Applies an index-aware action to every item.

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

Builds an array of count copies, treating a count below one as one.

Sorts the items by a projected key, descending.

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

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

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