Non-empty (and non-strict) list type.

Since: 4.9.0.0

Constructors

Map a function over aNonEmpty stream.

'intersperse x xs' alternates elements of the list with copies ofx.

intersperse 0 (1 :| [2,3]) == 1 :| [0,2,0,3]

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

scanl f z [x1, x2, ...] == z :| [z `f` x1, (z `f` x1) `f` x2, ...]

Note that

last (scanl f z xs) == foldl f z xs.

scanr is the right-to-left dual ofscanl. Note that

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

scanl1 is a variant ofscanl that has no starting value argument:

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

scanr1 is a variant ofscanr that has no starting value argument.

transpose forNonEmpty, behaves the same astranspose The rows/columns need not be the same length, in which case > transpose . transpose /= id

sortBy forNonEmpty, behaves the same assortBy

sortWith forNonEmpty, behaves the same as:

sortBy . comparing

Number of elements inNonEmpty list.

Extract the first element of the stream.

Extract the possibly-empty tail of the stream.

Extract the last element of the stream.

Extract everything except the last element of the stream.

Prepend an element to the stream.

Synonym for<|.

uncons produces the first element of the stream, and a stream of the remaining elements, if any.

Theunfoldr function is analogous toData.List'sunfoldr operation.

Sort a stream.

reverse a finite NonEmpty stream.

Theinits function takes a streamxs and returns all the finite prefixes ofxs.

Thetails function takes a streamxs and returns all the suffixes ofxs.

iterate f x produces the infinite sequence of repeated applications off tox.

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

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

cycle xs returns the infinite repetition ofxs:

cycle (1 :| [2,3]) = 1 :| [2,3,1,2,3,...]

unfold produces a new stream by repeatedly applying the unfolding function to the seed value to produce an element of typeb and a new seed value. When the unfolding function returnsNothing instead of a new seed value, the stream ends.

insert x xs insertsx into the last position inxs where it is still less than or equal to the next element. In particular, if the list is sorted beforehand, the result will also be sorted.

some1 x sequencesx one or more times.

take n xs returns the firstn elements ofxs.

drop n xs drops the firstn elements off the front of the sequencexs.

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

'splitAt' n xs == ('take' n xs, 'drop' n xs)xs == ys ++ zs where (ys, zs) = 'splitAt' n xs

takeWhile p xs returns the longest prefix of the streamxs for which the predicatep holds.

dropWhile p xs returns the suffix remaining aftertakeWhile p xs.

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

'span' p xs == ('takeWhile' p xs, 'dropWhile' p xs)xs == ys ++ zs where (ys, zs) = 'span' p xs

Thebreak p function is equivalent tospan (not . p).

filter p xs removes any elements fromxs that do not satisfyp.

Thepartition function takes a predicatep and a streamxs, and returns a pair of lists. The first list corresponds to the elements ofxs for whichp holds; the second corresponds to the elements ofxs for whichp does not hold.

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

Thegroup function 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. For example, in list notation:

'group' $ 'cycle' "Mississippi"  = "M" : "i" : "ss" : "i" : "ss" : "i" : "pp" : "i" : "M" : "i" : ...

groupBy operates likegroup, but uses the provided equality predicate instead of==.

groupWith operates likegroup, but uses the provided projection when comparing for equality

groupAllWith operates likegroupWith, but sorts the list first so that each equivalence class has, at most, one list in the output

group1 operates likegroup, but uses the knowledge that its input is non-empty to produce guaranteed non-empty output.

groupBy1 is togroup1 asgroupBy is togroup.

groupWith1 is togroup1 asgroupWith is togroup

groupAllWith1 is togroupWith1 asgroupAllWith is togroupWith

TheisPrefix function returnsTrue if the first argument is a prefix of the second.

Thenub function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The namenub means 'essence'.) It is a special case ofnubBy, which allows the programmer to supply their own inequality test.

ThenubBy function behaves just likenub, except it uses a user-supplied equality predicate instead of the overloaded== function.

xs !! n returns the element of the streamxs at indexn. Note that the head of the stream has index 0.

Beware: a negative or out-of-bounds index will cause an error.

Thezip function takes two streams and returns a stream of corresponding pairs.

ThezipWith function generalizeszip. Rather than tupling the elements, the elements are combined using the function passed as the first argument.

Theunzip function is the inverse of thezip function.

Converts a normal list to aNonEmpty stream.

Raises an error if given an empty list.

Convert a stream to a normal list efficiently.

nonEmpty efficiently turns a normal list into aNonEmpty stream, producingNothing if the input is empty.

Compute n-ary logic exclusive OR operation onNonEmpty list.