Copyright | (C) 2011-2015 Edward Kmett (C) 2010 Tony Morris Oliver Taylor Eelis van der Weegen |
---|---|
License | BSD-style (see the file LICENSE) |
Maintainer | [email protected] |
Stability | provisional |
Portability | portable |
Safe Haskell | Trustworthy |
Language | Haskell2010 |
A NonEmpty
list is one which always has at least one element, but is otherwise identical to the traditional list type in complexity and in terms of API. You will almost certainly want to import this module qualified
.
Since: 4.9.0.0
Non-empty (and non-strict) list type.
Since: 4.9.0.0
a :| [a] infixr 5 |
Monad NonEmpty | Since: 4.9.0.0 |
Functor NonEmpty | Since: 4.9.0.0 |
MonadFix NonEmpty | Since: 4.9.0.0 |
Applicative NonEmpty | Since: 4.9.0.0 |
Foldable NonEmpty | Since: 4.9.0.0 |
Traversable NonEmpty | Since: 4.9.0.0 |
MonadZip NonEmpty | Since: 4.9.0.0 |
Show1 NonEmpty | Since: 4.10.0.0 |
Read1 NonEmpty | Since: 4.10.0.0 |
Ord1 NonEmpty | Since: 4.10.0.0 |
Eq1 NonEmpty | Since: 4.10.0.0 |
IsList (NonEmpty a) | Since: 4.9.0.0 |
Eq a => Eq (NonEmpty a) | |
Data a => Data (NonEmpty a) | |
Ord a => Ord (NonEmpty a) | |
Read a => Read (NonEmpty a) | |
Show a => Show (NonEmpty a) | |
Generic (NonEmpty a) | |
Semigroup (NonEmpty a) | Since: 4.9.0.0 |
Generic1 * NonEmpty | |
type Rep (NonEmpty a) | |
type Item (NonEmpty a) | |
type Rep1 * NonEmpty | |
map :: (a -> b) -> NonEmpty a -> NonEmpty b Source
Map a function over a NonEmpty
stream.
intersperse :: a -> NonEmpty a -> NonEmpty a Source
'intersperse x xs' alternates elements of the list with copies of x
.
intersperse 0 (1 :| [2,3]) == 1 :| [0,2,0,3]
scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b Source
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 :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b Source
scanr
is the right-to-left dual of scanl
. Note that
head (scanr f z xs) == foldr f z xs.
scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a Source
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 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a Source
scanr1
is a variant of scanr
that has no starting value argument.
transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a) Source
transpose
for NonEmpty
, behaves the same as transpose
The rows/columns need not be the same length, in which case > transpose . transpose /= id
sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a Source
sortBy
for NonEmpty
, behaves the same as sortBy
sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a Source
sortWith
for NonEmpty
, behaves the same as:
sortBy . comparing
length :: NonEmpty a -> Int Source
Number of elements in NonEmpty
list.
head :: NonEmpty a -> a Source
Extract the first element of the stream.
tail :: NonEmpty a -> [a] Source
Extract the possibly-empty tail of the stream.
last :: NonEmpty a -> a Source
Extract the last element of the stream.
init :: NonEmpty a -> [a] Source
Extract everything except the last element of the stream.
(<|) :: a -> NonEmpty a -> NonEmpty a infixr 5 Source
Prepend an element to the stream.
cons :: a -> NonEmpty a -> NonEmpty a Source
Synonym for <|
.
uncons :: NonEmpty a -> (a, Maybe (NonEmpty a)) Source
uncons
produces the first element of the stream, and a stream of the remaining elements, if any.
unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b Source
The unfoldr
function is analogous to Data.List's unfoldr
operation.
sort :: Ord a => NonEmpty a -> NonEmpty a Source
Sort a stream.
reverse :: NonEmpty a -> NonEmpty a Source
reverse
a finite NonEmpty stream.
inits :: Foldable f => f a -> NonEmpty [a] Source
The inits
function takes a stream xs
and returns all the finite prefixes of xs
.
tails :: Foldable f => f a -> NonEmpty [a] Source
The tails
function takes a stream xs
and returns all the suffixes of xs
.
iterate :: (a -> a) -> a -> NonEmpty a Source
iterate f x
produces the infinite sequence of repeated applications of f
to x
.
iterate f x = x :| [f x, f (f x), ..]
repeat :: a -> NonEmpty a Source
repeat x
returns a constant stream, where all elements are equal to x
.
cycle :: NonEmpty a -> NonEmpty a Source
cycle xs
returns the infinite repetition of xs
:
cycle (1 :| [2,3]) = 1 :| [2,3,1,2,3,...]
unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b Source
Deprecated: Use unfoldr
unfold
produces a new stream by repeatedly applying the unfolding function to the seed value to produce an element of type b
and a new seed value. When the unfolding function returns Nothing
instead of a new seed value, the stream ends.
insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a Source
insert x xs
inserts x
into the last position in xs
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 :: Alternative f => f a -> f (NonEmpty a) Source
some1 x
sequences x
one or more times.
take :: Int -> NonEmpty a -> [a] Source
take n xs
returns the first n
elements of xs
.
drop :: Int -> NonEmpty a -> [a] Source
drop n xs
drops the first n
elements off the front of the sequence xs
.
splitAt :: Int -> NonEmpty a -> ([a], [a]) Source
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) xs == ys ++ zs where (ys, zs) = 'splitAt' n xs
takeWhile :: (a -> Bool) -> NonEmpty a -> [a] Source
takeWhile p xs
returns the longest prefix of the stream xs
for which the predicate p
holds.
dropWhile :: (a -> Bool) -> NonEmpty a -> [a] Source
dropWhile p xs
returns the suffix remaining after takeWhile p xs
.
span :: (a -> Bool) -> NonEmpty a -> ([a], [a]) Source
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) xs == ys ++ zs where (ys, zs) = 'span' p xs
break :: (a -> Bool) -> NonEmpty a -> ([a], [a]) Source
The break p
function is equivalent to span (not . p)
.
filter :: (a -> Bool) -> NonEmpty a -> [a] Source
filter p xs
removes any elements from xs
that do not satisfy p
.
partition :: (a -> Bool) -> NonEmpty a -> ([a], [a]) Source
The partition
function takes a predicate p
and a stream xs
, and returns a pair of lists. The first list corresponds to the elements of xs
for which p
holds; the second corresponds to the elements of xs
for which p
does not hold.
'partition' p xs = ('filter' p xs, 'filter' (not . p) xs)
group :: (Foldable f, Eq a) => f a -> [NonEmpty a] Source
The group
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 :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a] Source
groupBy
operates like group
, but uses the provided equality predicate instead of ==
.
groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a] Source
groupWith
operates like group
, but uses the provided projection when comparing for equality
groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a] Source
groupAllWith
operates like groupWith
, but sorts the list first so that each equivalence class has, at most, one list in the output
group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a) Source
group1
operates like group
, but uses the knowledge that its input is non-empty to produce guaranteed non-empty output.
groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a) Source
groupBy1
is to group1
as groupBy
is to group
.
groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a) Source
groupWith1
is to group1
as groupWith
is to group
groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a) Source
groupAllWith1
is to groupWith1
as groupAllWith
is to groupWith
isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool Source
The isPrefix
function returns True
if the first argument is a prefix of the second.
nub :: Eq a => NonEmpty a -> NonEmpty a Source
The nub
function 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.
nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a Source
The nubBy
function behaves just like nub
, except it uses a user-supplied equality predicate instead of the overloaded ==
function.
(!!) :: NonEmpty a -> Int -> a Source
xs !! n
returns the element of the stream xs
at index n
. Note that the head of the stream has index 0.
Beware: a negative or out-of-bounds index will cause an error.
zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b) Source
The zip
function takes two streams and returns a stream of corresponding pairs.
zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c Source
The zipWith
function generalizes zip
. Rather than tupling the elements, the elements are combined using the function passed as the first argument.
unzip :: Functor f => f (a, b) -> (f a, f b) Source
The unzip
function is the inverse of the zip
function.
fromList :: [a] -> NonEmpty a Source
Converts a normal list to a NonEmpty
stream.
Raises an error if given an empty list.
toList :: NonEmpty a -> [a] Source
Convert a stream to a normal list efficiently.
nonEmpty :: [a] -> Maybe (NonEmpty a) Source
nonEmpty
efficiently turns a normal list into a NonEmpty
stream, producing Nothing
if the input is empty.
xor :: NonEmpty Bool -> Bool Source
Compute n-ary logic exclusive OR operation on NonEmpty
list.
© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.2.1/docs/html/libraries/base-4.10.0.0/Data-List-NonEmpty.html