base-4.9.0.0: Basic libraries

Copyright(C) 2011-2015 Edward Kmett, (C) 2010 Tony Morris, Oliver Taylor, Eelis van der Weegen
LicenseBSD-style (see the file LICENSE)
Maintainerlibraries@haskell.org
Stabilityprovisional
Portabilityportable
Safe HaskellTrustworthy
LanguageHaskell2010

Data.List.NonEmpty

Contents

Description

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

Synopsis

The type of non-empty streams

data NonEmpty a Source

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

Since: 4.9.0.0

Constructors

a :| [a] infixr 5 

Instances

Monad NonEmpty 
Functor NonEmpty 

Methods

fmap :: (a -> b) -> NonEmpty a -> NonEmpty b Source

(<$) :: a -> NonEmpty b -> NonEmpty a Source

MonadFix NonEmpty 

Methods

mfix :: (a -> NonEmpty a) -> NonEmpty a Source

Applicative NonEmpty 

Methods

pure :: a -> NonEmpty a Source

(<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b Source

(*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Source

(<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a Source

Foldable NonEmpty 

Methods

fold :: 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

sum :: Num a => NonEmpty a -> a Source

product :: Num a => NonEmpty a -> a Source

Traversable NonEmpty 

Methods

traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) Source

sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) Source

mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) Source

sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) Source

Generic1 NonEmpty 

Associated Types

type Rep1 (NonEmpty :: * -> TYPE Lifted) :: * -> * Source

MonadZip NonEmpty 

Methods

mzip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b) Source

mzipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c Source

munzip :: NonEmpty (a, b) -> (NonEmpty a, NonEmpty b) Source

IsList (NonEmpty a) 

Associated Types

type Item (NonEmpty a) :: TYPE Lifted Source

Eq a => Eq (NonEmpty a) 

Methods

(==) :: NonEmpty a -> NonEmpty a -> Bool Source

(/=) :: NonEmpty a -> NonEmpty a -> Bool Source

Data a => Data (NonEmpty a) 

Methods

gfoldl :: (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 (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) 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) 
Read a => Read (NonEmpty a) 
Show a => Show (NonEmpty a) 
Generic (NonEmpty a) 

Associated Types

type Rep (NonEmpty a) :: * -> * Source

Methods

from :: NonEmpty a -> Rep (NonEmpty a) x Source

to :: Rep (NonEmpty a) x -> NonEmpty a Source

Semigroup (NonEmpty a) 
type Rep1 NonEmpty = D1 (MetaData "NonEmpty" "Data.List.NonEmpty" "base" False) (C1 (MetaCons ":|" (InfixI RightAssociative 5) False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 [])))) 
type Rep (NonEmpty a) = D1 (MetaData "NonEmpty" "Data.List.NonEmpty" "base" False) (C1 (MetaCons ":|" (InfixI RightAssociative 5) False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [a])))) 
type Item (NonEmpty a) = a 

Non-empty stream transformations

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

Basic functions

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.

Building streams

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

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.

Extracting sublists

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

Sublist predicates

isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool Source

The isPrefix function returns True if the first argument is a prefix of the second.

"Set" operations

nub :: Eq a => NonEmpty a -> NonEmpty a Source

The nub function removes duplicate elements from a list. In particular, it keeps only the first occurence 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.

Indexing streams

(!!) :: 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.

Zipping and unzipping streams

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.

Converting to and from a list

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.