    {-# LANGUAGE CPP #-}
    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE Safe #-}
    -----------------------------------------------------------------------------
    -- |
    -- Copyright   :  (C) 2011-2015 Edward Kmett
    -- License     :  BSD-style (see the file LICENSE)
    --
    -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
    -- Stability   :  provisional
    -- Portability :  portable
    --
    -- Re-exports a subset of the "Data.Foldable1" module along with some additional
    -- combinators that require 'Foldable1' constraints.
    --
    ----------------------------------------------------------------------------
    module Data.Semigroup.Foldable
      ( -- @Data.Foldable1@ re-exports
        Foldable1(fold1, foldMap1, toNonEmpty)
      , intercalate1
      , foldrM1
      , foldlM1

        -- Additional @Foldable1@ functionality
      , intercalateMap1
      , traverse1_
      , for1_
      , sequenceA1_
      , foldMapDefault1
      , asum1

        -- Generic defaults
      , gfold1
      , gfoldMap1
      , gtoNonEmpty
      ) where

    import Data.Foldable
    import Data.Foldable1
    import Data.Functor.Alt (Alt(..))
    import Data.Functor.Apply
    import Data.List.NonEmpty (NonEmpty(..))
    import Data.Traversable.Instances ()
    import Data.Semigroup hiding (Product, Sum)
    import GHC.Generics
    import Prelude hiding (foldr)

    -- $setup
    -- >>> import Data.List.NonEmpty (NonEmpty (..))
    -- >>> import Data.Monoid (Monoid (..))

    newtype JoinWith a = JoinWith {forall a. JoinWith a -> a -> a
    joinee :: (a -> a)}

    instance Semigroup a => Semigroup (JoinWith a) where
      JoinWith a -> a
    a <> :: JoinWith a -> JoinWith a -> JoinWith a
    <> JoinWith a -> a
    b = (a -> a) -> JoinWith a
    forall a. (a -> a) -> JoinWith a
    JoinWith ((a -> a) -> JoinWith a) -> (a -> a) -> JoinWith a
    forall a b. (a -> b) -> a -> b
    $ \a
    j -> a -> a
    a a
    j a -> a -> a
    forall a. Semigroup a => a -> a -> a
    <> a
    j a -> a -> a
    forall a. Semigroup a => a -> a -> a
    <> a -> a
    b a
    j

    -- | Insert @m@ between each pair of @m@ derived from @a@.
    --
    -- >>> intercalateMap1 " " show $ True :| [False, True]
    -- "True False True"
    --
    -- >>> intercalateMap1 " " show $ True :| []
    -- "True"
    intercalateMap1 :: (Foldable1 t, Semigroup m) => m -> (a -> m) -> t a -> m
    intercalateMap1 :: forall (t :: * -> *) m a.
    (Foldable1 t, Semigroup m) =>
    m -> (a -> m) -> t a -> m
    intercalateMap1 m
    j a -> m
    f = (JoinWith m -> m -> m) -> m -> JoinWith m -> m
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip JoinWith m -> m -> m
    forall a. JoinWith a -> a -> a
    joinee m
    j (JoinWith m -> m) -> (t a -> JoinWith m) -> t a -> m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> JoinWith m) -> t a -> JoinWith m
    forall m a. Semigroup m => (a -> m) -> t a -> m
    forall (t :: * -> *) m a.
    (Foldable1 t, Semigroup m) =>
    (a -> m) -> t a -> m
    foldMap1 ((m -> m) -> JoinWith m
    forall a. (a -> a) -> JoinWith a
    JoinWith ((m -> m) -> JoinWith m) -> (a -> m -> m) -> a -> JoinWith m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . m -> m -> m
    forall a b. a -> b -> a
    const (m -> m -> m) -> (a -> m) -> a -> m -> m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> m
    f)
    {-# INLINE intercalateMap1 #-}

    newtype Act f a = Act { forall (f :: * -> *) a. Act f a -> f a
    getAct :: f a }

    instance Apply f => Semigroup (Act f a) where
      Act f a
    a <> :: Act f a -> Act f a -> Act f a
    <> Act f a
    b = f a -> Act f a
    forall (f :: * -> *) a. f a -> Act f a
    Act (f a
    a f a -> f a -> f a
    forall a b. f a -> f b -> f b
    forall (f :: * -> *) a b. Apply f => f a -> f b -> f b
    .> f a
    b)

    instance Functor f => Functor (Act f) where
      fmap :: forall a b. (a -> b) -> Act f a -> Act f b
    fmap a -> b
    f (Act f a
    a) = f b -> Act f b
    forall (f :: * -> *) a. f a -> Act f a
    Act (a -> b
    f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f a
    a)
      a
    b <$ :: forall a b. a -> Act f b -> Act f a
    <$ Act f b
    a = f a -> Act f a
    forall (f :: * -> *) a. f a -> Act f a
    Act (a
    b a -> f b -> f a
    forall a b. a -> f b -> f a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ f b
    a)

    traverse1_ :: (Foldable1 t, Apply f) => (a -> f b) -> t a -> f ()
    traverse1_ :: forall (t :: * -> *) (f :: * -> *) a b.
    (Foldable1 t, Apply f) =>
    (a -> f b) -> t a -> f ()
    traverse1_ a -> f b
    f t a
    t = () () -> f b -> f ()
    forall a b. a -> f b -> f a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Act f b -> f b
    forall (f :: * -> *) a. Act f a -> f a
    getAct ((a -> Act f b) -> t a -> Act f b
    forall m a. Semigroup m => (a -> m) -> t a -> m
    forall (t :: * -> *) m a.
    (Foldable1 t, Semigroup m) =>
    (a -> m) -> t a -> m
    foldMap1 (f b -> Act f b
    forall (f :: * -> *) a. f a -> Act f a
    Act (f b -> Act f b) -> (a -> f b) -> a -> Act f b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> f b
    f) t a
    t)
    {-# INLINE traverse1_ #-}

    for1_ :: (Foldable1 t, Apply f) => t a -> (a -> f b) -> f ()
    for1_ :: forall (t :: * -> *) (f :: * -> *) a b.
    (Foldable1 t, Apply f) =>
    t a -> (a -> f b) -> f ()
    for1_ = ((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.
    (Foldable1 t, Apply f) =>
    (a -> f b) -> t a -> f ()
    traverse1_
    {-# INLINE for1_ #-}

    sequenceA1_ :: (Foldable1 t, Apply f) => t (f a) -> f ()
    sequenceA1_ :: forall (t :: * -> *) (f :: * -> *) a.
    (Foldable1 t, Apply f) =>
    t (f a) -> f ()
    sequenceA1_ t (f a)
    t = () () -> f a -> f ()
    forall a b. a -> f b -> f a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Act f a -> f a
    forall (f :: * -> *) a. Act f a -> f a
    getAct ((f a -> Act f a) -> t (f a) -> Act f a
    forall m a. Semigroup m => (a -> m) -> t a -> m
    forall (t :: * -> *) m a.
    (Foldable1 t, Semigroup m) =>
    (a -> m) -> t a -> m
    foldMap1 f a -> Act f a
    forall (f :: * -> *) a. f a -> Act f a
    Act t (f a)
    t)
    {-# INLINE sequenceA1_ #-}

    -- | Usable default for foldMap, but only if you define foldMap1 yourself
    foldMapDefault1 :: (Foldable1 t, Monoid m) => (a -> m) -> t a -> m
    foldMapDefault1 :: forall (t :: * -> *) m a.
    (Foldable1 t, Monoid m) =>
    (a -> m) -> t a -> m
    foldMapDefault1 a -> m
    f = WrappedMonoid m -> m
    forall m. WrappedMonoid m -> m
    unwrapMonoid (WrappedMonoid m -> m) -> (t a -> WrappedMonoid m) -> t a -> m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> WrappedMonoid m) -> t a -> WrappedMonoid 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 -> WrappedMonoid m
    forall m. m -> WrappedMonoid m
    WrapMonoid (m -> WrappedMonoid m) -> (a -> m) -> a -> WrappedMonoid m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> m
    f)
    {-# INLINE foldMapDefault1 #-}

    -- toStream :: Foldable1 t => t a -> Stream a
    -- concat1 :: Foldable1 t => t (Stream a) -> Stream a
    -- concatMap1 :: Foldable1 t => (a -> Stream b) -> t a -> Stream b

    newtype Alt_ f a = Alt_ { forall (f :: * -> *) a. Alt_ f a -> f a
    getAlt_ :: f a }

    instance Alt f => Semigroup (Alt_ f a) where
      Alt_ f a
    a <> :: Alt_ f a -> Alt_ f a -> Alt_ f a
    <> Alt_ f a
    b = f a -> Alt_ f a
    forall (f :: * -> *) a. f a -> Alt_ f a
    Alt_ (f a
    a f a -> f a -> f a
    forall a. f a -> f a -> f a
    forall (f :: * -> *) a. Alt f => f a -> f a -> f a
    <!> f a
    b)

    asum1 :: (Foldable1 t, Alt m) => t (m a) -> m a
    asum1 :: forall (t :: * -> *) (m :: * -> *) a.
    (Foldable1 t, Alt m) =>
    t (m a) -> m a
    asum1 = Alt_ m a -> m a
    forall (f :: * -> *) a. Alt_ f a -> f a
    getAlt_ (Alt_ m a -> m a) -> (t (m a) -> Alt_ m a) -> t (m a) -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (m a -> Alt_ m a) -> t (m a) -> Alt_ m a
    forall m a. Semigroup m => (a -> m) -> t a -> m
    forall (t :: * -> *) m a.
    (Foldable1 t, Semigroup m) =>
    (a -> m) -> t a -> m
    foldMap1 m a -> Alt_ m a
    forall (f :: * -> *) a. f a -> Alt_ f a
    Alt_
    {-# INLINE asum1 #-}

    -- | Generic 'fold1'. Caveats:
    --
    --   1. Will not compile if @t@ is an empty constructor.
    --   2. Will not compile if @t@ has some fields that don't mention @a@, for exmaple @data Bar a = MkBar a Int@
    --
    -- @since 5.3.8
    gfold1 :: (Foldable1 (Rep1 t), Generic1 t, Semigroup m) => t m -> m
    gfold1 :: forall (t :: * -> *) m.
    (Foldable1 (Rep1 t), Generic1 t, Semigroup m) =>
    t m -> m
    gfold1 = Rep1 t m -> m
    forall m. Semigroup m => Rep1 t m -> m
    forall (t :: * -> *) m. (Foldable1 t, Semigroup m) => t m -> m
    fold1 (Rep1 t m -> m) -> (t m -> Rep1 t m) -> t m -> m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . t m -> Rep1 t m
    forall a. t a -> Rep1 t a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1

    -- | Generic 'foldMap1'. Caveats are the same as for 'gfold1'.
    --
    -- @since 5.3.8
    gfoldMap1 :: (Foldable1 (Rep1 t), Generic1 t, Semigroup m) => (a -> m) -> t a -> m
    gfoldMap1 :: forall (t :: * -> *) m a.
    (Foldable1 (Rep1 t), Generic1 t, Semigroup m) =>
    (a -> m) -> t a -> m
    gfoldMap1 a -> m
    f = (a -> m) -> Rep1 t a -> m
    forall m a. Semigroup m => (a -> m) -> Rep1 t a -> m
    forall (t :: * -> *) m a.
    (Foldable1 t, Semigroup m) =>
    (a -> m) -> t a -> m
    foldMap1 a -> m
    f (Rep1 t a -> m) -> (t a -> Rep1 t a) -> t a -> m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . t a -> Rep1 t a
    forall a. t a -> Rep1 t a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1

    -- | Generic 'toNonEmpty'. Caveats are the same as for 'gfold1'.
    --
    -- @since 5.3.8
    gtoNonEmpty :: (Foldable1 (Rep1 t), Generic1 t) => t a -> NonEmpty a
    gtoNonEmpty :: forall (t :: * -> *) a.
    (Foldable1 (Rep1 t), Generic1 t) =>
    t a -> NonEmpty a
    gtoNonEmpty = Rep1 t a -> NonEmpty a
    forall a. Rep1 t a -> NonEmpty a
    forall (t :: * -> *) a. Foldable1 t => t a -> NonEmpty a
    toNonEmpty (Rep1 t a -> NonEmpty a) -> (t a -> Rep1 t a) -> t a -> NonEmpty a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . t a -> Rep1 t a
    forall a. t a -> Rep1 t a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1