|
| Data.List.NonEmpty | | Portability | portable | | Stability | provisional | | Maintainer | Edward Kmett <ekmett@gmail.com> |
|
|
|
|
|
| Description |
| A NonEmpty list forms a monad as per list, but always contains at least
one element.
|
|
| Synopsis |
|
| data NonEmpty a = a :| [a] | | | map :: (a -> b) -> NonEmpty a -> NonEmpty b | | | intersperse :: a -> NonEmpty a -> NonEmpty a | | | scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b | | | scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b | | | scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a | | | scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a | | | head :: NonEmpty a -> a | | | tail :: NonEmpty a -> [a] | | | last :: NonEmpty a -> a | | | init :: NonEmpty a -> [a] | | | (<|) :: a -> NonEmpty a -> NonEmpty a | | | cons :: a -> NonEmpty a -> NonEmpty a | | | uncons :: NonEmpty a -> (a, Maybe (NonEmpty a)) | | | sort :: Ord a => NonEmpty a -> NonEmpty a | | | reverse :: NonEmpty a -> NonEmpty a | | | inits :: Foldable f => f a -> NonEmpty [a] | | | tails :: Foldable f => f a -> NonEmpty [a] | | | iterate :: (a -> a) -> a -> NonEmpty a | | | repeat :: a -> NonEmpty a | | | cycle :: NonEmpty a -> NonEmpty a | | | unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b | | | insert :: Foldable f => Ord a => a -> f a -> NonEmpty a | | | take :: Int -> NonEmpty a -> [a] | | | drop :: Int -> NonEmpty a -> [a] | | | splitAt :: Int -> NonEmpty a -> ([a], [a]) | | | takeWhile :: (a -> Bool) -> NonEmpty a -> [a] | | | dropWhile :: (a -> Bool) -> NonEmpty a -> [a] | | | span :: (a -> Bool) -> NonEmpty a -> ([a], [a]) | | | break :: (a -> Bool) -> NonEmpty a -> ([a], [a]) | | | filter :: (a -> Bool) -> NonEmpty a -> [a] | | | partition :: (a -> Bool) -> NonEmpty a -> ([a], [a]) | | | group :: (Foldable f, Eq a) => f a -> [NonEmpty a] | | | groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a] | | | group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a) | | | groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a) | | | isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool | | | (!!) :: NonEmpty a -> Int -> a | | | zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b) | | | zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c | | | unzip :: Functor f => f (a, b) -> (f a, f b) | | | words :: NonEmpty Char -> NonEmpty String | | | unwords :: NonEmpty String -> NonEmpty Char | | | lines :: NonEmpty Char -> NonEmpty String | | | unlines :: NonEmpty String -> NonEmpty Char | | | fromList :: [a] -> NonEmpty a | | | toList :: NonEmpty a -> [a] | | | nonEmpty :: [a] -> Maybe (NonEmpty a) |
|
|
|
| The type of streams
|
|
|
| Constructors | |  Instances | |
|
|
| non-empty stream transformations
|
|
|
| map a function over a NonEmpty stream
|
|
|
|
|
scanl is similar to foldl, 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 of scanl.
Note that
head (scanr f z xs) == foldr f z xs.
|
|
|
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), ...]
|
|
|
| scanr1 is a variant of scanr that has no starting value argument.
|
|
| Basic functions
|
|
|
| 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
|
|
|
| cons onto a stream
|
|
|
|
|
|
|
| Sort a stream
|
|
|
| reverse a finite NonEmpty
|
|
|
| The inits function takes a stream xs and returns all the
finite prefixes of xs.
|
|
|
| The tails function takes a stream xs and returns all the
suffixes of xs.
|
|
| Building streams
|
|
|
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 an item into a NonEmpty
|
|
| Extracting sublists
|
|
|
take n xs returns the first n elements of xs.
Beware: passing a negative integer as the first argument will
cause an error.
|
|
|
drop n xs drops the first n elements off the front of
the sequence xs.
Beware: passing a negative integer as the first argument will
cause an error.
|
|
|
splitAt n xs returns a pair consisting of the prefix of xs
of length n and the remaining stream immediately following this prefix.
Beware: passing a negative integer as the first argument will
cause an error.
|
|
|
| takeWhile p xs returns the longest prefix of the stream
xs for which the predicate p holds.
|
|
|
| dropWhile p xs returns 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.
|
|
|
| The break p function is equivalent to span not . p.
|
|
|
| filter p xs, removes any elements from xs that do not satisfy p.
|
|
|
| The partition function takes a predicate p and a stream
xs, and returns a pair of streams. The first stream corresponds
to the elements of xs for which p holds; the second stream
corresponds to the elements of xs for which p does not hold.
|
|
|
The group function takes a stream and returns a stream of
lists such that flattening the resulting stream is equal to the
argument. Moreover, each sublist in the resulting stream
contains only equal elements. For example,
group $ cycle "Mississippi" = "M" : "i" : "ss" : "i" : "ss" : "i" : "pp" : "i" : "M" : "i" : ...
|
|
|
|
|
|
|
|
| Sublist predicates
|
|
|
| The isPrefix function returns True if the first argument is
a prefix of the second.
|
|
| Indexing streams
|
|
|
xs !! n returns the element of the stream xs at index
n. Note that the head of the stream has index 0.
Beware: passing a negative integer as the first argument will cause
an error.
|
|
| Zipping and unzipping streams
|
|
|
| The zip function takes two streams and returns a list of
corresponding pairs.
|
|
|
| The zipWith function generalizes zip. Rather than tupling
the functions, the elements are combined using the function
passed as the first argument to zipWith.
|
|
|
| The unzip function is the inverse of the zip function.
|
|
| Functions on streams of characters
|
|
|
| The words function breaks a stream of characters into a
stream of words, which were delimited by white space.
|
|
|
| The unwords function is an inverse operation to words. It
joins words with separating spaces.
|
|
|
| The lines function breaks a stream of characters into a list
of strings at newline characters. The resulting strings do not
contain newlines.
|
|
|
| The unlines function is an inverse operation to lines. It
joins lines, after appending a terminating newline to each.
|
|
| Converting to and from a list
|
|
|
| Converts an non-empty list to a stream.
|
|
|
| Convert a stream to a list efficiently
|
|
|
|
| Produced by Haddock version 2.6.1 |
