{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE TypeOperators #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  GHC.Internal.Data.Foldable
-- Copyright   :  Ross Paterson 2005
-- License     :  BSD-style (see the LICENSE file in the distribution)
--
-- Maintainer  :  libraries@haskell.org
-- Stability   :  stable
-- Portability :  portable
--
-- Class of data structures that can be folded to a summary value.
--
-----------------------------------------------------------------------------

module GHC.Internal.Data.Foldable (
    Foldable(..),
    -- * Special biased folds
    foldrM,
    foldlM,
    -- * Folding actions
    -- ** Applicative actions
    traverse_,
    for_,
    sequenceA_,
    asum,
    -- ** Monadic actions
    mapM_,
    forM_,
    sequence_,
    msum,
    -- * Specialized folds
    concat,
    concatMap,
    and,
    or,
    any,
    all,
    maximumBy,
    minimumBy,
    -- * Searches
    notElem,
    find
    ) where

import GHC.Internal.Data.Bool
import GHC.Internal.Data.Either
import GHC.Internal.Data.Eq
import GHC.Internal.Data.Functor.Utils (Max(..), Min(..), (#.))
import qualified GHC.Internal.List as List
import GHC.Internal.Data.Maybe
import GHC.Internal.Data.Monoid
import GHC.Internal.Data.Ord
import GHC.Internal.Data.Proxy

import GHC.Internal.Arr  ( Array(..), elems, numElements,
                  foldlElems, foldrElems,
                  foldlElems', foldrElems',
                  foldl1Elems, foldr1Elems)
import GHC.Internal.Base hiding ( foldr )
import GHC.Internal.Generics
import GHC.Tuple (Solo (..))
import GHC.Internal.Num  ( Num(..) )

-- $setup
-- >>> :set -XDeriveFoldable
-- >>> import Prelude
-- >>> import GHC.Internal.Data.Monoid (Product (..), Sum (..))
-- >>> data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a) deriving (Show, Foldable)

infix  4 `elem`, `notElem`

-- XXX: Missing haddock feature.  Links to anchors in other modules
-- don't have a sensible way to name the link within the module itself.
-- Thus, the below "Data.Foldable#overview" works well when shown as
-- @Data.Foldable@ from other modules, but in the home module it should
-- be possible to specify alternative link text. :-(

-- | The Foldable class represents data structures that can be reduced to a
-- summary value one element at a time.  Strict left-associative folds are a
-- good fit for space-efficient reduction, while lazy right-associative folds
-- are a good fit for corecursive iteration, or for folds that short-circuit
-- after processing an initial subsequence of the structure's elements.
--
-- Instances can be derived automatically by enabling the @DeriveFoldable@
-- extension.  For example, a derived instance for a binary tree might be:
--
-- > {-# LANGUAGE DeriveFoldable #-}
-- > data Tree a = Empty
-- >             | Leaf a
-- >             | Node (Tree a) a (Tree a)
-- >     deriving Foldable
--
-- A more detailed description can be found in the __Overview__ section of
-- "Data.Foldable#overview".
--
-- For the class laws see the __Laws__ section of "Data.Foldable#laws".
--
class Foldable t where
    {-# MINIMAL foldMap | foldr #-}

    -- | Given a structure with elements whose type is a 'Monoid', combine them
    -- via the monoid's @('<>')@ operator.  This fold is right-associative and
    -- lazy in the accumulator.  When you need a strict left-associative fold,
    -- use 'foldMap'' instead, with 'id' as the map.
    --
    -- ==== __Examples__
    --
    -- Basic usage:
    --
    -- >>> fold [[1, 2, 3], [4, 5], [6], []]
    -- [1,2,3,4,5,6]
    --
    -- >>> fold $ Node (Leaf (Sum 1)) (Sum 3) (Leaf (Sum 5))
    -- Sum {getSum = 9}
    --
    -- Folds of unbounded structures do not terminate when the monoid's
    -- @('<>')@ operator is strict:
    --
    -- >>> fold (repeat Nothing)
    -- * Hangs forever *
    --
    -- Lazy corecursive folds of unbounded structures are fine:
    --
    -- >>> take 12 $ fold $ map (\i -> [i..i+2]) [0..]
    -- [0,1,2,1,2,3,2,3,4,3,4,5]
    -- >>> sum $ take 4000000 $ fold $ map (\i -> [i..i+2]) [0..]
    -- 2666668666666
    --
    fold :: Monoid m => t m -> m
    {-# INLINE fold #-}
    fold = (m -> m) -> t m -> m
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap m -> m
forall a. a -> a
id

    -- | Map each element of the structure into a monoid, and combine the
    -- results with @('<>')@.  This fold is right-associative and lazy in the
    -- accumulator.  For strict left-associative folds consider 'foldMap''
    -- instead.
    --
    -- ==== __Examples__
    --
    -- Basic usage:
    --
    -- >>> foldMap Sum [1, 3, 5]
    -- Sum {getSum = 9}
    --
    -- >>> foldMap Product [1, 3, 5]
    -- Product {getProduct = 15}
    --
    -- >>> foldMap (replicate 3) [1, 2, 3]
    -- [1,1,1,2,2,2,3,3,3]
    --
    -- When a Monoid's @('<>')@ is lazy in its second argument, 'foldMap' can
    -- return a result even from an unbounded structure.  For example, lazy
    -- accumulation enables "Data.ByteString.Builder" to efficiently serialise
    -- large data structures and produce the output incrementally:
    --
    -- >>> import qualified Data.ByteString.Lazy as L
    -- >>> import qualified Data.ByteString.Builder as B
    -- >>> let bld :: Int -> B.Builder; bld i = B.intDec i <> B.word8 0x20
    -- >>> let lbs = B.toLazyByteString $ foldMap bld [0..]
    -- >>> L.take 64 lbs
    -- "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24"
    --
    foldMap :: Monoid m => (a -> m) -> t a -> m
    {-# INLINE foldMap #-}
    -- This INLINE allows more list functions to fuse.  See #9848.
    foldMap a -> m
f = (a -> m -> m) -> m -> t a -> m
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (m -> m -> m
forall a. Monoid a => a -> a -> a
mappend (m -> m -> m) -> (a -> m) -> a -> m -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m
f) m
forall a. Monoid a => a
mempty

    -- | A left-associative variant of 'foldMap' that is strict in the
    -- accumulator.  Use this method for strict reduction when partial
    -- results are merged via @('<>')@.
    --
    -- ==== __Examples__
    --
    -- Define a 'Monoid' over finite bit strings under 'xor'.  Use it to
    -- strictly compute the `xor` of a list of 'Int' values.
    --
    -- >>> :set -XGeneralizedNewtypeDeriving
    -- >>> import Data.Bits (Bits, FiniteBits, xor, zeroBits)
    -- >>> import Data.Foldable (foldMap')
    -- >>> import Numeric (showHex)
    -- >>>
    -- >>> newtype X a = X a deriving (Eq, Bounded, Enum, Bits, FiniteBits)
    -- >>> instance Bits a => Semigroup (X a) where X a <> X b = X (a `xor` b)
    -- >>> instance Bits a => Monoid    (X a) where mempty     = X zeroBits
    -- >>>
    -- >>> let bits :: [Int]; bits = [0xcafe, 0xfeed, 0xdeaf, 0xbeef, 0x5411]
    -- >>> (\ (X a) -> showString "0x" . showHex a $ "") $ foldMap' X bits
    -- "0x42"
    --
    -- @since base-4.13.0.0
    foldMap' :: Monoid m => (a -> m) -> t a -> m
    foldMap' a -> m
f = (m -> a -> m) -> m -> t a -> m
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\ m
acc a
a -> m
acc m -> m -> m
forall a. Semigroup a => a -> a -> a
<> a -> m
f a
a) m
forall a. Monoid a => a
mempty

    -- | Right-associative fold of a structure, lazy in the accumulator.
    --
    -- In the case of lists, 'foldr', when 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)...)
    --
    -- Note that since the head of the resulting expression is produced by an
    -- application of the operator to the first element of the list, given an
    -- operator lazy in its right argument, 'foldr' can produce a terminating
    -- expression from an unbounded list.
    --
    -- For a general 'Foldable' structure this should be semantically identical
    -- to,
    --
    -- @foldr f z = 'List.foldr' f z . 'toList'@
    --
    -- ==== __Examples__
    --
    -- Basic usage:
    --
    -- >>> foldr (||) False [False, True, False]
    -- True
    --
    -- >>> foldr (||) False []
    -- False
    --
    -- >>> foldr (\c acc -> acc ++ [c]) "foo" ['a', 'b', 'c', 'd']
    -- "foodcba"
    --
    -- ===== Infinite structures
    --
    -- ⚠️ Applying 'foldr' to infinite structures usually doesn't terminate.
    --
    -- It may still terminate under one of the following conditions:
    --
    -- * the folding function is short-circuiting
    -- * the folding function is lazy on its second argument
    --
    -- ====== Short-circuiting
    --
    -- @('||')@ short-circuits on 'True' values, so the following terminates
    -- because there is a 'True' value finitely far from the left side:
    --
    -- >>> foldr (||) False (True : repeat False)
    -- True
    --
    -- But the following doesn't terminate:
    --
    -- >>> foldr (||) False (repeat False ++ [True])
    -- * Hangs forever *
    --
    -- ====== Laziness in the second argument
    --
    -- Applying 'foldr' to infinite structures terminates when the operator is
    -- lazy in its second argument (the initial accumulator is never used in
    -- this case, and so could be left 'undefined', but @[]@ is more clear):
    --
    -- >>> take 5 $ foldr (\i acc -> i : fmap (+3) acc) [] (repeat 1)
    -- [1,4,7,10,13]
    foldr :: (a -> b -> b) -> b -> t a -> b
    foldr a -> b -> b
f b
z t a
t = Endo b -> b -> b
forall a. Endo a -> a -> a
appEndo ((a -> Endo b) -> t a -> Endo b
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((b -> b) -> Endo b
forall a. (a -> a) -> Endo a
Endo ((b -> b) -> Endo b) -> (a -> b -> b) -> a -> Endo b
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. a -> b -> b
f) t a
t) b
z

    -- | 'foldr'' is a variant of 'foldr' that performs strict reduction from
    -- right to left, i.e. starting with the right-most element.  The input
    -- structure /must/ be finite, otherwise 'foldr'' runs out of space
    -- (/diverges/).
    --
    -- If you want a strict right fold in constant space, you need a structure
    -- that supports faster than /O(n)/ access to the right-most element, such
    -- as @Seq@ from the @containers@ package.
    --
    -- This method does not run in constant space for structures such as lists
    -- that don't support efficient right-to-left iteration and so require
    -- /O(n)/ space to perform right-to-left reduction.  Use of this method
    -- with such a structure is a hint that the chosen 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.
    --
    -- @since base-4.6.0.0
    foldr' :: (a -> b -> b) -> b -> t a -> b
    foldr' a -> b -> b
f b
z0 = \ t a
xs ->
        ((b -> b) -> a -> b -> b) -> (b -> b) -> t a -> b -> b
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\ (b -> b
k::b->b) (a
x::a) -> (b -> b) -> b -> b
forall a b. (a -> b) -> a -> b
oneShot (\ (b
z::b) -> b
z b -> b -> b
forall a b. a -> b -> b
`seq` b -> b
k (a -> b -> b
f a
x b
z)))
              (b -> b
forall a. a -> a
id::b->b) t a
xs b
z0
    -- Mirror image of 'foldl''.

    -- | Left-associative fold of a structure, lazy in the accumulator.  This
    -- is rarely what you want, but can work well for structures with efficient
    -- right-to-left sequencing and an operator that is lazy in its left
    -- argument.
    --
    -- In the case of lists, 'foldl', when 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
    --
    -- Note that to produce the outermost application of the operator the
    -- entire input list must be traversed.  Like all left-associative folds,
    -- 'foldl' will diverge if given an infinite list.
    --
    -- If you want an efficient strict left-fold, you probably want to use
    -- 'foldl'' instead of 'foldl'.  The reason for this is that the latter
    -- does not force the /inner/ results (e.g. @z \`f\` x1@ in the above
    -- example) before applying them to the operator (e.g. to @(\`f\` x2)@).
    -- This results in a thunk chain /O(n)/ elements long, which then must be
    -- evaluated from the outside-in.
    --
    -- For a general 'Foldable' structure this should be semantically identical
    -- to:
    --
    -- @foldl f z = 'List.foldl' f z . 'toList'@
    --
    -- ==== __Examples__
    --
    -- The first example is a strict fold, which in practice is best performed
    -- with 'foldl''.
    --
    -- >>> foldl (+) 42 [1,2,3,4]
    -- 52
    --
    -- Though the result below is lazy, the input is reversed before prepending
    -- it to the initial accumulator, so corecursion begins only after traversing
    -- the entire input string.
    --
    -- >>> foldl (\acc c -> c : acc) "abcd" "efgh"
    -- "hgfeabcd"
    --
    -- A left fold of a structure that is infinite on the right cannot
    -- terminate, even when for any finite input the fold just returns the
    -- initial accumulator:
    --
    -- >>> foldl (\a _ -> a) 0 $ repeat 1
    -- * Hangs forever *
    --
    -- WARNING: When it comes to lists, you always want to use either 'foldl'' or 'foldr' instead.
    foldl :: (b -> a -> b) -> b -> t a -> b
    foldl b -> a -> b
f b
z t a
t = Endo b -> b -> b
forall a. Endo a -> a -> a
appEndo (Dual (Endo b) -> Endo b
forall a. Dual a -> a
getDual ((a -> Dual (Endo b)) -> t a -> Dual (Endo b)
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Endo b -> Dual (Endo b)
forall a. a -> Dual a
Dual (Endo b -> Dual (Endo b)) -> (a -> Endo b) -> a -> Dual (Endo b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> b) -> Endo b
forall a. (a -> a) -> Endo a
Endo ((b -> b) -> Endo b) -> (a -> b -> b) -> a -> Endo b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> a -> b) -> a -> b -> b
forall a b c. (a -> b -> c) -> b -> a -> c
flip b -> a -> b
f) t a
t)) b
z
    -- There's no point mucking around with coercions here,
    -- because flip forces us to build a new function anyway.

    -- | Left-associative fold of a structure but with strict application of
    -- the operator.
    --
    -- This ensures that each step of the fold is forced to Weak Head Normal
    -- Form before being applied, avoiding the collection of thunks that would
    -- otherwise occur.  This is often what you want to strictly reduce a
    -- finite structure to a single strict result (e.g. 'sum').
    --
    -- For a general 'Foldable' structure this should be semantically identical
    -- to,
    --
    -- @foldl' f z = 'List.foldl'' f z . 'toList'@
    --
    -- @since base-4.6.0.0
    foldl' :: (b -> a -> b) -> b -> t a -> b
    {-# INLINE foldl' #-}
    foldl' b -> a -> b
f b
z0 = \ t a
xs ->
        (a -> (b -> b) -> b -> b) -> (b -> b) -> t a -> b -> b
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\ (a
x::a) (b -> b
k::b->b) -> (b -> b) -> b -> b
forall a b. (a -> b) -> a -> b
oneShot (\ (b
z::b) -> b
z b -> b -> b
forall a b. a -> b -> b
`seq` b -> b
k (b -> a -> b
f b
z a
x)))
              (b -> b
forall a. a -> a
id::b->b) t a
xs b
z0
    --
    -- We now force the accumulator `z` rather than the value computed by the
    -- operator `k`, this matches the documented strictness.
    --
    -- For the rationale for the arity reduction from 3 to 2, inlining, etc.
    -- see Note [Definition of foldl'] in GHC.List.

    -- | A variant of 'foldr' that has no base case,
    -- and thus may only be applied to non-empty structures.
    --
    -- This function is non-total and will raise a runtime exception if the
    -- structure happens to be empty.
    --
    -- ==== __Examples__
    --
    -- Basic usage:
    --
    -- >>> foldr1 (+) [1..4]
    -- 10
    --
    -- >>> foldr1 (+) []
    -- Exception: Prelude.foldr1: empty list
    --
    -- >>> foldr1 (+) Nothing
    -- *** Exception: foldr1: empty structure
    --
    -- >>> foldr1 (-) [1..4]
    -- -2
    --
    -- >>> foldr1 (&&) [True, False, True, True]
    -- False
    --
    -- >>> foldr1 (||) [False, False, True, True]
    -- True
    --
    -- >>> foldr1 (+) [1..]
    -- * Hangs forever *
    foldr1 :: (a -> a -> a) -> t a -> a
    foldr1 a -> a -> a
f t a
xs = a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"foldr1: empty structure")
                    ((a -> Maybe a -> Maybe a) -> Maybe a -> t a -> Maybe a
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> Maybe a -> Maybe a
mf Maybe a
forall a. Maybe a
Nothing t a
xs)
      where
        mf :: a -> Maybe a -> Maybe a
mf a
x Maybe a
m = a -> Maybe a
forall a. a -> Maybe a
Just (case Maybe a
m of
                         Maybe a
Nothing -> a
x
                         Just a
y  -> a -> a -> a
f a
x a
y)

    -- | A variant of 'foldl' that has no base case,
    -- and thus may only be applied to non-empty structures.
    --
    -- This function is non-total and will raise a runtime exception if the
    -- structure happens to be empty.
    --
    -- @'foldl1' f = 'List.foldl1' f . 'toList'@
    --
    -- ==== __Examples__
    --
    -- Basic usage:
    --
    -- >>> foldl1 (+) [1..4]
    -- 10
    --
    -- >>> foldl1 (+) []
    -- *** Exception: Prelude.foldl1: empty list
    --
    -- >>> foldl1 (+) Nothing
    -- *** Exception: foldl1: empty structure
    --
    -- >>> foldl1 (-) [1..4]
    -- -8
    --
    -- >>> foldl1 (&&) [True, False, True, True]
    -- False
    --
    -- >>> foldl1 (||) [False, False, True, True]
    -- True
    --
    -- >>> foldl1 (+) [1..]
    -- * Hangs forever *
    foldl1 :: (a -> a -> a) -> t a -> a
    foldl1 a -> a -> a
f t a
xs = a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"foldl1: empty structure")
                    ((Maybe a -> a -> Maybe a) -> Maybe a -> t a -> Maybe a
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl Maybe a -> a -> Maybe a
mf Maybe a
forall a. Maybe a
Nothing t a
xs)
      where
        mf :: Maybe a -> a -> Maybe a
mf Maybe a
m a
y = a -> Maybe a
forall a. a -> Maybe a
Just (case Maybe a
m of
                         Maybe a
Nothing -> a
y
                         Just a
x  -> a -> a -> a
f a
x a
y)

    -- | 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__
    --
    -- 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
    toList :: t a -> [a]
    {-# INLINE toList #-}
    toList t a
t = (forall b. (a -> b -> b) -> b -> b) -> [a]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (\ a -> b -> b
c b
n -> (a -> b -> b) -> b -> t a -> b
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> b -> b
c b
n t a
t)

    -- | Test whether the structure is empty.  The default implementation is
    -- Left-associative and lazy in both the initial element and the
    -- accumulator.  Thus optimised for structures where the first element can
    -- be accessed in constant time.  Structures where this is not the case
    -- should have a non-default implementation.
    --
    -- ==== __Examples__
    --
    -- Basic usage:
    --
    -- >>> null []
    -- True
    --
    -- >>> null [1]
    -- False
    --
    -- 'null' is expected to terminate even for infinite structures.
    -- The default implementation terminates provided the structure
    -- is bounded on the left (there is a leftmost element).
    --
    -- >>> null [1..]
    -- False
    --
    -- @since base-4.8.0.0
    null :: t a -> Bool
    null = (a -> Bool -> Bool) -> Bool -> t a -> Bool
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\a
_ Bool
_ -> Bool
False) Bool
True

    -- | Returns the size/length of a finite structure as an 'Int'.  The
    -- default implementation just counts elements starting with the leftmost.
    -- Instances for structures that can compute the element count faster
    -- than via element-by-element counting, should provide a specialised
    -- implementation.
    --
    -- ==== __Examples__
    --
    -- Basic usage:
    --
    -- >>> length []
    -- 0
    --
    -- >>> length ['a', 'b', 'c']
    -- 3
    -- >>> length [1..]
    -- * Hangs forever *
    --
    -- @since base-4.8.0.0
    length :: t a -> Int
    length = (Int -> a -> Int) -> Int -> t a -> Int
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\Int
c a
_ -> Int
cInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) Int
0

    -- | Does the element occur in the structure?
    --
    -- Note: 'elem' is often used in infix form.
    --
    -- ==== __Examples__
    --
    -- Basic usage:
    --
    -- >>> 3 `elem` []
    -- False
    --
    -- >>> 3 `elem` [1,2]
    -- False
    --
    -- >>> 3 `elem` [1,2,3,4,5]
    -- True
    --
    -- For infinite structures, the default implementation of 'elem'
    -- terminates if the sought-after value exists at a finite distance
    -- from the left side of the structure:
    --
    -- >>> 3 `elem` [1..]
    -- True
    --
    -- >>> 3 `elem` ([4..] ++ [3])
    -- * Hangs forever *
    --
    -- @since base-4.8.0.0
    elem :: Eq a => a -> t a -> Bool
    elem = (a -> Bool) -> t a -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ((a -> Bool) -> t a -> Bool)
-> (a -> a -> Bool) -> a -> t a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==)

    -- | The largest element of a non-empty structure.
    --
    -- This function is non-total and will raise a runtime exception if the
    -- structure happens to be empty.  A structure that supports random access
    -- and maintains its elements in order should provide a specialised
    -- implementation to return the maximum in faster than linear time.
    --
    -- ==== __Examples__
    --
    -- Basic usage:
    --
    -- >>> maximum [1..10]
    -- 10
    --
    -- >>> maximum []
    -- *** Exception: Prelude.maximum: empty list
    --
    -- >>> maximum Nothing
    -- *** Exception: maximum: empty structure
    --
    -- WARNING: This function is partial for possibly-empty structures like lists.
    --
    -- @since base-4.8.0.0
    maximum :: forall a . Ord a => t a -> a
    maximum = a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"maximum: empty structure") (Maybe a -> a) -> (t a -> Maybe a) -> t a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
       Max a -> Maybe a
forall a. Max a -> Maybe a
getMax (Max a -> Maybe a) -> (t a -> Max a) -> t a -> Maybe a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Max a) -> t a -> Max a
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap' (Maybe a -> Max a
forall a. Maybe a -> Max a
Max (Maybe a -> Max a) -> (a -> Maybe a) -> a -> Max a
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. (a -> Maybe a
forall a. a -> Maybe a
Just :: a -> Maybe a))
    {-# INLINEABLE maximum #-}

    -- | The least element of a non-empty structure.
    --
    -- This function is non-total and will raise a runtime exception if the
    -- structure happens to be empty.  A structure that supports random access
    -- and maintains its elements in order should provide a specialised
    -- implementation to return the minimum in faster than linear time.
    --
    -- ==== __Examples__
    --
    -- Basic usage:
    --
    -- >>> minimum [1..10]
    -- 1
    --
    -- >>> minimum []
    -- *** Exception: Prelude.minimum: empty list
    --
    -- >>> minimum Nothing
    -- *** Exception: minimum: empty structure
    --
    -- WARNING: This function is partial for possibly-empty structures like lists.
    --
    -- @since base-4.8.0.0
    minimum :: forall a . Ord a => t a -> a
    minimum = a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"minimum: empty structure") (Maybe a -> a) -> (t a -> Maybe a) -> t a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
       Min a -> Maybe a
forall a. Min a -> Maybe a
getMin (Min a -> Maybe a) -> (t a -> Min a) -> t a -> Maybe a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Min a) -> t a -> Min a
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap' (Maybe a -> Min a
forall a. Maybe a -> Min a
Min (Maybe a -> Min a) -> (a -> Maybe a) -> a -> Min a
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. (a -> Maybe a
forall a. a -> Maybe a
Just :: a -> Maybe a))
    {-# INLINEABLE minimum #-}

    -- | The 'sum' function computes the sum of the numbers of a structure.
    --
    -- ==== __Examples__
    --
    -- Basic usage:
    --
    -- >>> sum []
    -- 0
    --
    -- >>> sum [42]
    -- 42
    --
    -- >>> sum [1..10]
    -- 55
    --
    -- >>> sum [4.1, 2.0, 1.7]
    -- 7.8
    --
    -- >>> sum [1..]
    -- * Hangs forever *
    --
    -- @since base-4.8.0.0
    sum :: Num a => t a -> a
    sum = Sum a -> a
forall a. Sum a -> a
getSum (Sum a -> a) -> (t a -> Sum a) -> t a -> a
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. (a -> Sum a) -> t a -> Sum a
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap' a -> Sum a
forall a. a -> Sum a
Sum
    {-# INLINEABLE sum #-}

    -- | The 'product' function computes the product of the numbers of a
    -- structure.
    --
    -- ==== __Examples__
    --
    -- Basic usage:
    --
    -- >>> product []
    -- 1
    --
    -- >>> product [42]
    -- 42
    --
    -- >>> product [1..10]
    -- 3628800
    --
    -- >>> product [4.1, 2.0, 1.7]
    -- 13.939999999999998
    --
    -- >>> product [1..]
    -- * Hangs forever *
    --
    -- @since base-4.8.0.0
    product :: Num a => t a -> a
    product = Product a -> a
forall a. Product a -> a
getProduct (Product a -> a) -> (t a -> Product a) -> t a -> a
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. (a -> Product a) -> t a -> Product a
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap' a -> Product a
forall a. a -> Product a
Product
    {-# INLINEABLE product #-}

-- instances for Prelude types

-- | @since base-2.01
instance Foldable Maybe where
    foldMap :: forall m a. Monoid m => (a -> m) -> Maybe a -> m
foldMap = m -> (a -> m) -> Maybe a -> m
forall b a. b -> (a -> b) -> Maybe a -> b
maybe m
forall a. Monoid a => a
mempty

    foldr :: forall a b. (a -> b -> b) -> b -> Maybe a -> b
foldr a -> b -> b
_ b
z Maybe a
Nothing = b
z
    foldr a -> b -> b
f b
z (Just a
x) = a -> b -> b
f a
x b
z

    foldl :: forall b a. (b -> a -> b) -> b -> Maybe a -> b
foldl b -> a -> b
_ b
z Maybe a
Nothing = b
z
    foldl b -> a -> b
f b
z (Just a
x) = b -> a -> b
f b
z a
x

-- | @since base-2.01
instance Foldable [] where
    elem :: forall a. Eq a => a -> [a] -> Bool
elem    = a -> [a] -> Bool
forall a. Eq a => a -> [a] -> Bool
List.elem
    foldl :: forall b a. (b -> a -> b) -> b -> [a] -> b
foldl   = (b -> a -> b) -> b -> [a] -> b
forall a b. (b -> a -> b) -> b -> [a] -> b
List.foldl
    foldl' :: forall b a. (b -> a -> b) -> b -> [a] -> b
foldl'  = (b -> a -> b) -> b -> [a] -> b
forall a b. (b -> a -> b) -> b -> [a] -> b
List.foldl'
    foldl1 :: forall a. (a -> a -> a) -> [a] -> a
foldl1  = (a -> a -> a) -> [a] -> a
forall a. HasCallStack => (a -> a -> a) -> [a] -> a
List.foldl1
    foldr :: forall a b. (a -> b -> b) -> b -> [a] -> b
foldr   = (a -> b -> b) -> b -> [a] -> b
forall a b. (a -> b -> b) -> b -> [a] -> b
List.foldr
    foldr' :: forall a b. (a -> b -> b) -> b -> [a] -> b
foldr'  = (a -> b -> b) -> b -> [a] -> b
forall a b. (a -> b -> b) -> b -> [a] -> b
List.foldr'
    foldr1 :: forall a. (a -> a -> a) -> [a] -> a
foldr1  = (a -> a -> a) -> [a] -> a
forall a. HasCallStack => (a -> a -> a) -> [a] -> a
List.foldr1
    foldMap :: forall m a. Monoid m => (a -> m) -> [a] -> m
foldMap = ([m] -> m
forall m. Monoid m => [m] -> m
mconcat ([m] -> m) -> ([a] -> [m]) -> [a] -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) (([a] -> [m]) -> [a] -> m)
-> ((a -> m) -> [a] -> [m]) -> (a -> m) -> [a] -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> m) -> [a] -> [m]
forall a b. (a -> b) -> [a] -> [b]
map -- See Note [Monoidal list folds]
    fold :: forall m. Monoid m => [m] -> m
fold    = [m] -> m
forall m. Monoid m => [m] -> m
mconcat           -- See Note [Monoidal list folds]
    length :: forall a. [a] -> Int
length  = [a] -> Int
forall a. [a] -> Int
List.length
    maximum :: forall a. Ord a => [a] -> a
maximum = [a] -> a
forall a. (Ord a, HasCallStack) => [a] -> a
List.maximum
    minimum :: forall a. Ord a => [a] -> a
minimum = [a] -> a
forall a. (Ord a, HasCallStack) => [a] -> a
List.minimum
    null :: forall a. [a] -> Bool
null    = [a] -> Bool
forall a. [a] -> Bool
List.null
    product :: forall a. Num a => [a] -> a
product = [a] -> a
forall a. Num a => [a] -> a
List.product
    sum :: forall a. Num a => [a] -> a
sum     = [a] -> a
forall a. Num a => [a] -> a
List.sum
    toList :: forall a. [a] -> [a]
toList  = [a] -> [a]
forall a. a -> a
id

-- | @since base-4.9.0.0
instance Foldable NonEmpty where
  foldr :: forall a b. (a -> b -> b) -> b -> NonEmpty a -> b
foldr a -> b -> b
f b
z ~(a
a :| [a]
as) = a -> b -> b
f a
a ((a -> b -> b) -> b -> [a] -> b
forall a b. (a -> b -> b) -> b -> [a] -> b
List.foldr a -> b -> b
f b
z [a]
as)
  foldl :: forall b a. (b -> a -> b) -> b -> NonEmpty a -> b
foldl b -> a -> b
f b
z (a
a :| [a]
as) = (b -> a -> b) -> b -> [a] -> b
forall a b. (b -> a -> b) -> b -> [a] -> b
List.foldl b -> a -> b
f (b -> a -> b
f b
z a
a) [a]
as
  foldl1 :: forall a. (a -> a -> a) -> NonEmpty a -> a
foldl1 a -> a -> a
f (a
a :| [a]
as) = (a -> a -> a) -> a -> [a] -> a
forall a b. (b -> a -> b) -> b -> [a] -> b
List.foldl a -> a -> a
f a
a [a]
as

  -- GHC isn't clever enough to transform the default definition
  -- into anything like this, so we'd end up shuffling a bunch of
  -- Maybes around.
  foldr1 :: forall a. (a -> a -> a) -> NonEmpty a -> a
foldr1 a -> a -> a
f (a
p :| [a]
ps) = (a -> (a -> a) -> a -> a) -> (a -> a) -> [a] -> a -> a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> (a -> a) -> a -> a
forall {t}. t -> (t -> a) -> a -> a
go a -> a
forall a. a -> a
id [a]
ps a
p
    where
      go :: t -> (t -> a) -> a -> a
go t
x t -> a
r a
prev = a -> a -> a
f a
prev (t -> a
r t
x)

  -- We used to say
  --
  --   length (_ :| as) = 1 + length as
  --
  -- but the default definition is better, counting from 1.
  --
  -- The default definition also works great for null and foldl'.
  -- As usual for cons lists, foldr' is basically hopeless.

  foldMap :: forall m a. Monoid m => (a -> m) -> NonEmpty a -> m
foldMap a -> m
f ~(a
a :| [a]
as) = a -> m
f a
a m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (a -> m) -> [a] -> m
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> m
f [a]
as
  fold :: forall m. Monoid m => NonEmpty m -> m
fold ~(m
m :| [m]
ms) = m
m m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` [m] -> m
forall m. Monoid m => [m] -> m
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold [m]
ms
  toList :: forall a. NonEmpty a -> [a]
toList ~(a
a :| [a]
as) = a
a a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
as

-- | @since base-4.7.0.0
instance Foldable (Either a) where
    foldMap :: forall m a. Monoid m => (a -> m) -> Either a a -> m
foldMap a -> m
_ (Left a
_) = m
forall a. Monoid a => a
mempty
    foldMap a -> m
f (Right a
y) = a -> m
f a
y

    foldr :: forall a b. (a -> b -> b) -> b -> Either a a -> b
foldr a -> b -> b
_ b
z (Left a
_) = b
z
    foldr a -> b -> b
f b
z (Right a
y) = a -> b -> b
f a
y b
z

    length :: forall a. Either a a -> Int
length (Left a
_)  = Int
0
    length (Right a
_) = Int
1

    null :: forall a. Either a a -> Bool
null             = Either a a -> Bool
forall a a. Either a a -> Bool
isLeft

-- | @since base-4.15
deriving instance Foldable Solo

-- | @since base-4.7.0.0
instance Foldable ((,) a) where
    foldMap :: forall m a. Monoid m => (a -> m) -> (a, a) -> m
foldMap a -> m
f (a
_, a
y) = a -> m
f a
y

    foldr :: forall a b. (a -> b -> b) -> b -> (a, a) -> b
foldr a -> b -> b
f b
z (a
_, a
y) = a -> b -> b
f a
y b
z
    length :: forall a. (a, a) -> Int
length (a, a)
_  = Int
1
    null :: forall a. (a, a) -> Bool
null (a, a)
_ = Bool
False

-- | @since base-4.8.0.0
instance Foldable (Array i) where
    foldr :: forall a b. (a -> b -> b) -> b -> Array i a -> b
foldr = (a -> b -> b) -> b -> Array i a -> b
forall a b i. (a -> b -> b) -> b -> Array i a -> b
foldrElems
    foldl :: forall b a. (b -> a -> b) -> b -> Array i a -> b
foldl = (b -> a -> b) -> b -> Array i a -> b
forall b a i. (b -> a -> b) -> b -> Array i a -> b
foldlElems
    foldl' :: forall b a. (b -> a -> b) -> b -> Array i a -> b
foldl' = (b -> a -> b) -> b -> Array i a -> b
forall b a i. (b -> a -> b) -> b -> Array i a -> b
foldlElems'
    foldr' :: forall a b. (a -> b -> b) -> b -> Array i a -> b
foldr' = (a -> b -> b) -> b -> Array i a -> b
forall a b i. (a -> b -> b) -> b -> Array i a -> b
foldrElems'
    foldl1 :: forall a. (a -> a -> a) -> Array i a -> a
foldl1 = (a -> a -> a) -> Array i a -> a
forall a i. (a -> a -> a) -> Array i a -> a
foldl1Elems
    foldr1 :: forall a. (a -> a -> a) -> Array i a -> a
foldr1 = (a -> a -> a) -> Array i a -> a
forall a i. (a -> a -> a) -> Array i a -> a
foldr1Elems
    toList :: forall a. Array i a -> [a]
toList = Array i a -> [a]
forall i a. Array i a -> [a]
elems
    length :: forall a. Array i a -> Int
length = Array i a -> Int
forall i a. Array i a -> Int
numElements
    null :: forall a. Array i a -> Bool
null Array i a
a = Array i a -> Int
forall i a. Array i a -> Int
numElements Array i a
a Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0

-- | @since base-4.7.0.0
instance Foldable Proxy where
    foldMap :: forall m a. Monoid m => (a -> m) -> Proxy a -> m
foldMap a -> m
_ Proxy a
_ = m
forall a. Monoid a => a
mempty
    {-# INLINE foldMap #-}
    fold :: forall m. Monoid m => Proxy m -> m
fold Proxy m
_ = m
forall a. Monoid a => a
mempty
    {-# INLINE fold #-}
    foldr :: forall a b. (a -> b -> b) -> b -> Proxy a -> b
foldr a -> b -> b
_ b
z Proxy a
_ = b
z
    {-# INLINE foldr #-}
    foldl :: forall b a. (b -> a -> b) -> b -> Proxy a -> b
foldl b -> a -> b
_ b
z Proxy a
_ = b
z
    {-# INLINE foldl #-}
    foldl1 :: forall a. (a -> a -> a) -> Proxy a -> a
foldl1 a -> a -> a
_ Proxy a
_ = [Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"foldl1: Proxy"
    foldr1 :: forall a. (a -> a -> a) -> Proxy a -> a
foldr1 a -> a -> a
_ Proxy a
_ = [Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"foldr1: Proxy"
    length :: forall a. Proxy a -> Int
length Proxy a
_   = Int
0
    null :: forall a. Proxy a -> Bool
null Proxy a
_     = Bool
True
    elem :: forall a. Eq a => a -> Proxy a -> Bool
elem a
_ Proxy a
_   = Bool
False
    sum :: forall a. Num a => Proxy a -> a
sum Proxy a
_      = a
0
    product :: forall a. Num a => Proxy a -> a
product Proxy a
_  = a
1

-- | @since base-4.8.0.0
instance Foldable Dual where
    foldMap :: forall m a. Monoid m => (a -> m) -> Dual a -> m
foldMap            = (a -> m) -> Dual a -> m
forall a b. Coercible a b => a -> b
coerce

    elem :: forall a. Eq a => a -> Dual a -> Bool
elem               = ((a -> Bool) -> (Dual a -> a) -> Dual a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Dual a -> a
forall a. Dual a -> a
getDual) ((a -> Bool) -> Dual a -> Bool)
-> (a -> a -> Bool) -> a -> Dual a -> Bool
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==)
    foldl :: forall b a. (b -> a -> b) -> b -> Dual a -> b
foldl              = (b -> a -> b) -> b -> Dual a -> b
forall a b. Coercible a b => a -> b
coerce
    foldl' :: forall b a. (b -> a -> b) -> b -> Dual a -> b
foldl'             = (b -> a -> b) -> b -> Dual a -> b
forall a b. Coercible a b => a -> b
coerce
    foldl1 :: forall a. (a -> a -> a) -> Dual a -> a
foldl1 a -> a -> a
_           = Dual a -> a
forall a. Dual a -> a
getDual
    foldr :: forall a b. (a -> b -> b) -> b -> Dual a -> b
foldr a -> b -> b
f b
z (Dual a
x) = a -> b -> b
f a
x b
z
    foldr' :: forall a b. (a -> b -> b) -> b -> Dual a -> b
foldr'             = (a -> b -> b) -> b -> Dual a -> b
forall a b. (a -> b -> b) -> b -> Dual a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
    foldr1 :: forall a. (a -> a -> a) -> Dual a -> a
foldr1 a -> a -> a
_           = Dual a -> a
forall a. Dual a -> a
getDual
    length :: forall a. Dual a -> Int
length Dual a
_           = Int
1
    maximum :: forall a. Ord a => Dual a -> a
maximum            = Dual a -> a
forall a. Dual a -> a
getDual
    minimum :: forall a. Ord a => Dual a -> a
minimum            = Dual a -> a
forall a. Dual a -> a
getDual
    null :: forall a. Dual a -> Bool
null Dual a
_             = Bool
False
    product :: forall a. Num a => Dual a -> a
product            = Dual a -> a
forall a. Dual a -> a
getDual
    sum :: forall a. Num a => Dual a -> a
sum                = Dual a -> a
forall a. Dual a -> a
getDual
    toList :: forall a. Dual a -> [a]
toList (Dual a
x)    = [a
x]

-- | @since base-4.8.0.0
instance Foldable Sum where
    foldMap :: forall m a. Monoid m => (a -> m) -> Sum a -> m
foldMap            = (a -> m) -> Sum a -> m
forall a b. Coercible a b => a -> b
coerce

    elem :: forall a. Eq a => a -> Sum a -> Bool
elem               = ((a -> Bool) -> (Sum a -> a) -> Sum a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sum a -> a
forall a. Sum a -> a
getSum) ((a -> Bool) -> Sum a -> Bool)
-> (a -> a -> Bool) -> a -> Sum a -> Bool
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==)
    foldl :: forall b a. (b -> a -> b) -> b -> Sum a -> b
foldl              = (b -> a -> b) -> b -> Sum a -> b
forall a b. Coercible a b => a -> b
coerce
    foldl' :: forall b a. (b -> a -> b) -> b -> Sum a -> b
foldl'             = (b -> a -> b) -> b -> Sum a -> b
forall a b. Coercible a b => a -> b
coerce
    foldl1 :: forall a. (a -> a -> a) -> Sum a -> a
foldl1 a -> a -> a
_           = Sum a -> a
forall a. Sum a -> a
getSum
    foldr :: forall a b. (a -> b -> b) -> b -> Sum a -> b
foldr a -> b -> b
f b
z (Sum a
x)  = a -> b -> b
f a
x b
z
    foldr' :: forall a b. (a -> b -> b) -> b -> Sum a -> b
foldr'             = (a -> b -> b) -> b -> Sum a -> b
forall a b. (a -> b -> b) -> b -> Sum a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
    foldr1 :: forall a. (a -> a -> a) -> Sum a -> a
foldr1 a -> a -> a
_           = Sum a -> a
forall a. Sum a -> a
getSum
    length :: forall a. Sum a -> Int
length Sum a
_           = Int
1
    maximum :: forall a. Ord a => Sum a -> a
maximum            = Sum a -> a
forall a. Sum a -> a
getSum
    minimum :: forall a. Ord a => Sum a -> a
minimum            = Sum a -> a
forall a. Sum a -> a
getSum
    null :: forall a. Sum a -> Bool
null Sum a
_             = Bool
False
    product :: forall a. Num a => Sum a -> a
product            = Sum a -> a
forall a. Sum a -> a
getSum
    sum :: forall a. Num a => Sum a -> a
sum                = Sum a -> a
forall a. Sum a -> a
getSum
    toList :: forall a. Sum a -> [a]
toList (Sum a
x)     = [a
x]

-- | @since base-4.8.0.0
instance Foldable Product where
    foldMap :: forall m a. Monoid m => (a -> m) -> Product a -> m
foldMap               = (a -> m) -> Product a -> m
forall a b. Coercible a b => a -> b
coerce

    elem :: forall a. Eq a => a -> Product a -> Bool
elem                  = ((a -> Bool) -> (Product a -> a) -> Product a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Product a -> a
forall a. Product a -> a
getProduct) ((a -> Bool) -> Product a -> Bool)
-> (a -> a -> Bool) -> a -> Product a -> Bool
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==)
    foldl :: forall b a. (b -> a -> b) -> b -> Product a -> b
foldl                 = (b -> a -> b) -> b -> Product a -> b
forall a b. Coercible a b => a -> b
coerce
    foldl' :: forall b a. (b -> a -> b) -> b -> Product a -> b
foldl'                = (b -> a -> b) -> b -> Product a -> b
forall a b. Coercible a b => a -> b
coerce
    foldl1 :: forall a. (a -> a -> a) -> Product a -> a
foldl1 a -> a -> a
_              = Product a -> a
forall a. Product a -> a
getProduct
    foldr :: forall a b. (a -> b -> b) -> b -> Product a -> b
foldr a -> b -> b
f b
z (Product a
x) = a -> b -> b
f a
x b
z
    foldr' :: forall a b. (a -> b -> b) -> b -> Product a -> b
foldr'                = (a -> b -> b) -> b -> Product a -> b
forall a b. (a -> b -> b) -> b -> Product a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
    foldr1 :: forall a. (a -> a -> a) -> Product a -> a
foldr1 a -> a -> a
_              = Product a -> a
forall a. Product a -> a
getProduct
    length :: forall a. Product a -> Int
length Product a
_              = Int
1
    maximum :: forall a. Ord a => Product a -> a
maximum               = Product a -> a
forall a. Product a -> a
getProduct
    minimum :: forall a. Ord a => Product a -> a
minimum               = Product a -> a
forall a. Product a -> a
getProduct
    null :: forall a. Product a -> Bool
null Product a
_                = Bool
False
    product :: forall a. Num a => Product a -> a
product               = Product a -> a
forall a. Product a -> a
getProduct
    sum :: forall a. Num a => Product a -> a
sum                   = Product a -> a
forall a. Product a -> a
getProduct
    toList :: forall a. Product a -> [a]
toList (Product a
x)    = [a
x]

-- | @since base-4.8.0.0
instance Foldable First where
    foldMap :: forall m a. Monoid m => (a -> m) -> First a -> m
foldMap a -> m
f = (a -> m) -> Maybe a -> m
forall m a. Monoid m => (a -> m) -> Maybe a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> m
f (Maybe a -> m) -> (First a -> Maybe a) -> First a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. First a -> Maybe a
forall a. First a -> Maybe a
getFirst

-- | @since base-4.8.0.0
instance Foldable Last where
    foldMap :: forall m a. Monoid m => (a -> m) -> Last a -> m
foldMap a -> m
f = (a -> m) -> Maybe a -> m
forall m a. Monoid m => (a -> m) -> Maybe a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> m
f (Maybe a -> m) -> (Last a -> Maybe a) -> Last a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Last a -> Maybe a
forall a. Last a -> Maybe a
getLast

-- | @since base-4.12.0.0
instance (Foldable f) => Foldable (Alt f) where
    foldMap :: forall m a. Monoid m => (a -> m) -> Alt f a -> m
foldMap a -> m
f = (a -> m) -> f a -> m
forall m a. Monoid m => (a -> m) -> f a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> m
f (f a -> m) -> (Alt f a -> f a) -> Alt f a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Alt f a -> f a
forall {k} (f :: k -> *) (a :: k). Alt f a -> f a
getAlt

-- | @since base-4.12.0.0
instance (Foldable f) => Foldable (Ap f) where
    foldMap :: forall m a. Monoid m => (a -> m) -> Ap f a -> m
foldMap a -> m
f = (a -> m) -> f a -> m
forall m a. Monoid m => (a -> m) -> f a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> m
f (f a -> m) -> (Ap f a -> f a) -> Ap f a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ap f a -> f a
forall {k} (f :: k -> *) (a :: k). Ap f a -> f a
getAp

-- Instances for GHC.Generics
-- | @since base-4.9.0.0
instance Foldable U1 where
    foldMap :: forall m a. Monoid m => (a -> m) -> U1 a -> m
foldMap a -> m
_ U1 a
_ = m
forall a. Monoid a => a
mempty
    {-# INLINE foldMap #-}
    fold :: forall m. Monoid m => U1 m -> m
fold U1 m
_ = m
forall a. Monoid a => a
mempty
    {-# INLINE fold #-}
    foldr :: forall a b. (a -> b -> b) -> b -> U1 a -> b
foldr a -> b -> b
_ b
z U1 a
_ = b
z
    {-# INLINE foldr #-}
    foldl :: forall b a. (b -> a -> b) -> b -> U1 a -> b
foldl b -> a -> b
_ b
z U1 a
_ = b
z
    {-# INLINE foldl #-}
    foldl1 :: forall a. (a -> a -> a) -> U1 a -> a
foldl1 a -> a -> a
_ U1 a
_ = [Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"foldl1: U1"
    foldr1 :: forall a. (a -> a -> a) -> U1 a -> a
foldr1 a -> a -> a
_ U1 a
_ = [Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"foldr1: U1"
    length :: forall a. U1 a -> Int
length U1 a
_   = Int
0
    null :: forall a. U1 a -> Bool
null U1 a
_     = Bool
True
    elem :: forall a. Eq a => a -> U1 a -> Bool
elem a
_ U1 a
_   = Bool
False
    sum :: forall a. Num a => U1 a -> a
sum U1 a
_      = a
0
    product :: forall a. Num a => U1 a -> a
product U1 a
_  = a
1

-- | @since base-4.9.0.0
deriving instance Foldable V1

-- | @since base-4.9.0.0
deriving instance Foldable Par1

-- | @since base-4.9.0.0
deriving instance Foldable f => Foldable (Rec1 f)

-- | @since base-4.9.0.0
deriving instance Foldable (K1 i c)

-- | @since base-4.9.0.0
deriving instance Foldable f => Foldable (M1 i c f)

-- | @since base-4.9.0.0
deriving instance (Foldable f, Foldable g) => Foldable (f :+: g)

-- | @since base-4.9.0.0
deriving instance (Foldable f, Foldable g) => Foldable (f :*: g)

-- | @since base-4.9.0.0
deriving instance (Foldable f, Foldable g) => Foldable (f :.: g)

-- | @since base-4.9.0.0
deriving instance Foldable UAddr

-- | @since base-4.9.0.0
deriving instance Foldable UChar

-- | @since base-4.9.0.0
deriving instance Foldable UDouble

-- | @since base-4.9.0.0
deriving instance Foldable UFloat

-- | @since base-4.9.0.0
deriving instance Foldable UInt

-- | @since base-4.9.0.0
deriving instance Foldable UWord

-- Instances for Data.Ord
-- | @since base-4.12.0.0
deriving instance Foldable Down

-- | Right-to-left monadic fold over the elements of a structure.
--
-- Given a structure @t@ with elements @(a, b, c, ..., x, y)@, the result of
-- a fold with an operator function @f@ is equivalent to:
--
-- > foldrM f z t = do
-- >     yy <- f y z
-- >     xx <- f x yy
-- >     ...
-- >     bb <- f b cc
-- >     aa <- f a bb
-- >     return aa -- Just @return z@ when the structure is empty
--
-- For a Monad @m@, given two functions @f1 :: a -> m b@ and @f2 :: b -> m c@,
-- their Kleisli composition @(f1 >=> f2) :: a -> m c@ is defined by:
--
-- > (f1 >=> f2) a = f1 a >>= f2
--
-- Another way of thinking about @foldrM@ is that it amounts to an application
-- to @z@ of a Kleisli composition:
--
-- > foldrM f z t = f y >=> f x >=> ... >=> f b >=> f a $ z
--
-- The monadic effects of @foldrM@ are sequenced from right to left, and e.g.
-- folds of infinite lists will diverge.
--
-- If at some step the bind operator @('>>=')@ short-circuits (as with, e.g.,
-- 'mzero' in a 'MonadPlus'), the evaluated effects will be from a tail of the
-- element sequence.  If you want to evaluate the monadic effects in
-- left-to-right order, or perhaps be able to short-circuit after an initial
-- sequence of elements, you'll need to use `foldlM` instead.
--
-- If the monadic effects don't short-circuit, the outermost application of
-- @f@ is to the leftmost element @a@, so that, ignoring effects, the result
-- looks like a right fold:
--
-- > a `f` (b `f` (c `f` (... (x `f` (y `f` z))))).
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> let f i acc = do { print i ; return $ i : acc }
-- >>> foldrM f [] [0..3]
-- 3
-- 2
-- 1
-- 0
-- [0,1,2,3]
--
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
foldrM :: forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> b -> m b) -> b -> t a -> m b
foldrM a -> b -> m b
f b
z0 t a
xs = ((b -> m b) -> a -> b -> m b) -> (b -> m b) -> t a -> b -> m b
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (b -> m b) -> a -> b -> m b
forall {b}. (b -> m b) -> a -> b -> m b
c b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return t a
xs b
z0
  -- See Note [List fusion and continuations in 'c']
  where c :: (b -> m b) -> a -> b -> m b
c b -> m b
k a
x b
z = a -> b -> m b
f a
x b
z m b -> (b -> m b) -> m b
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= b -> m b
k
        {-# INLINE c #-}

-- | Left-to-right monadic fold over the elements of a structure.
--
-- Given a structure @t@ with elements @(a, b, ..., w, x, y)@, the result of
-- a fold with an operator function @f@ is equivalent to:
--
-- > foldlM f z t = do
-- >     aa <- f z a
-- >     bb <- f aa b
-- >     ...
-- >     xx <- f ww x
-- >     yy <- f xx y
-- >     return yy -- Just @return z@ when the structure is empty
--
-- For a Monad @m@, given two functions @f1 :: a -> m b@ and @f2 :: b -> m c@,
-- their Kleisli composition @(f1 >=> f2) :: a -> m c@ is defined by:
--
-- > (f1 >=> f2) a = f1 a >>= f2
--
-- Another way of thinking about @foldlM@ is that it amounts to an application
-- to @z@ of a Kleisli composition:
--
-- > foldlM f z t =
-- >     flip f a >=> flip f b >=> ... >=> flip f x >=> flip f y $ z
--
-- The monadic effects of @foldlM@ are sequenced from left to right.
--
-- If at some step the bind operator @('>>=')@ short-circuits (as with, e.g.,
-- 'mzero' in a 'MonadPlus'), the evaluated effects will be from an initial
-- segment of the element sequence.  If you want to evaluate the monadic
-- effects in right-to-left order, or perhaps be able to short-circuit after
-- processing a tail of the sequence of elements, you'll need to use `foldrM`
-- instead.
--
-- If the monadic effects don't short-circuit, the outermost application of
-- @f@ is to the rightmost element @y@, so that, ignoring effects, the result
-- looks like a left fold:
--
-- > ((((z `f` a) `f` b) ... `f` w) `f` x) `f` y
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> let f a e = do { print e ; return $ e : a }
-- >>> foldlM f [] [0..3]
-- 0
-- 1
-- 2
-- 3
-- [3,2,1,0]
--
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
foldlM :: forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldlM b -> a -> m b
f b
z0 t a
xs = (a -> (b -> m b) -> b -> m b) -> (b -> m b) -> t a -> b -> m b
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> (b -> m b) -> b -> m b
forall {b}. a -> (b -> m b) -> b -> m b
c b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return t a
xs b
z0
  -- See Note [List fusion and continuations in 'c']
  where c :: a -> (b -> m b) -> b -> m b
c a
x b -> m b
k b
z = b -> a -> m b
f b
z a
x m b -> (b -> m b) -> m b
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= b -> m b
k
        {-# INLINE c #-}

-- | Map each element of a structure to an 'Applicative' action, evaluate these
-- actions from left to right, and ignore the results.  For a version that
-- doesn't ignore the results see 'Data.Traversable.traverse'.
--
-- 'traverse_' is just like 'mapM_', but generalised to 'Applicative' actions.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> traverse_ print ["Hello", "world", "!"]
-- "Hello"
-- "world"
-- "!"
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
traverse_ :: forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ a -> f b
f = (a -> f () -> f ()) -> f () -> t a -> f ()
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> f () -> f ()
forall {b}. a -> f b -> f b
c (() -> f ()
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
  -- See Note [List fusion and continuations in 'c']
  where c :: a -> f b -> f b
c a
x f b
k = a -> f b
f a
x f b -> f b -> f b
forall a b. f a -> f b -> f b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> f b
k
        {-# INLINE c #-}

-- | 'for_' is 'traverse_' with its arguments flipped.  For a version
-- that doesn't ignore the results see 'Data.Traversable.for'.  This
-- is 'forM_' generalised to 'Applicative' actions.
--
-- 'for_' is just like 'forM_', but generalised to 'Applicative' actions.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> for_ [1..4] print
-- 1
-- 2
-- 3
-- 4
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
{-# INLINE for_ #-}
for_ :: forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ = ((a -> f b) -> t a -> f ()) -> t a -> (a -> f b) -> f ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip (a -> f b) -> t a -> f ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_

-- | Map each element of a structure to a monadic action, evaluate
-- these actions from left to right, and ignore the results.  For a
-- version that doesn't ignore the results see
-- 'Data.Traversable.mapM'.
--
-- 'mapM_' is just like 'traverse_', but specialised to monadic actions.
--
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
mapM_ :: forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ a -> m b
f = (a -> m () -> m ()) -> m () -> t a -> m ()
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> m () -> m ()
forall {b}. a -> m b -> m b
c (() -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
  -- See Note [List fusion and continuations in 'c']
  where c :: a -> m b -> m b
c a
x m b
k = a -> m b
f a
x m b -> m b -> m b
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m b
k
        {-# INLINE c #-}

-- | 'forM_' is 'mapM_' with its arguments flipped.  For a version that
-- doesn't ignore the results see 'Data.Traversable.forM'.
--
-- 'forM_' is just like 'for_', but specialised to monadic actions.
--
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
{-# INLINE forM_ #-}
forM_ :: forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ = ((a -> m b) -> t a -> m ()) -> t a -> (a -> m b) -> m ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip (a -> m b) -> t a -> m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_

-- | Evaluate each action in the structure from left to right, and
-- ignore the results.  For a version that doesn't ignore the results
-- see 'Data.Traversable.sequenceA'.
--
-- 'sequenceA_' is just like 'sequence_', but generalised to 'Applicative'
-- actions.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> sequenceA_ [print "Hello", print "world", print "!"]
-- "Hello"
-- "world"
-- "!"
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
sequenceA_ :: forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Applicative f) =>
t (f a) -> f ()
sequenceA_ = (f a -> f () -> f ()) -> f () -> t (f a) -> f ()
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr f a -> f () -> f ()
forall {f :: * -> *} {a} {b}. Applicative f => f a -> f b -> f b
c (() -> f ()
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
  -- See Note [List fusion and continuations in 'c']
  where c :: f a -> f b -> f b
c f a
m f b
k = f a
m f a -> f b -> f b
forall a b. f a -> f b -> f b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> f b
k
        {-# INLINE c #-}

-- | Evaluate each monadic action in the structure from left to right,
-- and ignore the results.  For a version that doesn't ignore the
-- results see 'Data.Traversable.sequence'.
--
-- 'sequence_' is just like 'sequenceA_', but specialised to monadic
-- actions.
--
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
sequence_ :: forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ = (m a -> m () -> m ()) -> m () -> t (m a) -> m ()
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr m a -> m () -> m ()
forall {m :: * -> *} {a} {b}. Monad m => m a -> m b -> m b
c (() -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
  -- See Note [List fusion and continuations in 'c']
  where c :: m a -> m b -> m b
c m a
m m b
k = m a
m m a -> m b -> m b
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m b
k
        {-# INLINE c #-}

-- | The sum of a collection of actions using '(<|>)', generalizing 'concat'.
--
-- 'asum' is just like 'msum', but generalised to 'Alternative'.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> asum [Just "Hello", Nothing, Just "World"]
-- Just "Hello"
asum :: (Foldable t, Alternative f) => t (f a) -> f a
{-# INLINE asum #-}
asum :: forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum = (f a -> f a -> f a) -> f a -> t (f a) -> f a
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr f a -> f a -> f a
forall a. f a -> f a -> f a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
(<|>) f a
forall a. f a
forall (f :: * -> *) a. Alternative f => f a
empty

-- | The sum of a collection of actions using '(<|>)', generalizing 'concat'.
--
-- 'msum' is just like 'asum', but specialised to 'MonadPlus'.
--
-- ==== __Examples__
--
-- Basic usage, using the 'MonadPlus' instance for 'Maybe':
--
-- >>> msum [Just "Hello", Nothing, Just "World"]
-- Just "Hello"
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
{-# INLINE msum #-}
msum :: forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum = t (m a) -> m a
forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum

-- | The concatenation of all the elements of a container of lists.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> concat (Just [1, 2, 3])
-- [1,2,3]
--
-- >>> concat (Left 42)
-- []
--
-- >>> concat [[1, 2, 3], [4, 5], [6], []]
-- [1,2,3,4,5,6]
concat :: Foldable t => t [a] -> [a]
concat :: forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat t [a]
xs = (forall b. (a -> b -> b) -> b -> b) -> [a]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (\a -> b -> b
c b
n -> ([a] -> b -> b) -> b -> t [a] -> b
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\[a]
x b
y -> (a -> b -> b) -> b -> [a] -> b
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> b -> b
c b
y [a]
x) b
n t [a]
xs)
{-# INLINE concat #-}

-- | Map a function over all the elements of a container and concatenate
-- the resulting lists.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> concatMap (take 3) [[1..], [10..], [100..], [1000..]]
-- [1,2,3,10,11,12,100,101,102,1000,1001,1002]
--
-- >>> concatMap (take 3) (Just [1..])
-- [1,2,3]
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
concatMap :: forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap a -> [b]
f t a
xs = (forall b. (b -> b -> b) -> b -> b) -> [b]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (\b -> b -> b
c b
n -> (a -> b -> b) -> b -> t a -> b
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\a
x b
b -> (b -> b -> b) -> b -> [b] -> b
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr b -> b -> b
c b
b (a -> [b]
f a
x)) b
n t a
xs)
{-# INLINE concatMap #-}

-- These use foldr rather than foldMap to avoid repeated concatenation.

-- | 'and' returns the conjunction of a container of Bools.  For the
-- result to be 'True', the container must be finite; 'False', however,
-- results from a 'False' value finitely far from the left end.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> and []
-- True
--
-- >>> and [True]
-- True
--
-- >>> and [False]
-- False
--
-- >>> and [True, True, False]
-- False
--
-- >>> and (False : repeat True) -- Infinite list [False,True,True,True,...
-- False
--
-- >>> and (repeat True)
-- * Hangs forever *
and :: Foldable t => t Bool -> Bool
and :: forall (t :: * -> *). Foldable t => t Bool -> Bool
and = All -> Bool
getAll (All -> Bool) -> (t Bool -> All) -> t Bool -> Bool
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. (Bool -> All) -> t Bool -> All
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Bool -> All
All

-- | 'or' returns the disjunction of a container of Bools.  For the
-- result to be 'False', the container must be finite; 'True', however,
-- results from a 'True' value finitely far from the left end.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> or []
-- False
--
-- >>> or [True]
-- True
--
-- >>> or [False]
-- False
--
-- >>> or [True, True, False]
-- True
--
-- >>> or (True : repeat False) -- Infinite list [True,False,False,False,...
-- True
--
-- >>> or (repeat False)
-- * Hangs forever *
or :: Foldable t => t Bool -> Bool
or :: forall (t :: * -> *). Foldable t => t Bool -> Bool
or = Any -> Bool
getAny (Any -> Bool) -> (t Bool -> Any) -> t Bool -> Bool
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. (Bool -> Any) -> t Bool -> Any
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Bool -> Any
Any

-- | Determines whether any element of the structure satisfies the predicate.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> 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 *
any :: Foldable t => (a -> Bool) -> t a -> Bool
any :: forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any a -> Bool
p = Any -> Bool
getAny (Any -> Bool) -> (t a -> Any) -> t a -> Bool
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. (a -> Any) -> t a -> Any
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Bool -> Any
Any (Bool -> Any) -> (a -> Bool) -> a -> Any
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. a -> Bool
p)

-- | Determines whether all elements of the structure satisfy the predicate.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> 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 *
all :: Foldable t => (a -> Bool) -> t a -> Bool
all :: forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all a -> Bool
p = All -> Bool
getAll (All -> Bool) -> (t a -> All) -> t a -> Bool
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. (a -> All) -> t a -> All
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Bool -> All
All (Bool -> All) -> (a -> Bool) -> a -> All
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. a -> Bool
p)

-- | The largest element of a non-empty structure with respect to the
-- given comparison function.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> maximumBy (compare `on` length) ["Hello", "World", "!", "Longest", "bar"]
-- "Longest"
--
-- WARNING: This function is partial for possibly-empty structures like lists.

-- See Note [maximumBy/minimumBy space usage]
maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
maximumBy :: forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
maximumBy a -> a -> Ordering
cmp = a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"maximumBy: empty structure")
  (Maybe a -> a) -> (t a -> Maybe a) -> t a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe a -> a -> Maybe a) -> Maybe a -> t a -> Maybe a
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' Maybe a -> a -> Maybe a
max' Maybe a
forall a. Maybe a
Nothing
  where
    max' :: Maybe a -> a -> Maybe a
max' Maybe a
mx a
y = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$! case Maybe a
mx of
      Maybe a
Nothing -> a
y
      Just a
x -> case a -> a -> Ordering
cmp a
x a
y of
        Ordering
GT -> a
x
        Ordering
_ -> a
y
-- #22609 showed that maximumBy is too large to reliably inline,
-- See Note [maximumBy/minimumBy INLINE pragma]
{-# INLINE[2] maximumBy #-}

-- | The least element of a non-empty structure with respect to the
-- given comparison function.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> minimumBy (compare `on` length) ["Hello", "World", "!", "Longest", "bar"]
-- "!"
--
-- WARNING: This function is partial for possibly-empty structures like lists.

-- See Note [maximumBy/minimumBy space usage]
-- See Note [maximumBy/minimumBy INLINE pragma]
minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
minimumBy :: forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
minimumBy a -> a -> Ordering
cmp = a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"minimumBy: empty structure")
  (Maybe a -> a) -> (t a -> Maybe a) -> t a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe a -> a -> Maybe a) -> Maybe a -> t a -> Maybe a
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' Maybe a -> a -> Maybe a
min' Maybe a
forall a. Maybe a
Nothing
  where
    min' :: Maybe a -> a -> Maybe a
min' Maybe a
mx a
y = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$! case Maybe a
mx of
      Maybe a
Nothing -> a
y
      Just a
x -> case a -> a -> Ordering
cmp a
x a
y of
        Ordering
GT -> a
y
        Ordering
_ -> a
x
-- See Note [maximumBy/minimumBy INLINE pragma]
{-# INLINE[2] minimumBy #-}


-- | 'notElem' is the negation of 'elem'.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> 3 `notElem` []
-- True
--
-- >>> 3 `notElem` [1,2]
-- True
--
-- >>> 3 `notElem` [1,2,3,4,5]
-- False
--
-- For infinite structures, 'notElem' terminates if the value exists at a
-- finite distance from the left side of the structure:
--
-- >>> 3 `notElem` [1..]
-- False
--
-- >>> 3 `notElem` ([4..] ++ [3])
-- * Hangs forever *
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
notElem :: forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
notElem a
x = Bool -> Bool
not (Bool -> Bool) -> (t a -> Bool) -> t a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> t a -> Bool
forall a. Eq a => a -> t a -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem a
x

-- | The 'find' function takes a predicate and a structure and returns
-- the leftmost element of the structure matching the predicate, or
-- 'Nothing' if there is no such element.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> find (> 42) [0, 5..]
-- Just 45
--
-- >>> find (> 12) [1..7]
-- Nothing
find :: Foldable t => (a -> Bool) -> t a -> Maybe a
find :: forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find a -> Bool
p = First a -> Maybe a
forall a. First a -> Maybe a
getFirst (First a -> Maybe a) -> (t a -> First a) -> t a -> Maybe a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> First a) -> t a -> First a
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (\ a
x -> Maybe a -> First a
forall a. Maybe a -> First a
First (if a -> Bool
p a
x then a -> Maybe a
forall a. a -> Maybe a
Just a
x else Maybe a
forall a. Maybe a
Nothing))

{-
Note [List fusion and continuations in 'c']
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Suppose we define
  mapM_ f = foldr ((>>) . f) (return ())
(this is the way it used to be).

Now suppose we want to optimise the call

  mapM_ <big> (build g)
    where
  g c n = ...(c x1 y1)...(c x2 y2)....n...

GHC used to proceed like this:

  mapM_ <big> (build g)

  = { Definition of mapM_ }
    foldr ((>>) . <big>) (return ()) (build g)

  = { foldr/build rule }
    g ((>>) . <big>) (return ())

  = { Inline g }
    let c = (>>) . <big>
        n = return ()
    in ...(c x1 y1)...(c x2 y2)....n...

The trouble is that `c`, being big, will not be inlined.  And that can
be absolutely terrible for performance, as we saw in #8763.

It's much better to define

  mapM_ f = foldr c (return ())
    where
      c x k = f x >> k
      {-# INLINE c #-}

Now we get
  mapM_ <big> (build g)

  = { inline mapM_ }
    foldr c (return ()) (build g)
      where c x k = f x >> k
            {-# INLINE c #-}
            f = <big>

Notice that `f` does not inline into the RHS of `c`,
because the INLINE pragma stops it; see
Note [Simplifying inside stable unfoldings] in GHC.Core.Opt.Simplify.Utils.
Continuing:

  = { foldr/build rule }
    g c (return ())
      where ...
         c x k = f x >> k
         {-# INLINE c #-}
            f = <big>

  = { inline g }
    ...(c x1 y1)...(c x2 y2)....n...
      where c x k = f x >> k
            {-# INLINE c #-}
            f = <big>
            n = return ()

      Now, crucially, `c` does inline

  = { inline c }
    ...(f x1 >> y1)...(f x2 >> y2)....n...
      where f = <big>
            n = return ()

And all is well!  The key thing is that the fragment
`(f x1 >> y1)` is inlined into the body of the builder
`g`.
-}

{-
Note [maximumBy/minimumBy space usage]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When the type signatures of maximumBy and minimumBy were generalized to work
over any Foldable instance (instead of just lists), they were defined using
foldr1.  This was problematic for space usage, as the semantics of maximumBy
and minimumBy essentially require that they examine every element of the
data structure.  Using foldr1 to examine every element results in space usage
proportional to the size of the data structure.  For the common case of lists,
this could be particularly bad (see #10830).

For the common case of lists, switching the implementations of maximumBy and
minimumBy to foldl1 solves the issue, assuming GHC's strictness analysis can then
make these functions only use O(1) stack space.  As of base 4.16, we have
switched to employing foldl' over foldl1, not relying on GHC's optimiser.  See
https://gitlab.haskell.org/ghc/ghc/-/issues/17867 for more context.

Note [maximumBy/minimumBy INLINE pragma]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Currently maximumBy/minimumBy wrap the accumulator into Maybe to deal with the
empty case. Commonly one would just pass in a bottom default value alas this is
not easily done here if we want to remain strict in the accumulator.
See #17867 for why we want to be strict in the accumulator here.

For optimal code we want the Maybe to optimize away and the accumulator to be
unpacked if possible. For this to happen we need:
* SpecConstr to eliminate the Maybe
* W/W to unpack the accumulator
This only happens if we compile the RHS with -O2 at a specific type.
There are two ways to achieve this: Using a SPECIALIZE pragma inside base for a
blessed set of types since we know base will be compiled using -O2.
Or using INLINE and counting at call sites to be compiled with -O2.


We've chosen to use INLINE as this guarantees optimal code at -O2 no matter what
element type is used. However this comes at the cost of less optimal code when
the call site is using -O as SpecConstr won't fire, preventing W/W from firing
as well. See #22609 and the discussion in !9565.
Sadly we can't use both SPECIALIZE and INLINE. This would result in the RHS being
inlined before the specialization rule fires. Giving the same result as if we had
only used INLINE.
-}

{-
Note [Monoidal list folds]
~~~~~~~~~~~~~~~~~~~~~~~~~~
Folds of lists of monoid elements should generally use 'mconcat', rather than
@foldr mappend mempty@.  This allows specialized mconcat implementations an
opportunity to combine elements efficiently.  For example, `mappend` of strict
`Text` and `ByteString` values typically needs to reallocate and copy the
existing data, making incremental construction expensive (likely quadratic in
the number of elements combined).  The `mconcat` implementations for `Text` and
`ByteString` preallocate the required storage, and then combine all the list
elements in a single pass.
-}