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: base-4.9.0.0

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

Since: base-4.9.0.0

a :| [a] infixr 5 |

Monad NonEmpty | Since: base-4.9.0.0 |

Functor NonEmpty | Since: base-4.9.0.0 |

MonadFix NonEmpty | Since: base-4.9.0.0 |

Defined in Control.Monad.Fix | |

Applicative NonEmpty | Since: base-4.9.0.0 |

Defined in GHC.Base | |

Foldable NonEmpty | Since: base-4.9.0.0 |

Defined in Data.Foldable ## Methodsfold :: Monoid m => NonEmpty m -> m Source foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m Source foldr :: (a -> b -> b) -> b -> NonEmpty a -> b Source foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b Source foldl :: (b -> a -> b) -> b -> NonEmpty a -> b Source foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b Source foldr1 :: (a -> a -> a) -> NonEmpty a -> a Source foldl1 :: (a -> a -> a) -> NonEmpty a -> a Source toList :: NonEmpty a -> [a] Source null :: NonEmpty a -> Bool Source length :: NonEmpty a -> Int Source elem :: Eq a => a -> NonEmpty a -> Bool Source maximum :: Ord a => NonEmpty a -> a Source minimum :: Ord a => NonEmpty a -> a Source | |

Traversable NonEmpty | Since: base-4.9.0.0 |

Defined in Data.Traversable | |

MonadZip NonEmpty | Since: base-4.9.0.0 |

Show1 NonEmpty | Since: base-4.10.0.0 |

Read1 NonEmpty | Since: base-4.10.0.0 |

Defined in Data.Functor.Classes ## MethodsliftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NonEmpty a) Source liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [NonEmpty a] Source liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (NonEmpty a) Source liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [NonEmpty a] Source | |

Ord1 NonEmpty | Since: base-4.10.0.0 |

Defined in Data.Functor.Classes | |

Eq1 NonEmpty | Since: base-4.10.0.0 |

IsList (NonEmpty a) | Since: base-4.9.0.0 |

Eq a => Eq (NonEmpty a) | Since: base-4.9.0.0 |

Data a => Data (NonEmpty a) | Since: base-4.9.0.0 |

Defined in Data.Data ## Methodsgfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a) Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NonEmpty a) Source toConstr :: NonEmpty a -> Constr Source dataTypeOf :: NonEmpty a -> DataType Source dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a)) Source dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NonEmpty a)) Source gmapT :: (forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r Source gmapQ :: (forall d. Data d => d -> u) -> NonEmpty a -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) Source | |

Ord a => Ord (NonEmpty a) | Since: base-4.9.0.0 |

Defined in GHC.Base ## Methodscompare :: NonEmpty a -> NonEmpty a -> Ordering Source (<) :: NonEmpty a -> NonEmpty a -> Bool Source (<=) :: NonEmpty a -> NonEmpty a -> Bool Source (>) :: NonEmpty a -> NonEmpty a -> Bool Source (>=) :: NonEmpty a -> NonEmpty a -> Bool Source | |

Read a => Read (NonEmpty a) | Since: base-4.11.0.0 |

Show a => Show (NonEmpty a) | Since: base-4.11.0.0 |

Generic (NonEmpty a) | |

Semigroup (NonEmpty a) | Since: base-4.9.0.0 |

Generic1 NonEmpty | |

type Rep (NonEmpty a) | Since: base-4.6.0.0 |

Defined in GHC.Generics type Rep (NonEmpty a) = D1 (MetaData "NonEmpty" "GHC.Base" "base" False) (C1 (MetaCons ":|" (InfixI LeftAssociative 9) False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [a]))) | |

type Item (NonEmpty a) | |

type Rep1 NonEmpty | Since: base-4.6.0.0 |

Defined in GHC.Generics type Rep1 NonEmpty = D1 (MetaData "NonEmpty" "GHC.Base" "base" False) (C1 (MetaCons ":|" (InfixI LeftAssociative 9) False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 []))) |

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 infixl 9 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.6.1/docs/html/libraries/base-4.12.0.0/Data-List-NonEmpty.html