A list with one or more elements.

Construct a NonEmpty from an element and a list.

Construct a NonEmpty list from a single element.

Construct a NonEmpty from an element and a list.

A non empty thing. Useful as a syntactically lightweight type annotation, especially when using OverloadedLists:

>>> :set -XOverloadedLists
>>> [(), ()]
    • Ambiguous type variable ‘a0’ arising from a use of ‘print’
      prevents the constraint ‘(Show a0)’ from being solved.
>>> aNonEmpty [(), ()]
[(),()]

Converts base's NonEmpty to a NonEmpty

Converts a NonEmpty to base's NonEmpty

Converts a normal list to a NonEmpty list, given the list has at least one element

Converts a NonEmpty list to a normal list

Number of elements in NonEmpty list.

Extract the first element of the nonempty stream.

Extract the possibly-empty tail of the nonempty stream.

Extract the last element of the nonempty stream.

Extract everything except the last element of the nonempty stream.

Prepend an element to the nonempty stream.

Produces the first element of the nonempty stream, and a stream of the remaining elements.

Append an element to the back of a nonempty stream.

Produces all elements up to the last element, and the last element

Dual of foldr, see unfoldr.

Sort a nonempty stream.

Reverse a nonempty stream.

Produces all the prefixes of a stream, starting with the shortest. The result is NonEmpty because the result always contains the empty list as the first element.

>>> inits [1,2,3]
[[], [1], [1,2], [1,2,3]]

>>> inits [1]
[[], [1]]

>>> inits []
[[]]

Produces all the nonempty prefixes of a nonempty stream, starting with the shortest.

>>> inits1 [1,2,3]
[[1], [1,2], [1,2,3]]

>>> inits1 [1]
[[1]]

Produces all the suffixes of a stream, starting with the longest. The result is NonEmpty because the result always contains the empty list as the first element.

>>> tails [1,2,3]
[[1, 2, 3], [2, 3], [3], []]

>>> tails [1]
[[1], []]

>>> tails []
[[]]

Produces all the nonempty suffixes of a nonempty stream, starting with the longest.

>>> tails1 [1,2,3]
[[1, 2, 3], [2, 3], [3]]

>>> tails1 [1]
[[1]]

A monomorphic version of <> for NonEmpty.

>>> append [1] [2, 3]
[1, 2, 3]

Append a list at the end of a NonEmpty.

>>> appendList [1, 2, 3] []
[1, 2, 3]

>>> appendList [1, 2, 3] [4, 5]
[1, 2, 3, 4, 5]

Prepend a list to the front of a NonEmpty.

>>> prependList [] [1, 2, 3]
[1, 2, 3]

>>> prependList [negate 1, 0] [1, 2, 3]
[-1, 0, 1, 2, 3]

Map a function over a NonEmpty stream.

Produces a NonEmpty which alternates between elementes of the input list, and the supplied element.

>>> intersperse 0 [1, 2, 3])
[1, 0, 2, 0, 3]

>>> intersperse 0 [1]
[1]

Left-associative fold, lazy in the accumulator. See foldl.

Left-associative fold, strict in the accumulator. See foldl'.

Left-associative fold, strict in the accumulator. See foldl'.

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

>>> scanl (+) 1 [20, 300, 4000]
[1,21,321,4321]

A strict version of scanl.

scanl1 is a variant of scanl that has no starting value argument:

scanl1 f [x1, x2, ...] == [x1, x1 f x2, x1 f (x2 f x3), ...]

Right-to-left dual of scanl. Note that the order of parameters on the accumulating function are reversed compared to scanl. Also note that

head (scanr f z xs) == foldr f z xs

>>> scanr (+) 0 [1..4]
[10,9,7,4,0]

>>> scanr (+) 42 []
[42]

>>> scanr (-) 100 [1..4]
[98,-97,99,-96,100]

scanr1 is a variant of scanr that has no starting value argument.

>>> scanr1 (+) [1..4]
[10,9,7,4]

>>> scanr1 (+) []
[]

>>> scanr1 (-) [1..4]
[-2,3,-1,4]

transpose for NonEmpty, behaves the same as transpose. The rows/columns need not be the same length, in which case

transpose . transpose /= id

Behaves the same as sortBy

Sort a list on a projection of its elements. Projects once, then sorts, then un-projects. This is useful when the projection function is expensive. If it's not, you should probably use sortWith.

Sort a list on a projection of its elements. Projects during comparison. This is useful when the projection function is cheap. If it's not, you should probably use sortOn.

iterate f x produces the infinite sequence of repeated applications of f to x.

iterate f x = [x, f x, f (f x), ..]

repeat x returns a constant stream, where all elements are equal to x.

cycle xs returns the infinite repetition of xs:

cycle [1, 2, 3] == [1, 2, 3, 1, 2, 3, ...]

insert x xs inserts x into the last position in xs where it is still less than or equal to the next element. If the list is sorted beforehand, the result will also be sorted.

some1 x sequences x one or more times.

take n xs returns the first n elements of xs.

drop n xs drops the first n elements from the front of the sequence xs.

splitAt n xs returns a pair consisting of the prefix of xs of length n and the remaining stream immediately following this prefix.

splitAt n xs == (take n xs, drop n xs)

Produces the longest prefix of the stream for which the predicate holds.

dropWhile p xs produces the suffix remaining after takeWhile p xs.

span p xs returns the longest prefix of xs that satisfies p, together with the remainder of the stream.

span p xs == (takeWhile p xs, dropWhile p xs)

break p is equivalent to span (not . p).

Removes any elements of a nonempty stream that do not satisfy a predicate.

Produces a pair of lists, the first of elements that satisfy the given predicate, the second of elements that did not.

partition p xs == (filter p xs, filter (not . p) xs)

Takes a stream and returns a list of streams such that flattening the resulting list is equal to the argument. Moreover, each stream in the resulting list contains only equal elements.

>>> group "Mississippi"
["M", "i", "ss", "i", "ss", "i", "pp", "i"]

Similar to group, but sorts the input first so that each equivalence class has, at most, one list in the output.

Similar to group, but uses the provided equality predicate instead of ==.

Similar to groupBy, but sorts the input first so that each equivalence class has, at most, one list in the output.

Similar to group, but uses the provided projection when comparing for equality.

Similar to groupWith, but sorts the input first so that each equivalence class has, at most, one list in the output.

Similar to group, but uses the knowledge that its input is non-empty to produce guaranteed non-empty output.

Similar to group1, but sorts the input first so that each equivalence class has, at most, one list in the output.

Similar to group1, but uses the provided equality predicate instead of ==.

Similar to group, but sorts the input first so that each equivalence class has, at most, one list in the output.

Similar to group1, but uses the provided projection when comparing for equality.

Similar to groupWith1, but sorts the list first so that each equivalence class has, at most, one list in the output.

Returns True if the first argument is a prefix of the second.

>>> isPrefixOf [1, 2, 3] [1, 2, 3, 4, 5]
True
>>> isPrefixOf "abc" "defghi"
False
>>> isPrefixOf "abc" ""
False

Removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name nub means essence.) It is a special case of nubBy, which allows the programmer to supply their own inequality test.

Behaves just like nub, except it uses a user-supplied equality predicate instead of the overloaded == function.

xs !! n returns the element of the stream xs at index n, if present. Note that the head of the stream has index 0.

\(\mathcal{O}(\min(m,n))\). Takes two streams and produces a stream of corresponding pairs.

>>> zip [1, 2] ['a', 'b']
[(1, 'a'),(2, 'b')]

\(\mathcal{O}(\min(m,n))\). Generalises zip by zipping with the provided function, instead of a tupling function.