    -- | Import this module qualified, like this:
    --
    -- > import qualified Rank2
    --
    -- This will bring into scope the standard classes 'Functor', 'Applicative', 'Foldable', and 'Traversable', but with a
    -- @Rank2.@ prefix and a twist that their methods operate on a heterogenous collection. The same property is shared by
    -- the less standard classes 'Apply', 'Distributive', and 'Logistic'.
    {-# LANGUAGE DefaultSignatures, InstanceSigs, KindSignatures, PolyKinds, Rank2Types #-}
    {-# LANGUAGE ScopedTypeVariables, StandaloneDeriving, TypeOperators, UndecidableInstances #-}
    {-# LANGUAGE EmptyCase #-}
    {-# LANGUAGE TypeApplications #-}
    module Rank2 (
    -- * Rank 2 classes
       Functor(..), Apply(..), Applicative(..),
       Foldable(..), Traversable(..), Distributive(..), DistributiveTraversable(..), Logistic(..), distributeJoin,
    -- * Rank 2 data types
       Compose(..), Empty(..), Only(..), Flip(..), Identity(..), Product(..), Sum(..), Arrow(..), type (~>),
    -- * Method synonyms and helper functions
       ($), fst, snd, ap, fmap, liftA4, liftA5,
       fmapTraverse, liftA2Traverse1, liftA2Traverse2, liftA2TraverseBoth,
       distributeWith, distributeWithTraversable,
       getters, setters)
    where

    import qualified Control.Applicative as Rank1
    import qualified Control.Monad as Rank1
    import qualified Data.Foldable as Rank1
    import qualified Data.Traversable as Rank1
    import qualified Data.Functor.Compose as Rank1
    import qualified Data.Functor.Contravariant as Rank1
    import qualified Data.Functor.Logistic as Rank1
    import qualified Data.Distributive as Rank1
    import Data.Coerce (coerce)
    import Data.Semigroup (Semigroup(..))
    import Data.Monoid (Monoid(..))
    import Data.Functor.Const (Const(..))
    import Data.Functor.Product (Product(Pair))
    import Data.Functor.Sum (Sum(InL, InR))
    import Data.Kind (Type)
    import Data.Proxy (Proxy(..))
    import qualified GHC.Generics as Generics

    import Prelude hiding (Foldable(..), Traversable(..), Functor(..), Applicative(..), ($), (<$>), fst, snd)

    -- | Helper function for accessing the first field of a 'Pair'
    fst :: Product g h p -> g p
    fst :: forall {k} (g :: k -> *) (h :: k -> *) (p :: k).
    Product g h p -> g p
    fst (Pair g p
    x h p
    _) = g p
    x

    -- | Helper function for accessing the second field of a 'Pair'
    snd :: Product g h p -> h p
    snd :: forall {k} (g :: k -> *) (h :: k -> *) (p :: k).
    Product g h p -> h p
    snd (Pair g p
    _ h p
    y) = h p
    y

    -- | Equivalent of 'Rank1.Functor' for rank 2 data types, satisfying the usual functor laws
    --
    -- > id <$> g == g
    -- > (p . q) <$> g == p <$> (q <$> g)
    class Functor g where
       (<$>) :: (forall a. p a -> q a) -> g p -> g q
    infixl 4 <$>

    -- | Alphabetical synonym for '<$>'
    fmap :: Functor g => (forall a. p a -> q a) -> g p -> g q
    fmap :: forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    fmap forall (a :: k). p a -> q a
    f g p
    g = p a -> q a
    forall (a :: k). p a -> q a
    f (forall (a :: k). p a -> q a) -> g p -> g q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> g p -> g q
    <$> g p
    g
    {-# INLINE fmap #-}

    -- | Equivalent of 'Rank1.Foldable' for rank 2 data types
    class Foldable g where
       foldMap :: Monoid m => (forall a. p a -> m) -> g p -> m

    -- | Equivalent of 'Rank1.Traversable' for rank 2 data types
    class (Functor g, Foldable g) => Traversable g where
       {-# MINIMAL traverse | sequence #-}
       traverse :: Rank1.Applicative m => (forall a. p a -> m (q a)) -> g p -> m (g q)
       sequence :: Rank1.Applicative m => g (Rank1.Compose m p) -> m (g p)
       traverse forall (a :: k). p a -> m (q a)
    f = g (Compose m q) -> m (g q)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *).
    (Traversable g, Applicative m) =>
    g (Compose m p) -> m (g p)
    forall (m :: * -> *) (p :: k -> *).
    Applicative m =>
    g (Compose m p) -> m (g p)
    sequence (g (Compose m q) -> m (g q))
    -> (g p -> g (Compose m q)) -> g p -> m (g q)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (a :: k). p a -> Compose m q a) -> g p -> g (Compose m q)
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    fmap (m (q a) -> Compose m q a
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose (m (q a) -> Compose m q a)
    -> (p a -> m (q a)) -> p a -> Compose m q a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f)
       sequence = (forall (a :: k). Compose m p a -> m (p a))
    -> g (Compose m p) -> m (g p)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    traverse Compose m p a -> m (p a)
    forall (a :: k). Compose m p a -> m (p a)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    Rank1.getCompose
    -- | Wrapper for functions that map the argument constructor type
    newtype Arrow p q a = Arrow{forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    Arrow p q a -> p a -> q a
    apply :: p a -> q a}

    type (~>) = Arrow
    ($) :: Arrow p q a -> p a -> q a
    $ :: forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    Arrow p q a -> p a -> q a
    ($) = Arrow p q a -> p a -> q a
    forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    Arrow p q a -> p a -> q a
    apply
    infixr 0 ~>
    infixr 0 $

    -- | Subclass of 'Functor' halfway to 'Applicative', satisfying
    --
    -- > (.) <$> u <*> v <*> w == u <*> (v <*> w)
    class Functor g => Apply g where
       {-# MINIMAL liftA2 | (<*>) #-}
       -- | Equivalent of 'Rank1.<*>' for rank 2 data types
       (<*>) :: g (p ~> q) -> g p -> g q
       -- | Equivalent of 'Rank1.liftA2' for rank 2 data types
       liftA2 :: (forall a. p a -> q a -> r a) -> g p -> g q -> g r
       -- | Equivalent of 'Rank1.liftA3' for rank 2 data types
       liftA3 :: (forall a. p a -> q a -> r a -> s a) -> g p -> g q -> g r -> g s

       (<*>) = (forall (a :: k). (~>) p q a -> p a -> q a)
    -> g (p ~> q) -> g p -> g q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    liftA2 Arrow p q a -> p a -> q a
    forall (a :: k). (~>) p q a -> p a -> q a
    forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    Arrow p q a -> p a -> q a
    apply
       liftA2 forall (a :: k). p a -> q a -> r a
    f g p
    g g q
    h = ((q a -> r a) -> (~>) q r a
    forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    (p a -> q a) -> Arrow p q a
    Arrow ((q a -> r a) -> (~>) q r a)
    -> (p a -> q a -> r a) -> p a -> (~>) q r a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . p a -> q a -> r a
    forall (a :: k). p a -> q a -> r a
    f) (forall {a :: k}. p a -> (~>) q r a) -> g p -> g (q ~> r)
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> g p -> g q
    <$> g p
    g g (q ~> r) -> g q -> g r
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *). g (p ~> q) -> g p -> g q
    <*> g q
    h
       liftA3 forall (a :: k). p a -> q a -> r a -> s a
    f g p
    g g q
    h g r
    i = (forall (a :: k). p a -> q a -> (~>) r s a)
    -> g p -> g q -> g (r ~> s)
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    liftA2 (\p a
    p q a
    q-> (r a -> s a) -> (~>) r s a
    forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    (p a -> q a) -> Arrow p q a
    Arrow (p a -> q a -> r a -> s a
    forall (a :: k). p a -> q a -> r a -> s a
    f p a
    p q a
    q)) g p
    g g q
    h g (r ~> s) -> g r -> g s
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *). g (p ~> q) -> g p -> g q
    <*> g r
    i
    infixl 4 <*>

    liftA4 :: Apply g => (forall a. p a -> q a -> r a -> s a -> t a) -> g p -> g q -> g r -> g s -> g t
    liftA4 :: forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *) (s :: k -> *) (t :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a -> s a -> t a)
    -> g p -> g q -> g r -> g s -> g t
    liftA4 forall (a :: k). p a -> q a -> r a -> s a -> t a
    f g p
    g g q
    h g r
    i g s
    j = (forall (a :: k). p a -> q a -> r a -> (~>) s t a)
    -> g p -> g q -> g r -> g (s ~> t)
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *) (s :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a -> s a)
    -> g p -> g q -> g r -> g s
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *) (s :: k -> *).
    (forall (a :: k). p a -> q a -> r a -> s a)
    -> g p -> g q -> g r -> g s
    liftA3 (\p a
    p q a
    q r a
    r-> (s a -> t a) -> (~>) s t a
    forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    (p a -> q a) -> Arrow p q a
    Arrow (p a -> q a -> r a -> s a -> t a
    forall (a :: k). p a -> q a -> r a -> s a -> t a
    f p a
    p q a
    q r a
    r)) g p
    g g q
    h g r
    i g (s ~> t) -> g s -> g t
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *). g (p ~> q) -> g p -> g q
    <*> g s
    j

    liftA5 :: Apply g => (forall a. p a -> q a -> r a -> s a -> t a -> u a) -> g p -> g q -> g r -> g s -> g t -> g u
    liftA5 :: forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *) (s :: k -> *) (t :: k -> *) (u :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a -> s a -> t a -> u a)
    -> g p -> g q -> g r -> g s -> g t -> g u
    liftA5 forall (a :: k). p a -> q a -> r a -> s a -> t a -> u a
    f g p
    g1 g q
    g2 g r
    g3 g s
    g4 g t
    g5 = (forall (a :: k). p a -> q a -> r a -> s a -> (~>) t u a)
    -> g p -> g q -> g r -> g s -> g (t ~> u)
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *) (s :: k -> *) (t :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a -> s a -> t a)
    -> g p -> g q -> g r -> g s -> g t
    liftA4 (\p a
    p q a
    q r a
    r s a
    s-> (t a -> u a) -> (~>) t u a
    forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    (p a -> q a) -> Arrow p q a
    Arrow (p a -> q a -> r a -> s a -> t a -> u a
    forall (a :: k). p a -> q a -> r a -> s a -> t a -> u a
    f p a
    p q a
    q r a
    r s a
    s)) g p
    g1 g q
    g2 g r
    g3 g s
    g4 g (t ~> u) -> g t -> g u
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *). g (p ~> q) -> g p -> g q
    <*> g t
    g5

    -- | Alphabetical synonym for '<*>'
    ap :: Apply g => g (p ~> q) -> g p -> g q
    ap :: forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    ap = g (p ~> q) -> g p -> g q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *). g (p ~> q) -> g p -> g q
    (<*>)

    -- | Equivalent of 'Rank1.Applicative' for rank 2 data types
    class Apply g => Applicative g where
       pure :: (forall a. f a) -> g f

    -- | Equivalent of 'Rank1.Distributive' for rank 2 data types
    class DistributiveTraversable g => Distributive g where
       {-# MINIMAL cotraverse|distribute #-}
       collect :: Rank1.Functor p => (a -> g q) -> p a -> g (Rank1.Compose p q)
       distribute :: Rank1.Functor p => p (g q) -> g (Rank1.Compose p q)
       -- | Dual of 'traverse', equivalent of 'Rank1.cotraverse' for rank 2 data types
       cotraverse :: Rank1.Functor m => (forall a. m (p a) -> q a) -> m (g p) -> g q

       collect a -> g q
    f = p (g q) -> g (Compose p q)
    forall {k1} (g :: (k1 -> *) -> *) (p :: * -> *) (q :: k1 -> *).
    (Distributive g, Functor p) =>
    p (g q) -> g (Compose p q)
    forall (p :: * -> *) (q :: k1 -> *).
    Functor p =>
    p (g q) -> g (Compose p q)
    distribute (p (g q) -> g (Compose p q))
    -> (p a -> p (g q)) -> p a -> g (Compose p q)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> g q) -> p a -> p (g q)
    forall a b. (a -> b) -> p a -> p b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap a -> g q
    f
       distribute = (forall (a :: k1). p (q a) -> Compose p q a)
    -> p (g q) -> g (Compose p q)
    forall {k1} (g :: (k1 -> *) -> *) (m :: * -> *) (p :: k1 -> *)
           (q :: k1 -> *).
    (Distributive g, Functor m) =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    cotraverse p (q a) -> Compose p q a
    forall (a :: k1). p (q a) -> Compose p q a
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose
       cotraverse forall (a :: k1). m (p a) -> q a
    f = (forall (a :: k1). Compose m p a -> q a) -> g (Compose m p) -> g q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    fmap (m (p a) -> q a
    forall (a :: k1). m (p a) -> q a
    f (m (p a) -> q a)
    -> (Compose m p a -> m (p a)) -> Compose m p a -> q a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Compose m p a -> m (p a)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    Rank1.getCompose) (g (Compose m p) -> g q)
    -> (m (g p) -> g (Compose m p)) -> m (g p) -> g q
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . m (g p) -> g (Compose m p)
    forall {k1} (g :: (k1 -> *) -> *) (p :: * -> *) (q :: k1 -> *).
    (Distributive g, Functor p) =>
    p (g q) -> g (Compose p q)
    forall (p :: * -> *) (q :: k1 -> *).
    Functor p =>
    p (g q) -> g (Compose p q)
    distribute

    -- | A weaker 'Distributive' that requires 'Rank1.Traversable' to use, not just a 'Rank1.Functor'.
    class Functor g => DistributiveTraversable (g :: (k -> Type) -> Type) where
       collectTraversable :: Rank1.Traversable f1 => (a -> g f2) -> f1 a -> g (Rank1.Compose f1 f2)
       distributeTraversable :: Rank1.Traversable f1 => f1 (g f2) -> g (Rank1.Compose f1 f2)
       cotraverseTraversable :: Rank1.Traversable f1 => (forall x. f1 (f2 x) -> f x) -> f1 (g f2) -> g f

       collectTraversable a -> g f2
    f = f1 (g f2) -> g (Compose f1 f2)
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    f1 (g f2) -> g (Compose f1 f2)
    forall (f1 :: * -> *) (f2 :: k -> *).
    Traversable f1 =>
    f1 (g f2) -> g (Compose f1 f2)
    distributeTraversable (f1 (g f2) -> g (Compose f1 f2))
    -> (f1 a -> f1 (g f2)) -> f1 a -> g (Compose f1 f2)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> g f2) -> f1 a -> f1 (g f2)
    forall a b. (a -> b) -> f1 a -> f1 b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap a -> g f2
    f
       distributeTraversable = (forall (x :: k). f1 (f2 x) -> Compose f1 f2 x)
    -> f1 (g f2) -> g (Compose f1 f2)
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *)
           (f :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    cotraverseTraversable f1 (f2 x) -> Compose f1 f2 x
    forall (x :: k). f1 (f2 x) -> Compose f1 f2 x
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose

       default cotraverseTraversable :: (Rank1.Traversable m, Distributive g) =>
                                        (forall a. m (p a) -> q a) -> m (g p) -> g q
       cotraverseTraversable = (forall (a :: k). m (p a) -> q a) -> m (g p) -> g q
    forall {k1} (g :: (k1 -> *) -> *) (m :: * -> *) (p :: k1 -> *)
           (q :: k1 -> *).
    (Distributive g, Functor m) =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Functor m =>
    (forall (a :: k). m (p a) -> q a) -> m (g p) -> g q
    cotraverse

    -- | Equivalent of 'Rank1.Logistic' for rank 2 data types
    class Functor g => Logistic g where
       deliver :: Rank1.Contravariant p => p (g q -> g q) -> g (Rank1.Compose p (q ~> q))

    -- | A variant of 'distribute' convenient with 'Rank1.Monad' instances
    distributeJoin :: (Distributive g, Rank1.Monad f) => f (g f) -> g f
    distributeJoin :: forall (g :: (* -> *) -> *) (f :: * -> *).
    (Distributive g, Monad f) =>
    f (g f) -> g f
    distributeJoin = (forall a. f (f a) -> f a) -> f (g f) -> g f
    forall {k1} (g :: (k1 -> *) -> *) (m :: * -> *) (p :: k1 -> *)
           (q :: k1 -> *).
    (Distributive g, Functor m) =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall (m :: * -> *) (p :: * -> *) (q :: * -> *).
    Functor m =>
    (forall a. m (p a) -> q a) -> m (g p) -> g q
    cotraverse f (f a) -> f a
    forall a. f (f a) -> f a
    forall (m :: * -> *) a. Monad m => m (m a) -> m a
    Rank1.join

    -- | Like 'fmap', but traverses over its argument
    fmapTraverse :: (DistributiveTraversable g, Rank1.Traversable f) => (forall a. f (t a) -> u a) -> f (g t) -> g u
    fmapTraverse :: forall {k} (g :: (k -> *) -> *) (f :: * -> *) (t :: k -> *)
           (u :: k -> *).
    (DistributiveTraversable g, Traversable f) =>
    (forall (a :: k). f (t a) -> u a) -> f (g t) -> g u
    fmapTraverse forall (a :: k). f (t a) -> u a
    f f (g t)
    x = (forall (a :: k). Compose f t a -> u a) -> g (Compose f t) -> g u
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    fmap (f (t a) -> u a
    forall (a :: k). f (t a) -> u a
    f (f (t a) -> u a)
    -> (Compose f t a -> f (t a)) -> Compose f t a -> u a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Compose f t a -> f (t a)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    Rank1.getCompose) (f (g t) -> g (Compose f t)
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    f1 (g f2) -> g (Compose f1 f2)
    forall (f1 :: * -> *) (f2 :: k -> *).
    Traversable f1 =>
    f1 (g f2) -> g (Compose f1 f2)
    distributeTraversable f (g t)
    x)

    -- | Like 'liftA2', but traverses over its first argument
    liftA2Traverse1 :: (Apply g, DistributiveTraversable g, Rank1.Traversable f) =>
                       (forall a. f (t a) -> u a -> v a) -> f (g t) -> g u -> g v
    liftA2Traverse1 :: forall {k} (g :: (k -> *) -> *) (f :: * -> *) (t :: k -> *)
           (u :: k -> *) (v :: k -> *).
    (Apply g, DistributiveTraversable g, Traversable f) =>
    (forall (a :: k). f (t a) -> u a -> v a) -> f (g t) -> g u -> g v
    liftA2Traverse1 forall (a :: k). f (t a) -> u a -> v a
    f f (g t)
    x = (forall (a :: k). Compose f t a -> u a -> v a)
    -> g (Compose f t) -> g u -> g v
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    liftA2 (f (t a) -> u a -> v a
    forall (a :: k). f (t a) -> u a -> v a
    f (f (t a) -> u a -> v a)
    -> (Compose f t a -> f (t a)) -> Compose f t a -> u a -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Compose f t a -> f (t a)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    Rank1.getCompose) (f (g t) -> g (Compose f t)
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    f1 (g f2) -> g (Compose f1 f2)
    forall (f1 :: * -> *) (f2 :: k -> *).
    Traversable f1 =>
    f1 (g f2) -> g (Compose f1 f2)
    distributeTraversable f (g t)
    x)

    -- | Like 'liftA2', but traverses over its second argument
    liftA2Traverse2 :: (Apply g, DistributiveTraversable g, Rank1.Traversable f) =>
                       (forall a. t a -> f (u a) -> v a) -> g t -> f (g u) -> g v
    liftA2Traverse2 :: forall {k} (g :: (k -> *) -> *) (f :: * -> *) (t :: k -> *)
           (u :: k -> *) (v :: k -> *).
    (Apply g, DistributiveTraversable g, Traversable f) =>
    (forall (a :: k). t a -> f (u a) -> v a) -> g t -> f (g u) -> g v
    liftA2Traverse2 forall (a :: k). t a -> f (u a) -> v a
    f g t
    x f (g u)
    y = (forall (a :: k). t a -> Compose f u a -> v a)
    -> g t -> g (Compose f u) -> g v
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    liftA2 (\t a
    x' Compose f u a
    y' -> t a -> f (u a) -> v a
    forall (a :: k). t a -> f (u a) -> v a
    f t a
    x' (Compose f u a -> f (u a)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    Rank1.getCompose Compose f u a
    y')) g t
    x (f (g u) -> g (Compose f u)
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    f1 (g f2) -> g (Compose f1 f2)
    forall (f1 :: * -> *) (f2 :: k -> *).
    Traversable f1 =>
    f1 (g f2) -> g (Compose f1 f2)
    distributeTraversable f (g u)
    y)

    -- | Like 'liftA2', but traverses over both its arguments
    liftA2TraverseBoth :: forall f1 f2 g t u v.
                          (Apply g, DistributiveTraversable g, Rank1.Traversable f1, Rank1.Traversable f2) =>
                          (forall a. f1 (t a) -> f2 (u a) -> v a) -> f1 (g t) -> f2 (g u) -> g v
    liftA2TraverseBoth :: forall {k} (f1 :: * -> *) (f2 :: * -> *) (g :: (k -> *) -> *)
           (t :: k -> *) (u :: k -> *) (v :: k -> *).
    (Apply g, DistributiveTraversable g, Traversable f1,
     Traversable f2) =>
    (forall (a :: k). f1 (t a) -> f2 (u a) -> v a)
    -> f1 (g t) -> f2 (g u) -> g v
    liftA2TraverseBoth forall (a :: k). f1 (t a) -> f2 (u a) -> v a
    f f1 (g t)
    x f2 (g u)
    y = (forall (a :: k). Compose f1 t a -> Compose f2 u a -> v a)
    -> g (Compose f1 t) -> g (Compose f2 u) -> g v
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    liftA2 Compose f1 t a -> Compose f2 u a -> v a
    forall (a :: k). Compose f1 t a -> Compose f2 u a -> v a
    applyCompose (f1 (g t) -> g (Compose f1 t)
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    f1 (g f2) -> g (Compose f1 f2)
    forall (f1 :: * -> *) (f2 :: k -> *).
    Traversable f1 =>
    f1 (g f2) -> g (Compose f1 f2)
    distributeTraversable f1 (g t)
    x) (f2 (g u) -> g (Compose f2 u)
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    f1 (g f2) -> g (Compose f1 f2)
    forall (f1 :: * -> *) (f2 :: k -> *).
    Traversable f1 =>
    f1 (g f2) -> g (Compose f1 f2)
    distributeTraversable f2 (g u)
    y)
       where applyCompose :: forall a. Rank1.Compose f1 t a -> Rank1.Compose f2 u a -> v a
             applyCompose :: forall (a :: k). Compose f1 t a -> Compose f2 u a -> v a
    applyCompose Compose f1 t a
    x' Compose f2 u a
    y' = f1 (t a) -> f2 (u a) -> v a
    forall (a :: k). f1 (t a) -> f2 (u a) -> v a
    f (Compose f1 t a -> f1 (t a)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    Rank1.getCompose Compose f1 t a
    x') (Compose f2 u a -> f2 (u a)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    Rank1.getCompose Compose f2 u a
    y')

    -- | Enumerate getters for each element
    getters :: Distributive g => g (Rank1.Compose ((->) (g f)) f)
    getters :: forall {k1} (g :: (k1 -> *) -> *) (f :: k1 -> *).
    Distributive g =>
    g (Compose ((->) (g f)) f)
    getters = (g f -> g f) -> g (Compose ((->) (g f)) f)
    forall {k1} (g :: (k1 -> *) -> *) (p :: * -> *) (q :: k1 -> *).
    (Distributive g, Functor p) =>
    p (g q) -> g (Compose p q)
    forall (p :: * -> *) (q :: k1 -> *).
    Functor p =>
    p (g q) -> g (Compose p q)
    distribute g f -> g f
    forall a. a -> a
    id

    -- | Enumerate setters for each element
    setters :: Logistic g => g ((f ~> f) ~> Const (g f -> g f))
    setters :: forall {k1} (g :: (k1 -> *) -> *) (f :: k1 -> *).
    Logistic g =>
    g ((f ~> f) ~> Const (g f -> g f))
    setters = ((~>) f f a -> Const (g f -> g f) a)
    -> (~>) (f ~> f) (Const (g f -> g f)) a
    forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    (p a -> q a) -> Arrow p q a
    Arrow (((~>) f f a -> Const (g f -> g f) a)
     -> (~>) (f ~> f) (Const (g f -> g f)) a)
    -> (Compose (Op (g f -> g f)) (f ~> f) a
        -> (~>) f f a -> Const (g f -> g f) a)
    -> Compose (Op (g f -> g f)) (f ~> f) a
    -> (~>) (f ~> f) (Const (g f -> g f)) a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((g f -> g f) -> Const (g f -> g f) a
    forall {k} a (b :: k). a -> Const a b
    Const ((g f -> g f) -> Const (g f -> g f) a)
    -> ((~>) f f a -> g f -> g f) -> (~>) f f a -> Const (g f -> g f) a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) (((~>) f f a -> g f -> g f) -> (~>) f f a -> Const (g f -> g f) a)
    -> (Compose (Op (g f -> g f)) (f ~> f) a
        -> (~>) f f a -> g f -> g f)
    -> Compose (Op (g f -> g f)) (f ~> f) a
    -> (~>) f f a
    -> Const (g f -> g f) a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Op (g f -> g f) ((~>) f f a) -> (~>) f f a -> g f -> g f
    forall a b. Op a b -> b -> a
    Rank1.getOp (Op (g f -> g f) ((~>) f f a) -> (~>) f f a -> g f -> g f)
    -> (Compose (Op (g f -> g f)) (f ~> f) a
        -> Op (g f -> g f) ((~>) f f a))
    -> Compose (Op (g f -> g f)) (f ~> f) a
    -> (~>) f f a
    -> g f
    -> g f
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Compose (Op (g f -> g f)) (f ~> f) a
    -> Op (g f -> g f) ((~>) f f a)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    Rank1.getCompose (forall {a :: k1}.
     Compose (Op (g f -> g f)) (f ~> f) a
     -> (~>) (f ~> f) (Const (g f -> g f)) a)
    -> g (Compose (Op (g f -> g f)) (f ~> f))
    -> g ((f ~> f) ~> Const (g f -> g f))
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k1 -> *) (q :: k1 -> *).
    (forall (a :: k1). p a -> q a) -> g p -> g q
    <$> Op (g f -> g f) (g f -> g f)
    -> g (Compose (Op (g f -> g f)) (f ~> f))
    forall {k1} (g :: (k1 -> *) -> *) (p :: * -> *) (q :: k1 -> *).
    (Logistic g, Contravariant p) =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    deliver (((g f -> g f) -> g f -> g f) -> Op (g f -> g f) (g f -> g f)
    forall a b. (b -> a) -> Op a b
    Rank1.Op (g f -> g f) -> g f -> g f
    forall a. a -> a
    id)

    {-# DEPRECATED distributeWith "Use cotraverse instead." #-}
    -- | Synonym for 'cotraverse'
    distributeWith :: (Distributive g, Rank1.Functor f) => (forall i. f (a i) -> b i) -> f (g a) -> g b
    distributeWith :: forall {k1} (g :: (k1 -> *) -> *) (f :: * -> *) (a :: k1 -> *)
           (b :: k1 -> *).
    (Distributive g, Functor f) =>
    (forall (i :: k1). f (a i) -> b i) -> f (g a) -> g b
    distributeWith = (forall (a :: k1). f (a a) -> b a) -> f (g a) -> g b
    forall {k1} (g :: (k1 -> *) -> *) (m :: * -> *) (p :: k1 -> *)
           (q :: k1 -> *).
    (Distributive g, Functor m) =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    cotraverse

    {-# DEPRECATED distributeWithTraversable "Use cotraverseTraversable instead." #-}
    -- | Synonym for 'cotraverseTraversable'
    distributeWithTraversable :: (DistributiveTraversable g, Rank1.Traversable m) =>
                                 (forall a. m (p a) -> q a) -> m (g p) -> g q
    distributeWithTraversable :: forall {k} (g :: (k -> *) -> *) (f :: * -> *) (t :: k -> *)
           (u :: k -> *).
    (DistributiveTraversable g, Traversable f) =>
    (forall (a :: k). f (t a) -> u a) -> f (g t) -> g u
    distributeWithTraversable = (forall (x :: k). m (p x) -> q x) -> m (g p) -> g q
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *)
           (f :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    cotraverseTraversable

    -- | A rank-2 equivalent of @()@, a zero-element tuple
    data Empty f = Empty deriving (Empty f -> Empty f -> Bool
    (Empty f -> Empty f -> Bool)
    -> (Empty f -> Empty f -> Bool) -> Eq (Empty f)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (f :: k). Empty f -> Empty f -> Bool
    $c== :: forall k (f :: k). Empty f -> Empty f -> Bool
    == :: Empty f -> Empty f -> Bool
    $c/= :: forall k (f :: k). Empty f -> Empty f -> Bool
    /= :: Empty f -> Empty f -> Bool
    Eq, Eq (Empty f)
    Eq (Empty f) =>
    (Empty f -> Empty f -> Ordering)
    -> (Empty f -> Empty f -> Bool)
    -> (Empty f -> Empty f -> Bool)
    -> (Empty f -> Empty f -> Bool)
    -> (Empty f -> Empty f -> Bool)
    -> (Empty f -> Empty f -> Empty f)
    -> (Empty f -> Empty f -> Empty f)
    -> Ord (Empty f)
    Empty f -> Empty f -> Bool
    Empty f -> Empty f -> Ordering
    Empty f -> Empty f -> Empty f
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (f :: k). Eq (Empty f)
    forall k (f :: k). Empty f -> Empty f -> Bool
    forall k (f :: k). Empty f -> Empty f -> Ordering
    forall k (f :: k). Empty f -> Empty f -> Empty f
    $ccompare :: forall k (f :: k). Empty f -> Empty f -> Ordering
    compare :: Empty f -> Empty f -> Ordering
    $c< :: forall k (f :: k). Empty f -> Empty f -> Bool
    < :: Empty f -> Empty f -> Bool
    $c<= :: forall k (f :: k). Empty f -> Empty f -> Bool
    <= :: Empty f -> Empty f -> Bool
    $c> :: forall k (f :: k). Empty f -> Empty f -> Bool
    > :: Empty f -> Empty f -> Bool
    $c>= :: forall k (f :: k). Empty f -> Empty f -> Bool
    >= :: Empty f -> Empty f -> Bool
    $cmax :: forall k (f :: k). Empty f -> Empty f -> Empty f
    max :: Empty f -> Empty f -> Empty f
    $cmin :: forall k (f :: k). Empty f -> Empty f -> Empty f
    min :: Empty f -> Empty f -> Empty f
    Ord, Int -> Empty f -> ShowS
    [Empty f] -> ShowS
    Empty f -> String
    (Int -> Empty f -> ShowS)
    -> (Empty f -> String) -> ([Empty f] -> ShowS) -> Show (Empty f)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (f :: k). Int -> Empty f -> ShowS
    forall k (f :: k). [Empty f] -> ShowS
    forall k (f :: k). Empty f -> String
    $cshowsPrec :: forall k (f :: k). Int -> Empty f -> ShowS
    showsPrec :: Int -> Empty f -> ShowS
    $cshow :: forall k (f :: k). Empty f -> String
    show :: Empty f -> String
    $cshowList :: forall k (f :: k). [Empty f] -> ShowS
    showList :: [Empty f] -> ShowS
    Show)

    -- | A rank-2 tuple of only one element
    newtype Only a f = Only {forall {k} (a :: k) (f :: k -> *). Only a f -> f a
    fromOnly :: f a} deriving (Only a f -> Only a f -> Bool
    (Only a f -> Only a f -> Bool)
    -> (Only a f -> Only a f -> Bool) -> Eq (Only a f)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (a :: k) (f :: k -> *).
    Eq (f a) =>
    Only a f -> Only a f -> Bool
    $c== :: forall k (a :: k) (f :: k -> *).
    Eq (f a) =>
    Only a f -> Only a f -> Bool
    == :: Only a f -> Only a f -> Bool
    $c/= :: forall k (a :: k) (f :: k -> *).
    Eq (f a) =>
    Only a f -> Only a f -> Bool
    /= :: Only a f -> Only a f -> Bool
    Eq, Eq (Only a f)
    Eq (Only a f) =>
    (Only a f -> Only a f -> Ordering)
    -> (Only a f -> Only a f -> Bool)
    -> (Only a f -> Only a f -> Bool)
    -> (Only a f -> Only a f -> Bool)
    -> (Only a f -> Only a f -> Bool)
    -> (Only a f -> Only a f -> Only a f)
    -> (Only a f -> Only a f -> Only a f)
    -> Ord (Only a f)
    Only a f -> Only a f -> Bool
    Only a f -> Only a f -> Ordering
    Only a f -> Only a f -> Only a f
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (a :: k) (f :: k -> *). Ord (f a) => Eq (Only a f)
    forall k (a :: k) (f :: k -> *).
    Ord (f a) =>
    Only a f -> Only a f -> Bool
    forall k (a :: k) (f :: k -> *).
    Ord (f a) =>
    Only a f -> Only a f -> Ordering
    forall k (a :: k) (f :: k -> *).
    Ord (f a) =>
    Only a f -> Only a f -> Only a f
    $ccompare :: forall k (a :: k) (f :: k -> *).
    Ord (f a) =>
    Only a f -> Only a f -> Ordering
    compare :: Only a f -> Only a f -> Ordering
    $c< :: forall k (a :: k) (f :: k -> *).
    Ord (f a) =>
    Only a f -> Only a f -> Bool
    < :: Only a f -> Only a f -> Bool
    $c<= :: forall k (a :: k) (f :: k -> *).
    Ord (f a) =>
    Only a f -> Only a f -> Bool
    <= :: Only a f -> Only a f -> Bool
    $c> :: forall k (a :: k) (f :: k -> *).
    Ord (f a) =>
    Only a f -> Only a f -> Bool
    > :: Only a f -> Only a f -> Bool
    $c>= :: forall k (a :: k) (f :: k -> *).
    Ord (f a) =>
    Only a f -> Only a f -> Bool
    >= :: Only a f -> Only a f -> Bool
    $cmax :: forall k (a :: k) (f :: k -> *).
    Ord (f a) =>
    Only a f -> Only a f -> Only a f
    max :: Only a f -> Only a f -> Only a f
    $cmin :: forall k (a :: k) (f :: k -> *).
    Ord (f a) =>
    Only a f -> Only a f -> Only a f
    min :: Only a f -> Only a f -> Only a f
    Ord, Int -> Only a f -> ShowS
    [Only a f] -> ShowS
    Only a f -> String
    (Int -> Only a f -> ShowS)
    -> (Only a f -> String) -> ([Only a f] -> ShowS) -> Show (Only a f)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (a :: k) (f :: k -> *).
    Show (f a) =>
    Int -> Only a f -> ShowS
    forall k (a :: k) (f :: k -> *). Show (f a) => [Only a f] -> ShowS
    forall k (a :: k) (f :: k -> *). Show (f a) => Only a f -> String
    $cshowsPrec :: forall k (a :: k) (f :: k -> *).
    Show (f a) =>
    Int -> Only a f -> ShowS
    showsPrec :: Int -> Only a f -> ShowS
    $cshow :: forall k (a :: k) (f :: k -> *). Show (f a) => Only a f -> String
    show :: Only a f -> String
    $cshowList :: forall k (a :: k) (f :: k -> *). Show (f a) => [Only a f] -> ShowS
    showList :: [Only a f] -> ShowS
    Show)

    -- | Equivalent of 'Data.Functor.Identity' for rank 2 data types
    newtype Identity g f = Identity {forall {k} (g :: k -> *) (f :: k). Identity g f -> g f
    runIdentity :: g f} deriving (Identity g f -> Identity g f -> Bool
    (Identity g f -> Identity g f -> Bool)
    -> (Identity g f -> Identity g f -> Bool) -> Eq (Identity g f)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (g :: k -> *) (f :: k).
    Eq (g f) =>
    Identity g f -> Identity g f -> Bool
    $c== :: forall k (g :: k -> *) (f :: k).
    Eq (g f) =>
    Identity g f -> Identity g f -> Bool
    == :: Identity g f -> Identity g f -> Bool
    $c/= :: forall k (g :: k -> *) (f :: k).
    Eq (g f) =>
    Identity g f -> Identity g f -> Bool
    /= :: Identity g f -> Identity g f -> Bool
    Eq, Eq (Identity g f)
    Eq (Identity g f) =>
    (Identity g f -> Identity g f -> Ordering)
    -> (Identity g f -> Identity g f -> Bool)
    -> (Identity g f -> Identity g f -> Bool)
    -> (Identity g f -> Identity g f -> Bool)
    -> (Identity g f -> Identity g f -> Bool)
    -> (Identity g f -> Identity g f -> Identity g f)
    -> (Identity g f -> Identity g f -> Identity g f)
    -> Ord (Identity g f)
    Identity g f -> Identity g f -> Bool
    Identity g f -> Identity g f -> Ordering
    Identity g f -> Identity g f -> Identity g f
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (g :: k -> *) (f :: k). Ord (g f) => Eq (Identity g f)
    forall k (g :: k -> *) (f :: k).
    Ord (g f) =>
    Identity g f -> Identity g f -> Bool
    forall k (g :: k -> *) (f :: k).
    Ord (g f) =>
    Identity g f -> Identity g f -> Ordering
    forall k (g :: k -> *) (f :: k).
    Ord (g f) =>
    Identity g f -> Identity g f -> Identity g f
    $ccompare :: forall k (g :: k -> *) (f :: k).
    Ord (g f) =>
    Identity g f -> Identity g f -> Ordering
    compare :: Identity g f -> Identity g f -> Ordering
    $c< :: forall k (g :: k -> *) (f :: k).
    Ord (g f) =>
    Identity g f -> Identity g f -> Bool
    < :: Identity g f -> Identity g f -> Bool
    $c<= :: forall k (g :: k -> *) (f :: k).
    Ord (g f) =>
    Identity g f -> Identity g f -> Bool
    <= :: Identity g f -> Identity g f -> Bool
    $c> :: forall k (g :: k -> *) (f :: k).
    Ord (g f) =>
    Identity g f -> Identity g f -> Bool
    > :: Identity g f -> Identity g f -> Bool
    $c>= :: forall k (g :: k -> *) (f :: k).
    Ord (g f) =>
    Identity g f -> Identity g f -> Bool
    >= :: Identity g f -> Identity g f -> Bool
    $cmax :: forall k (g :: k -> *) (f :: k).
    Ord (g f) =>
    Identity g f -> Identity g f -> Identity g f
    max :: Identity g f -> Identity g f -> Identity g f
    $cmin :: forall k (g :: k -> *) (f :: k).
    Ord (g f) =>
    Identity g f -> Identity g f -> Identity g f
    min :: Identity g f -> Identity g f -> Identity g f
    Ord, Int -> Identity g f -> ShowS
    [Identity g f] -> ShowS
    Identity g f -> String
    (Int -> Identity g f -> ShowS)
    -> (Identity g f -> String)
    -> ([Identity g f] -> ShowS)
    -> Show (Identity g f)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (g :: k -> *) (f :: k).
    Show (g f) =>
    Int -> Identity g f -> ShowS
    forall k (g :: k -> *) (f :: k).
    Show (g f) =>
    [Identity g f] -> ShowS
    forall k (g :: k -> *) (f :: k).
    Show (g f) =>
    Identity g f -> String
    $cshowsPrec :: forall k (g :: k -> *) (f :: k).
    Show (g f) =>
    Int -> Identity g f -> ShowS
    showsPrec :: Int -> Identity g f -> ShowS
    $cshow :: forall k (g :: k -> *) (f :: k).
    Show (g f) =>
    Identity g f -> String
    show :: Identity g f -> String
    $cshowList :: forall k (g :: k -> *) (f :: k).
    Show (g f) =>
    [Identity g f] -> ShowS
    showList :: [Identity g f] -> ShowS
    Show)

    -- | Equivalent of 'Data.Functor.Compose' for rank 2 data types
    newtype Compose g p q = Compose {forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    Compose g p q -> g (Compose p q)
    getCompose :: g (Rank1.Compose p q)}

    deriving instance Eq (g (Rank1.Compose p q)) => Eq (Compose g p q)
    deriving instance Ord (g (Rank1.Compose p q)) => Ord (Compose g p q)
    deriving instance Show (g (Rank1.Compose p q)) => Show (Compose g p q)

    -- | A nested parametric type represented as a rank-2 type
    newtype Flip g a f = Flip {forall {k} {k} (g :: k -> *) (a :: k) (f :: k -> k).
    Flip g a f -> g (f a)
    unFlip :: g (f a)} deriving (Flip g a f -> Flip g a f -> Bool
    (Flip g a f -> Flip g a f -> Bool)
    -> (Flip g a f -> Flip g a f -> Bool) -> Eq (Flip g a f)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Eq (g (f a)) =>
    Flip g a f -> Flip g a f -> Bool
    $c== :: forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Eq (g (f a)) =>
    Flip g a f -> Flip g a f -> Bool
    == :: Flip g a f -> Flip g a f -> Bool
    $c/= :: forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Eq (g (f a)) =>
    Flip g a f -> Flip g a f -> Bool
    /= :: Flip g a f -> Flip g a f -> Bool
    Eq, Eq (Flip g a f)
    Eq (Flip g a f) =>
    (Flip g a f -> Flip g a f -> Ordering)
    -> (Flip g a f -> Flip g a f -> Bool)
    -> (Flip g a f -> Flip g a f -> Bool)
    -> (Flip g a f -> Flip g a f -> Bool)
    -> (Flip g a f -> Flip g a f -> Bool)
    -> (Flip g a f -> Flip g a f -> Flip g a f)
    -> (Flip g a f -> Flip g a f -> Flip g a f)
    -> Ord (Flip g a f)
    Flip g a f -> Flip g a f -> Bool
    Flip g a f -> Flip g a f -> Ordering
    Flip g a f -> Flip g a f -> Flip g a f
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Ord (g (f a)) =>
    Eq (Flip g a f)
    forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Ord (g (f a)) =>
    Flip g a f -> Flip g a f -> Bool
    forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Ord (g (f a)) =>
    Flip g a f -> Flip g a f -> Ordering
    forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Ord (g (f a)) =>
    Flip g a f -> Flip g a f -> Flip g a f
    $ccompare :: forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Ord (g (f a)) =>
    Flip g a f -> Flip g a f -> Ordering
    compare :: Flip g a f -> Flip g a f -> Ordering
    $c< :: forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Ord (g (f a)) =>
    Flip g a f -> Flip g a f -> Bool
    < :: Flip g a f -> Flip g a f -> Bool
    $c<= :: forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Ord (g (f a)) =>
    Flip g a f -> Flip g a f -> Bool
    <= :: Flip g a f -> Flip g a f -> Bool
    $c> :: forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Ord (g (f a)) =>
    Flip g a f -> Flip g a f -> Bool
    > :: Flip g a f -> Flip g a f -> Bool
    $c>= :: forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Ord (g (f a)) =>
    Flip g a f -> Flip g a f -> Bool
    >= :: Flip g a f -> Flip g a f -> Bool
    $cmax :: forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Ord (g (f a)) =>
    Flip g a f -> Flip g a f -> Flip g a f
    max :: Flip g a f -> Flip g a f -> Flip g a f
    $cmin :: forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Ord (g (f a)) =>
    Flip g a f -> Flip g a f -> Flip g a f
    min :: Flip g a f -> Flip g a f -> Flip g a f
    Ord, Int -> Flip g a f -> ShowS
    [Flip g a f] -> ShowS
    Flip g a f -> String
    (Int -> Flip g a f -> ShowS)
    -> (Flip g a f -> String)
    -> ([Flip g a f] -> ShowS)
    -> Show (Flip g a f)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Show (g (f a)) =>
    Int -> Flip g a f -> ShowS
    forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Show (g (f a)) =>
    [Flip g a f] -> ShowS
    forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Show (g (f a)) =>
    Flip g a f -> String
    $cshowsPrec :: forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Show (g (f a)) =>
    Int -> Flip g a f -> ShowS
    showsPrec :: Int -> Flip g a f -> ShowS
    $cshow :: forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Show (g (f a)) =>
    Flip g a f -> String
    show :: Flip g a f -> String
    $cshowList :: forall k (g :: k -> *) k (a :: k) (f :: k -> k).
    Show (g (f a)) =>
    [Flip g a f] -> ShowS
    showList :: [Flip g a f] -> ShowS
    Show)

    instance Semigroup (g (f a)) => Semigroup (Flip g a f) where
       Flip g (f a)
    x <> :: Flip g a f -> Flip g a f -> Flip g a f
    <> Flip g (f a)
    y = g (f a) -> Flip g a f
    forall {k} {k} (g :: k -> *) (a :: k) (f :: k -> k).
    g (f a) -> Flip g a f
    Flip (g (f a)
    x g (f a) -> g (f a) -> g (f a)
    forall a. Semigroup a => a -> a -> a
    <> g (f a)
    y)

    instance Monoid (g (f a)) => Monoid (Flip g a f) where
       mempty :: Flip g a f
    mempty = g (f a) -> Flip g a f
    forall {k} {k} (g :: k -> *) (a :: k) (f :: k -> k).
    g (f a) -> Flip g a f
    Flip g (f a)
    forall a. Monoid a => a
    mempty
       mappend :: Flip g a f -> Flip g a f -> Flip g a f
    mappend = Flip g a f -> Flip g a f -> Flip g a f
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance Rank1.Functor g => Rank2.Functor (Flip g a) where
       forall (a :: k). p a -> q a
    f <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> Flip g a p -> Flip g a q
    <$> Flip g (p a)
    g = g (q a) -> Flip g a q
    forall {k} {k} (g :: k -> *) (a :: k) (f :: k -> k).
    g (f a) -> Flip g a f
    Flip (p a -> q a
    forall (a :: k). p a -> q a
    f (p a -> q a) -> g (p a) -> g (q a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.<$> g (p a)
    g)

    instance Rank1.Applicative g => Rank2.Apply (Flip g a) where
       Flip g ((~>) p q a)
    g <*> :: forall (p :: k -> *) (q :: k -> *).
    Flip g a (p ~> q) -> Flip g a p -> Flip g a q
    <*> Flip g (p a)
    h = g (q a) -> Flip g a q
    forall {k} {k} (g :: k -> *) (a :: k) (f :: k -> k).
    g (f a) -> Flip g a f
    Flip ((~>) p q a -> p a -> q a
    forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    Arrow p q a -> p a -> q a
    apply ((~>) p q a -> p a -> q a) -> g ((~>) p q a) -> g (p a -> q a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.<$> g ((~>) p q a)
    g g (p a -> q a) -> g (p a) -> g (q a)
    forall a b. g (a -> b) -> g a -> g b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    Rank1.<*> g (p a)
    h)

    instance Rank1.Applicative g => Rank2.Applicative (Flip g a) where
       pure :: forall (f :: k -> *). (forall (a :: k). f a) -> Flip g a f
    pure forall (a :: k). f a
    f = g (f a) -> Flip g a f
    forall {k} {k} (g :: k -> *) (a :: k) (f :: k -> k).
    g (f a) -> Flip g a f
    Flip (f a -> g (f a)
    forall a. a -> g a
    forall (f :: * -> *) a. Applicative f => a -> f a
    Rank1.pure f a
    forall (a :: k). f a
    f)

    instance Rank1.Foldable g => Rank2.Foldable (Flip g a) where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> Flip g a p -> m
    foldMap forall (a :: k). p a -> m
    f (Flip g (p a)
    g) = (p a -> m) -> g (p a) -> m
    forall m a. Monoid m => (a -> m) -> g a -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    Rank1.foldMap p a -> m
    forall (a :: k). p a -> m
    f g (p a)
    g

    instance Rank1.Traversable g => Rank2.Traversable (Flip g a) where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> Flip g a p -> m (Flip g a q)
    traverse forall (a :: k). p a -> m (q a)
    f (Flip g (p a)
    g) = g (q a) -> Flip g a q
    forall {k} {k} (g :: k -> *) (a :: k) (f :: k -> k).
    g (f a) -> Flip g a f
    Flip (g (q a) -> Flip g a q) -> m (g (q a)) -> m (Flip g a q)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.<$> (p a -> m (q a)) -> g (p a) -> m (g (q a))
    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) -> g a -> f (g b)
    Rank1.traverse p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f g (p a)
    g

    instance Functor Empty where
       forall (a :: k). p a -> q a
    _ <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> Empty p -> Empty q
    <$> Empty p
    _ = Empty q
    forall {k} (f :: k). Empty f
    Empty

    instance Functor Proxy where
       forall (a :: k). p a -> q a
    _ <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> Proxy p -> Proxy q
    <$> Proxy p
    _ = Proxy q
    forall {k} (t :: k). Proxy t
    Proxy

    instance Functor (Const a) where
       forall (a :: k). p a -> q a
    _ <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> Const a p -> Const a q
    <$> Const a
    a = a -> Const a q
    forall {k} a (b :: k). a -> Const a b
    Const a
    a

    instance Functor (Only a) where
       forall (a :: k). p a -> q a
    f <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> Only a p -> Only a q
    <$> Only p a
    a = q a -> Only a q
    forall {k} (a :: k) (f :: k -> *). f a -> Only a f
    Only (p a -> q a
    forall (a :: k). p a -> q a
    f p a
    a)

    instance Functor g => Functor (Identity g) where
       forall (a :: k). p a -> q a
    f <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> Identity g p -> Identity g q
    <$> Identity g p
    g = g q -> Identity g q
    forall {k} (g :: k -> *) (f :: k). g f -> Identity g f
    Identity (p a -> q a
    forall (a :: k). p a -> q a
    f (forall (a :: k). p a -> q a) -> g p -> g q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> g p -> g q
    <$> g p
    g)

    instance (Functor g, Rank1.Functor p) => Functor (Compose g p) where
       (<$>) :: forall q r. (forall a. q a -> r a) -> Compose g p q -> Compose g p r
       forall (a :: k). q a -> r a
    f <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> Compose g p p -> Compose g p q
    <$> Compose g (Compose p q)
    g = g (Compose p r) -> Compose g p r
    forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    g (Compose p q) -> Compose g p q
    Compose (Compose p q a -> Compose p r a
    forall (a :: k). Compose p q a -> Compose p r a
    f' (forall (a :: k). Compose p q a -> Compose p r a)
    -> g (Compose p q) -> g (Compose p r)
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> g p -> g q
    <$> g (Compose p q)
    g)
          where f' :: forall a. Rank1.Compose p q a -> Rank1.Compose p r a
                f' :: forall (a :: k). Compose p q a -> Compose p r a
    f' (Rank1.Compose p (q a)
    q) = p (r a) -> Compose p r a
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose (q a -> r a
    forall (a :: k). q a -> r a
    f (q a -> r a) -> p (q a) -> p (r a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.<$> p (q a)
    q)

    instance (Functor g, Functor h) => Functor (Product g h) where
       forall (a :: k). p a -> q a
    f <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> Product g h p -> Product g h q
    <$> Pair g p
    a h p
    b = g q -> h q -> Product g h q
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair (p a -> q a
    forall (a :: k). p a -> q a
    f (forall (a :: k). p a -> q a) -> g p -> g q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> g p -> g q
    <$> g p
    a) (p a -> q a
    forall (a :: k). p a -> q a
    f (forall (a :: k). p a -> q a) -> h p -> h q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> h p -> h q
    <$> h p
    b)

    instance (Functor g, Functor h) => Functor (Sum g h) where
       forall (a :: k). p a -> q a
    f <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> Sum g h p -> Sum g h q
    <$> InL g p
    g = g q -> Sum g h q
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k). f a -> Sum f g a
    InL (p a -> q a
    forall (a :: k). p a -> q a
    f (forall (a :: k). p a -> q a) -> g p -> g q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> g p -> g q
    <$> g p
    g)
       forall (a :: k). p a -> q a
    f <$> InR h p
    h = h q -> Sum g h q
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k). g a -> Sum f g a
    InR (p a -> q a
    forall (a :: k). p a -> q a
    f (forall (a :: k). p a -> q a) -> h p -> h q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> h p -> h q
    <$> h p
    h)

    instance Functor Generics.V1 where
       <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> V1 p -> V1 q
    (<$>) forall (a :: k). p a -> q a
    _ = V1 p -> V1 q
    forall a b. Coercible a b => a -> b
    coerce

    instance Functor Generics.U1 where
       <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> U1 p -> U1 q
    (<$>) forall (a :: k). p a -> q a
    _ = U1 p -> U1 q
    forall a b. Coercible a b => a -> b
    coerce

    instance Functor (Generics.K1 i c) where
       <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> K1 i c p -> K1 i c q
    (<$>) forall (a :: k). p a -> q a
    _ = K1 i c p -> K1 i c q
    forall a b. Coercible a b => a -> b
    coerce

    instance Functor f => Functor (Generics.M1 i c f) where
       forall (a :: k). p a -> q a
    f <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> M1 i c f p -> M1 i c f q
    <$> Generics.M1 f p
    x = f q -> M1 i c f q
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    Generics.M1 (p a -> q a
    forall (a :: k). p a -> q a
    f (forall (a :: k). p a -> q a) -> f p -> f q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> f p -> f q
    <$> f p
    x)

    instance Functor f => Functor (Generics.Rec1 f) where
       forall (a :: k). p a -> q a
    f <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> Rec1 f p -> Rec1 f q
    <$> Generics.Rec1 f p
    x = f q -> Rec1 f q
    forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
    Generics.Rec1 (p a -> q a
    forall (a :: k). p a -> q a
    f (forall (a :: k). p a -> q a) -> f p -> f q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> f p -> f q
    <$> f p
    x)

    -- instance (Rank1.Functor f, Functor g) => Functor ((Generics.:.:) f g) where
    --    f <$> Generics.Comp1 x = Generics.Comp1 (Rank1.fmap (f <$>) x)

    instance (Functor f, Functor g) => Functor ((Generics.:+:) f g) where
       forall (a :: k). p a -> q a
    f <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> (:+:) f g p -> (:+:) f g q
    <$> Generics.L1 f p
    x = f q -> (:+:) f g q
    forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
    Generics.L1 (p a -> q a
    forall (a :: k). p a -> q a
    f (forall (a :: k). p a -> q a) -> f p -> f q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> f p -> f q
    <$> f p
    x)
       forall (a :: k). p a -> q a
    f <$> Generics.R1 g p
    x = g q -> (:+:) f g q
    forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
    Generics.R1 (p a -> q a
    forall (a :: k). p a -> q a
    f (forall (a :: k). p a -> q a) -> g p -> g q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> g p -> g q
    <$> g p
    x)

    instance (Functor f, Functor g) => Functor ((Generics.:*:) f g) where
       forall (a :: k). p a -> q a
    f <$> :: forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> (:*:) f g p -> (:*:) f g q
    <$> (f p
    x Generics.:*: g p
    y) = (p a -> q a
    forall (a :: k). p a -> q a
    f (forall (a :: k). p a -> q a) -> f p -> f q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> f p -> f q
    <$> f p
    x) f q -> g q -> (:*:) f g q
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    Generics.:*: (p a -> q a
    forall (a :: k). p a -> q a
    f (forall (a :: k). p a -> q a) -> g p -> g q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *).
    (forall (a :: k). p a -> q a) -> g p -> g q
    <$> g p
    y)

    instance Foldable Empty where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> Empty p -> m
    foldMap forall (a :: k). p a -> m
    _ Empty p
    _ = m
    forall a. Monoid a => a
    mempty

    instance Foldable Proxy where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> Proxy p -> m
    foldMap forall (a :: k). p a -> m
    _ Proxy p
    _ = m
    forall a. Monoid a => a
    mempty

    instance Foldable (Const x) where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> Const x p -> m
    foldMap forall (a :: k). p a -> m
    _ Const x p
    _ = m
    forall a. Monoid a => a
    mempty

    instance Foldable (Only x) where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> Only x p -> m
    foldMap forall (a :: k). p a -> m
    f (Only p x
    x) = p x -> m
    forall (a :: k). p a -> m
    f p x
    x

    instance Foldable g => Foldable (Identity g) where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> Identity g p -> m
    foldMap forall (a :: k). p a -> m
    f (Identity g p
    g) = (forall (a :: k). p a -> m) -> g p -> m
    forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> g p -> m
    forall {k} (g :: (k -> *) -> *) m (p :: k -> *).
    (Foldable g, Monoid m) =>
    (forall (a :: k). p a -> m) -> g p -> m
    foldMap p a -> m
    forall (a :: k). p a -> m
    f g p
    g

    instance (Foldable g, Rank1.Foldable p) => Foldable (Compose g p) where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> Compose g p p -> m
    foldMap forall (a :: k). p a -> m
    f (Compose g (Compose p p)
    g) = (forall (a :: k). Compose p p a -> m) -> g (Compose p p) -> m
    forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> g p -> m
    forall {k} (g :: (k -> *) -> *) m (p :: k -> *).
    (Foldable g, Monoid m) =>
    (forall (a :: k). p a -> m) -> g p -> m
    foldMap ((p a -> m) -> p (p a) -> m
    forall m a. Monoid m => (a -> m) -> p a -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    Rank1.foldMap p a -> m
    forall (a :: k). p a -> m
    f (p (p a) -> m) -> (Compose p p a -> p (p a)) -> Compose p p a -> m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Compose p p a -> p (p a)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    Rank1.getCompose) g (Compose p p)
    g

    instance (Foldable g, Foldable h) => Foldable (Product g h) where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> Product g h p -> m
    foldMap forall (a :: k). p a -> m
    f (Pair g p
    g h p
    h) = (forall (a :: k). p a -> m) -> g p -> m
    forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> g p -> m
    forall {k} (g :: (k -> *) -> *) m (p :: k -> *).
    (Foldable g, Monoid m) =>
    (forall (a :: k). p a -> m) -> g p -> m
    foldMap p a -> m
    forall (a :: k). p a -> m
    f g p
    g m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` (forall (a :: k). p a -> m) -> h p -> m
    forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> h p -> m
    forall {k} (g :: (k -> *) -> *) m (p :: k -> *).
    (Foldable g, Monoid m) =>
    (forall (a :: k). p a -> m) -> g p -> m
    foldMap p a -> m
    forall (a :: k). p a -> m
    f h p
    h

    instance (Foldable g, Foldable h) => Foldable (Sum g h) where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> Sum g h p -> m
    foldMap forall (a :: k). p a -> m
    f (InL g p
    g) = (forall (a :: k). p a -> m) -> g p -> m
    forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> g p -> m
    forall {k} (g :: (k -> *) -> *) m (p :: k -> *).
    (Foldable g, Monoid m) =>
    (forall (a :: k). p a -> m) -> g p -> m
    foldMap p a -> m
    forall (a :: k). p a -> m
    f g p
    g
       foldMap forall (a :: k). p a -> m
    f (InR h p
    h) = (forall (a :: k). p a -> m) -> h p -> m
    forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> h p -> m
    forall {k} (g :: (k -> *) -> *) m (p :: k -> *).
    (Foldable g, Monoid m) =>
    (forall (a :: k). p a -> m) -> g p -> m
    foldMap p a -> m
    forall (a :: k). p a -> m
    f h p
    h

    instance Foldable Generics.V1 where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> V1 p -> m
    foldMap forall (a :: k). p a -> m
    _ V1 p
    v = case V1 p
    v of {}

    instance Foldable Generics.U1 where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> U1 p -> m
    foldMap forall (a :: k). p a -> m
    _ U1 p
    _ = m
    forall a. Monoid a => a
    mempty

    instance Foldable (Generics.K1 i c) where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> K1 i c p -> m
    foldMap forall (a :: k). p a -> m
    _ K1 i c p
    _ = m
    forall a. Monoid a => a
    mempty

    instance Foldable f => Foldable (Generics.M1 i c f) where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> M1 i c f p -> m
    foldMap forall (a :: k). p a -> m
    f (Generics.M1 f p
    x) = (forall (a :: k). p a -> m) -> f p -> m
    forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> f p -> m
    forall {k} (g :: (k -> *) -> *) m (p :: k -> *).
    (Foldable g, Monoid m) =>
    (forall (a :: k). p a -> m) -> g p -> m
    foldMap p a -> m
    forall (a :: k). p a -> m
    f f p
    x

    instance Foldable f => Foldable (Generics.Rec1 f) where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> Rec1 f p -> m
    foldMap forall (a :: k). p a -> m
    f (Generics.Rec1 f p
    x) = (forall (a :: k). p a -> m) -> f p -> m
    forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> f p -> m
    forall {k} (g :: (k -> *) -> *) m (p :: k -> *).
    (Foldable g, Monoid m) =>
    (forall (a :: k). p a -> m) -> g p -> m
    foldMap p a -> m
    forall (a :: k). p a -> m
    f f p
    x

    instance (Foldable f, Foldable g) => Foldable ((Generics.:+:) f g) where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> (:+:) f g p -> m
    foldMap forall (a :: k). p a -> m
    f (Generics.L1 f p
    x) = (forall (a :: k). p a -> m) -> f p -> m
    forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> f p -> m
    forall {k} (g :: (k -> *) -> *) m (p :: k -> *).
    (Foldable g, Monoid m) =>
    (forall (a :: k). p a -> m) -> g p -> m
    foldMap p a -> m
    forall (a :: k). p a -> m
    f f p
    x
       foldMap forall (a :: k). p a -> m
    f (Generics.R1 g p
    x) = (forall (a :: k). p a -> m) -> g p -> m
    forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> g p -> m
    forall {k} (g :: (k -> *) -> *) m (p :: k -> *).
    (Foldable g, Monoid m) =>
    (forall (a :: k). p a -> m) -> g p -> m
    foldMap p a -> m
    forall (a :: k). p a -> m
    f g p
    x

    instance (Foldable f, Foldable g) => Foldable ((Generics.:*:) f g) where
       foldMap :: forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> (:*:) f g p -> m
    foldMap forall (a :: k). p a -> m
    f (f p
    x Generics.:*: g p
    y) = (forall (a :: k). p a -> m) -> f p -> m
    forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> f p -> m
    forall {k} (g :: (k -> *) -> *) m (p :: k -> *).
    (Foldable g, Monoid m) =>
    (forall (a :: k). p a -> m) -> g p -> m
    foldMap p a -> m
    forall (a :: k). p a -> m
    f f p
    x m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` (forall (a :: k). p a -> m) -> g p -> m
    forall m (p :: k -> *).
    Monoid m =>
    (forall (a :: k). p a -> m) -> g p -> m
    forall {k} (g :: (k -> *) -> *) m (p :: k -> *).
    (Foldable g, Monoid m) =>
    (forall (a :: k). p a -> m) -> g p -> m
    foldMap p a -> m
    forall (a :: k). p a -> m
    f g p
    y

    instance Traversable Empty where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> Empty p -> m (Empty q)
    traverse forall (a :: k). p a -> m (q a)
    _ Empty p
    _ = Empty q -> m (Empty q)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    Rank1.pure Empty q
    forall {k} (f :: k). Empty f
    Empty

    instance Traversable Proxy where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> Proxy p -> m (Proxy q)
    traverse forall (a :: k). p a -> m (q a)
    _ Proxy p
    _ = Proxy q -> m (Proxy q)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    Rank1.pure Proxy q
    forall {k} (t :: k). Proxy t
    Proxy

    instance Traversable (Const x) where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> Const x p -> m (Const x q)
    traverse forall (a :: k). p a -> m (q a)
    _ (Const x
    x) = Const x q -> m (Const x q)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    Rank1.pure (x -> Const x q
    forall {k} a (b :: k). a -> Const a b
    Const x
    x)

    instance Traversable (Only x) where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> Only x p -> m (Only x q)
    traverse forall (a :: k). p a -> m (q a)
    f (Only p x
    x) = q x -> Only x q
    forall {k} (a :: k) (f :: k -> *). f a -> Only a f
    Only (q x -> Only x q) -> m (q x) -> m (Only x q)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.<$> p x -> m (q x)
    forall (a :: k). p a -> m (q a)
    f p x
    x

    instance Traversable g => Traversable (Identity g) where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a))
    -> Identity g p -> m (Identity g q)
    traverse forall (a :: k). p a -> m (q a)
    f (Identity g p
    g) = g q -> Identity g q
    forall {k} (g :: k -> *) (f :: k). g f -> Identity g f
    Identity (g q -> Identity g q) -> m (g q) -> m (Identity g q)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.<$> (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    traverse p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f g p
    g

    instance (Traversable g, Rank1.Traversable p) => Traversable (Compose g p) where
       traverse :: forall m q r. Rank1.Applicative m => (forall a. q a -> m (r a)) -> Compose g p q -> m (Compose g p r)
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a))
    -> Compose g p p -> m (Compose g p q)
    traverse forall (a :: k). q a -> m (r a)
    f (Compose g (Compose p q)
    g) = g (Compose p r) -> Compose g p r
    forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    g (Compose p q) -> Compose g p q
    Compose (g (Compose p r) -> Compose g p r)
    -> m (g (Compose p r)) -> m (Compose g p r)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.<$> (forall (a :: k). Compose p q a -> m (Compose p r a))
    -> g (Compose p q) -> m (g (Compose p r))
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    traverse Compose p q a -> m (Compose p r a)
    forall (a :: k). Compose p q a -> m (Compose p r a)
    f' g (Compose p q)
    g
          where f' :: forall a. Rank1.Compose p q a -> m (Rank1.Compose p r a)
                f' :: forall (a :: k). Compose p q a -> m (Compose p r a)
    f' (Rank1.Compose p (q a)
    q) = p (r a) -> Compose p r a
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose (p (r a) -> Compose p r a) -> m (p (r a)) -> m (Compose p r a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.<$> (q a -> m (r a)) -> p (q a) -> m (p (r a))
    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) -> p a -> f (p b)
    Rank1.traverse q a -> m (r a)
    forall (a :: k). q a -> m (r a)
    f p (q a)
    q

    instance (Traversable g, Traversable h) => Traversable (Product g h) where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a))
    -> Product g h p -> m (Product g h q)
    traverse forall (a :: k). p a -> m (q a)
    f (Pair g p
    g h p
    h) = (g q -> h q -> Product g h q)
    -> m (g q) -> m (h q) -> m (Product g h q)
    forall a b c. (a -> b -> c) -> m a -> m b -> m c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    Rank1.liftA2 g q -> h q -> Product g h q
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair ((forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    traverse p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f g p
    g) ((forall (a :: k). p a -> m (q a)) -> h p -> m (h q)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> h p -> m (h q)
    traverse p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f h p
    h)

    instance (Traversable g, Traversable h) => Traversable (Sum g h) where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> Sum g h p -> m (Sum g h q)
    traverse forall (a :: k). p a -> m (q a)
    f (InL g p
    g) = g q -> Sum g h q
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k). f a -> Sum f g a
    InL (g q -> Sum g h q) -> m (g q) -> m (Sum g h q)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.<$> (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    traverse p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f g p
    g
       traverse forall (a :: k). p a -> m (q a)
    f (InR h p
    h) = h q -> Sum g h q
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k). g a -> Sum f g a
    InR (h q -> Sum g h q) -> m (h q) -> m (Sum g h q)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.<$> (forall (a :: k). p a -> m (q a)) -> h p -> m (h q)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> h p -> m (h q)
    traverse p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f h p
    h

    instance Traversable Generics.V1 where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> V1 p -> m (V1 q)
    traverse forall (a :: k). p a -> m (q a)
    _ = V1 q -> m (V1 q)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    Rank1.pure (V1 q -> m (V1 q)) -> (V1 p -> V1 q) -> V1 p -> m (V1 q)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . V1 p -> V1 q
    forall a b. Coercible a b => a -> b
    coerce

    instance Traversable Generics.U1 where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> U1 p -> m (U1 q)
    traverse forall (a :: k). p a -> m (q a)
    _ = U1 q -> m (U1 q)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    Rank1.pure (U1 q -> m (U1 q)) -> (U1 p -> U1 q) -> U1 p -> m (U1 q)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . U1 p -> U1 q
    forall a b. Coercible a b => a -> b
    coerce

    instance Traversable (Generics.K1 i c) where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> K1 i c p -> m (K1 i c q)
    traverse forall (a :: k). p a -> m (q a)
    _ = K1 i c q -> m (K1 i c q)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    Rank1.pure (K1 i c q -> m (K1 i c q))
    -> (K1 i c p -> K1 i c q) -> K1 i c p -> m (K1 i c q)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . K1 i c p -> K1 i c q
    forall a b. Coercible a b => a -> b
    coerce

    instance Traversable f => Traversable (Generics.M1 i c f) where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> M1 i c f p -> m (M1 i c f q)
    traverse forall (a :: k). p a -> m (q a)
    f (Generics.M1 f p
    x) = (f q -> M1 i c f q) -> m (f q) -> m (M1 i c f q)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap f q -> M1 i c f q
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    Generics.M1 ((forall (a :: k). p a -> m (q a)) -> f p -> m (f q)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> f p -> m (f q)
    traverse p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f f p
    x)

    instance Traversable f => Traversable (Generics.Rec1 f) where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> Rec1 f p -> m (Rec1 f q)
    traverse forall (a :: k). p a -> m (q a)
    f (Generics.Rec1 f p
    x) = (f q -> Rec1 f q) -> m (f q) -> m (Rec1 f q)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap f q -> Rec1 f q
    forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
    Generics.Rec1 ((forall (a :: k). p a -> m (q a)) -> f p -> m (f q)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> f p -> m (f q)
    traverse p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f f p
    x)

    instance (Traversable f, Traversable g) => Traversable ((Generics.:+:) f g) where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> (:+:) f g p -> m ((:+:) f g q)
    traverse forall (a :: k). p a -> m (q a)
    f (Generics.L1 f p
    x) = (f q -> (:+:) f g q) -> m (f q) -> m ((:+:) f g q)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap f q -> (:+:) f g q
    forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
    Generics.L1 ((forall (a :: k). p a -> m (q a)) -> f p -> m (f q)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> f p -> m (f q)
    traverse p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f f p
    x)
       traverse forall (a :: k). p a -> m (q a)
    f (Generics.R1 g p
    x) = (g q -> (:+:) f g q) -> m (g q) -> m ((:+:) f g q)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap g q -> (:+:) f g q
    forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
    Generics.R1 ((forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    traverse p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f g p
    x)

    instance (Traversable f, Traversable g) => Traversable ((Generics.:*:) f g) where
       traverse :: forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> (:*:) f g p -> m ((:*:) f g q)
    traverse forall (a :: k). p a -> m (q a)
    f (f p
    x Generics.:*: g p
    y) = (f q -> g q -> (:*:) f g q)
    -> m (f q) -> m (g q) -> m ((:*:) f g q)
    forall a b c. (a -> b -> c) -> m a -> m b -> m c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    Rank1.liftA2 f q -> g q -> (:*:) f g q
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    (Generics.:*:) ((forall (a :: k). p a -> m (q a)) -> f p -> m (f q)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> f p -> m (f q)
    traverse p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f f p
    x) ((forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall {k} (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
           (q :: k -> *).
    (Traversable g, Applicative m) =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    forall (m :: * -> *) (p :: k -> *) (q :: k -> *).
    Applicative m =>
    (forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
    traverse p a -> m (q a)
    forall (a :: k). p a -> m (q a)
    f g p
    y)

    instance Apply Empty where
       Empty (p ~> q)
    _ <*> :: forall (p :: k -> *) (q :: k -> *).
    Empty (p ~> q) -> Empty p -> Empty q
    <*> Empty p
    _ = Empty q
    forall {k} (f :: k). Empty f
    Empty
       liftA2 :: forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a)
    -> Empty p -> Empty q -> Empty r
    liftA2 forall (a :: k). p a -> q a -> r a
    _ Empty p
    _ Empty q
    _ = Empty r
    forall {k} (f :: k). Empty f
    Empty

    instance Apply Proxy where
       Proxy (p ~> q)
    _ <*> :: forall (p :: k -> *) (q :: k -> *).
    Proxy (p ~> q) -> Proxy p -> Proxy q
    <*> Proxy p
    _ = Proxy q
    forall {k} (t :: k). Proxy t
    Proxy
       liftA2 :: forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a)
    -> Proxy p -> Proxy q -> Proxy r
    liftA2 forall (a :: k). p a -> q a -> r a
    _ Proxy p
    _ Proxy q
    _ = Proxy r
    forall {k} (t :: k). Proxy t
    Proxy

    instance Semigroup x => Apply (Const x) where
       Const x
    x <*> :: forall (p :: k -> *) (q :: k -> *).
    Const x (p ~> q) -> Const x p -> Const x q
    <*> Const x
    y = x -> Const x q
    forall {k} a (b :: k). a -> Const a b
    Const (x
    x x -> x -> x
    forall a. Semigroup a => a -> a -> a
    <> x
    y)
       liftA2 :: forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a)
    -> Const x p -> Const x q -> Const x r
    liftA2 forall (a :: k). p a -> q a -> r a
    _ (Const x
    x) (Const x
    y) = x -> Const x r
    forall {k} a (b :: k). a -> Const a b
    Const (x
    x x -> x -> x
    forall a. Semigroup a => a -> a -> a
    <> x
    y)

    instance Apply (Only x) where
       Only (~>) p q x
    f <*> :: forall (p :: k -> *) (q :: k -> *).
    Only x (p ~> q) -> Only x p -> Only x q
    <*> Only p x
    x = q x -> Only x q
    forall {k} (a :: k) (f :: k -> *). f a -> Only a f
    Only ((~>) p q x -> p x -> q x
    forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    Arrow p q a -> p a -> q a
    apply (~>) p q x
    f p x
    x)
       liftA2 :: forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a)
    -> Only x p -> Only x q -> Only x r
    liftA2 forall (a :: k). p a -> q a -> r a
    f (Only p x
    x) (Only q x
    y) = r x -> Only x r
    forall {k} (a :: k) (f :: k -> *). f a -> Only a f
    Only (p x -> q x -> r x
    forall (a :: k). p a -> q a -> r a
    f p x
    x q x
    y)

    instance Apply g => Apply (Identity g) where
       Identity g (p ~> q)
    g <*> :: forall (p :: k -> *) (q :: k -> *).
    Identity g (p ~> q) -> Identity g p -> Identity g q
    <*> Identity g p
    h = g q -> Identity g q
    forall {k} (g :: k -> *) (f :: k). g f -> Identity g f
    Identity (g (p ~> q)
    g g (p ~> q) -> g p -> g q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *). g (p ~> q) -> g p -> g q
    <*> g p
    h)
       liftA2 :: forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a)
    -> Identity g p -> Identity g q -> Identity g r
    liftA2 forall (a :: k). p a -> q a -> r a
    f (Identity g p
    g) (Identity g q
    h) = g r -> Identity g r
    forall {k} (g :: k -> *) (f :: k). g f -> Identity g f
    Identity ((forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    liftA2 p a -> q a -> r a
    forall (a :: k). p a -> q a -> r a
    f g p
    g g q
    h)

    instance (Apply g, Rank1.Applicative p) => Apply (Compose g p) where
       (<*>)  :: forall q r. Compose g p (q ~> r) -> Compose g p q -> Compose g p r
       liftA2 :: forall q r s. (forall a. q a -> r a -> s a) -> Compose g p q -> Compose g p r -> Compose g p s
       Compose g (Compose p (q ~> r))
    g <*> :: forall (p :: k -> *) (q :: k -> *).
    Compose g p (p ~> q) -> Compose g p p -> Compose g p q
    <*> Compose g (Compose p q)
    h = g (Compose p r) -> Compose g p r
    forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    g (Compose p q) -> Compose g p q
    Compose ((forall (a :: k).
     Compose p (q ~> r) a -> Compose p q a -> Compose p r a)
    -> g (Compose p (q ~> r)) -> g (Compose p q) -> g (Compose p r)
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    liftA2 Compose p (q ~> r) a -> Compose p q a -> Compose p r a
    forall (a :: k).
    Compose p (q ~> r) a -> Compose p q a -> Compose p r a
    f' g (Compose p (q ~> r))
    g g (Compose p q)
    h)
          where f' :: forall a. Rank1.Compose p (q ~> r) a -> Rank1.Compose p q a -> Rank1.Compose p r a
                f' :: forall (a :: k).
    Compose p (q ~> r) a -> Compose p q a -> Compose p r a
    f' (Rank1.Compose p ((~>) q r a)
    f) (Rank1.Compose p (q a)
    q) = p (r a) -> Compose p r a
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose (((~>) q r a -> q a -> r a) -> p ((~>) q r a) -> p (q a) -> p (r a)
    forall a b c. (a -> b -> c) -> p a -> p b -> p c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    Rank1.liftA2 (~>) q r a -> q a -> r a
    forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    Arrow p q a -> p a -> q a
    apply p ((~>) q r a)
    f p (q a)
    q)
       liftA2 :: forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a)
    -> Compose g p p -> Compose g p q -> Compose g p r
    liftA2 forall (a :: k). q a -> r a -> s a
    f (Compose g (Compose p q)
    g) (Compose g (Compose p r)
    h) = g (Compose p s) -> Compose g p s
    forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    g (Compose p q) -> Compose g p q
    Compose ((forall (a :: k). Compose p q a -> Compose p r a -> Compose p s a)
    -> g (Compose p q) -> g (Compose p r) -> g (Compose p s)
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    liftA2 Compose p q a -> Compose p r a -> Compose p s a
    forall (a :: k). Compose p q a -> Compose p r a -> Compose p s a
    f' g (Compose p q)
    g g (Compose p r)
    h)
          where f' :: forall a. Rank1.Compose p q a -> Rank1.Compose p r a -> Rank1.Compose p s a
                f' :: forall (a :: k). Compose p q a -> Compose p r a -> Compose p s a
    f' (Rank1.Compose p (q a)
    q) (Rank1.Compose p (r a)
    r) = p (s a) -> Compose p s a
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose ((q a -> r a -> s a) -> p (q a) -> p (r a) -> p (s a)
    forall a b c. (a -> b -> c) -> p a -> p b -> p c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    Rank1.liftA2 q a -> r a -> s a
    forall (a :: k). q a -> r a -> s a
    f p (q a)
    q p (r a)
    r)

    instance (Apply g, Apply h) => Apply (Product g h) where
       Pair g (p ~> q)
    gf h (p ~> q)
    hf <*> :: forall (p :: k -> *) (q :: k -> *).
    Product g h (p ~> q) -> Product g h p -> Product g h q
    <*> ~(Pair g p
    gx h p
    hx) = g q -> h q -> Product g h q
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair (g (p ~> q)
    gf g (p ~> q) -> g p -> g q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *). g (p ~> q) -> g p -> g q
    <*> g p
    gx) (h (p ~> q)
    hf h (p ~> q) -> h p -> h q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *). h (p ~> q) -> h p -> h q
    <*> h p
    hx)
       liftA2 :: forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a)
    -> Product g h p -> Product g h q -> Product g h r
    liftA2 forall (a :: k). p a -> q a -> r a
    f (Pair g p
    g1 h p
    h1) ~(Pair g q
    g2 h q
    h2) = g r -> h r -> Product g h r
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair ((forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    liftA2 p a -> q a -> r a
    forall (a :: k). p a -> q a -> r a
    f g p
    g1 g q
    g2) ((forall (a :: k). p a -> q a -> r a) -> h p -> h q -> h r
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *).
    (forall (a :: k). p a -> q a -> r a) -> h p -> h q -> h r
    liftA2 p a -> q a -> r a
    forall (a :: k). p a -> q a -> r a
    f h p
    h1 h q
    h2)
       liftA3 :: forall (p :: k -> *) (q :: k -> *) (r :: k -> *) (s :: k -> *).
    (forall (a :: k). p a -> q a -> r a -> s a)
    -> Product g h p -> Product g h q -> Product g h r -> Product g h s
    liftA3 forall (a :: k). p a -> q a -> r a -> s a
    f (Pair g p
    g1 h p
    h1) ~(Pair g q
    g2 h q
    h2) ~(Pair g r
    g3 h r
    h3) = g s -> h s -> Product g h s
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair ((forall (a :: k). p a -> q a -> r a -> s a)
    -> g p -> g q -> g r -> g s
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *) (s :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a -> s a)
    -> g p -> g q -> g r -> g s
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *) (s :: k -> *).
    (forall (a :: k). p a -> q a -> r a -> s a)
    -> g p -> g q -> g r -> g s
    liftA3 p a -> q a -> r a -> s a
    forall (a :: k). p a -> q a -> r a -> s a
    f g p
    g1 g q
    g2 g r
    g3) ((forall (a :: k). p a -> q a -> r a -> s a)
    -> h p -> h q -> h r -> h s
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
           (r :: k -> *) (s :: k -> *).
    Apply g =>
    (forall (a :: k). p a -> q a -> r a -> s a)
    -> g p -> g q -> g r -> g s
    forall (p :: k -> *) (q :: k -> *) (r :: k -> *) (s :: k -> *).
    (forall (a :: k). p a -> q a -> r a -> s a)
    -> h p -> h q -> h r -> h s
    liftA3 p a -> q a -> r a -> s a
    forall (a :: k). p a -> q a -> r a -> s a
    f h p
    h1 h q
    h2 h r
    h3)

    instance Apply Generics.V1 where
       <*> :: forall (p :: k -> *) (q :: k -> *). V1 (p ~> q) -> V1 p -> V1 q
    (<*>) V1 (p ~> q)
    _ = V1 p -> V1 q
    forall a b. Coercible a b => a -> b
    coerce

    instance Apply Generics.U1 where
       <*> :: forall (p :: k -> *) (q :: k -> *). U1 (p ~> q) -> U1 p -> U1 q
    (<*>) U1 (p ~> q)
    _ = U1 p -> U1 q
    forall a b. Coercible a b => a -> b
    coerce

    instance Semigroup c => Apply (Generics.K1 i c) where
       Generics.K1 c
    x <*> :: forall (p :: k -> *) (q :: k -> *).
    K1 i c (p ~> q) -> K1 i c p -> K1 i c q
    <*> Generics.K1 c
    y = c -> K1 i c q
    forall k i c (p :: k). c -> K1 i c p
    Generics.K1 (c
    x c -> c -> c
    forall a. Semigroup a => a -> a -> a
    <> c
    y)

    instance Apply f => Apply (Generics.M1 i c f) where
       Generics.M1 f (p ~> q)
    f <*> :: forall (p :: k -> *) (q :: k -> *).
    M1 i c f (p ~> q) -> M1 i c f p -> M1 i c f q
    <*> Generics.M1 f p
    x = f q -> M1 i c f q
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    Generics.M1 (f (p ~> q)
    f f (p ~> q) -> f p -> f q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *). f (p ~> q) -> f p -> f q
    <*> f p
    x)

    instance Apply f => Apply (Generics.Rec1 f) where
       Generics.Rec1 f (p ~> q)
    f <*> :: forall (p :: k -> *) (q :: k -> *).
    Rec1 f (p ~> q) -> Rec1 f p -> Rec1 f q
    <*> Generics.Rec1 f p
    x = f q -> Rec1 f q
    forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
    Generics.Rec1 (f (p ~> q)
    f f (p ~> q) -> f p -> f q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *). f (p ~> q) -> f p -> f q
    <*> f p
    x)

    instance (Apply f, Apply g) => Apply ((Generics.:*:) f g) where
       (f (p ~> q)
    x1 Generics.:*: g (p ~> q)
    y1) <*> :: forall (p :: k -> *) (q :: k -> *).
    (:*:) f g (p ~> q) -> (:*:) f g p -> (:*:) f g q
    <*> (f p
    x2 Generics.:*: g p
    y2) = (f (p ~> q)
    x1 f (p ~> q) -> f p -> f q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *). f (p ~> q) -> f p -> f q
    <*> f p
    x2) f q -> g q -> (:*:) f g q
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    Generics.:*: (g (p ~> q)
    y1 g (p ~> q) -> g p -> g q
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Apply g =>
    g (p ~> q) -> g p -> g q
    forall (p :: k -> *) (q :: k -> *). g (p ~> q) -> g p -> g q
    <*> g p
    y2)

    instance Applicative Empty where
       pure :: forall (f :: k -> *). (forall (a :: k). f a) -> Empty f
    pure forall (a :: k). f a
    _ = Empty f
    forall {k} (f :: k). Empty f
    Empty

    instance Applicative Proxy where
       pure :: forall (f :: k -> *). (forall (a :: k). f a) -> Proxy f
    pure forall (a :: k). f a
    _ = Proxy f
    forall {k} (t :: k). Proxy t
    Proxy

    instance (Semigroup x, Monoid x) => Applicative (Const x) where
       pure :: forall (f :: k -> *). (forall (a :: k). f a) -> Const x f
    pure forall (a :: k). f a
    _ = x -> Const x f
    forall {k} a (b :: k). a -> Const a b
    Const x
    forall a. Monoid a => a
    mempty

    instance Applicative (Only x) where
       pure :: forall (f :: k -> *). (forall (a :: k). f a) -> Only x f
    pure forall (a :: k). f a
    f = f x -> Only x f
    forall {k} (a :: k) (f :: k -> *). f a -> Only a f
    Only f x
    forall (a :: k). f a
    f

    instance Applicative g => Applicative (Identity g) where
       pure :: forall (f :: k -> *). (forall (a :: k). f a) -> Identity g f
    pure forall (a :: k). f a
    f = g f -> Identity g f
    forall {k} (g :: k -> *) (f :: k). g f -> Identity g f
    Identity ((forall (a :: k). f a) -> g f
    forall {k} (g :: (k -> *) -> *) (f :: k -> *).
    Applicative g =>
    (forall (a :: k). f a) -> g f
    forall (f :: k -> *). (forall (a :: k). f a) -> g f
    pure f a
    forall (a :: k). f a
    f)

    instance (Applicative g, Rank1.Applicative p) => Applicative (Compose g p) where
       pure :: forall (f :: k -> *). (forall (a :: k). f a) -> Compose g p f
    pure forall (a :: k). f a
    f = g (Compose p f) -> Compose g p f
    forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    g (Compose p q) -> Compose g p q
    Compose ((forall (a :: k). Compose p f a) -> g (Compose p f)
    forall {k} (g :: (k -> *) -> *) (f :: k -> *).
    Applicative g =>
    (forall (a :: k). f a) -> g f
    forall (f :: k -> *). (forall (a :: k). f a) -> g f
    pure (p (f a) -> Compose p f a
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose (f a -> p (f a)
    forall a. a -> p a
    forall (f :: * -> *) a. Applicative f => a -> f a
    Rank1.pure f a
    forall (a :: k). f a
    f)))

    instance (Applicative g, Applicative h) => Applicative (Product g h) where
       pure :: forall (f :: k -> *). (forall (a :: k). f a) -> Product g h f
    pure forall (a :: k). f a
    f = g f -> h f -> Product g h f
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair ((forall (a :: k). f a) -> g f
    forall {k} (g :: (k -> *) -> *) (f :: k -> *).
    Applicative g =>
    (forall (a :: k). f a) -> g f
    forall (f :: k -> *). (forall (a :: k). f a) -> g f
    pure f a
    forall (a :: k). f a
    f) ((forall (a :: k). f a) -> h f
    forall {k} (g :: (k -> *) -> *) (f :: k -> *).
    Applicative g =>
    (forall (a :: k). f a) -> g f
    forall (f :: k -> *). (forall (a :: k). f a) -> h f
    pure f a
    forall (a :: k). f a
    f)

    instance (Semigroup c, Monoid c) => Applicative (Generics.K1 i c) where
       pure :: forall (f :: k -> *). (forall (a :: k). f a) -> K1 i c f
    pure forall (a :: k). f a
    _ = c -> K1 i c f
    forall k i c (p :: k). c -> K1 i c p
    Generics.K1 c
    forall a. Monoid a => a
    mempty

    instance Applicative f => Applicative (Generics.M1 i c f) where
       pure :: forall (f :: k -> *). (forall (a :: k). f a) -> M1 i c f f
    pure forall (a :: k). f a
    f = f f -> M1 i c f f
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    Generics.M1 ((forall (a :: k). f a) -> f f
    forall {k} (g :: (k -> *) -> *) (f :: k -> *).
    Applicative g =>
    (forall (a :: k). f a) -> g f
    forall (f :: k -> *). (forall (a :: k). f a) -> f f
    pure f a
    forall (a :: k). f a
    f)

    instance Applicative f => Applicative (Generics.Rec1 f) where
       pure :: forall (f :: k -> *). (forall (a :: k). f a) -> Rec1 f f
    pure forall (a :: k). f a
    f = f f -> Rec1 f f
    forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
    Generics.Rec1 ((forall (a :: k). f a) -> f f
    forall {k} (g :: (k -> *) -> *) (f :: k -> *).
    Applicative g =>
    (forall (a :: k). f a) -> g f
    forall (f :: k -> *). (forall (a :: k). f a) -> f f
    pure f a
    forall (a :: k). f a
    f)

    instance (Applicative f, Applicative g) => Applicative ((Generics.:*:) f g) where
       pure :: forall (f :: k -> *). (forall (a :: k). f a) -> (:*:) f g f
    pure forall (a :: k). f a
    f = (forall (a :: k). f a) -> f f
    forall {k} (g :: (k -> *) -> *) (f :: k -> *).
    Applicative g =>
    (forall (a :: k). f a) -> g f
    forall (f :: k -> *). (forall (a :: k). f a) -> f f
    pure f a
    forall (a :: k). f a
    f f f -> g f -> (:*:) f g f
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    Generics.:*: (forall (a :: k). f a) -> g f
    forall {k} (g :: (k -> *) -> *) (f :: k -> *).
    Applicative g =>
    (forall (a :: k). f a) -> g f
    forall (f :: k -> *). (forall (a :: k). f a) -> g f
    pure f a
    forall (a :: k). f a
    f

    instance DistributiveTraversable Empty
    instance DistributiveTraversable Proxy
    instance DistributiveTraversable (Only x)
    instance DistributiveTraversable g => DistributiveTraversable (Identity g) where
       cotraverseTraversable :: forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x)
    -> f1 (Identity g f2) -> Identity g f
    cotraverseTraversable forall (x :: k). f1 (f2 x) -> f x
    w f1 (Identity g f2)
    f = g f -> Identity g f
    forall {k} (g :: k -> *) (f :: k). g f -> Identity g f
    Identity ((forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *)
           (f :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    cotraverseTraversable f1 (f2 x) -> f x
    forall (x :: k). f1 (f2 x) -> f x
    w ((Identity g f2 -> g f2) -> f1 (Identity g f2) -> f1 (g f2)
    forall a b. (a -> b) -> f1 a -> f1 b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Identity g f2 -> g f2
    forall {k} (g :: k -> *) (f :: k). Identity g f -> g f
    runIdentity f1 (Identity g f2)
    f))
    instance (DistributiveTraversable g, Rank1.Distributive p) => DistributiveTraversable (Compose g p) where
       cotraverseTraversable :: forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x)
    -> f1 (Compose g p f2) -> Compose g p f
    cotraverseTraversable forall (x :: k). f1 (f2 x) -> f x
    w f1 (Compose g p f2)
    f = g (Compose p f) -> Compose g p f
    forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    g (Compose p q) -> Compose g p q
    Compose ((forall (x :: k). f1 (Compose p f2 x) -> Compose p f x)
    -> f1 (g (Compose p f2)) -> g (Compose p f)
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *)
           (f :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    cotraverseTraversable
                                            (p (f x) -> Compose p f x
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose (p (f x) -> Compose p f x)
    -> (f1 (Compose p f2 x) -> p (f x))
    -> f1 (Compose p f2 x)
    -> Compose p f x
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (f1 (f2 x) -> f x) -> p (f1 (f2 x)) -> p (f x)
    forall a b. (a -> b) -> p a -> p b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap f1 (f2 x) -> f x
    forall (x :: k). f1 (f2 x) -> f x
    w (p (f1 (f2 x)) -> p (f x))
    -> (f1 (Compose p f2 x) -> p (f1 (f2 x)))
    -> f1 (Compose p f2 x)
    -> p (f x)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . f1 (p (f2 x)) -> p (f1 (f2 x))
    forall (g :: * -> *) (f :: * -> *) a.
    (Distributive g, Functor f) =>
    f (g a) -> g (f a)
    forall (f :: * -> *) a. Functor f => f (p a) -> p (f a)
    Rank1.distribute (f1 (p (f2 x)) -> p (f1 (f2 x)))
    -> (f1 (Compose p f2 x) -> f1 (p (f2 x)))
    -> f1 (Compose p f2 x)
    -> p (f1 (f2 x))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Compose p f2 x -> p (f2 x))
    -> f1 (Compose p f2 x) -> f1 (p (f2 x))
    forall a b. (a -> b) -> f1 a -> f1 b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Compose p f2 x -> p (f2 x)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    Rank1.getCompose)
                                            ((Compose g p f2 -> g (Compose p f2))
    -> f1 (Compose g p f2) -> f1 (g (Compose p f2))
    forall a b. (a -> b) -> f1 a -> f1 b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Compose g p f2 -> g (Compose p f2)
    forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    Compose g p q -> g (Compose p q)
    getCompose f1 (Compose g p f2)
    f))
    instance (DistributiveTraversable g, DistributiveTraversable h) => DistributiveTraversable (Product g h) where
       cotraverseTraversable :: forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x)
    -> f1 (Product g h f2) -> Product g h f
    cotraverseTraversable forall (x :: k). f1 (f2 x) -> f x
    w f1 (Product g h f2)
    f = g f -> h f -> Product g h f
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair ((forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *)
           (f :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    cotraverseTraversable f1 (f2 x) -> f x
    forall (x :: k). f1 (f2 x) -> f x
    w ((Product g h f2 -> g f2) -> f1 (Product g h f2) -> f1 (g f2)
    forall a b. (a -> b) -> f1 a -> f1 b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Product g h f2 -> g f2
    forall {k} (g :: k -> *) (h :: k -> *) (p :: k).
    Product g h p -> g p
    fst f1 (Product g h f2)
    f))
                                        ((forall (x :: k). f1 (f2 x) -> f x) -> f1 (h f2) -> h f
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *)
           (f :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (h f2) -> h f
    cotraverseTraversable f1 (f2 x) -> f x
    forall (x :: k). f1 (f2 x) -> f x
    w ((Product g h f2 -> h f2) -> f1 (Product g h f2) -> f1 (h f2)
    forall a b. (a -> b) -> f1 a -> f1 b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Product g h f2 -> h f2
    forall {k} (g :: k -> *) (h :: k -> *) (p :: k).
    Product g h p -> h p
    snd f1 (Product g h f2)
    f))

    instance DistributiveTraversable f => DistributiveTraversable (Generics.M1 i c f) where
       cotraverseTraversable :: forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x)
    -> f1 (M1 i c f f2) -> M1 i c f f
    cotraverseTraversable forall (x :: k). f1 (f2 x) -> f x
    w f1 (M1 i c f f2)
    f = f f -> M1 i c f f
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    Generics.M1 ((forall (x :: k). f1 (f2 x) -> f x) -> f1 (f f2) -> f f
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *)
           (f :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (f f2) -> f f
    cotraverseTraversable f1 (f2 x) -> f x
    forall (x :: k). f1 (f2 x) -> f x
    w ((M1 i c f f2 -> f f2) -> f1 (M1 i c f f2) -> f1 (f f2)
    forall a b. (a -> b) -> f1 a -> f1 b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap M1 i c f f2 -> f f2
    forall k i (c :: Meta) (f :: k -> *) (p :: k). M1 i c f p -> f p
    Generics.unM1 f1 (M1 i c f f2)
    f))
    instance DistributiveTraversable f => DistributiveTraversable (Generics.Rec1 f) where
       cotraverseTraversable :: forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (Rec1 f f2) -> Rec1 f f
    cotraverseTraversable forall (x :: k). f1 (f2 x) -> f x
    w f1 (Rec1 f f2)
    f = f f -> Rec1 f f
    forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
    Generics.Rec1 ((forall (x :: k). f1 (f2 x) -> f x) -> f1 (f f2) -> f f
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *)
           (f :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (f f2) -> f f
    cotraverseTraversable f1 (f2 x) -> f x
    forall (x :: k). f1 (f2 x) -> f x
    w ((Rec1 f f2 -> f f2) -> f1 (Rec1 f f2) -> f1 (f f2)
    forall a b. (a -> b) -> f1 a -> f1 b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Rec1 f f2 -> f f2
    forall k (f :: k -> *) (p :: k). Rec1 f p -> f p
    Generics.unRec1 f1 (Rec1 f f2)
    f))
    instance (DistributiveTraversable f, DistributiveTraversable g) => DistributiveTraversable ((Generics.:*:) f g) where
       cotraverseTraversable :: forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x)
    -> f1 ((:*:) f g f2) -> (:*:) f g f
    cotraverseTraversable forall (x :: k). f1 (f2 x) -> f x
    w f1 ((:*:) f g f2)
    f = (forall (x :: k). f1 (f2 x) -> f x) -> f1 (f f2) -> f f
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *)
           (f :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (f f2) -> f f
    cotraverseTraversable f1 (f2 x) -> f x
    forall (x :: k). f1 (f2 x) -> f x
    w (((:*:) f g f2 -> f f2) -> f1 ((:*:) f g f2) -> f1 (f f2)
    forall a b. (a -> b) -> f1 a -> f1 b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap (\(f f2
    a Generics.:*: g f2
    _) -> f f2
    a) f1 ((:*:) f g f2)
    f) f f -> g f -> (:*:) f g f
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    Generics.:*: (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall k (g :: (k -> *) -> *) (f1 :: * -> *) (f2 :: k -> *)
           (f :: k -> *).
    (DistributiveTraversable g, Traversable f1) =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (g f2) -> g f
    cotraverseTraversable f1 (f2 x) -> f x
    forall (x :: k). f1 (f2 x) -> f x
    w (((:*:) f g f2 -> g f2) -> f1 ((:*:) f g f2) -> f1 (g f2)
    forall a b. (a -> b) -> f1 a -> f1 b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap (\(f f2
    _ Generics.:*: g f2
    b) -> g f2
    b) f1 ((:*:) f g f2)
    f)

    instance Distributive Empty where
       cotraverse :: forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (Empty p) -> Empty q
    cotraverse forall (a :: k1). m (p a) -> q a
    _ m (Empty p)
    _ = Empty q
    forall {k} (f :: k). Empty f
    Empty

    instance Distributive Proxy where
       cotraverse :: forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (Proxy p) -> Proxy q
    cotraverse forall (a :: k1). m (p a) -> q a
    _ m (Proxy p)
    _ = Proxy q
    forall {k} (t :: k). Proxy t
    Proxy

    instance Monoid x => DistributiveTraversable (Const x) where
       cotraverseTraversable :: forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (Const x f2) -> Const x f
    cotraverseTraversable forall (x :: k). f1 (f2 x) -> f x
    _ f1 (Const x f2)
    f = Const x f2 -> Const x f
    forall a b. Coercible a b => a -> b
    coerce (f1 (Const x f2) -> Const x f2
    forall m. Monoid m => f1 m -> m
    forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
    Rank1.fold f1 (Const x f2)
    f)

    instance Distributive (Only x) where
       cotraverse :: forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (Only x p) -> Only x q
    cotraverse forall (a :: k1). m (p a) -> q a
    w m (Only x p)
    f = q x -> Only x q
    forall {k} (a :: k) (f :: k -> *). f a -> Only a f
    Only (m (p x) -> q x
    forall (a :: k1). m (p a) -> q a
    w ((Only x p -> p x) -> m (Only x p) -> m (p x)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Only x p -> p x
    forall {k} (a :: k) (f :: k -> *). Only a f -> f a
    fromOnly m (Only x p)
    f))

    instance Distributive g => Distributive (Identity g) where
       cotraverse :: forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a)
    -> m (Identity g p) -> Identity g q
    cotraverse forall (a :: k1). m (p a) -> q a
    w m (Identity g p)
    f = g q -> Identity g q
    forall {k} (g :: k -> *) (f :: k). g f -> Identity g f
    Identity ((forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall {k1} (g :: (k1 -> *) -> *) (m :: * -> *) (p :: k1 -> *)
           (q :: k1 -> *).
    (Distributive g, Functor m) =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    cotraverse m (p a) -> q a
    forall (a :: k1). m (p a) -> q a
    w ((Identity g p -> g p) -> m (Identity g p) -> m (g p)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Identity g p -> g p
    forall {k} (g :: k -> *) (f :: k). Identity g f -> g f
    runIdentity m (Identity g p)
    f))

    instance (Distributive g, Rank1.Distributive p) => Distributive (Compose g p) where
       cotraverse :: forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a)
    -> m (Compose g p p) -> Compose g p q
    cotraverse forall (a :: k1). m (p a) -> q a
    w m (Compose g p p)
    f = g (Compose p q) -> Compose g p q
    forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    g (Compose p q) -> Compose g p q
    Compose ((forall (a :: k1). m (Compose p p a) -> Compose p q a)
    -> m (g (Compose p p)) -> g (Compose p q)
    forall {k1} (g :: (k1 -> *) -> *) (m :: * -> *) (p :: k1 -> *)
           (q :: k1 -> *).
    (Distributive g, Functor m) =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    cotraverse (p (q a) -> Compose p q a
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose (p (q a) -> Compose p q a)
    -> (m (Compose p p a) -> p (q a))
    -> m (Compose p p a)
    -> Compose p q a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (m (p a) -> q a) -> p (m (p a)) -> p (q a)
    forall a b. (a -> b) -> p a -> p b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap m (p a) -> q a
    forall (a :: k1). m (p a) -> q a
    w (p (m (p a)) -> p (q a))
    -> (m (Compose p p a) -> p (m (p a)))
    -> m (Compose p p a)
    -> p (q a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . m (p (p a)) -> p (m (p a))
    forall (g :: * -> *) (f :: * -> *) a.
    (Distributive g, Functor f) =>
    f (g a) -> g (f a)
    forall (f :: * -> *) a. Functor f => f (p a) -> p (f a)
    Rank1.distribute (m (p (p a)) -> p (m (p a)))
    -> (m (Compose p p a) -> m (p (p a)))
    -> m (Compose p p a)
    -> p (m (p a))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Compose p p a -> p (p a)) -> m (Compose p p a) -> m (p (p a))
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Compose p p a -> p (p a)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    Rank1.getCompose)
                                            ((Compose g p p -> g (Compose p p))
    -> m (Compose g p p) -> m (g (Compose p p))
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Compose g p p -> g (Compose p p)
    forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    Compose g p q -> g (Compose p q)
    getCompose m (Compose g p p)
    f))

    instance (Distributive g, Distributive h) => Distributive (Product g h) where
       cotraverse :: forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a)
    -> m (Product g h p) -> Product g h q
    cotraverse forall (a :: k1). m (p a) -> q a
    w m (Product g h p)
    f = g q -> h q -> Product g h q
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair ((forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall {k1} (g :: (k1 -> *) -> *) (m :: * -> *) (p :: k1 -> *)
           (q :: k1 -> *).
    (Distributive g, Functor m) =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    cotraverse m (p a) -> q a
    forall (a :: k1). m (p a) -> q a
    w ((Product g h p -> g p) -> m (Product g h p) -> m (g p)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Product g h p -> g p
    forall {k} (g :: k -> *) (h :: k -> *) (p :: k).
    Product g h p -> g p
    fst m (Product g h p)
    f)) ((forall (a :: k1). m (p a) -> q a) -> m (h p) -> h q
    forall {k1} (g :: (k1 -> *) -> *) (m :: * -> *) (p :: k1 -> *)
           (q :: k1 -> *).
    (Distributive g, Functor m) =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (h p) -> h q
    cotraverse m (p a) -> q a
    forall (a :: k1). m (p a) -> q a
    w ((Product g h p -> h p) -> m (Product g h p) -> m (h p)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Product g h p -> h p
    forall {k} (g :: k -> *) (h :: k -> *) (p :: k).
    Product g h p -> h p
    snd m (Product g h p)
    f))

    instance Monoid c => DistributiveTraversable (Generics.K1 i c) where
       cotraverseTraversable :: forall (f1 :: * -> *) (f2 :: k -> *) (f :: k -> *).
    Traversable f1 =>
    (forall (x :: k). f1 (f2 x) -> f x) -> f1 (K1 i c f2) -> K1 i c f
    cotraverseTraversable forall (x :: k). f1 (f2 x) -> f x
    _ f1 (K1 i c f2)
    f = c -> K1 i c f
    forall a b. Coercible a b => a -> b
    coerce ((K1 i c f2 -> c) -> f1 (K1 i c f2) -> c
    forall m a. Monoid m => (a -> m) -> f1 a -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    Rank1.foldMap K1 i c f2 -> c
    forall k i c (p :: k). K1 i c p -> c
    Generics.unK1 f1 (K1 i c f2)
    f)

    instance Distributive f => Distributive (Generics.M1 i c f) where
       cotraverse :: forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (M1 i c f p) -> M1 i c f q
    cotraverse forall (a :: k1). m (p a) -> q a
    w m (M1 i c f p)
    f = f q -> M1 i c f q
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    Generics.M1 ((forall (a :: k1). m (p a) -> q a) -> m (f p) -> f q
    forall {k1} (g :: (k1 -> *) -> *) (m :: * -> *) (p :: k1 -> *)
           (q :: k1 -> *).
    (Distributive g, Functor m) =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (f p) -> f q
    cotraverse m (p a) -> q a
    forall (a :: k1). m (p a) -> q a
    w ((M1 i c f p -> f p) -> m (M1 i c f p) -> m (f p)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap M1 i c f p -> f p
    forall k i (c :: Meta) (f :: k -> *) (p :: k). M1 i c f p -> f p
    Generics.unM1 m (M1 i c f p)
    f))
    instance Distributive f => Distributive (Generics.Rec1 f) where
       cotraverse :: forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (Rec1 f p) -> Rec1 f q
    cotraverse forall (a :: k1). m (p a) -> q a
    w m (Rec1 f p)
    f = f q -> Rec1 f q
    forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
    Generics.Rec1 ((forall (a :: k1). m (p a) -> q a) -> m (f p) -> f q
    forall {k1} (g :: (k1 -> *) -> *) (m :: * -> *) (p :: k1 -> *)
           (q :: k1 -> *).
    (Distributive g, Functor m) =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (f p) -> f q
    cotraverse m (p a) -> q a
    forall (a :: k1). m (p a) -> q a
    w ((Rec1 f p -> f p) -> m (Rec1 f p) -> m (f p)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap Rec1 f p -> f p
    forall k (f :: k -> *) (p :: k). Rec1 f p -> f p
    Generics.unRec1 m (Rec1 f p)
    f))
    instance (Distributive f, Distributive g) => Distributive ((Generics.:*:) f g) where
       cotraverse :: forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a)
    -> m ((:*:) f g p) -> (:*:) f g q
    cotraverse forall (a :: k1). m (p a) -> q a
    w m ((:*:) f g p)
    f = (forall (a :: k1). m (p a) -> q a) -> m (f p) -> f q
    forall {k1} (g :: (k1 -> *) -> *) (m :: * -> *) (p :: k1 -> *)
           (q :: k1 -> *).
    (Distributive g, Functor m) =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (f p) -> f q
    cotraverse m (p a) -> q a
    forall (a :: k1). m (p a) -> q a
    w (((:*:) f g p -> f p) -> m ((:*:) f g p) -> m (f p)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap (\(f p
    a Generics.:*: g p
    _) -> f p
    a) m ((:*:) f g p)
    f) f q -> g q -> (:*:) f g q
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    Generics.:*: (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall {k1} (g :: (k1 -> *) -> *) (m :: * -> *) (p :: k1 -> *)
           (q :: k1 -> *).
    (Distributive g, Functor m) =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    forall (m :: * -> *) (p :: k1 -> *) (q :: k1 -> *).
    Functor m =>
    (forall (a :: k1). m (p a) -> q a) -> m (g p) -> g q
    cotraverse m (p a) -> q a
    forall (a :: k1). m (p a) -> q a
    w (((:*:) f g p -> g p) -> m ((:*:) f g p) -> m (g p)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap (\(f p
    _ Generics.:*: g p
    b) -> g p
    b) m ((:*:) f g p)
    f)

    instance Logistic Empty where
       deliver :: forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (Empty q -> Empty q) -> Empty (Compose p (q ~> q))
    deliver p (Empty q -> Empty q)
    _ = Empty (Compose p (q ~> q))
    forall {k} (f :: k). Empty f
    Empty

    instance Logistic Proxy where
       deliver :: forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (Proxy q -> Proxy q) -> Proxy (Compose p (q ~> q))
    deliver p (Proxy q -> Proxy q)
    _ = Proxy (Compose p (q ~> q))
    forall {k} (t :: k). Proxy t
    Proxy

    instance Logistic (Only x) where
       deliver :: forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (Only x q -> Only x q) -> Only x (Compose p (q ~> q))
    deliver p (Only x q -> Only x q)
    f = Compose p (q ~> q) x -> Only x (Compose p (q ~> q))
    forall {k} (a :: k) (f :: k -> *). f a -> Only a f
    Only (p ((~>) q q x) -> Compose p (q ~> q) x
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose (((~>) q q x -> Only x q -> Only x q)
    -> p (Only x q -> Only x q) -> p ((~>) q q x)
    forall a' a. (a' -> a) -> p a -> p a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    Rank1.contramap (~>) q q x -> Only x q -> Only x q
    forall a b. Coercible a b => a -> b
    coerce p (Only x q -> Only x q)
    f))

    instance Logistic g => Logistic (Identity g) where
       deliver :: forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (Identity g q -> Identity g q) -> Identity g (Compose p (q ~> q))
    deliver p (Identity g q -> Identity g q)
    f = g (Compose p (q ~> q)) -> Identity g (Compose p (q ~> q))
    forall {k} (g :: k -> *) (f :: k). g f -> Identity g f
    Identity (p (g q -> g q) -> g (Compose p (q ~> q))
    forall {k1} (g :: (k1 -> *) -> *) (p :: * -> *) (q :: k1 -> *).
    (Logistic g, Contravariant p) =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    deliver (((g q -> g q) -> Identity g q -> Identity g q)
    -> p (Identity g q -> Identity g q) -> p (g q -> g q)
    forall a' a. (a' -> a) -> p a -> p a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    Rank1.contramap (g q -> g q) -> Identity g q -> Identity g q
    forall a b. Coercible a b => a -> b
    coerce p (Identity g q -> Identity g q)
    f))

    instance (Logistic g, Rank1.Logistic p) => Logistic (Compose g p) where
       deliver :: forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (Compose g p q -> Compose g p q)
    -> Compose g p (Compose p (q ~> q))
    deliver = g (Compose p (Compose p (q ~> q)))
    -> Compose g p (Compose p (q ~> q))
    forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    g (Compose p q) -> Compose g p q
    Compose
                 (g (Compose p (Compose p (q ~> q)))
     -> Compose g p (Compose p (q ~> q)))
    -> (p (Compose g p q -> Compose g p q)
        -> g (Compose p (Compose p (q ~> q))))
    -> p (Compose g p q -> Compose g p q)
    -> Compose g p (Compose p (q ~> q))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (a :: k1).
     Compose p (Compose p q ~> Compose p q) a
     -> Compose p (Compose p (q ~> q)) a)
    -> g (Compose p (Compose p q ~> Compose p q))
    -> g (Compose p (Compose p (q ~> q)))
    forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
    Functor g =>
    (forall (a :: k). p a -> q a) -> g p -> g q
    fmap ((p (Arrow (Compose p q) (Compose p q) a)
     -> p (Compose p (q ~> q) a))
    -> Compose p (Compose p q ~> Compose p q) a
    -> Compose p (Compose p (q ~> q)) a
    forall {k} {k1} {k} {k1} (p :: k -> *) (q :: k1 -> k) (a :: k1)
           (p' :: k -> *) (q' :: k1 -> k) (a' :: k1).
    (p (q a) -> p' (q' a')) -> Compose p q a -> Compose p' q' a'
    inRank1Compose ((p (q a -> q a) -> Compose p (q ~> q) a)
    -> p (p (q a -> q a)) -> p (Compose p (q ~> q) a)
    forall a b. (a -> b) -> p a -> p b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Rank1.fmap (p ((~>) q q a) -> Compose p (q ~> q) a
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose (p ((~>) q q a) -> Compose p (q ~> q) a)
    -> (p (q a -> q a) -> p ((~>) q q a))
    -> p (q a -> q a)
    -> Compose p (q ~> q) a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((~>) q q a -> q a -> q a) -> p (q a -> q a) -> p ((~>) q q a)
    forall a' a. (a' -> a) -> p a -> p a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    Rank1.contramap (~>) q q a -> q a -> q a
    forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    Arrow p q a -> p a -> q a
    apply)
                                         (p (p (q a -> q a)) -> p (Compose p (q ~> q) a))
    -> (p (Arrow (Compose p q) (Compose p q) a) -> p (p (q a -> q a)))
    -> p (Arrow (Compose p q) (Compose p q) a)
    -> p (Compose p (q ~> q) a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . p (p (q a) -> p (q a)) -> p (p (q a -> q a))
    forall (t :: * -> *) (f :: * -> *) a.
    (Logistic t, Contravariant f) =>
    f (t a -> t a) -> t (f (a -> a))
    forall (f :: * -> *) a.
    Contravariant f =>
    f (p a -> p a) -> p (f (a -> a))
    Rank1.deliver
                                         (p (p (q a) -> p (q a)) -> p (p (q a -> q a)))
    -> (p (Arrow (Compose p q) (Compose p q) a)
        -> p (p (q a) -> p (q a)))
    -> p (Arrow (Compose p q) (Compose p q) a)
    -> p (p (q a -> q a))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((p (q a) -> p (q a)) -> Arrow (Compose p q) (Compose p q) a)
    -> p (Arrow (Compose p q) (Compose p q) a)
    -> p (p (q a) -> p (q a))
    forall a' a. (a' -> a) -> p a -> p a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    Rank1.contramap ((Compose p q a -> Compose p q a)
    -> Arrow (Compose p q) (Compose p q) a
    forall {k} (p :: k -> *) (q :: k -> *) (a :: k).
    (p a -> q a) -> Arrow p q a
    Arrow ((Compose p q a -> Compose p q a)
     -> Arrow (Compose p q) (Compose p q) a)
    -> ((p (q a) -> p (q a)) -> Compose p q a -> Compose p q a)
    -> (p (q a) -> p (q a))
    -> Arrow (Compose p q) (Compose p q) a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (p (q a) -> p (q a)) -> Compose p q a -> Compose p q a
    forall {k} {k1} {k} {k1} (p :: k -> *) (q :: k1 -> k) (a :: k1)
           (p' :: k -> *) (q' :: k1 -> k) (a' :: k1).
    (p (q a) -> p' (q' a')) -> Compose p q a -> Compose p' q' a'
    inRank1Compose)))
                 (g (Compose p (Compose p q ~> Compose p q))
     -> g (Compose p (Compose p (q ~> q))))
    -> (p (Compose g p q -> Compose g p q)
        -> g (Compose p (Compose p q ~> Compose p q)))
    -> p (Compose g p q -> Compose g p q)
    -> g (Compose p (Compose p (q ~> q)))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . p (g (Compose p q) -> g (Compose p q))
    -> g (Compose p (Compose p q ~> Compose p q))
    forall {k1} (g :: (k1 -> *) -> *) (p :: * -> *) (q :: k1 -> *).
    (Logistic g, Contravariant p) =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    deliver
                 (p (g (Compose p q) -> g (Compose p q))
     -> g (Compose p (Compose p q ~> Compose p q)))
    -> (p (Compose g p q -> Compose g p q)
        -> p (g (Compose p q) -> g (Compose p q)))
    -> p (Compose g p q -> Compose g p q)
    -> g (Compose p (Compose p q ~> Compose p q))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((g (Compose p q) -> g (Compose p q))
     -> Compose g p q -> Compose g p q)
    -> p (Compose g p q -> Compose g p q)
    -> p (g (Compose p q) -> g (Compose p q))
    forall a' a. (a' -> a) -> p a -> p a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    Rank1.contramap (g (Compose p q) -> g (Compose p q))
    -> Compose g p q -> Compose g p q
    forall {k1} {k} {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *)
           (q :: k1 -> k) (g' :: (k1 -> *) -> *) (p' :: k -> *)
           (q' :: k1 -> k).
    (g (Compose p q) -> g' (Compose p' q'))
    -> Compose g p q -> Compose g' p' q'
    inCompose

    inCompose :: (g (Rank1.Compose p q) -> g' (Rank1.Compose p' q')) -> Compose g p q -> Compose g' p' q'
    inCompose :: forall {k1} {k} {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *)
           (q :: k1 -> k) (g' :: (k1 -> *) -> *) (p' :: k -> *)
           (q' :: k1 -> k).
    (g (Compose p q) -> g' (Compose p' q'))
    -> Compose g p q -> Compose g' p' q'
    inCompose g (Compose p q) -> g' (Compose p' q')
    f = g' (Compose p' q') -> Compose g' p' q'
    forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    g (Compose p q) -> Compose g p q
    Compose (g' (Compose p' q') -> Compose g' p' q')
    -> (Compose g p q -> g' (Compose p' q'))
    -> Compose g p q
    -> Compose g' p' q'
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . g (Compose p q) -> g' (Compose p' q')
    f (g (Compose p q) -> g' (Compose p' q'))
    -> (Compose g p q -> g (Compose p q))
    -> Compose g p q
    -> g' (Compose p' q')
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Compose g p q -> g (Compose p q)
    forall {k1} {k} (g :: (k1 -> *) -> *) (p :: k -> *) (q :: k1 -> k).
    Compose g p q -> g (Compose p q)
    getCompose

    inRank1Compose :: (p (q a) -> p' (q' a')) -> Rank1.Compose p q a -> Rank1.Compose p' q' a'
    inRank1Compose :: forall {k} {k1} {k} {k1} (p :: k -> *) (q :: k1 -> k) (a :: k1)
           (p' :: k -> *) (q' :: k1 -> k) (a' :: k1).
    (p (q a) -> p' (q' a')) -> Compose p q a -> Compose p' q' a'
    inRank1Compose p (q a) -> p' (q' a')
    f = p' (q' a') -> Compose p' q' a'
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Rank1.Compose (p' (q' a') -> Compose p' q' a')
    -> (Compose p q a -> p' (q' a'))
    -> Compose p q a
    -> Compose p' q' a'
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . p (q a) -> p' (q' a')
    f (p (q a) -> p' (q' a'))
    -> (Compose p q a -> p (q a)) -> Compose p q a -> p' (q' a')
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Compose p q a -> p (q a)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    Rank1.getCompose

    instance (Logistic g, Logistic h) => Logistic (Product g h) where
       deliver :: forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (Product g h q -> Product g h q)
    -> Product g h (Compose p (q ~> q))
    deliver p (Product g h q -> Product g h q)
    f = g (Compose p (q ~> q))
    -> h (Compose p (q ~> q)) -> Product g h (Compose p (q ~> q))
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair (p (g q -> g q) -> g (Compose p (q ~> q))
    forall {k1} (g :: (k1 -> *) -> *) (p :: * -> *) (q :: k1 -> *).
    (Logistic g, Contravariant p) =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    deliver (((g q -> g q) -> Product g h q -> Product g h q)
    -> p (Product g h q -> Product g h q) -> p (g q -> g q)
    forall a' a. (a' -> a) -> p a -> p a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    Rank1.contramap (g q -> g q) -> Product g h q -> Product g h q
    forall {k} (g :: k -> *) (p :: k) (g' :: k -> *) (h :: k -> *).
    (g p -> g' p) -> Product g h p -> Product g' h p
    first p (Product g h q -> Product g h q)
    f)) (p (h q -> h q) -> h (Compose p (q ~> q))
    forall {k1} (g :: (k1 -> *) -> *) (p :: * -> *) (q :: k1 -> *).
    (Logistic g, Contravariant p) =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (h q -> h q) -> h (Compose p (q ~> q))
    deliver (((h q -> h q) -> Product g h q -> Product g h q)
    -> p (Product g h q -> Product g h q) -> p (h q -> h q)
    forall a' a. (a' -> a) -> p a -> p a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    Rank1.contramap (h q -> h q) -> Product g h q -> Product g h q
    forall {k} (h :: k -> *) (p :: k) (h' :: k -> *) (g :: k -> *).
    (h p -> h' p) -> Product g h p -> Product g h' p
    second p (Product g h q -> Product g h q)
    f))

    first :: (g p -> g' p) -> Product g h p -> Product g' h p
    first :: forall {k} (g :: k -> *) (p :: k) (g' :: k -> *) (h :: k -> *).
    (g p -> g' p) -> Product g h p -> Product g' h p
    first g p -> g' p
    f (Pair g p
    g h p
    h) = g' p -> h p -> Product g' h p
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair (g p -> g' p
    f g p
    g) h p
    h

    second :: (h p -> h' p) -> Product g h p -> Product g h' p
    second :: forall {k} (h :: k -> *) (p :: k) (h' :: k -> *) (g :: k -> *).
    (h p -> h' p) -> Product g h p -> Product g h' p
    second h p -> h' p
    f (Pair g p
    g h p
    h) = g p -> h' p -> Product g h' p
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair g p
    g (h p -> h' p
    f h p
    h)

    instance Logistic f => Logistic (Generics.M1 i c f) where
       deliver :: forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (M1 i c f q -> M1 i c f q) -> M1 i c f (Compose p (q ~> q))
    deliver p (M1 i c f q -> M1 i c f q)
    f = f (Compose p (q ~> q)) -> M1 i c f (Compose p (q ~> q))
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    Generics.M1 (p (f q -> f q) -> f (Compose p (q ~> q))
    forall {k1} (g :: (k1 -> *) -> *) (p :: * -> *) (q :: k1 -> *).
    (Logistic g, Contravariant p) =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (f q -> f q) -> f (Compose p (q ~> q))
    deliver (((f q -> f q) -> M1 i c f q -> M1 i c f q)
    -> p (M1 i c f q -> M1 i c f q) -> p (f q -> f q)
    forall a' a. (a' -> a) -> p a -> p a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    Rank1.contramap (\f q -> f q
    f'-> f q -> M1 i c f q
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    Generics.M1 (f q -> M1 i c f q)
    -> (M1 i c f q -> f q) -> M1 i c f q -> M1 i c f q
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . f q -> f q
    f' (f q -> f q) -> (M1 i c f q -> f q) -> M1 i c f q -> f q
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . M1 i c f q -> f q
    forall k i (c :: Meta) (f :: k -> *) (p :: k). M1 i c f p -> f p
    Generics.unM1) p (M1 i c f q -> M1 i c f q)
    f))

    instance Logistic f => Logistic (Generics.Rec1 f) where
       deliver :: forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (Rec1 f q -> Rec1 f q) -> Rec1 f (Compose p (q ~> q))
    deliver p (Rec1 f q -> Rec1 f q)
    f = f (Compose p (q ~> q)) -> Rec1 f (Compose p (q ~> q))
    forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
    Generics.Rec1 (p (f q -> f q) -> f (Compose p (q ~> q))
    forall {k1} (g :: (k1 -> *) -> *) (p :: * -> *) (q :: k1 -> *).
    (Logistic g, Contravariant p) =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (f q -> f q) -> f (Compose p (q ~> q))
    deliver (((f q -> f q) -> Rec1 f q -> Rec1 f q)
    -> p (Rec1 f q -> Rec1 f q) -> p (f q -> f q)
    forall a' a. (a' -> a) -> p a -> p a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    Rank1.contramap (\f q -> f q
    f'-> f q -> Rec1 f q
    forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
    Generics.Rec1 (f q -> Rec1 f q) -> (Rec1 f q -> f q) -> Rec1 f q -> Rec1 f q
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . f q -> f q
    f' (f q -> f q) -> (Rec1 f q -> f q) -> Rec1 f q -> f q
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rec1 f q -> f q
    forall k (f :: k -> *) (p :: k). Rec1 f p -> f p
    Generics.unRec1) p (Rec1 f q -> Rec1 f q)
    f))

    instance (Logistic f, Logistic g) => Logistic ((Generics.:*:) f g) where
       deliver :: forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p ((:*:) f g q -> (:*:) f g q) -> (:*:) f g (Compose p (q ~> q))
    deliver p ((:*:) f g q -> (:*:) f g q)
    f = p (f q -> f q) -> f (Compose p (q ~> q))
    forall {k1} (g :: (k1 -> *) -> *) (p :: * -> *) (q :: k1 -> *).
    (Logistic g, Contravariant p) =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (f q -> f q) -> f (Compose p (q ~> q))
    deliver (((f q -> f q) -> (:*:) f g q -> (:*:) f g q)
    -> p ((:*:) f g q -> (:*:) f g q) -> p (f q -> f q)
    forall a' a. (a' -> a) -> p a -> p a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    Rank1.contramap (\f q -> f q
    f' (f q
    a Generics.:*: g q
    b) -> f q -> f q
    f' f q
    a f q -> g q -> (:*:) f g q
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    Generics.:*: g q
    b) p ((:*:) f g q -> (:*:) f g q)
    f)
                   f (Compose p (q ~> q))
    -> g (Compose p (q ~> q)) -> (:*:) f g (Compose p (q ~> q))
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    Generics.:*:
                   p (g q -> g q) -> g (Compose p (q ~> q))
    forall {k1} (g :: (k1 -> *) -> *) (p :: * -> *) (q :: k1 -> *).
    (Logistic g, Contravariant p) =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    forall (p :: * -> *) (q :: k1 -> *).
    Contravariant p =>
    p (g q -> g q) -> g (Compose p (q ~> q))
    deliver (((g q -> g q) -> (:*:) f g q -> (:*:) f g q)
    -> p ((:*:) f g q -> (:*:) f g q) -> p (g q -> g q)
    forall a' a. (a' -> a) -> p a -> p a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    Rank1.contramap (\g q -> g q
    f' (f q
    a Generics.:*: g q
    b) -> f q
    a f q -> g q -> (:*:) f g q
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    Generics.:*: g q -> g q
    f' g q
    b) p ((:*:) f g q -> (:*:) f g q)
    f)