    {-# LANGUAGE PolyKinds    #-}
    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE UndecidableInstances #-}
    {-# OPTIONS_GHC -Wno-orphans #-}
    module Barbies.Internal.TraversableT
      ( TraversableT(..)
      , tfor
      , ttraverse_
      , tfor_
      , tsequence
      , tsequence'
      , tfoldMap

      , CanDeriveTraversableT
      , ttraverseDefault
      )

    where

    import Barbies.Generics.Traversable(GTraversable(..))
    import Barbies.Internal.FunctorT(FunctorT (..))
    import Barbies.Internal.Writer(execWr, tell)

    import Control.Applicative.Backwards(Backwards (..))
    import Control.Applicative.Lift(Lift(..))
    import Control.Monad.Trans.Except(ExceptT(..))
    import Control.Monad.Trans.Identity(IdentityT(..))
    import Control.Monad.Trans.Maybe(MaybeT(..))
    import Control.Monad.Trans.Writer.Lazy as Lazy (WriterT(..))
    import Control.Monad.Trans.Writer.Strict as Strict (WriterT(..))

    import Data.Functor           (void)
    import Data.Functor.Compose   (Compose (..))
    import Data.Functor.Const     (Const (..))
    import Data.Functor.Identity  (Identity (..))
    import Data.Functor.Product   (Product (..))
    import Data.Functor.Reverse   (Reverse (..))
    import Data.Functor.Sum       (Sum (..))
    import Data.Kind              (Type)
    import Data.Generics.GenericN
    import Data.Proxy             (Proxy (..))

    -- | Indexed-functors that can be traversed from left to right. Instances should
    --   satisfy the following laws:
    --
    -- @
    --  t . 'ttraverse' f   = 'ttraverse' (t . f)  -- naturality
    -- 'ttraverse' 'Data.Functor.Identity' = 'Data.Functor.Identity'           -- identity
    -- 'ttraverse' ('Compose' . 'fmap' g . f) = 'Compose' . 'fmap' ('ttraverse' g) . 'ttraverse' f -- composition
    -- @
    --
    -- There is a default 'ttraverse' implementation for 'Generic' types, so
    -- instances can derived automatically.
    class FunctorT t => TraversableT (t :: (k -> Type) -> k' -> Type) where
      ttraverse
        :: Applicative e
        => (forall a . f a -> e (g a))
        -> t f x -> e (t g x)

      default ttraverse
        :: ( Applicative e, CanDeriveTraversableT t f g x)
        => (forall a . f a -> e (g a)) -> t f x -> e (t g x)
      ttraverse = (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    forall {k1} {k} (t :: (k1 -> *) -> k -> *) (f :: k1 -> *)
           (g :: k1 -> *) (e :: * -> *) (x :: k).
    (Applicative e, CanDeriveTraversableT t f g x) =>
    (forall (a :: k1). f a -> e (g a)) -> t f x -> e (t g x)
    ttraverseDefault

    -- | 'ttraverse' with the arguments flipped. Useful when the traversing function is a large lambda:
    --
    -- @
    -- tfor someTransformer $ \fa -> ...
    -- @
    --
    -- @since 2.1.0.0
    tfor
      :: (TraversableT t, Applicative e)
      => t f x
      -> (forall a . f a -> e (g a))
      -> e (t g x)
    tfor :: forall {k} {k'} (t :: (k -> *) -> k' -> *) (e :: * -> *)
           (f :: k -> *) (x :: k') (g :: k -> *).
    (TraversableT t, Applicative e) =>
    t f x -> (forall (a :: k). f a -> e (g a)) -> e (t g x)
    tfor t f x
    t forall (a :: k). f a -> e (g a)
    f = (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    forall k k' (t :: (k -> *) -> k' -> *) (e :: * -> *) (f :: k -> *)
           (g :: k -> *) (x :: k').
    (TraversableT t, Applicative e) =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    forall (e :: * -> *) (f :: k -> *) (g :: k -> *) (x :: k').
    Applicative e =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    ttraverse f a -> e (g a)
    forall (a :: k). f a -> e (g a)
    f t f x
    t

    -- | Map each element to an action, evaluate these actions from left to right,
    --   and ignore the results.
    ttraverse_
      :: (TraversableT t, Applicative e)
      => (forall a. f a -> e c)
      -> t f x -> e ()
    ttraverse_ :: forall {k} {k'} (t :: (k -> *) -> k' -> *) (e :: * -> *)
           (f :: k -> *) c (x :: k').
    (TraversableT t, Applicative e) =>
    (forall (a :: k). f a -> e c) -> t f x -> e ()
    ttraverse_ forall (a :: k). f a -> e c
    f
      = e (t (Const ()) x) -> e ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (e (t (Const ()) x) -> e ())
    -> (t f x -> e (t (Const ()) x)) -> t f x -> e ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (a :: k). f a -> e (Const () a))
    -> t f x -> e (t (Const ()) x)
    forall k k' (t :: (k -> *) -> k' -> *) (e :: * -> *) (f :: k -> *)
           (g :: k -> *) (x :: k').
    (TraversableT t, Applicative e) =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    forall (e :: * -> *) (f :: k -> *) (g :: k -> *) (x :: k').
    Applicative e =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    ttraverse ((c -> Const () a) -> e c -> e (Const () a)
    forall a b. (a -> b) -> e a -> e b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Const () a -> c -> Const () a
    forall a b. a -> b -> a
    const (Const () a -> c -> Const () a) -> Const () a -> c -> Const () a
    forall a b. (a -> b) -> a -> b
    $ () -> Const () a
    forall {k} a (b :: k). a -> Const a b
    Const ()) (e c -> e (Const () a)) -> (f a -> e c) -> f a -> e (Const () a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . f a -> e c
    forall (a :: k). f a -> e c
    f)

    -- | 'ttraverse_' with the arguments flipped.
    --
    -- @since 2.1.0.0
    tfor_
      :: (TraversableT t, Applicative e)
      => t f x
      -> (forall a . f a -> e c)
      -> e ()
    tfor_ :: forall {k} {k'} (t :: (k -> *) -> k' -> *) (e :: * -> *)
           (f :: k -> *) (x :: k') c.
    (TraversableT t, Applicative e) =>
    t f x -> (forall (a :: k). f a -> e c) -> e ()
    tfor_ t f x
    t forall (a :: k). f a -> e c
    f = (forall (a :: k). f a -> e c) -> t f x -> e ()
    forall {k} {k'} (t :: (k -> *) -> k' -> *) (e :: * -> *)
           (f :: k -> *) c (x :: k').
    (TraversableT t, Applicative e) =>
    (forall (a :: k). f a -> e c) -> t f x -> e ()
    ttraverse_ f a -> e c
    forall (a :: k). f a -> e c
    f t f x
    t

    -- | Evaluate each action in the structure from left to right,
    --   and collect the results.
    tsequence
      :: (Applicative e, TraversableT t)
      => t (Compose e f) x
      -> e (t f x)
    tsequence :: forall {k} {k'} (e :: * -> *) (t :: (k -> *) -> k' -> *)
           (f :: k -> *) (x :: k').
    (Applicative e, TraversableT t) =>
    t (Compose e f) x -> e (t f x)
    tsequence
      = (forall (a :: k). Compose e f a -> e (f a))
    -> t (Compose e f) x -> e (t f x)
    forall k k' (t :: (k -> *) -> k' -> *) (e :: * -> *) (f :: k -> *)
           (g :: k -> *) (x :: k').
    (TraversableT t, Applicative e) =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    forall (e :: * -> *) (f :: k -> *) (g :: k -> *) (x :: k').
    Applicative e =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    ttraverse Compose e f a -> e (f a)
    forall (a :: k). Compose e f a -> e (f a)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    getCompose

    -- | A version of 'tsequence' with @f@ specialized to 'Identity'.
    tsequence'
      :: (Applicative e, TraversableT t)
      => t e x
      -> e (t Identity x)
    tsequence' :: forall {k'} (e :: * -> *) (t :: (* -> *) -> k' -> *) (x :: k').
    (Applicative e, TraversableT t) =>
    t e x -> e (t Identity x)
    tsequence'
      = (forall a. e a -> e (Identity a)) -> t e x -> e (t Identity x)
    forall k k' (t :: (k -> *) -> k' -> *) (e :: * -> *) (f :: k -> *)
           (g :: k -> *) (x :: k').
    (TraversableT t, Applicative e) =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    forall (e :: * -> *) (f :: * -> *) (g :: * -> *) (x :: k').
    Applicative e =>
    (forall a. f a -> e (g a)) -> t f x -> e (t g x)
    ttraverse ((a -> Identity a) -> e a -> e (Identity a)
    forall a b. (a -> b) -> e a -> e b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> Identity a
    forall a. a -> Identity a
    Identity)

    -- | Map each element to a monoid, and combine the results.
    tfoldMap
      :: ( TraversableT t, Monoid m)
      => (forall a. f a -> m)
      -> t f x
      -> m
    tfoldMap :: forall {k} {k'} (t :: (k -> *) -> k' -> *) m (f :: k -> *)
           (x :: k').
    (TraversableT t, Monoid m) =>
    (forall (a :: k). f a -> m) -> t f x -> m
    tfoldMap forall (a :: k). f a -> m
    f
      = Wr m () -> m
    forall w a. Monoid w => Wr w a -> w
    execWr (Wr m () -> m) -> (t f x -> Wr m ()) -> t f x -> m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (a :: k). f a -> Wr m ()) -> t f x -> Wr m ()
    forall {k} {k'} (t :: (k -> *) -> k' -> *) (e :: * -> *)
           (f :: k -> *) c (x :: k').
    (TraversableT t, Applicative e) =>
    (forall (a :: k). f a -> e c) -> t f x -> e ()
    ttraverse_ (m -> Wr m ()
    forall w. Monoid w => w -> Wr w ()
    tell (m -> Wr m ()) -> (f a -> m) -> f a -> Wr m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . f a -> m
    forall (a :: k). f a -> m
    f)

    -- | @'CanDeriveTraversableT' T f g x@ is in practice a predicate about @T@ only.
    --   It is analogous to 'Barbies.Internal.FunctorT.CanDeriveFunctorT', so it
    --   essentially requires the following to hold, for any arbitrary @f@:
    --
    --     * There is an instance of @'Generic' (T f x)@.
    --
    --     * @T f x@ can contain fields of type @t f x@ as long as there exists a
    --       @'TraversableT' t@ instance. In particular, recursive usages of @T f x@
    --       are allowed.
    --
    --     * @T f x@ can also contain usages of @t f x@ under a @'Traversable' h@.
    --       For example, one could use @'Maybe' (T f x)@ when defining @T f x@.
    type CanDeriveTraversableT t f g x
      = ( GenericP 1 (t f x)
        , GenericP 1 (t g x)
        , GTraversable 1 f g (RepP 1 (t f x)) (RepP 1 (t g x))
        )

    -- | Default implementation of 'ttraverse' based on 'Generic'.
    ttraverseDefault
      :: forall t f g e x
      .  (Applicative e, CanDeriveTraversableT t f g x)
      => (forall a . f a -> e (g a))
      -> t f x -> e (t g x)
    ttraverseDefault :: forall {k1} {k} (t :: (k1 -> *) -> k -> *) (f :: k1 -> *)
           (g :: k1 -> *) (e :: * -> *) (x :: k).
    (Applicative e, CanDeriveTraversableT t f g x) =>
    (forall (a :: k1). f a -> e (g a)) -> t f x -> e (t g x)
    ttraverseDefault forall (a :: k1). f a -> e (g a)
    h
      = (Zip
       (Rep (FilterIndex 1 (Indexed t 2) (Param 1 g) x))
       (Rep (t g x))
       (ZonkAny 0)
     -> t g x)
    -> e (Zip
            (Rep (FilterIndex 1 (Indexed t 2) (Param 1 g) x))
            (Rep (t g x))
            (ZonkAny 0))
    -> e (t g x)
    forall a b. (a -> b) -> e a -> e b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Proxy 1 -> RepP 1 (t g x) (ZonkAny 0) -> t g x
    forall (n :: Natural) a x.
    GenericP n a =>
    Proxy n -> RepP n a x -> a
    forall x. Proxy 1 -> RepP 1 (t g x) x -> t g x
    toP (forall (t :: Natural). Proxy t
    forall {k} (t :: k). Proxy t
    Proxy @1)) (e (Zip
          (Rep (FilterIndex 1 (Indexed t 2) (Param 1 g) x))
          (Rep (t g x))
          (ZonkAny 0))
     -> e (t g x))
    -> (t f x
        -> e (Zip
                (Rep (FilterIndex 1 (Indexed t 2) (Param 1 g) x))
                (Rep (t g x))
                (ZonkAny 0)))
    -> t f x
    -> e (t g x)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy 1
    -> (forall (a :: k1). f a -> e (g a))
    -> Zip
         (Rep (FilterIndex 1 (Indexed t 2) (Param 1 f) x))
         (Rep (t f x))
         (ZonkAny 0)
    -> e (Zip
            (Rep (FilterIndex 1 (Indexed t 2) (Param 1 g) x))
            (Rep (t g x))
            (ZonkAny 0))
    forall {k} {k1} {k2} (n :: k) (f :: k1 -> *) (g :: k1 -> *)
           (repbf :: k2 -> *) (repbg :: k2 -> *) (t :: * -> *) (x :: k2).
    (GTraversable n f g repbf repbg, Applicative t) =>
    Proxy n
    -> (forall (a :: k1). f a -> t (g a)) -> repbf x -> t (repbg x)
    forall (t :: * -> *) x.
    Applicative t =>
    Proxy 1
    -> (forall (a :: k1). f a -> t (g a))
    -> Zip
         (Rep (FilterIndex 1 (Indexed t 2) (Param 1 f) x)) (Rep (t f x)) x
    -> t (Zip
            (Rep (FilterIndex 1 (Indexed t 2) (Param 1 g) x)) (Rep (t g x)) x)
    gtraverse (forall (t :: Natural). Proxy t
    forall {k} (t :: k). Proxy t
    Proxy @1) f a -> e (g a)
    forall (a :: k1). f a -> e (g a)
    h (Zip
       (Rep (FilterIndex 1 (Indexed t 2) (Param 1 f) x))
       (Rep (t f x))
       (ZonkAny 0)
     -> e (Zip
             (Rep (FilterIndex 1 (Indexed t 2) (Param 1 g) x))
             (Rep (t g x))
             (ZonkAny 0)))
    -> (t f x
        -> Zip
             (Rep (FilterIndex 1 (Indexed t 2) (Param 1 f) x))
             (Rep (t f x))
             (ZonkAny 0))
    -> t f x
    -> e (Zip
            (Rep (FilterIndex 1 (Indexed t 2) (Param 1 g) x))
            (Rep (t g x))
            (ZonkAny 0))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy 1 -> t f x -> RepP 1 (t f x) (ZonkAny 0)
    forall (n :: Natural) a x.
    GenericP n a =>
    Proxy n -> a -> RepP n a x
    forall x. Proxy 1 -> t f x -> RepP 1 (t f x) x
    fromP (forall (t :: Natural). Proxy t
    forall {k} (t :: k). Proxy t
    Proxy @1)
    {-# INLINE ttraverseDefault #-}

    -- ------------------------------------------------------------
    -- Generic derivation: Special cases for TraversableT
    -- -----------------------------------------------------------

    type P = Param

    instance
      ( TraversableT t
      ) => GTraversable 1 f g (Rec (t (P 1 f) x) (t f x))
                              (Rec (t (P 1 g) x) (t g x))
      where
      gtraverse :: forall (t :: * -> *) (x :: k2).
    Applicative t =>
    Proxy 1
    -> (forall (a :: k). f a -> t (g a))
    -> Rec (t (P 1 f) x) (t f x) x
    -> t (Rec (t (P 1 g) x) (t g x) x)
    gtraverse Proxy 1
    _ forall (a :: k). f a -> t (g a)
    h
        = (t g x -> Rec (t (P 1 g) x) (t g x) x)
    -> t (t g x) -> t (Rec (t (P 1 g) x) (t g x) x)
    forall a b. (a -> b) -> t a -> t b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (K1 R (t g x) x -> Rec (t (P 1 g) x) (t g x) x
    forall {k} p a (x :: k). K1 R a x -> Rec p a x
    Rec (K1 R (t g x) x -> Rec (t (P 1 g) x) (t g x) x)
    -> (t g x -> K1 R (t g x) x)
    -> t g x
    -> Rec (t (P 1 g) x) (t g x) x
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . t g x -> K1 R (t g x) x
    forall k i c (p :: k). c -> K1 i c p
    K1) (t (t g x) -> t (Rec (t (P 1 g) x) (t g x) x))
    -> (Rec (t (P 1 f) x) (t f x) x -> t (t g x))
    -> Rec (t (P 1 f) x) (t f x) x
    -> t (Rec (t (P 1 g) x) (t g x) x)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (a :: k). f a -> t (g a)) -> t f x -> t (t g x)
    forall k k' (t :: (k -> *) -> k' -> *) (e :: * -> *) (f :: k -> *)
           (g :: k -> *) (x :: k').
    (TraversableT t, Applicative e) =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    forall (e :: * -> *) (f :: k -> *) (g :: k -> *) (x :: k').
    Applicative e =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    ttraverse f a -> t (g a)
    forall (a :: k). f a -> t (g a)
    h (t f x -> t (t g x))
    -> (Rec (t (P 1 f) x) (t f x) x -> t f x)
    -> Rec (t (P 1 f) x) (t f x) x
    -> t (t g x)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . K1 R (t f x) x -> t f x
    forall k i c (p :: k). K1 i c p -> c
    unK1 (K1 R (t f x) x -> t f x)
    -> (Rec (t (P 1 f) x) (t f x) x -> K1 R (t f x) x)
    -> Rec (t (P 1 f) x) (t f x) x
    -> t f x
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rec (t (P 1 f) x) (t f x) x -> K1 R (t f x) x
    forall {k} p a (x :: k). Rec p a x -> K1 R a x
    unRec
      {-# INLINE gtraverse #-}

    instance
       ( Traversable h
       , TraversableT t
       ) => GTraversable 1 f g (Rec (h (t (P 1 f) x)) (h (t f x)))
                               (Rec (h (t (P 1 g) x)) (h (t g x)))
      where
      gtraverse :: forall (t :: * -> *) (x :: k2).
    Applicative t =>
    Proxy 1
    -> (forall (a :: k). f a -> t (g a))
    -> Rec (h (t (P 1 f) x)) (h (t f x)) x
    -> t (Rec (h (t (P 1 g) x)) (h (t g x)) x)
    gtraverse Proxy 1
    _ forall (a :: k). f a -> t (g a)
    h
        = (h (t g x) -> Rec (h (t (P 1 g) x)) (h (t g x)) x)
    -> t (h (t g x)) -> t (Rec (h (t (P 1 g) x)) (h (t g x)) x)
    forall a b. (a -> b) -> t a -> t b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (K1 R (h (t g x)) x -> Rec (h (t (P 1 g) x)) (h (t g x)) x
    forall {k} p a (x :: k). K1 R a x -> Rec p a x
    Rec (K1 R (h (t g x)) x -> Rec (h (t (P 1 g) x)) (h (t g x)) x)
    -> (h (t g x) -> K1 R (h (t g x)) x)
    -> h (t g x)
    -> Rec (h (t (P 1 g) x)) (h (t g x)) x
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . h (t g x) -> K1 R (h (t g x)) x
    forall k i c (p :: k). c -> K1 i c p
    K1) (t (h (t g x)) -> t (Rec (h (t (P 1 g) x)) (h (t g x)) x))
    -> (Rec (h (t (P 1 f) x)) (h (t f x)) x -> t (h (t g x)))
    -> Rec (h (t (P 1 f) x)) (h (t f x)) x
    -> t (Rec (h (t (P 1 g) x)) (h (t g x)) x)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (t f x -> t (t g x)) -> h (t f x) -> t (h (t g x))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> h a -> f (h b)
    traverse ((forall (a :: k). f a -> t (g a)) -> t f x -> t (t g x)
    forall k k' (t :: (k -> *) -> k' -> *) (e :: * -> *) (f :: k -> *)
           (g :: k -> *) (x :: k').
    (TraversableT t, Applicative e) =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    forall (e :: * -> *) (f :: k -> *) (g :: k -> *) (x :: k').
    Applicative e =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    ttraverse f a -> t (g a)
    forall (a :: k). f a -> t (g a)
    h) (h (t f x) -> t (h (t g x)))
    -> (Rec (h (t (P 1 f) x)) (h (t f x)) x -> h (t f x))
    -> Rec (h (t (P 1 f) x)) (h (t f x)) x
    -> t (h (t g x))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . K1 R (h (t f x)) x -> h (t f x)
    forall k i c (p :: k). K1 i c p -> c
    unK1 (K1 R (h (t f x)) x -> h (t f x))
    -> (Rec (h (t (P 1 f) x)) (h (t f x)) x -> K1 R (h (t f x)) x)
    -> Rec (h (t (P 1 f) x)) (h (t f x)) x
    -> h (t f x)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rec (h (t (P 1 f) x)) (h (t f x)) x -> K1 R (h (t f x)) x
    forall {k} p a (x :: k). Rec p a x -> K1 R a x
    unRec
      {-# INLINE gtraverse #-}

    -- This instance is the same as the previous instance but for nested
    -- Traversables.
    instance
       ( Traversable h
       , Traversable m
       , TraversableT t
       ) => GTraversable 1 f g (Rec (m (h (t (P 1 f) x))) (m (h (t f x))))
                               (Rec (m (h (t (P 1 g) x))) (m (h (t g x))))
      where
      gtraverse :: forall (t :: * -> *) (x :: k2).
    Applicative t =>
    Proxy 1
    -> (forall (a :: k). f a -> t (g a))
    -> Rec (m (h (t (P 1 f) x))) (m (h (t f x))) x
    -> t (Rec (m (h (t (P 1 g) x))) (m (h (t g x))) x)
    gtraverse Proxy 1
    _ forall (a :: k). f a -> t (g a)
    h
        = (m (h (t g x)) -> Rec (m (h (t (P 1 g) x))) (m (h (t g x))) x)
    -> t (m (h (t g x)))
    -> t (Rec (m (h (t (P 1 g) x))) (m (h (t g x))) x)
    forall a b. (a -> b) -> t a -> t b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (K1 R (m (h (t g x))) x
    -> Rec (m (h (t (P 1 g) x))) (m (h (t g x))) x
    forall {k} p a (x :: k). K1 R a x -> Rec p a x
    Rec (K1 R (m (h (t g x))) x
     -> Rec (m (h (t (P 1 g) x))) (m (h (t g x))) x)
    -> (m (h (t g x)) -> K1 R (m (h (t g x))) x)
    -> m (h (t g x))
    -> Rec (m (h (t (P 1 g) x))) (m (h (t g x))) x
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . m (h (t g x)) -> K1 R (m (h (t g x))) x
    forall k i c (p :: k). c -> K1 i c p
    K1) (t (m (h (t g x)))
     -> t (Rec (m (h (t (P 1 g) x))) (m (h (t g x))) x))
    -> (Rec (m (h (t (P 1 f) x))) (m (h (t f x))) x
        -> t (m (h (t g x))))
    -> Rec (m (h (t (P 1 f) x))) (m (h (t f x))) x
    -> t (Rec (m (h (t (P 1 g) x))) (m (h (t g x))) x)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (h (t f x) -> t (h (t g x))) -> m (h (t f x)) -> t (m (h (t g x)))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> m a -> f (m b)
    traverse ((t f x -> t (t g x)) -> h (t f x) -> t (h (t g x))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> h a -> f (h b)
    traverse ((forall (a :: k). f a -> t (g a)) -> t f x -> t (t g x)
    forall k k' (t :: (k -> *) -> k' -> *) (e :: * -> *) (f :: k -> *)
           (g :: k -> *) (x :: k').
    (TraversableT t, Applicative e) =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    forall (e :: * -> *) (f :: k -> *) (g :: k -> *) (x :: k').
    Applicative e =>
    (forall (a :: k). f a -> e (g a)) -> t f x -> e (t g x)
    ttraverse f a -> t (g a)
    forall (a :: k). f a -> t (g a)
    h)) (m (h (t f x)) -> t (m (h (t g x))))
    -> (Rec (m (h (t (P 1 f) x))) (m (h (t f x))) x -> m (h (t f x)))
    -> Rec (m (h (t (P 1 f) x))) (m (h (t f x))) x
    -> t (m (h (t g x)))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . K1 R (m (h (t f x))) x -> m (h (t f x))
    forall k i c (p :: k). K1 i c p -> c
    unK1 (K1 R (m (h (t f x))) x -> m (h (t f x)))
    -> (Rec (m (h (t (P 1 f) x))) (m (h (t f x))) x
        -> K1 R (m (h (t f x))) x)
    -> Rec (m (h (t (P 1 f) x))) (m (h (t f x))) x
    -> m (h (t f x))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rec (m (h (t (P 1 f) x))) (m (h (t f x))) x
    -> K1 R (m (h (t f x))) x
    forall {k} p a (x :: k). Rec p a x -> K1 R a x
    unRec
      {-# INLINE gtraverse #-}

    -- -----------------------------------------------------------
    -- Instances for base types
    -- -----------------------------------------------------------

    instance Traversable f => TraversableT (Compose f) where
      ttraverse :: forall (e :: * -> *) (f :: k' -> *) (g :: k' -> *) (x :: k').
    Applicative e =>
    (forall (a :: k'). f a -> e (g a))
    -> Compose f f x -> e (Compose f g x)
    ttraverse forall (a :: k'). f a -> e (g a)
    h (Compose f (f x)
    fga)
        = f (g x) -> Compose f g x
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Compose (f (g x) -> Compose f g x) -> e (f (g x)) -> e (Compose f g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (f x -> e (g x)) -> f (f x) -> e (f (g x))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> f a -> f (f b)
    traverse f x -> e (g x)
    forall (a :: k'). f a -> e (g a)
    h f (f x)
    fga
      {-# INLINE ttraverse #-}

    instance TraversableT (Product f) where
      ttraverse :: forall (e :: * -> *) (f :: k' -> *) (g :: k' -> *) (x :: k').
    Applicative e =>
    (forall (a :: k'). f a -> e (g a))
    -> Product f f x -> e (Product f g x)
    ttraverse forall (a :: k'). f a -> e (g a)
    h (Pair f x
    fa f x
    ga) = f x -> g x -> Product f g x
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair f x
    fa (g x -> Product f g x) -> e (g x) -> e (Product f g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f x -> e (g x)
    forall (a :: k'). f a -> e (g a)
    h f x
    ga
      {-# INLINE ttraverse #-}

    instance TraversableT (Sum f) where
      ttraverse :: forall (e :: * -> *) (f :: k' -> *) (g :: k' -> *) (x :: k').
    Applicative e =>
    (forall (a :: k'). f a -> e (g a)) -> Sum f f x -> e (Sum f g x)
    ttraverse forall (a :: k'). f a -> e (g a)
    h = \case
        InL f x
    fa -> Sum f g x -> e (Sum f g x)
    forall a. a -> e a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Sum f g x -> e (Sum f g x)) -> Sum f g x -> e (Sum f g x)
    forall a b. (a -> b) -> a -> b
    $ f x -> Sum f g x
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k). f a -> Sum f g a
    InL f x
    fa
        InR f x
    ga -> g x -> Sum f g x
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k). g a -> Sum f g a
    InR (g x -> Sum f g x) -> e (g x) -> e (Sum f g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f x -> e (g x)
    forall (a :: k'). f a -> e (g a)
    h f x
    ga
      {-# INLINE ttraverse #-}

    -- -----------------------------------------------------------
    -- Instances for transformers types
    -- -----------------------------------------------------------

    instance TraversableT Backwards where
      ttraverse :: forall (e :: * -> *) (f :: k' -> *) (g :: k' -> *) (x :: k').
    Applicative e =>
    (forall (a :: k'). f a -> e (g a))
    -> Backwards f x -> e (Backwards g x)
    ttraverse forall (a :: k'). f a -> e (g a)
    h (Backwards f x
    fa)
        = g x -> Backwards g x
    forall {k} (f :: k -> *) (a :: k). f a -> Backwards f a
    Backwards (g x -> Backwards g x) -> e (g x) -> e (Backwards g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f x -> e (g x)
    forall (a :: k'). f a -> e (g a)
    h f x
    fa
      {-# INLINE ttraverse #-}

    instance TraversableT Lift where
      ttraverse :: forall (e :: * -> *) (f :: * -> *) (g :: * -> *) x.
    Applicative e =>
    (forall a. f a -> e (g a)) -> Lift f x -> e (Lift g x)
    ttraverse forall a. f a -> e (g a)
    h = \case
        Pure  x
    a  -> Lift g x -> e (Lift g x)
    forall a. a -> e a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Lift g x -> e (Lift g x)) -> Lift g x -> e (Lift g x)
    forall a b. (a -> b) -> a -> b
    $ x -> Lift g x
    forall (f :: * -> *) a. a -> Lift f a
    Pure x
    a
        Other f x
    fa -> g x -> Lift g x
    forall (f :: * -> *) a. f a -> Lift f a
    Other (g x -> Lift g x) -> e (g x) -> e (Lift g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f x -> e (g x)
    forall a. f a -> e (g a)
    h f x
    fa
      {-# INLINE ttraverse #-}

    instance TraversableT Reverse where
      ttraverse :: forall (e :: * -> *) (f :: k' -> *) (g :: k' -> *) (x :: k').
    Applicative e =>
    (forall (a :: k'). f a -> e (g a))
    -> Reverse f x -> e (Reverse g x)
    ttraverse forall (a :: k'). f a -> e (g a)
    h (Reverse f x
    fa) = g x -> Reverse g x
    forall {k} (f :: k -> *) (a :: k). f a -> Reverse f a
    Reverse (g x -> Reverse g x) -> e (g x) -> e (Reverse g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f x -> e (g x)
    forall (a :: k'). f a -> e (g a)
    h f x
    fa
      {-# INLINE ttraverse #-}

    instance TraversableT (ExceptT e) where
      ttraverse :: forall (e :: * -> *) (f :: * -> *) (g :: * -> *) x.
    Applicative e =>
    (forall a. f a -> e (g a)) -> ExceptT e f x -> e (ExceptT e g x)
    ttraverse forall a. f a -> e (g a)
    h (ExceptT f (Either e x)
    mea)
        = g (Either e x) -> ExceptT e g x
    forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
    ExceptT (g (Either e x) -> ExceptT e g x)
    -> e (g (Either e x)) -> e (ExceptT e g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f (Either e x) -> e (g (Either e x))
    forall a. f a -> e (g a)
    h f (Either e x)
    mea
      {-# INLINE ttraverse #-}

    instance TraversableT IdentityT where
      ttraverse :: forall (e :: * -> *) (f :: k' -> *) (g :: k' -> *) (x :: k').
    Applicative e =>
    (forall (a :: k'). f a -> e (g a))
    -> IdentityT f x -> e (IdentityT g x)
    ttraverse forall (a :: k'). f a -> e (g a)
    h (IdentityT f x
    ma)
        = g x -> IdentityT g x
    forall {k} (f :: k -> *) (a :: k). f a -> IdentityT f a
    IdentityT (g x -> IdentityT g x) -> e (g x) -> e (IdentityT g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f x -> e (g x)
    forall (a :: k'). f a -> e (g a)
    h f x
    ma
      {-# INLINE ttraverse #-}

    instance TraversableT MaybeT where
      ttraverse :: forall (e :: * -> *) (f :: * -> *) (g :: * -> *) x.
    Applicative e =>
    (forall a. f a -> e (g a)) -> MaybeT f x -> e (MaybeT g x)
    ttraverse forall a. f a -> e (g a)
    h (MaybeT f (Maybe x)
    mma)
        = g (Maybe x) -> MaybeT g x
    forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
    MaybeT (g (Maybe x) -> MaybeT g x) -> e (g (Maybe x)) -> e (MaybeT g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f (Maybe x) -> e (g (Maybe x))
    forall a. f a -> e (g a)
    h f (Maybe x)
    mma
      {-# INLINE ttraverse #-}

    instance TraversableT (Lazy.WriterT w) where
      ttraverse :: forall (e :: * -> *) (f :: * -> *) (g :: * -> *) x.
    Applicative e =>
    (forall a. f a -> e (g a)) -> WriterT w f x -> e (WriterT w g x)
    ttraverse forall a. f a -> e (g a)
    h (Lazy.WriterT f (x, w)
    maw)
        = g (x, w) -> WriterT w g x
    forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
    Lazy.WriterT (g (x, w) -> WriterT w g x) -> e (g (x, w)) -> e (WriterT w g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f (x, w) -> e (g (x, w))
    forall a. f a -> e (g a)
    h f (x, w)
    maw
      {-# INLINE ttraverse #-}

    instance TraversableT (Strict.WriterT w) where
      ttraverse :: forall (e :: * -> *) (f :: * -> *) (g :: * -> *) x.
    Applicative e =>
    (forall a. f a -> e (g a)) -> WriterT w f x -> e (WriterT w g x)
    ttraverse forall a. f a -> e (g a)
    h (Strict.WriterT f (x, w)
    maw)
        = g (x, w) -> WriterT w g x
    forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
    Strict.WriterT (g (x, w) -> WriterT w g x) -> e (g (x, w)) -> e (WriterT w g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f (x, w) -> e (g (x, w))
    forall a. f a -> e (g a)
    h f (x, w)
    maw
      {-# INLINE ttraverse #-}