Documentation

Match a singleton List1.

Match a List1 of length at least 2.

Isomorphic to (:|), but instead with a Maybe List1.

Prepend a List1 to a list.

Append a List1 to a list.

Append an element to a list. C.f. (:|).

Append an element to a List1. C.f. (:||).

Append an element to a Maybe List1. C.f. (:?).

Together with unList1, witness the isomorphism [x] ~ Maybe (List1 x).

Forget the nonemptiness information.

Together with list1, witness the isomorphism [x] ~ Maybe (List1 x).

Apply a List1 function on a regular list.

Apply a regular list function on a List1. Avoid shortening the list.

Apply a List1 function if the list is not empty.

Flipped version of has01, consistent with other libraries' withNonEmpty.

Run an action taking a List1 if the list is not empty.

Case split on a list with a default value and a List1 function. Flipped variant of what some call withNonEmpty or withNotNull.

Case split on a List1 with a simple function and a List1 function.

Convenience function for decomposing List1 into its head and tail.

Convenience function for decomposing List1 into its init and last.

Type-restricted concatenation.

List1 the elements backwards.

Extract the first element of a List1.

Extract all but the first element of a List1.

Extract all but the last element of a List1.

Extract the last element of a List1.

The sequence of prefixes of a List1, from shortest to longest.

The sequence of suffixes of a List1, from longest to shortest.

Take the first (possibly no) elements of a List1.

Get rid of the first (possibly all) elements of a List1.

Keep the longest prefix of elements of a List1 that satisfy a predicate.

Drop the longest prefix of elements of a List1 that satisfy a predicate.

Remove the first occurrence of the given element from a List1.

Remove an element from a List1 according to a supplied equality test.

Remove all of the elements of the second argument from the first argument.

Keep only (possibly no) elements satisfying a predicate.

The prefix and suffix of a List1 where the elements of the prefix satisfy the predicate.

The prefix and suffix of a List1 where the elements of the prefix do not satisfy the predicate.

The elements of a List1 that do and do not satisfy the predicate, in order.

Split a List1 at the given index.

Attach the index to each element of a List1.

Whether the given element is found in the List1.

Whether the given element is not in the List1.

The first index of the element, if it is found, within the List1.

All the indices of the element, if it is found, within the List1.

The first element, if any, to satisfy a predicate.

The index of the first element, if any, to satisfy a predicate.

All of the positions of the elements satisfying a predicate.

The element at a given index.

Given a List1 of pairs, find the second coordinate of the first element matching in the first coordinate.

Apply a function to every element of a List1.

Map each element of the structure to a semigroup, and combine the results with (<>). This fold is right-associative and lazy in the accumulator. For strict left-associative folds consider foldMap1' instead.

>>> foldMap1 (:[]) (1 :| [2, 3, 4])
[1,2,3,4]

Since: base-4.18.0.0

A version of map that can eliminate (possibly all) values from a List1.

Returns a list of all (possibly no) Just values in a List1.

Pointwise product of two List1s.

Pointwise application of two List1s.

Decompose a List1 of pairs into a pair of List1s.

Traverse a List1 with an accumulating parameter from left to right.

Traverse a List1 with an accumulating parameter from right to left.

scanl is similar to foldl, but returns a List1 of successive reduced values from the left.

Strict version of scanl.

A variant of scanl that has no starting value argument and works on a List1.

Strict version of scanl1.

scanr is the right-to-left dual of scanl. Note that the parameters of the accumulating function are also reversed.

A variant of scanr with no starting value argument and works on a List1.

Build a List1 from a generating function and seed value.

The List1 analogue of build.

Sort a List1.

Sort a List1 using the projection.

Sort a List1 using an explicit comparison.

Group the elements of a List1 by equality.

Group the elements of a List1 by equality on a projection.

Group the elements of a List1 with an explicit equality test.

Find the (possibly no) elements that are in both List1s.

Find the (possibly no) elements that are found in both List1s using a projection.

Find the (possibly no) elements in the first List1 that match any element of the second List1 using an explicit equality test.

Combine two List1s, keeping only those elements from the second List1 that are not already in the first.

Similar to union but using equality on a projection.

Similar to union but with an explicit equality test.

Keep only one copy of each element.

Keep only one copy of each element whose projections match.

Keep only one copy of each element whose projections match the explicit equality test.

Find the maximum of a List1.

Find the maximum of a projection function.

Find the element with maximal projection.

Find the maximum using an explicit comparison function.

Find the minimum of a List1.

Find the minimum of a projection function.

Find the element with minimal projection.

Find the minimum using an explicit comparison function.

Apply a function repeatedly to a starting value. The first element is the starting value.

Apply a function strictly to a starting value. The first element is the starting value.

The infinite List1 consisting of a single value.

The List1 of given length consisting only of the given value.

The infinite List1 created by repeating the elements of the given List1.

Place an element between all other elements in a List1.

intersperse 'y' ('a' :|| 'b' :|| Sole 'c') == ('a' :|| 'y' :|| 'b' :|| 'y' :|| Sole 'c')

Squash a List1 of List1s together with the given argument in between each List1.

intercalate (1 :|| Sole 1) (Sole 2 :|| Sole 3 :|| Sole (Sole 4)) == (2 :|| 1 :|| 1 :|| 3 :|| 1 :|| 1 :|| Sole 4)

All of the non-empty sublists of a List1, including those that skip elements.

windows n lists the consecutive subsequences of length n of a List1: the subsequences of length n that do not skip any elements.

All of the consecutive subsequences of a List1: the subsequences that do not skip any elements.

The List1 of all rearrangements of a List1.

Apply a function on the prefix and suffix of a List1 at every index.

The init and tail of the List1 at each positive index.

>>> diagonals (1 :| [2, 3, 4])
[(1 :| [],2 :| [3,4]),(1 :| [2],3 :| [4]),(1 :| [2,3],4 :| [])]

Insert an element before each member of a List1.

insertions x (a :|| b :|| c :|| ...)
    == (x :|| a :|| b :|| c :|| ...)
   :|| (a :|| x :|| b :|| c :|| ...)
   :|| (a :|| b :|| x :|| c :|| ...) ...