    module Data.Foldable.Extra
        ( module Data.Foldable
        , notNull
        , sum'
        , product'
        , sumOn'
        , productOn'
        , anyM
        , allM
        , orM
        , andM
        , findM
        , firstJustM
        ) where

    import Data.Foldable
    import qualified Control.Monad.Extra as MX

    -- | Composition of 'not' and 'null'
    notNull :: Foldable f => f a -> Bool
    notNull :: forall (f :: * -> *) a. Foldable f => f a -> Bool
    notNull = Bool -> Bool
    not (Bool -> Bool) -> (f a -> Bool) -> f a -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . f a -> Bool
    forall a. f a -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null

    -- | A generalization of 'Data.List.Extra.sum'' to 'Foldable' instances.
    sum' :: (Foldable f, Num a) => f a -> a
    sum' :: forall (f :: * -> *) a. (Foldable f, Num a) => f a -> a
    sum' = (a -> a -> a) -> a -> f a -> a
    forall b a. (b -> a -> b) -> b -> f a -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl' a -> a -> a
    forall a. Num a => a -> a -> a
    (+) a
    0

    -- | A generalization of 'Data.List.Extra.product'' to 'Foldable' instances.
    product' :: (Foldable f, Num a) => f a -> a
    product' :: forall (f :: * -> *) a. (Foldable f, Num a) => f a -> a
    product' = (a -> a -> a) -> a -> f a -> a
    forall b a. (b -> a -> b) -> b -> f a -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl' a -> a -> a
    forall a. Num a => a -> a -> a
    (*) a
    1

    -- | A generalization of 'Data.List.Extra.sumOn'' to 'Foldable' instances.
    sumOn' :: (Foldable f, Num b) => (a -> b) -> f a -> b
    sumOn' :: forall (f :: * -> *) b a.
    (Foldable f, Num b) =>
    (a -> b) -> f a -> b
    sumOn' a -> b
    f = (b -> a -> b) -> b -> f a -> b
    forall b a. (b -> a -> b) -> b -> f a -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl' (\b
    acc a
    x -> b
    acc b -> b -> b
    forall a. Num a => a -> a -> a
    + a -> b
    f a
    x) b
    0

    -- | A generalization of 'Data.List.Extra.productOn'' to 'Foldable' instances.
    productOn' :: (Foldable f, Num b) => (a -> b) -> f a -> b
    productOn' :: forall (f :: * -> *) b a.
    (Foldable f, Num b) =>
    (a -> b) -> f a -> b
    productOn' a -> b
    f = (b -> a -> b) -> b -> f a -> b
    forall b a. (b -> a -> b) -> b -> f a -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl' (\b
    acc a
    x -> b
    acc b -> b -> b
    forall a. Num a => a -> a -> a
    * a -> b
    f a
    x) b
    1

    -- | A generalization of 'Control.Monad.Extra.anyM' to 'Foldable' instances. Retains the short-circuiting behaviour.
    anyM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
    anyM :: forall (f :: * -> *) (m :: * -> *) a.
    (Foldable f, Monad m) =>
    (a -> m Bool) -> f a -> m Bool
    anyM a -> m Bool
    p = (a -> m Bool -> m Bool) -> m Bool -> f a -> m Bool
    forall a b. (a -> b -> b) -> b -> f a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (m Bool -> m Bool -> m Bool
    forall (m :: * -> *). Monad m => m Bool -> m Bool -> m Bool
    (MX.||^) (m Bool -> m Bool -> m Bool)
    -> (a -> m Bool) -> a -> m Bool -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> m Bool
    p) (Bool -> m Bool
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Bool
    False)

    -- | A generalization of 'Control.Monad.Extra.allM' to 'Foldable' instances. Retains the short-circuiting behaviour.
    allM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
    allM :: forall (f :: * -> *) (m :: * -> *) a.
    (Foldable f, Monad m) =>
    (a -> m Bool) -> f a -> m Bool
    allM a -> m Bool
    p = (a -> m Bool -> m Bool) -> m Bool -> f a -> m Bool
    forall a b. (a -> b -> b) -> b -> f a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (m Bool -> m Bool -> m Bool
    forall (m :: * -> *). Monad m => m Bool -> m Bool -> m Bool
    (MX.&&^) (m Bool -> m Bool -> m Bool)
    -> (a -> m Bool) -> a -> m Bool -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> m Bool
    p) (Bool -> m Bool
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Bool
    True)

    -- | A generalization of 'Control.Monad.Extra.orM' to 'Foldable' instances. Retains the short-circuiting behaviour.
    orM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
    orM :: forall (f :: * -> *) (m :: * -> *).
    (Foldable f, Monad m) =>
    f (m Bool) -> m Bool
    orM = (m Bool -> m Bool) -> f (m Bool) -> m Bool
    forall (f :: * -> *) (m :: * -> *) a.
    (Foldable f, Monad m) =>
    (a -> m Bool) -> f a -> m Bool
    anyM m Bool -> m Bool
    forall a. a -> a
    id

    -- | A generalization of 'Control.Monad.Extra.andM' to 'Foldable' instances. Retains the short-circuiting behaviour.
    andM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
    andM :: forall (f :: * -> *) (m :: * -> *).
    (Foldable f, Monad m) =>
    f (m Bool) -> m Bool
    andM = (m Bool -> m Bool) -> f (m Bool) -> m Bool
    forall (f :: * -> *) (m :: * -> *) a.
    (Foldable f, Monad m) =>
    (a -> m Bool) -> f a -> m Bool
    allM m Bool -> m Bool
    forall a. a -> a
    id

    -- | A generalization of 'Control.Monad.Extra.findM' to 'Foldable' instances.
    findM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m (Maybe a)
    findM :: forall (f :: * -> *) (m :: * -> *) a.
    (Foldable f, Monad m) =>
    (a -> m Bool) -> f a -> m (Maybe a)
    findM a -> m Bool
    p = (a -> m (Maybe a) -> m (Maybe a))
    -> m (Maybe a) -> f a -> m (Maybe a)
    forall a b. (a -> b -> b) -> b -> f a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (\a
    x -> m Bool -> m (Maybe a) -> m (Maybe a) -> m (Maybe a)
    forall (m :: * -> *) a. Monad m => m Bool -> m a -> m a -> m a
    MX.ifM (a -> m Bool
    p a
    x) (Maybe a -> m (Maybe a)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Maybe a -> m (Maybe a)) -> Maybe a -> m (Maybe a)
    forall a b. (a -> b) -> a -> b
    $ a -> Maybe a
    forall a. a -> Maybe a
    Just a
    x)) (Maybe a -> m (Maybe a)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe a
    forall a. Maybe a
    Nothing)

    -- | A generalization of 'Control.Monad.Extra.firstJustM' to 'Foldable' instances.
    firstJustM :: (Foldable f, Monad m) => (a -> m (Maybe b)) -> f a -> m (Maybe b)
    firstJustM :: forall (f :: * -> *) (m :: * -> *) a b.
    (Foldable f, Monad m) =>
    (a -> m (Maybe b)) -> f a -> m (Maybe b)
    firstJustM a -> m (Maybe b)
    p = (a -> m (Maybe b)) -> [a] -> m (Maybe b)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m (Maybe b)) -> [a] -> m (Maybe b)
    MX.firstJustM a -> m (Maybe b)
    p ([a] -> m (Maybe b)) -> (f a -> [a]) -> f a -> m (Maybe b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . f a -> [a]
    forall a. f a -> [a]
    forall (t :: * -> *) a. Foldable t => t a -> [a]
    toList