(original) (raw)

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

module GHC.Internal.Data.Foldable ( Foldable(..),

[foldrM](GHC.Internal.Data.Foldable.html#foldrM),
[foldlM](GHC.Internal.Data.Foldable.html#foldlM),


[traverse_](GHC.Internal.Data.Foldable.html#traverse%5F),
[for_](GHC.Internal.Data.Foldable.html#for%5F),
[sequenceA_](GHC.Internal.Data.Foldable.html#sequenceA%5F),
[asum](GHC.Internal.Data.Foldable.html#asum),

[mapM_](GHC.Internal.Data.Foldable.html#mapM%5F),
[forM_](GHC.Internal.Data.Foldable.html#forM%5F),
[sequence_](GHC.Internal.Data.Foldable.html#sequence%5F),
[msum](GHC.Internal.Data.Foldable.html#msum),

[concat](GHC.Internal.Data.Foldable.html#concat),
[concatMap](GHC.Internal.Data.Foldable.html#concatMap),
[and](GHC.Internal.Data.Foldable.html#and),
[or](GHC.Internal.Data.Foldable.html#or),
[any](GHC.Internal.Data.Foldable.html#any),
[all](GHC.Internal.Data.Foldable.html#all),
[maximumBy](GHC.Internal.Data.Foldable.html#maximumBy),
[minimumBy](GHC.Internal.Data.Foldable.html#minimumBy),

[notElem](GHC.Internal.Data.Foldable.html#notElem),
[find](GHC.Internal.Data.Foldable.html#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(..) )

infix 4 elem, notElem

class Foldable t where {-# MINIMAL foldMap | foldr #-}

[fold](GHC.Internal.Data.Foldable.html#fold) :: [Monoid](GHC.Internal.Base.html#Monoid) [m](#local-6989586621679644267) => [t](#local-6989586621679644268) [m](#local-6989586621679644267) -> [m](#local-6989586621679644267)
{-# INLINE [fold](GHC.Internal.Data.Foldable.html#fold) #-}
[fold](GHC.Internal.Data.Foldable.html#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

[foldMap](GHC.Internal.Data.Foldable.html#foldMap) :: [Monoid](GHC.Internal.Base.html#Monoid) [m](#local-6989586621679644270) => ([a](#local-6989586621679644271) -> [m](#local-6989586621679644270)) -> [t](#local-6989586621679644268) [a](#local-6989586621679644271) -> [m](#local-6989586621679644270)
{-# INLINE [foldMap](GHC.Internal.Data.Foldable.html#foldMap) #-}

[foldMap](GHC.Internal.Data.Foldable.html#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

[foldMap'](GHC.Internal.Data.Foldable.html#foldMap%27) :: [Monoid](GHC.Internal.Base.html#Monoid) [m](#local-6989586621679644975) => ([a](#local-6989586621679644976) -> [m](#local-6989586621679644975)) -> [t](#local-6989586621679644268) [a](#local-6989586621679644976) -> [m](#local-6989586621679644975)
[foldMap'](GHC.Internal.Data.Foldable.html#foldMap%27) 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

[foldr](GHC.Internal.Data.Foldable.html#foldr) :: ([a](#local-6989586621679644275) -> [b](#local-6989586621679644276) -> [b](#local-6989586621679644276)) -> [b](#local-6989586621679644276) -> [t](#local-6989586621679644268) [a](#local-6989586621679644275) -> [b](#local-6989586621679644276)
[foldr](GHC.Internal.Data.Foldable.html#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'](GHC.Internal.Data.Foldable.html#foldr%27) :: ([a](#local-6989586621679644999) -> [b](#local-6989586621679645000) -> [b](#local-6989586621679645000)) -> [b](#local-6989586621679645000) -> [t](#local-6989586621679644268) [a](#local-6989586621679644999) -> [b](#local-6989586621679645000)
[foldr'](GHC.Internal.Data.Foldable.html#foldr%27) 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

[foldl](GHC.Internal.Data.Foldable.html#foldl) :: ([b](#local-6989586621679644358) -> [a](#local-6989586621679644359) -> [b](#local-6989586621679644358)) -> [b](#local-6989586621679644358) -> [t](#local-6989586621679644268) [a](#local-6989586621679644359) -> [b](#local-6989586621679644358)
[foldl](GHC.Internal.Data.Foldable.html#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

[foldl'](GHC.Internal.Data.Foldable.html#foldl%27) :: ([b](#local-6989586621679644283) -> [a](#local-6989586621679644284) -> [b](#local-6989586621679644283)) -> [b](#local-6989586621679644283) -> [t](#local-6989586621679644268) [a](#local-6989586621679644284) -> [b](#local-6989586621679644283)
{-# INLINE [foldl'](GHC.Internal.Data.Foldable.html#foldl%27) #-}
[foldl'](GHC.Internal.Data.Foldable.html#foldl%27) 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

[foldr1](GHC.Internal.Data.Foldable.html#foldr1) :: ([a](#local-6989586621679644315) -> [a](#local-6989586621679644315) -> [a](#local-6989586621679644315)) -> [t](#local-6989586621679644268) [a](#local-6989586621679644315) -> [a](#local-6989586621679644315)
[foldr1](GHC.Internal.Data.Foldable.html#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)

[foldl1](GHC.Internal.Data.Foldable.html#foldl1) :: ([a](#local-6989586621679645047) -> [a](#local-6989586621679645047) -> [a](#local-6989586621679645047)) -> [t](#local-6989586621679644268) [a](#local-6989586621679645047) -> [a](#local-6989586621679645047)
[foldl1](GHC.Internal.Data.Foldable.html#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)

[toList](GHC.Internal.Data.Foldable.html#toList) :: [t](#local-6989586621679644268) [a](#local-6989586621679644321) -> [[a](#local-6989586621679644321)]
{-# INLINE [toList](GHC.Internal.Data.Foldable.html#toList) #-}
[toList](GHC.Internal.Data.Foldable.html#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)

[null](GHC.Internal.Data.Foldable.html#null) :: [t](#local-6989586621679644268) [a](#local-6989586621679644326) -> [Bool](/package/ghc-prim-0.11.0/docs/src/GHC.Types.html#Bool)
[null](GHC.Internal.Data.Foldable.html#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

[length](GHC.Internal.Data.Foldable.html#length) :: [t](#local-6989586621679644268) [a](#local-6989586621679644328) -> [Int](/package/ghc-prim-0.11.0/docs/src/GHC.Types.html#Int)
[length](GHC.Internal.Data.Foldable.html#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

   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 (==)

[maximum](GHC.Internal.Data.Foldable.html#maximum) :: forall [a](#local-6989586621679644336) . [Ord](/package/ghc-prim-0.11.0/docs/src/GHC.Classes.html#Ord) [a](#local-6989586621679644336) => [t](#local-6989586621679644268) [a](#local-6989586621679644336) -> [a](#local-6989586621679644336)
[maximum](GHC.Internal.Data.Foldable.html#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 #-}

[minimum](GHC.Internal.Data.Foldable.html#minimum) :: forall [a](#local-6989586621679645088) . [Ord](/package/ghc-prim-0.11.0/docs/src/GHC.Classes.html#Ord) [a](#local-6989586621679645088) => [t](#local-6989586621679644268) [a](#local-6989586621679645088) -> [a](#local-6989586621679645088)
[minimum](GHC.Internal.Data.Foldable.html#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 #-}

[sum](GHC.Internal.Data.Foldable.html#sum) :: [Num](GHC.Internal.Num.html#Num) [a](#local-6989586621679644347) => [t](#local-6989586621679644268) [a](#local-6989586621679644347) -> [a](#local-6989586621679644347)
[sum](GHC.Internal.Data.Foldable.html#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 #-}

[product](GHC.Internal.Data.Foldable.html#product) :: [Num](GHC.Internal.Num.html#Num) [a](#local-6989586621679645107) => [t](#local-6989586621679644268) [a](#local-6989586621679645107) -> [a](#local-6989586621679645107)
[product](GHC.Internal.Data.Foldable.html#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 #-}

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

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 fold :: forall m. Monoid m => [m] -> m fold = [m] -> m forall m. Monoid m => [m] -> m mconcat
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

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

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)

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

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

deriving instance Foldable Solo

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

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

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

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]

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]

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]

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

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

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

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

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

deriving instance Foldable V1

deriving instance Foldable Par1

deriving instance Foldable f => Foldable (Rec1 f)

deriving instance Foldable (K1 i c)

deriving instance Foldable f => Foldable (M1 i c f)

deriving instance (Foldable f, Foldable g) => Foldable (f :+: g)

deriving instance (Foldable f, Foldable g) => Foldable (f :*: g)

deriving instance (Foldable f, Foldable g) => Foldable (f :.: g)

deriving instance Foldable UAddr

deriving instance Foldable UChar

deriving instance Foldable UDouble

deriving instance Foldable UFloat

deriving instance Foldable UInt

deriving instance Foldable UWord

deriving instance Foldable Down

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

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

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

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

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 ())

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_ :: (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_

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 ())

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_ :: (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_

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 ())

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

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 ())

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

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

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

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

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

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

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)

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)

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

{-# INLINE[2] maximumBy #-}

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

{-# INLINE[2] minimumBy #-}

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

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