base-4.18.1.0: Basic libraries

Copyright | (c) The University of Glasgow 1994-2002
License | see libraries/base/LICENSE
Maintainer | cvs-ghc@haskell.org
Stability | internal
Portability | non-portable (GHC Extensions)
Safe Haskell | Trustworthy
Language | Haskell2010

GHC.List

Contents

- GHC List fusion

Description

The List data type and its operations

Synopsis

- data List a
- foldr :: (a -> b -> b) -> b -> [a] -> b
- foldr' :: (a -> b -> b) -> b -> [a] -> b
- foldr1 :: HasCallStack => (a -> a -> a) -> [a] -> a
- foldl :: forall a b. (b -> a -> b) -> b -> [a] -> b
- foldl' :: forall a b. (b -> a -> b) -> b -> [a] -> b
- foldl1 :: HasCallStack => (a -> a -> a) -> [a] -> a
- null :: [a] -> Bool
- length :: [a] -> Int
- elem :: Eq a => a -> [a] -> Bool
- notElem :: Eq a => a -> [a] -> Bool
- maximum :: (Ord a, HasCallStack) => [a] -> a
- minimum :: (Ord a, HasCallStack) => [a] -> a
- sum :: Num a => [a] -> a
- product :: Num a => [a] -> a
- and :: [Bool] -> Bool
- or :: [Bool] -> Bool
- any :: (a -> Bool) -> [a] -> Bool
- all :: (a -> Bool) -> [a] -> Bool
- foldl1' :: HasCallStack => (a -> a -> a) -> [a] -> a
- concat :: [[a]] -> [a]
- concatMap :: (a -> [b]) -> [a] -> [b]
- map :: (a -> b) -> [a] -> [b]
- (++) :: [a] -> [a] -> [a]
- filter :: (a -> Bool) -> [a] -> [a]
- lookup :: Eq a => a -> [(a, b)] -> Maybe b
- head :: HasCallStack => [a] -> a
- last :: HasCallStack => [a] -> a
- tail :: HasCallStack => [a] -> [a]
- init :: HasCallStack => [a] -> [a]
- uncons :: [a] -> Maybe (a, [a])
- (!!) :: HasCallStack => [a] -> Int -> a
- scanl :: (b -> a -> b) -> b -> [a] -> [b]
- scanl1 :: (a -> a -> a) -> [a] -> [a]
- scanl' :: (b -> a -> b) -> b -> [a] -> [b]
- scanr :: (a -> b -> b) -> b -> [a] -> [b]
- scanr1 :: (a -> a -> a) -> [a] -> [a]
- iterate :: (a -> a) -> a -> [a]
- iterate' :: (a -> a) -> a -> [a]
- repeat :: a -> [a]
- replicate :: Int -> a -> [a]
- cycle :: HasCallStack => [a] -> [a]
- take :: Int -> [a] -> [a]
- drop :: Int -> [a] -> [a]
- splitAt :: Int -> [a] -> ([a], [a])
- takeWhile :: (a -> Bool) -> [a] -> [a]
- dropWhile :: (a -> Bool) -> [a] -> [a]
- span :: (a -> Bool) -> [a] -> ([a], [a])
- break :: (a -> Bool) -> [a] -> ([a], [a])
- reverse :: [a] -> [a]
- zip :: [a] -> [b] -> [(a, b)]
- zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- unzip :: [(a, b)] -> ([a], [b])
- unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- errorEmptyList :: HasCallStack => String -> a
- augment :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a]
- build :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]

# Documentation

data List a Source #

The builtin list type, usually written in its non-prefix form `[a]`.

#### Examples

Expand

Unless the OverloadedLists extension is enabled, list literals are syntactic sugar for repeated applications of `:` and `[]`.

    >>> 1:2:3:4:[] == [1,2,3,4]
    True

Similarly, unless the OverloadedStrings extension is enabled, string literals are syntactic sugar for a lists of characters.

    >>> ['h','e','l','l','o'] == "hello"
    True

#### Instances

Instances details

MonadFail List Source # | Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> [a] Source #
MonadFix List Source # | Since: base-2.1
Instance details Defined in Control.Monad.Fix Methods mfix :: (a -> [a]) -> [a] Source #
MonadZip List Source # | Since: base-4.3.1.0
Instance details Defined in Control.Monad.Zip Methods mzip :: [a] -> [b] -> [(a, b)] Source # mzipWith :: (a -> b -> c) -> [a] -> [b] -> [c] Source # munzip :: [(a, b)] -> ([a], [b]) Source #
Foldable List Source # | Since: base-2.1

Instance details

Defined in Data.Foldable

Methods

fold :: Monoid m => [m] -> m Source #

foldMap :: Monoid m => (a -> m) -> [a] -> m Source #

foldMap' :: Monoid m => (a -> m) -> [a] -> m Source #

foldr :: (a -> b -> b) -> b -> [a] -> b Source #

foldr' :: (a -> b -> b) -> b -> [a] -> b Source #

foldl :: (b -> a -> b) -> b -> [a] -> b Source #

foldl' :: (b -> a -> b) -> b -> [a] -> b Source #

foldr1 :: (a -> a -> a) -> [a] -> a Source #

foldl1 :: (a -> a -> a) -> [a] -> a Source #

toList :: [a] -> [a] Source #

null :: [a] -> Bool Source #

length :: [a] -> Int Source #

elem :: Eq a => a -> [a] -> Bool Source #

maximum :: Ord a => [a] -> a Source #

minimum :: Ord a => [a] -> a Source #

sum :: Num a => [a] -> a Source #

product :: Num a => [a] -> a Source #

Eq1 List Source # | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> [a] -> [b] -> Bool Source #
Ord1 List Source # | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> [a] -> [b] -> Ordering Source #
Read1 List Source # | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS [a] Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [[a]] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [a] Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [[a]] Source #
Show1 List Source # | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> [a] -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [[a]] -> ShowS Source #
Traversable List Source # | Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> [a] -> f [b] Source # sequenceA :: Applicative f => [f a] -> f [a] Source # mapM :: Monad m => (a -> m b) -> [a] -> m [b] Source # sequence :: Monad m => [m a] -> m [a] Source #
Alternative List Source # | Combines lists by concatenation, starting from the empty list. Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: [a] Source # (<|>) :: [a] -> [a] -> [a] Source # some :: [a] -> [[a]] Source # many :: [a] -> [[a]] Source #
Applicative List Source # | Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> [a] Source # (<*>) :: [a -> b] -> [a] -> [b] Source # liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c] Source # (*>) :: [a] -> [b] -> [b] Source # (<*) :: [a] -> [b] -> [a] Source #
Functor List Source # | Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> [a] -> [b] Source # (<$) :: a -> [b] -> [a] Source #
Monad List Source # | Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: [a] -> (a -> [b]) -> [b] Source # (>>) :: [a] -> [b] -> [b] Source # return :: a -> [a] Source #
MonadPlus List Source # | Combines lists by concatenation, starting from the empty list. Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: [a] Source # mplus :: [a] -> [a] -> [a] Source #
Generic1 List Source # |
Instance details Defined in GHC.Generics Associated Types type Rep1 List :: k -> Type Source # Methods from1 :: forall (a :: k). [a] -> Rep1 List a Source # to1 :: forall (a :: k). Rep1 List a -> [a] Source #
Data a => Data [a] Source # | Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

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

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

toConstr :: [a] -> Constr Source #

dataTypeOf :: [a] -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> [a] -> [a] Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> [a] -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> [a] -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> [a] -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> [a] -> m [a] Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> [a] -> m [a] Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> [a] -> m [a] Source #

a ~ Char => IsString [a] Source # | `(a ~ Char)` context was introduced in `4.9.0.0` Since: base-2.1
Instance details Defined in Data.String Methods fromString :: String -> [a] Source #
Monoid [a] Source # | Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: [a] Source # mappend :: [a] -> [a] -> [a] Source # mconcat :: [[a]] -> [a] Source #
Semigroup [a] Source # | Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: [a] -> [a] -> [a] Source # sconcat :: NonEmpty [a] -> [a] Source # stimes :: Integral b => b -> [a] -> [a] Source #
Generic [a] Source # |
Instance details Defined in GHC.Generics Associated Types type Rep [a] :: Type -> Type Source # Methods from :: [a] -> Rep [a] x Source # to :: Rep [a] x -> [a] Source #
IsList [a] Source # | Since: base-4.7.0.0
Instance details Defined in GHC.IsList Associated Types type Item [a] Source # Methods fromList :: [Item [a]] -> [a] Source # fromListN :: Int -> [Item [a]] -> [a] Source # toList :: [a] -> [Item [a]] Source #
Read a => Read [a] Source # | Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS [a] Source # readList :: ReadS [[a]] Source # readPrec :: ReadPrec [a] Source # readListPrec :: ReadPrec [[a]] Source #
Show a => Show [a] Source # | Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> [a] -> ShowS Source # show :: [a] -> String Source # showList :: [[a]] -> ShowS Source #
IsChar c => PrintfArg [c] Source # | Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: [c] -> FieldFormatter Source # parseFormat :: [c] -> ModifierParser Source #
IsChar c => PrintfType [c] Source # | Since: base-2.1
Instance details Defined in Text.Printf Methods spr :: String -> [UPrintf] -> [c]
Eq a => Eq [a] |
Instance details Defined in GHC.Classes Methods (==) :: [a] -> [a] -> Bool Source # (/=) :: [a] -> [a] -> Bool Source #
Ord a => Ord [a] |
Instance details Defined in GHC.Classes Methods compare :: [a] -> [a] -> Ordering Source # (<) :: [a] -> [a] -> Bool Source # (<=) :: [a] -> [a] -> Bool Source # (>) :: [a] -> [a] -> Bool Source # (>=) :: [a] -> [a] -> Bool Source # max :: [a] -> [a] -> [a] Source # min :: [a] -> [a] -> [a] Source #
type Rep1 List Source # | Since: base-4.6.0.0

Instance details

Defined in GHC.Generics

type Rep1 List = D1 ('MetaData "List" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "[]" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons ":" ('InfixI 'RightAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 List)))

type Rep [a] Source # | Since: base-4.6.0.0

Instance details

Defined in GHC.Generics

type Rep [a] = D1 ('MetaData "List" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "[]" 'PrefixI 'False) (U1 :: Type -> Type) :+: 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 [a] Source # |
Instance details Defined in GHC.IsList type Item [a] = a

foldr :: (a -> b -> b) -> b -> [a] -> b Source #

`foldr`, applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left:

    foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

foldr' :: (a -> b -> b) -> b -> [a] -> b Source #

`foldr'` is a variant of `foldr` that begins list reduction from the last element and evaluates the accumulator strictly as it unwinds the stack back to the beginning of the list. The input list must be finite, otherwise `foldr'` runs out of space (diverges).

Note that if the function that combines the accumulated value with each element is strict in the accumulator, other than a possible improvement in the constant factor, you get the same \(\mathcal{O}(n)\) space cost as with just `foldr`.

If you want a strict right fold in constant space, you need a structure that supports faster than \(\mathcal{O}(n)\) access to the right-most element, such as `Seq` from the `containers` package.

Use of this function is a hint that the `[]` structure may be a poor fit for the task at hand. If the order in which the elements are combined is not important, use `foldl'` instead.

    >>> foldr' (+) [1..4]  -- Use foldl' instead!
    10
    >>> foldr' (&&) [True, False, True, True] -- Use foldr instead!
    False
    >>> foldr' (||) [False, False, True, True] -- Use foldr instead!
    True

foldr1 :: HasCallStack => (a -> a -> a) -> [a] -> a Source #

`foldr1` is a variant of `foldr` that has no starting value argument, and thus must be applied to non-empty lists. Note that unlike `foldr`, the accumulated value must be of the same type as the list elements.

    >>> foldr1 (+) [1..4]
    10
    >>> foldr1 (+) []
    *** Exception: Prelude.foldr1: empty list
    >>> foldr1 (-) [1..4]
    -2
    >>> foldr1 (&&) [True, False, True, True]
    False
    >>> foldr1 (||) [False, False, True, True]
    True
    >>> force $ foldr1 (+) [1..]
    *** Exception: stack overflow

foldl :: forall a b. (b -> a -> b) -> b -> [a] -> b Source #

`foldl`, applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:

    foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn

The list must be finite.

    >>> foldl (+) 0 [1..4]
    10
    >>> foldl (+) 42 []
    42
    >>> foldl (-) 100 [1..4]
    90
    >>> foldl (\reversedString nextChar -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']
    "dcbafoo"
    >>> foldl (+) 0 [1..]
    * Hangs forever *

foldl' :: forall a b. (b -> a -> b) -> b -> [a] -> b Source #

A strict version of `foldl`.

foldl1 :: HasCallStack => (a -> a -> a) -> [a] -> a Source #

`foldl1` is a variant of `foldl` that has no starting value argument, and thus must be applied to non-empty lists. Note that unlike `foldl`, the accumulated value must be of the same type as the list elements.

    >>> foldl1 (+) [1..4]
    10
    >>> foldl1 (+) []
    *** Exception: Prelude.foldl1: empty list
    >>> foldl1 (-) [1..4]
    -8
    >>> foldl1 (&&) [True, False, True, True]
    False
    >>> foldl1 (||) [False, False, True, True]
    True
    >>> foldl1 (+) [1..]
    * Hangs forever *

null :: [a] -> Bool Source #

\(\mathcal{O}(1)\). Test whether a list is empty.

    >>> null []
    True
    >>> null [1]
    False
    >>> null [1..]
    False

length :: [a] -> Int Source #

\(\mathcal{O}(n)\). `length` returns the length of a finite list as an `Int`. It is an instance of the more general `genericLength`, the result type of which may be any kind of number.

    >>> length []
    0
    >>> length ['a', 'b', 'c']
    3
    >>> length [1..]
    * Hangs forever *

elem :: Eq a => a -> [a] -> Bool infix 4 Source #

`elem` is the list membership predicate, usually written in infix form, e.g., `x `elem` xs`. For the result to be `False`, the list must be finite; `True`, however, results from an element equal to `x` found at a finite index of a finite or infinite list.

    >>> 3 `elem` []
    False
    >>> 3 `elem` [1,2]
    False
    >>> 3 `elem` [1,2,3,4,5]
    True
    >>> 3 `elem` [1..]
    True
    >>> 3 `elem` [4..]
    * Hangs forever *

notElem :: Eq a => a -> [a] -> Bool infix 4 Source #

`notElem` is the negation of `elem`.

    >>> 3 `notElem` []
    True
    >>> 3 `notElem` [1,2]
    True
    >>> 3 `notElem` [1,2,3,4,5]
    False
    >>> 3 `notElem` [1..]
    False
    >>> 3 `notElem` [4..]
    * Hangs forever *

maximum :: (Ord a, HasCallStack) => [a] -> a Source #

`maximum` returns the maximum value from a list, which must be non-empty, finite, and of an ordered type. It is a special case of `maximumBy`, which allows the programmer to supply their own comparison function.

    >>> maximum []
    *** Exception: Prelude.maximum: empty list
    >>> maximum [42]
    42
    >>> maximum [55, -12, 7, 0, -89]
    55
    >>> maximum [1..]
    * Hangs forever *

minimum :: (Ord a, HasCallStack) => [a] -> a Source #

`minimum` returns the minimum value from a list, which must be non-empty, finite, and of an ordered type. It is a special case of `minimumBy`, which allows the programmer to supply their own comparison function.

    >>> minimum []
    *** Exception: Prelude.minimum: empty list
    >>> minimum [42]
    42
    >>> minimum [55, -12, 7, 0, -89]
    -89
    >>> minimum [1..]
    * Hangs forever *

sum :: Num a => [a] -> a Source #

The `sum` function computes the sum of a finite list of numbers.

    >>> sum []
    0
    >>> sum [42]
    42
    >>> sum [1..10]
    55
    >>> sum [4.1, 2.0, 1.7]
    7.8
    >>> sum [1..]
    * Hangs forever *

product :: Num a => [a] -> a Source #

The `product` function computes the product of a finite list of numbers.

    >>> product []
    1
    >>> product [42]
    42
    >>> product [1..10]
    3628800
    >>> product [4.1, 2.0, 1.7]
    13.939999999999998
    >>> product [1..]
    * Hangs forever *

and :: [Bool] -> Bool Source #

`and` returns the conjunction of a Boolean list. For the result to be `True`, the list must be finite; `False`, however, results from a `False` value at a finite index of a finite or infinite list.

    >>> and []
    True
    >>> and [True]
    True
    >>> and [False]
    False
    >>> and [True, True, False]
    False
    >>> and (False : repeat True) -- Infinite list [False,True,True,True,True,True,True...
    False
    >>> and (repeat True)
    * Hangs forever *

or :: [Bool] -> Bool Source #

`or` returns the disjunction of a Boolean list. For the result to be `False`, the list must be finite; `True`, however, results from a `True` value at a finite index of a finite or infinite list.

    >>> or []
    False
    >>> or [True]
    True
    >>> or [False]
    False
    >>> or [True, True, False]
    True
    >>> or (True : repeat False) -- Infinite list [True,False,False,False,False,False,False...
    True
    >>> or (repeat False)
    * Hangs forever *

any :: (a -> Bool) -> [a] -> Bool Source #

Applied to a predicate and a list, `any` determines if any element of the list satisfies the predicate. For the result to be `False`, the list must be finite; `True`, however, results from a `True` value for the predicate applied to an element at a finite index of a finite or infinite list.

    >>> any (> 3) []
    False
    >>> any (> 3) [1,2]
    False
    >>> any (> 3) [1,2,3,4,5]
    True
    >>> any (> 3) [1..]
    True
    >>> any (> 3) [0, -1..]
    * Hangs forever *

all :: (a -> Bool) -> [a] -> Bool Source #

Applied to a predicate and a list, `all` determines if all elements of the list satisfy the predicate. For the result to be `True`, the list must be finite; `False`, however, results from a `False` value for the predicate applied to an element at a finite index of a finite or infinite list.

    >>> all (> 3) []
    True
    >>> all (> 3) [1,2]
    False
    >>> all (> 3) [1,2,3,4,5]
    False
    >>> all (> 3) [1..]
    False
    >>> all (> 3) [4..]
    * Hangs forever *

foldl1' :: HasCallStack => (a -> a -> a) -> [a] -> a Source #

A strict version of `foldl1`.

concat :: [[a]] -> [a] Source #

Concatenate a list of lists.

    >>> concat []
    []
    >>> concat [[42]]
    [42]
    >>> concat [[1,2,3], [4,5], [6], []]
    [1,2,3,4,5,6]

concatMap :: (a -> [b]) -> [a] -> [b] Source #

Map a function returning a list over a list and concatenate the results. `concatMap` can be seen as the composition of `concat` and `map`.

    concatMap f xs == (concat . map f) xs

    >>> concatMap (\i -> [-i,i]) []
    []
    >>> concatMap (\i -> [-i,i]) [1,2,3]
    [-1,1,-2,2,-3,3]

map :: (a -> b) -> [a] -> [b] Source #

\(\mathcal{O}(n)\). `map` `f xs` is the list obtained by applying `f` to each element of `xs`, i.e.,

    map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
    map f [x1, x2, ...] == [f x1, f x2, ...]

    >>> map (+1) [1, 2, 3]
    [2,3,4]

(++) :: [a] -> [a] -> [a] infixr 5 Source #

Append two lists, i.e.,

    [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
    [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]

If the first list is not finite, the result is the first list.

WARNING: This function takes linear time in the number of elements of the first list.

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

\(\mathcal{O}(n)\). `filter`, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,

    filter p xs = [ x | x <- xs, p x]

    >>> filter odd [1, 2, 3]
    [1,3]

lookup :: Eq a => a -> [(a, b)] -> Maybe b Source #

\(\mathcal{O}(n)\). `lookup` `key assocs` looks up a key in an association list. For the result to be `Nothing`, the list must be finite.

    >>> lookup 2 []
    Nothing
    >>> lookup 2 [(1, "first")]
    Nothing
    >>> lookup 2 [(1, "first"), (2, "second"), (3, "third")]
    Just "second"

head :: HasCallStack => [a] -> a Source #

\(\mathcal{O}(1)\). Extract the first element of a list, which must be non-empty.

    >>> head [1, 2, 3]
    1
    >>> head [1..]
    1
    >>> head []
    *** Exception: Prelude.head: empty list

WARNING: This function is partial. You can use case-matching, `uncons` or `listToMaybe` instead.

last :: HasCallStack => [a] -> a Source #

\(\mathcal{O}(n)\). Extract the last element of a list, which must be finite and non-empty.

    >>> last [1, 2, 3]
    3
    >>> last [1..]
    * Hangs forever *
    >>> last []
    *** Exception: Prelude.last: empty list

WARNING: This function is partial. You can use `reverse` with case-matching, `uncons` or `listToMaybe` instead.

tail :: HasCallStack => [a] -> [a] Source #

\(\mathcal{O}(1)\). Extract the elements after the head of a list, which must be non-empty.

    >>> tail [1, 2, 3]
    [2,3]
    >>> tail [1]
    []
    >>> tail []
    *** Exception: Prelude.tail: empty list

WARNING: This function is partial. You can use case-matching or `uncons` instead.

init :: HasCallStack => [a] -> [a] Source #

\(\mathcal{O}(n)\). Return all the elements of a list except the last one. The list must be non-empty.

    >>> init [1, 2, 3]
    [1,2]
    >>> init [1]
    []
    >>> init []
    *** Exception: Prelude.init: empty list

WARNING: This function is partial. You can use `reverse` with case-matching or `uncons` instead.

uncons :: [a] -> Maybe (a, [a]) Source #

\(\mathcal{O}(1)\). Decompose a list into its head and tail.

- If the list is empty, returns `Nothing`.
- If the list is non-empty, returns ``Just` (x, xs)`, where `x` is the head of the list and `xs` its tail.

    >>> uncons []
    Nothing
    >>> uncons [1]
    Just (1,[])
    >>> uncons [1, 2, 3]
    Just (1,[2,3])

Since: base-4.8.0.0

(!!) :: HasCallStack => [a] -> Int -> a infixl 9 Source #

List index (subscript) operator, starting from 0. It is an instance of the more general `genericIndex`, which takes an index of any integral type.

    >>> ['a', 'b', 'c'] !! 0
    'a'
    >>> ['a', 'b', 'c'] !! 2
    'c'
    >>> ['a', 'b', 'c'] !! 3
    *** Exception: Prelude.!!: index too large
    >>> ['a', 'b', 'c'] !! (-1)
    *** Exception: Prelude.!!: negative index

WARNING: This function is partial. You can use atMay instead.

scanl :: (b -> a -> b) -> b -> [a] -> [b] Source #

\(\mathcal{O}(n)\). `scanl` is similar to `foldl`, but returns a list 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

    >>> scanl (+) 0 [1..4]
    [0,1,3,6,10]
    >>> scanl (+) 42 []
    [42]
    >>> scanl (-) 100 [1..4]
    [100,99,97,94,90]
    >>> scanl (\reversedString nextChar -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']
    ["foo","afoo","bafoo","cbafoo","dcbafoo"]
    >>> scanl (+) 0 [1..]
    * Hangs forever *

scanl1 :: (a -> a -> a) -> [a] -> [a] Source #

\(\mathcal{O}(n)\). `scanl1` is a variant of `scanl` that has no starting value argument:

    scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]

    >>> scanl1 (+) [1..4]
    [1,3,6,10]
    >>> scanl1 (+) []
    []
    >>> scanl1 (-) [1..4]
    [1,-1,-4,-8]
    >>> scanl1 (&&) [True, False, True, True]
    [True,False,False,False]
    >>> scanl1 (||) [False, False, True, True]
    [False,False,True,True]
    >>> scanl1 (+) [1..]
    * Hangs forever *

scanl' :: (b -> a -> b) -> b -> [a] -> [b] Source #

\(\mathcal{O}(n)\). A strict version of `scanl`.

scanr :: (a -> b -> b) -> b -> [a] -> [b] Source #

\(\mathcal{O}(n)\). `scanr` is the right-to-left dual of `scanl`. Note that the order of parameters on the accumulating function are reversed compared to `scanl`. Also note that

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

    >>> scanr (+) 0 [1..4]
    [10,9,7,4,0]
    >>> scanr (+) 42 []
    [42]
    >>> scanr (-) 100 [1..4]
    [98,-97,99,-96,100]
    >>> scanr (\nextChar reversedString -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']
    ["abcdfoo","bcdfoo","cdfoo","dfoo","foo"]
    >>> force $ scanr (+) 0 [1..]
    *** Exception: stack overflow

scanr1 :: (a -> a -> a) -> [a] -> [a] Source #

\(\mathcal{O}(n)\). `scanr1` is a variant of `scanr` that has no starting value argument.

    >>> scanr1 (+) [1..4]
    [10,9,7,4]
    >>> scanr1 (+) []
    []
    >>> scanr1 (-) [1..4]
    [-2,3,-1,4]
    >>> scanr1 (&&) [True, False, True, True]
    [False,False,True,True]
    >>> scanr1 (||) [True, True, False, False]
    [True,True,False,False]
    >>> force $ scanr1 (+) [1..]
    *** Exception: stack overflow

iterate :: (a -> a) -> a -> [a] Source #

`iterate` `f x` returns an infinite list of repeated applications of `f` to `x`:

    iterate f x == [x, f x, f (f x), ...]

Note that `iterate` is lazy, potentially leading to thunk build-up if the consumer doesn't force each iterate. See `iterate'` for a strict variant of this function.

    >>> take 10 $ iterate not True
    [True,False,True,False...
    >>> take 10 $ iterate (+3) 42
    [42,45,48,51,54,57,60,63...

iterate' :: (a -> a) -> a -> [a] Source #

`iterate'` is the strict version of `iterate`.

It forces the result of each application of the function to weak head normal form (WHNF) before proceeding.

repeat :: a -> [a] Source #

`repeat` `x` is an infinite list, with `x` the value of every element.

    >>> repeat 17
    [17,17,17,17,17,17,17,17,17...

replicate :: Int -> a -> [a] Source #

`replicate` `n x` is a list of length `n` with `x` the value of every element. It is an instance of the more general `genericReplicate`, in which `n` may be of any integral type.

    >>> replicate 0 True
    []
    >>> replicate (-1) True
    []
    >>> replicate 4 True
    [True,True,True,True]

cycle :: HasCallStack => [a] -> [a] Source #

`cycle` ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.

    >>> cycle []
    *** Exception: Prelude.cycle: empty list
    >>> cycle [42]
    [42,42,42,42,42,42,42,42,42,42...
    >>> cycle [2, 5, 7]
    [2,5,7,2,5,7,2,5,7,2,5,7...

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

`take` `n`, applied to a list `xs`, returns the prefix of `xs` of length `n`, or `xs` itself if `n >= `length` xs`.

    >>> take 5 "Hello World!"
    "Hello"
    >>> take 3 [1,2,3,4,5]
    [1,2,3]
    >>> take 3 [1,2]
    [1,2]
    >>> take 3 []
    []
    >>> take (-1) [1,2]
    []
    >>> take 0 [1,2]
    []

It is an instance of the more general `genericTake`, in which `n` may be of any integral type.

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

`drop` `n xs` returns the suffix of `xs` after the first `n` elements, or `[]` if `n >= `length` xs`.

    >>> drop 6 "Hello World!"
    "World!"
    >>> drop 3 [1,2,3,4,5]
    [4,5]
    >>> drop 3 [1,2]
    []
    >>> drop 3 []
    []
    >>> drop (-1) [1,2]
    [1,2]
    >>> drop 0 [1,2]
    [1,2]

It is an instance of the more general `genericDrop`, in which `n` may be of any integral type.

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

`splitAt` `n xs` returns a tuple where first element is `xs` prefix of length `n` and second element is the remainder of the list:

    >>> splitAt 6 "Hello World!"
    ("Hello ","World!")
    >>> splitAt 3 [1,2,3,4,5]
    ([1,2,3],[4,5])
    >>> splitAt 1 [1,2,3]
    ([1],[2,3])
    >>> splitAt 3 [1,2,3]
    ([1,2,3],[])
    >>> splitAt 4 [1,2,3]
    ([1,2,3],[])
    >>> splitAt 0 [1,2,3]
    ([],[1,2,3])
    >>> splitAt (-1) [1,2,3]
    ([],[1,2,3])

It is equivalent to `(`take` n xs, `drop` n xs)` when `n` is not `_|_` (`splitAt _|_ xs = _|_`). `splitAt` is an instance of the more general `genericSplitAt`, in which `n` may be of any integral type.

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

`takeWhile`, applied to a predicate `p` and a list `xs`, returns the longest prefix (possibly empty) of `xs` of elements that satisfy `p`.

    >>> takeWhile (< 3) [1,2,3,4,1,2,3,4]
    [1,2]
    >>> takeWhile (< 9) [1,2,3]
    [1,2,3]
    >>> takeWhile (< 0) [1,2,3]
    []

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

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

    >>> dropWhile (< 3) [1,2,3,4,5,1,2,3]
    [3,4,5,1,2,3]
    >>> dropWhile (< 9) [1,2,3]
    []
    >>> dropWhile (< 0) [1,2,3]
    [1,2,3]

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

`span`, applied to a predicate `p` and a list `xs`, returns a tuple where first element is longest prefix (possibly empty) of `xs` of elements that satisfy `p` and second element is the remainder of the list:

    >>> span (< 3) [1,2,3,4,1,2,3,4]
    ([1,2],[3,4,1,2,3,4])
    >>> span (< 9) [1,2,3]
    ([1,2,3],[])
    >>> span (< 0) [1,2,3]
    ([],[1,2,3])

`span` `p xs` is equivalent to `(`takeWhile` p xs, `dropWhile` p xs)`

break :: (a -> Bool) -> [a] -> ([a], [a]) Source #

`break`, applied to a predicate `p` and a list `xs`, returns a tuple where first element is longest prefix (possibly empty) of `xs` of elements that do not satisfy `p` and second element is the remainder of the list:

    >>> break (> 3) [1,2,3,4,1,2,3,4]
    ([1,2,3],[4,1,2,3,4])
    >>> break (< 9) [1,2,3]
    ([],[1,2,3])
    >>> break (> 9) [1,2,3]
    ([1,2,3],[])

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

reverse :: [a] -> [a] Source #

`reverse` `xs` returns the elements of `xs` in reverse order. `xs` must be finite.

    >>> reverse []
    []
    >>> reverse [42]
    [42]
    >>> reverse [2,5,7]
    [7,5,2]
    >>> reverse [1..]
    * Hangs forever *

zip :: [a] -> [b] -> [(a, b)] Source #

\(\mathcal{O}(\min(m,n))\). `zip` takes two lists and returns a list of corresponding pairs.

    >>> zip [1, 2] ['a', 'b']
    [(1,'a'),(2,'b')]

If one input list is shorter than the other, excess elements of the longer list are discarded, even if one of the lists is infinite:

    >>> zip [1] ['a', 'b']
    [(1,'a')]
    >>> zip [1, 2] ['a']
    [(1,'a')]
    >>> zip [] [1..]
    []
    >>> zip [1..] []
    []

`zip` is right-lazy:

    >>> zip [] undefined
    []
    >>> zip undefined []
    *** Exception: Prelude.undefined
    ...

`zip` is capable of list fusion, but it is restricted to its first list argument and its resulting list.

zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] Source #

`zip3` takes three lists and returns a list of triples, analogous to `zip`. It is capable of list fusion, but it is restricted to its first list argument and its resulting list.

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] Source #

\(\mathcal{O}(\min(m,n))\). `zipWith` generalises `zip` by zipping with the function given as the first argument, instead of a tupling function.

    zipWith (,) xs ys == zip xs ys
    zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]

For example, ``zipWith` (+)` is applied to two lists to produce the list of corresponding sums:

    >>> zipWith (+) [1, 2, 3] [4, 5, 6]
    [5,7,9]

`zipWith` is right-lazy:

    >>> let f = undefined
    >>> zipWith f [] undefined
    []

`zipWith` is capable of list fusion, but it is restricted to its first list argument and its resulting list.

zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] Source #

The `zipWith3` function takes a function which combines three elements, as well as three lists and returns a list of the function applied to corresponding elements, analogous to `zipWith`. It is capable of list fusion, but it is restricted to its first list argument and its resulting list.

    zipWith3 (,,) xs ys zs == zip3 xs ys zs
    zipWith3 f [x1,x2,x3..] [y1,y2,y3..] [z1,z2,z3..] == [f x1 y1 z1, f x2 y2 z2, f x3 y3 z3..]

unzip :: [(a, b)] -> ([a], [b]) Source #

`unzip` transforms a list of pairs into a list of first components and a list of second components.

    >>> unzip []
    ([],[])
    >>> unzip [(1, 'a'), (2, 'b')]
    ([1,2],"ab")

unzip3 :: [(a, b, c)] -> ([a], [b], [c]) Source #

The `unzip3` function takes a list of triples and returns three lists, analogous to `unzip`.

    >>> unzip3 []
    ([],[],[])
    >>> unzip3 [(1, 'a', True), (2, 'b', False)]
    ([1,2],"ab",[True,False])

errorEmptyList :: HasCallStack => String -> a Source #

# GHC List fusion

augment :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a] Source #

A list producer that can be fused with `foldr`. This function is merely

       augment g xs = g (:) xs

but GHC's simplifier will transform an expression of the form ``foldr` k z (`augment` g xs)`, which may arise after inlining, to `g k (`foldr` k z xs)`, which avoids producing an intermediate list.

build :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a] Source #

A list producer that can be fused with `foldr`. This function is merely

       build g = g (:) []

but GHC's simplifier will transform an expression of the form ``foldr` k z (`build` g)`, which may arise after inlining, to `g k z`, which avoids producing an intermediate list.