ghc-lib-parser-9.14.1.20251220: The GHC API, decoupled from GHC versions

Safe Haskell | Ignore
Language | GHC2021

GHC.Data.List.NonEmpty

Synopsis

- unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b
- sortOn :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty a
- transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
- sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
- cycle :: NonEmpty a -> NonEmpty a
- filter :: (a -> Bool) -> NonEmpty a -> [a]
- zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
- map :: (a -> b) -> NonEmpty a -> NonEmpty b
- fromList :: HasCallStack => [a] -> NonEmpty a
- data NonEmpty a = a :| [a]
- head :: NonEmpty a -> a
- uncons :: NonEmpty a -> (a, Maybe (NonEmpty a))
- tail :: NonEmpty a -> [a]
- last :: NonEmpty a -> a
- init :: NonEmpty a -> [a]
- length :: NonEmpty a -> Int
- scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b
- scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
- scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b
- scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
- iterate :: (a -> a) -> a -> NonEmpty a
- repeat :: a -> NonEmpty a
- takeWhile :: (a -> Bool) -> NonEmpty a -> [a]
- dropWhile :: (a -> Bool) -> NonEmpty a -> [a]
- take :: Int -> NonEmpty a -> [a]
- drop :: Int -> NonEmpty a -> [a]
- splitAt :: Int -> NonEmpty a -> ([a], [a])
- span :: (a -> Bool) -> NonEmpty a -> ([a], [a])
- break :: (a -> Bool) -> NonEmpty a -> ([a], [a])
- reverse :: NonEmpty a -> NonEmpty a
- (!!) :: HasCallStack => NonEmpty a -> Int -> a
- zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
- xor :: NonEmpty Bool -> Bool
- isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool
- nub :: Eq a => NonEmpty a -> NonEmpty a
- nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a
- intersperse :: a -> NonEmpty a -> NonEmpty a
- partition :: (a -> Bool) -> NonEmpty a -> ([a], [a])
- insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a
- group :: (Foldable f, Eq a) => f a -> [NonEmpty a]
- groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]
- inits :: Foldable f => f a -> NonEmpty [a]
- tails :: Foldable f => f a -> NonEmpty [a]
- permutations :: [a] -> NonEmpty [a]
- sort :: Ord a => NonEmpty a -> NonEmpty a
- singleton :: a -> NonEmpty a
- sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a
- groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a]
- unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b
- nonEmpty :: [a] -> Maybe (NonEmpty a)
- (<|) :: a -> NonEmpty a -> NonEmpty a
- cons :: a -> NonEmpty a -> NonEmpty a
- inits1 :: NonEmpty a -> NonEmpty (NonEmpty a)
- tails1 :: NonEmpty a -> NonEmpty (NonEmpty a)
- some1 :: Alternative f => f a -> f (NonEmpty a)
- groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a]
- group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a)
- groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
- groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
- groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
- permutations1 :: NonEmpty a -> NonEmpty (NonEmpty a)
- append :: NonEmpty a -> NonEmpty a -> NonEmpty a
- appendList :: NonEmpty a -> [a] -> NonEmpty a
- prependList :: [a] -> NonEmpty a -> NonEmpty a
- unzip :: NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)
- unzip3 :: NonEmpty (a, b, c) -> (NonEmpty a, NonEmpty b, NonEmpty c)
- zipWithM :: Applicative f => (a -> b -> f c) -> NonEmpty a -> NonEmpty b -> f (NonEmpty c)
- isSingleton :: NonEmpty a -> Bool
- mapAndUnzip :: (a -> (b, c)) -> NonEmpty a -> (NonEmpty b, NonEmpty c)
- mapAndUnzip3 :: (a -> (b, c, d)) -> NonEmpty a -> (NonEmpty b, NonEmpty c, NonEmpty d)
- toList :: Foldable t => t a -> [a]

# Documentation

unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b #

The `unfoldr` function is analogous to Data.List's `unfoldr` operation.

sortOn :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty a #

Sort a `NonEmpty` on a user-supplied projection of its elements. See `sortOn` for more detailed information.

#### Examples

Expand

    >>> sortOn fst $ (2, "world") :| [(4, "!"), (1, "Hello")]
    (1,"Hello") :| [(2,"world"),(4,"!")]

    >>> sortOn length $ "jim" :| ["creed", "pam", "michael", "dwight", "kevin"]
    "jim" :| ["pam","creed","kevin","dwight","michael"]

#### Performance notes

Expand

This function minimises the projections performed, by materialising the projections in an intermediate list.

For trivial projections, you should prefer using `sortBy` with `comparing`, for example:

    >>> sortBy (comparing fst) $ (3, 1) :| [(2, 2), (1, 3)]
    (1,3) :| [(2,2),(3,1)]

Or, for the exact same API as `sortOn`, you can use `sortBy . comparing`:

    >>> (sortBy . comparing) fst $ (3, 1) :| [(2, 2), (1, 3)]
    (1,3) :| [(2,2),(3,1)]

`sortWith` is an alias for `sortBy . comparing`.

Since: base-4.20.0.0

transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a) #

`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 #

`sortBy` for `NonEmpty`, behaves the same as `sortBy`

cycle :: NonEmpty a -> NonEmpty a #

``cycle` xs` returns the infinite repetition of `xs`:

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

filter :: (a -> Bool) -> NonEmpty a -> [a] #

``filter` p xs` removes any elements from `xs` that do not satisfy `p`.

zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b) #

The `zip` function takes two streams and returns a stream of corresponding pairs.

map :: (a -> b) -> NonEmpty a -> NonEmpty b #

Map a function over a `NonEmpty` stream.

fromList :: HasCallStack => [a] -> NonEmpty a #

Converts a normal list to a `NonEmpty` stream.

Raises an error if given an empty list.

data NonEmpty a #

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

@since base-4.9.0.0

Constructors

a :| [a] infixr 5 |

#### Instances

Instances details

MonadZip NonEmpty | Since: base-4.9.0.0
Instance details Defined in Control.Monad.Zip Methods mzip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b) # mzipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c # munzip :: NonEmpty (a, b) -> (NonEmpty a, NonEmpty b) #
Foldable1 NonEmpty | Since: base-4.18.0.0

Instance details

Defined in Data.Foldable1

Methods

fold1 :: Semigroup m => NonEmpty m -> m #

foldMap1 :: Semigroup m => (a -> m) -> NonEmpty a -> m #

foldMap1' :: Semigroup m => (a -> m) -> NonEmpty a -> m #

toNonEmpty :: NonEmpty a -> NonEmpty a #

maximum :: Ord a => NonEmpty a -> a #

minimum :: Ord a => NonEmpty a -> a #

head :: NonEmpty a -> a #

last :: NonEmpty a -> a #

foldrMap1 :: (a -> b) -> (a -> b -> b) -> NonEmpty a -> b #

foldlMap1' :: (a -> b) -> (b -> a -> b) -> NonEmpty a -> b #

foldlMap1 :: (a -> b) -> (b -> a -> b) -> NonEmpty a -> b #

foldrMap1' :: (a -> b) -> (a -> b -> b) -> NonEmpty a -> b #

Eq1 NonEmpty | Since: base-4.10.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> NonEmpty a -> NonEmpty b -> Bool #
Ord1 NonEmpty | Since: base-4.10.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> NonEmpty a -> NonEmpty b -> Ordering #
Read1 NonEmpty | Since: base-4.10.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NonEmpty a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [NonEmpty a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (NonEmpty a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [NonEmpty a] #
Show1 NonEmpty | Since: base-4.10.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> NonEmpty a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [NonEmpty a] -> ShowS #
NFData1 NonEmpty | Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> NonEmpty a -> () #
Applicative NonEmpty | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods pure :: a -> NonEmpty a # (<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b # liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c # (*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # (<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a #
Functor NonEmpty | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b # (<$) :: a -> NonEmpty b -> NonEmpty a #
Monad NonEmpty | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # return :: a -> NonEmpty a #
MonadFix NonEmpty | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> NonEmpty a) -> NonEmpty a #
Foldable NonEmpty | @since base-4.9.0.0

Instance details

Defined in GHC.Internal.Data.Foldable

Methods

fold :: Monoid m => NonEmpty m -> m #

foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m #

foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m #

foldr :: (a -> b -> b) -> b -> NonEmpty a -> b #

foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b #

foldl :: (b -> a -> b) -> b -> NonEmpty a -> b #

foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b #

foldr1 :: (a -> a -> a) -> NonEmpty a -> a #

foldl1 :: (a -> a -> a) -> NonEmpty a -> a #

toList :: NonEmpty a -> [a] #

null :: NonEmpty a -> Bool #

length :: NonEmpty a -> Int #

elem :: Eq a => a -> NonEmpty a -> Bool #

maximum :: Ord a => NonEmpty a -> a #

minimum :: Ord a => NonEmpty a -> a #

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

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

Traversable NonEmpty | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) # sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) # mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) # sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) #
Generic1 NonEmpty |

Instance details

Defined in GHC.Internal.Generics

Associated Types

type Rep1 NonEmpty | @since base-4.6.0.0

Instance details

Defined in GHC.Internal.Generics

type Rep1 NonEmpty = D1 ('MetaData "NonEmpty" "GHC.Internal.Base" "ghc-internal" 'False) (C1 ('MetaCons ":|" ('InfixI 'RightAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 [])))

Methods

from1 :: NonEmpty a -> Rep1 NonEmpty a #

to1 :: Rep1 NonEmpty a -> NonEmpty a #

Lift a => Lift (NonEmpty a :: Type) | Since: template-haskell-2.15.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => NonEmpty a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => NonEmpty a -> Code m (NonEmpty a) #
Binary a => Binary (NonEmpty a) | Since: binary-0.8.4.0
Instance details Defined in Data.Binary.Class Methods put :: NonEmpty a -> Put # get :: Get (NonEmpty a) # putList :: [NonEmpty a] -> Put #
NFData a => NFData (NonEmpty a) | Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: NonEmpty a -> () #
Semigroup (NonEmpty a) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a # sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a # stimes :: Integral b => b -> NonEmpty a -> NonEmpty a #
Data a => Data (NonEmpty a) | @since base-4.9.0.0

Instance details

Defined in GHC.Internal.Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NonEmpty a) #

toConstr :: NonEmpty a -> Constr #

dataTypeOf :: NonEmpty a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NonEmpty a)) #

gmapT :: (forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r #

gmapQ :: (forall d. Data d => d -> u) -> NonEmpty a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) #

Generic (NonEmpty a) |

Instance details

Defined in GHC.Internal.Generics

Associated Types

type Rep (NonEmpty a) | @since base-4.6.0.0

Instance details

Defined in GHC.Internal.Generics

type Rep (NonEmpty a) = D1 ('MetaData "NonEmpty" "GHC.Internal.Base" "ghc-internal" 'False) (C1 ('MetaCons ":|" ('InfixI 'RightAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a])))

Methods

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

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

IsList (NonEmpty a) | @since base-4.9.0.0

Instance details

Defined in GHC.Internal.IsList

Associated Types

type Item (NonEmpty a) |
Instance details Defined in GHC.Internal.IsList type Item (NonEmpty a) = a

Methods

fromList :: [Item (NonEmpty a)] -> NonEmpty a #

fromListN :: Int -> [Item (NonEmpty a)] -> NonEmpty a #

toList :: NonEmpty a -> [Item (NonEmpty a)] #

Read a => Read (NonEmpty a) | @since base-4.11.0.0
Instance details Defined in GHC.Internal.Read Methods readsPrec :: Int -> ReadS (NonEmpty a) # readList :: ReadS [NonEmpty a] # readPrec :: ReadPrec (NonEmpty a) # readListPrec :: ReadPrec [NonEmpty a] #
Show a => Show (NonEmpty a) | @since base-4.11.0.0
Instance details Defined in GHC.Internal.Show Methods showsPrec :: Int -> NonEmpty a -> ShowS # show :: NonEmpty a -> String # showList :: [NonEmpty a] -> ShowS #
Binary a => Binary (NonEmpty a) # |
Instance details Defined in GHC.Utils.Binary Methods put_ :: WriteBinHandle -> NonEmpty a -> IO () # put :: WriteBinHandle -> NonEmpty a -> IO (Bin (NonEmpty a)) # get :: ReadBinHandle -> IO (NonEmpty a) #
Outputable a => Outputable (NonEmpty a) # |
Instance details Defined in GHC.Utils.Outputable Methods ppr :: NonEmpty a -> SDoc #
Eq a => Eq (NonEmpty a) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Ord a => Ord (NonEmpty a) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods compare :: NonEmpty a -> NonEmpty a -> Ordering # (<) :: NonEmpty a -> NonEmpty a -> Bool # (<=) :: NonEmpty a -> NonEmpty a -> Bool # (>) :: NonEmpty a -> NonEmpty a -> Bool # (>=) :: NonEmpty a -> NonEmpty a -> Bool # max :: NonEmpty a -> NonEmpty a -> NonEmpty a # min :: NonEmpty a -> NonEmpty a -> NonEmpty a #
type Rep1 NonEmpty | @since base-4.6.0.0

Instance details

Defined in GHC.Internal.Generics

type Rep1 NonEmpty = D1 ('MetaData "NonEmpty" "GHC.Internal.Base" "ghc-internal" 'False) (C1 ('MetaCons ":|" ('InfixI 'RightAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 [])))

type Rep (NonEmpty a) | @since base-4.6.0.0

Instance details

Defined in GHC.Internal.Generics

type Rep (NonEmpty a) = D1 ('MetaData "NonEmpty" "GHC.Internal.Base" "ghc-internal" 'False) (C1 ('MetaCons ":|" ('InfixI 'RightAssociative 5) '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) |
Instance details Defined in GHC.Internal.IsList type Item (NonEmpty a) = a

head :: NonEmpty a -> a #

Extract the first element of the stream.

uncons :: NonEmpty a -> (a, Maybe (NonEmpty a)) #

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

tail :: NonEmpty a -> [a] #

Extract the possibly-empty tail of the stream.

last :: NonEmpty a -> a #

Extract the last element of the stream.

init :: NonEmpty a -> [a] #

Extract everything except the last element of the stream.

length :: NonEmpty a -> Int #

Number of elements in `NonEmpty` list.

scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b #

`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.

scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a #

`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), ...]

scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b #

`scanr` is the right-to-left dual of `scanl`. Note that

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

scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a #

`scanr1` is a variant of `scanr` that has no starting value argument.

iterate :: (a -> a) -> a -> NonEmpty a #

``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 #

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

takeWhile :: (a -> Bool) -> NonEmpty a -> [a] #

``takeWhile` p xs` returns the longest prefix of the stream `xs` for which the predicate `p` holds.

dropWhile :: (a -> Bool) -> NonEmpty a -> [a] #

``dropWhile` p xs` returns the suffix remaining after ``takeWhile` p xs`.

take :: Int -> NonEmpty a -> [a] #

``take` n xs` returns the first `n` elements of `xs`.

drop :: Int -> NonEmpty a -> [a] #

``drop` n xs` drops the first `n` elements off the front of the sequence `xs`.

splitAt :: Int -> NonEmpty a -> ([a], [a]) #

``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

span :: (a -> Bool) -> NonEmpty a -> ([a], [a]) #

``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]) #

The ``break` p` function is equivalent to ``span` (not . p)`.

reverse :: NonEmpty a -> NonEmpty a #

`reverse` a finite NonEmpty stream.

(!!) :: HasCallStack => NonEmpty a -> Int -> a infixl 9 #

`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.

zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c #

The `zipWith` function generalizes `zip`. Rather than tupling the elements, the elements are combined using the function passed as the first argument.

xor :: NonEmpty Bool -> Bool #

Compute n-ary logic exclusive OR operation on `NonEmpty` list.

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

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

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

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 #

The `nubBy` function behaves just like `nub`, except it uses a user-supplied equality predicate instead of the overloaded `==` function.

intersperse :: a -> NonEmpty a -> NonEmpty a #

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

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

partition :: (a -> Bool) -> NonEmpty a -> ([a], [a]) #

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)

insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a #

``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.

group :: (Foldable f, Eq a) => f a -> [NonEmpty a] #

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, and consecutive equal elements of the input end up in the same stream of the output list. For example, in list notation:

    >>> group "Mississippi"
    ["M", "i", "ss", "i", "ss", "i", "pp", "i"]

groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a] #

`groupBy` operates like `group`, but uses the provided equality predicate instead of `==`.

inits :: Foldable f => f a -> NonEmpty [a] #

The `inits` function takes a stream `xs` and returns all the finite prefixes of `xs`, starting with the shortest. The result is `NonEmpty` because the result always contains the empty list as the first element.

    inits [1,2,3] == [] :| [[1], [1,2], [1,2,3]]
    inits [1] == [] :| [[1]]
    inits [] == [] :| []

tails :: Foldable f => f a -> NonEmpty [a] #

The `tails` function takes a stream `xs` and returns all the suffixes of `xs`, starting with the longest. The result is `NonEmpty` because the result always contains the empty list as the last element.

    tails [1,2,3] == [1,2,3] :| [[2,3], [3], []]
    tails [1] == [1] :| [[]]
    tails [] == [] :| []

permutations :: [a] -> NonEmpty [a] #

The `permutations` function returns the list of all permutations of the argument.

Since: base-4.20.0.0

sort :: Ord a => NonEmpty a -> NonEmpty a #

Sort a stream.

singleton :: a -> NonEmpty a #

Construct a `NonEmpty` list from a single element.

Since: base-4.15

sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a #

`sortWith` for `NonEmpty`, behaves the same as:

    sortBy . comparing

groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a] #

`groupWith` operates like `group`, but uses the provided projection when comparing for equality

unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b #

`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.

nonEmpty :: [a] -> Maybe (NonEmpty a) #

`nonEmpty` efficiently turns a normal list into a `NonEmpty` stream, producing `Nothing` if the input is empty.

(<|) :: a -> NonEmpty a -> NonEmpty a infixr 5 #

Prepend an element to the stream.

cons :: a -> NonEmpty a -> NonEmpty a #

Synonym for `<|`.

inits1 :: NonEmpty a -> NonEmpty (NonEmpty a) #

The `inits1` function takes a `NonEmpty` stream `xs` and returns all the `NonEmpty` finite prefixes of `xs`, starting with the shortest.

    inits1 (1 :| [2,3]) == (1 :| []) :| [1 :| [2], 1 :| [2,3]]
    inits1 (1 :| []) == (1 :| []) :| []

Since: base-4.18

tails1 :: NonEmpty a -> NonEmpty (NonEmpty a) #

The `tails1` function takes a `NonEmpty` stream `xs` and returns all the non-empty suffixes of `xs`, starting with the longest.

    tails1 (1 :| [2,3]) == (1 :| [2,3]) :| [2 :| [3], 3 :| []]
    tails1 (1 :| []) == (1 :| []) :| []

Since: base-4.18

some1 :: Alternative f => f a -> f (NonEmpty a) #

``some1` x` sequences `x` one or more times.

groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a] #

`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) #

`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) #

`groupBy1` is to `group1` as `groupBy` is to `group`.

groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a) #

`groupWith1` is to `group1` as `groupWith` is to `group`

groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a) #

`groupAllWith1` is to `groupWith1` as `groupAllWith` is to `groupWith`

permutations1 :: NonEmpty a -> NonEmpty (NonEmpty a) #

`permutations1` operates like `permutations`, but uses the knowledge that its input is non-empty to produce output where every element is non-empty.

    permutations1 = fmap fromList . permutations . toList

Since: base-4.20.0.0

append :: NonEmpty a -> NonEmpty a -> NonEmpty a #

A monomorphic version of `<>` for `NonEmpty`.

    >>> append (1 :| []) (2 :| [3])
    1 :| [2,3]

Since: base-4.16

appendList :: NonEmpty a -> [a] -> NonEmpty a #

Attach a list at the end of a `NonEmpty`.

    >>> appendList (1 :| [2,3]) []
    1 :| [2,3]

    >>> appendList (1 :| [2,3]) [4,5]
    1 :| [2,3,4,5]

Since: base-4.16

prependList :: [a] -> NonEmpty a -> NonEmpty a #

Attach a list at the beginning of a `NonEmpty`.

    >>> prependList [] (1 :| [2,3])
    1 :| [2,3]

    >>> prependList [negate 1, 0] (1 :| [2, 3])
    -1 :| [0,1,2,3]

Since: base-4.16

unzip :: NonEmpty (a, b) -> (NonEmpty a, NonEmpty b) #

unzip3 :: NonEmpty (a, b, c) -> (NonEmpty a, NonEmpty b, NonEmpty c) #

zipWithM :: Applicative f => (a -> b -> f c) -> NonEmpty a -> NonEmpty b -> f (NonEmpty c) #

isSingleton :: NonEmpty a -> Bool #

mapAndUnzip :: (a -> (b, c)) -> NonEmpty a -> (NonEmpty b, NonEmpty c) #

mapAndUnzip3 :: (a -> (b, c, d)) -> NonEmpty a -> (NonEmpty b, NonEmpty c, NonEmpty d) #

toList :: Foldable t => t a -> [a] #

List of elements of a structure, from left to right. If the entire list is intended to be reduced via a fold, just fold the structure directly bypassing the list.

#### Examples

Expand

Basic usage:

    >>> toList Nothing
    []

    >>> toList (Just 42)
    [42]

    >>> toList (Left "foo")
    []

    >>> toList (Node (Leaf 5) 17 (Node Empty 12 (Leaf 8)))
    [5,17,12,8]

For lists, `toList` is the identity:

    >>> toList [1, 2, 3]
    [1,2,3]

@since base-4.8.0.0