{-# Language Haskell2010, DeriveDataTypeable, FlexibleInstances, KindSignatures, MultiParamTypeClasses, RankNTypes,
             StandaloneDeriving, TypeFamilies, TypeOperators, UndecidableInstances #-}

-- | Type classes 'Functor', 'Foldable', and 'Traversable' that correspond to the standard type classes of the same
-- name, but applying the given transformation to every descendant of the given tree node. The corresponding classes
-- in the "Transformation.Shallow" module operate only on the immediate children, while those from the
-- "Transformation.Full" module include the argument node itself.

module Transformation.Deep where

import Data.Data (Data, Typeable)
import Data.Functor.Compose (Compose)
import Data.Functor.Const (Const)
import qualified Control.Applicative as Rank1
import qualified Data.Foldable as Rank1
import qualified Data.Functor as Rank1
import qualified Data.Traversable as Rank1
import Data.Kind (Type)
import qualified Rank2
import           Transformation (Transformation, Domain, Codomain)
import qualified Transformation.Full as Full

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

-- | Like "Transformation.Shallow".'Transformation.Shallow.Functor' except it maps all descendants and not only immediate children
class (Transformation t, Rank2.Functor (g (Domain t))) => Functor t g where
   (<$>) :: t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
   infixl 4 <$>

-- | Like "Transformation.Shallow".'Transformation.Shallow.Foldable' except it folds all descendants and not only immediate children
class (Transformation t, Rank2.Foldable (g (Domain t))) => Foldable t g where
   foldMap :: (Codomain t ~ Const m, Monoid m) => t -> g (Domain t) (Domain t) -> m

-- | Like "Transformation.Shallow".'Transformation.Shallow.Traversable' except it folds all descendants and not only immediate children
class (Transformation t, Rank2.Traversable (g (Domain t))) => Traversable t g where
   traverse :: Codomain t ~ Compose m f => t -> g (Domain t) (Domain t) -> m (g f f)

-- | A tuple of only one element
newtype Only g (d :: Type -> Type) (s :: Type -> Type) =
   Only {forall (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
Only g d s -> s (g d d)
fromOnly :: s (g d d)}

-- | Compose a regular type constructor with a data type with two type constructor parameters
newtype Nest (f :: Type -> Type) g (d :: Type -> Type) (s :: Type -> Type) =
   Nest {forall (f :: * -> *) (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
Nest f g d s -> f (g d s)
unNest :: f (g d s)}

-- | Like 'Data.Functor.Product.Product' for data types with two type constructor parameters
data Product g h (d :: Type -> Type) (s :: Type -> Type) =
   Pair{forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
Product g h d s -> g d s
fst :: g d s,
        forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
Product g h d s -> h d s
snd :: h d s}

-- | Like 'Data.Functor.Sum.Sum' for data types with two type constructor parameters
data Sum g h (d :: Type -> Type) (s :: Type -> Type) =
   InL (g d s)
   | InR (h d s)

-- Instances

instance Rank2.Functor (Only g d) where
   forall a. p a -> q a
f <$> :: forall (p :: * -> *) (q :: * -> *).
(forall a. p a -> q a) -> Only g d p -> Only g d q
<$> Only p (g d d)
x = q (g d d) -> Only g d q
forall (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
s (g d d) -> Only g d s
Only (p (g d d) -> q (g d d)
forall a. p a -> q a
f p (g d d)
x)

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

instance Rank2.Traversable (Only g d) where
   traverse :: forall (m :: * -> *) (p :: * -> *) (q :: * -> *).
Applicative m =>
(forall a. p a -> m (q a)) -> Only g d p -> m (Only g d q)
traverse forall a. p a -> m (q a)
f (Only p (g d d)
x) = q (g d d) -> Only g d q
forall (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
s (g d d) -> Only g d s
Only (q (g d d) -> Only g d q) -> m (q (g d d)) -> m (Only g d q)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Rank1.<$> p (g d d) -> m (q (g d d))
forall a. p a -> m (q a)
f p (g d d)
x

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

instance Rank2.Applicative (Only g d) where
   pure :: forall (f :: * -> *). (forall a. f a) -> Only g d f
pure forall a. f a
f = f (g d d) -> Only g d f
forall (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
s (g d d) -> Only g d s
Only f (g d d)
forall a. f a
f

instance Rank2.DistributiveTraversable (Only g d)

instance Rank2.Distributive (Only g d) where
   cotraverse :: forall (m :: * -> *) (p :: * -> *) (q :: * -> *).
Functor m =>
(forall a. m (p a) -> q a) -> m (Only g d p) -> Only g d q
cotraverse forall a. m (p a) -> q a
w m (Only g d p)
f = q (g d d) -> Only g d q
forall (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
s (g d d) -> Only g d s
Only (m (p (g d d)) -> q (g d d)
forall a. m (p a) -> q a
w ((Only g d p -> p (g d d)) -> m (Only g d p) -> m (p (g d d))
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Rank1.fmap Only g d p -> p (g d d)
forall (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
Only g d s -> s (g d d)
fromOnly m (Only g d p)
f))

instance Full.Functor t g => Functor t (Only g) where
   t
t <$> :: t
-> Only g (Domain t) (Domain t) -> Only g (Codomain t) (Codomain t)
<$> Only Domain t (g (Domain t) (Domain t))
x = Codomain t (g (Codomain t) (Codomain t))
-> Only g (Codomain t) (Codomain t)
forall (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
s (g d d) -> Only g d s
Only (t
t t
-> Domain t (g (Domain t) (Domain t))
-> Codomain t (g (Codomain t) (Codomain t))
forall t (g :: (* -> *) -> (* -> *) -> *).
Functor t g =>
t
-> Domain t (g (Domain t) (Domain t))
-> Codomain t (g (Codomain t) (Codomain t))
Full.<$> Domain t (g (Domain t) (Domain t))
x)

instance Full.Foldable t g => Foldable t (Only g) where
   foldMap :: forall m.
(Codomain t ~ Const m, Monoid m) =>
t -> Only g (Domain t) (Domain t) -> m
foldMap t
t (Only Domain t (g (Domain t) (Domain t))
x) = t -> Domain t (g (Domain t) (Domain t)) -> m
forall m.
(Codomain t ~ Const m, Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMap t
t Domain t (g (Domain t) (Domain t))
x

instance (Full.Traversable t g, Codomain t ~ Compose m f, Rank1.Functor m) => Traversable t (Only g) where
   traverse :: forall (m :: * -> *) (f :: * -> *).
(Codomain t ~ Compose m f) =>
t -> Only g (Domain t) (Domain t) -> m (Only g f f)
traverse t
t (Only Domain t (g (Domain t) (Domain t))
x) = f (g f f) -> Only g f f
forall (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
s (g d d) -> Only g d s
Only (f (g f f) -> Only g f f) -> m (f (g f f)) -> m (Only g f f)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Rank1.<$> t -> Domain t (g (Domain t) (Domain t)) -> m (f (g f f))
forall t (g :: (* -> *) -> (* -> *) -> *) (m :: * -> *)
       (f :: * -> *).
(Traversable t g, Codomain t ~ Compose m f) =>
t -> Domain t (g (Domain t) (Domain t)) -> m (f (g f f))
forall (m :: * -> *) (f :: * -> *).
(Codomain t ~ Compose m f) =>
t -> Domain t (g (Domain t) (Domain t)) -> m (f (g f f))
Full.traverse t
t Domain t (g (Domain t) (Domain t))
x

deriving instance (Typeable s, Typeable d, Typeable g, Data (s (g d d))) => Data (Only g d s)
deriving instance Eq (s (g d d)) => Eq (Only g d s)
deriving instance Ord (s (g d d)) => Ord (Only g d s)
deriving instance Show (s (g d d)) => Show (Only g d s)

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

instance (Rank1.Applicative f, Rank2.Apply (g d)) => Rank2.Apply (Nest f g d) where
   Nest f (g d (p ~> q))
x <*> :: forall (p :: * -> *) (q :: * -> *).
Nest f g d (p ~> q) -> Nest f g d p -> Nest f g d q
<*> Nest f (g d p)
y = f (g d q) -> Nest f g d q
forall (f :: * -> *) (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
f (g d s) -> Nest f g d s
Nest ((g d (p ~> q) -> g d p -> g d q)
-> f (g d (p ~> q)) -> f (g d p) -> f (g d q)
forall a b c. (a -> b -> c) -> f a -> f b -> f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
Rank1.liftA2 g d (p ~> q) -> g d p -> g d q
forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Apply g =>
g (p ~> q) -> g p -> g q
forall (p :: * -> *) (q :: * -> *). g d (p ~> q) -> g d p -> g d q
(Rank2.<*>) f (g d (p ~> q))
x f (g d p)
y)

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

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

instance (Rank1.Traversable f, Rank2.Traversable (g d)) => Rank2.Traversable (Nest f g d) where
   traverse :: forall (m :: * -> *) (p :: * -> *) (q :: * -> *).
Applicative m =>
(forall a. p a -> m (q a)) -> Nest f g d p -> m (Nest f g d q)
traverse forall a. p a -> m (q a)
f (Nest f (g d p)
x) = f (g d q) -> Nest f g d q
forall (f :: * -> *) (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
f (g d s) -> Nest f g d s
Nest (f (g d q) -> Nest f g d q) -> m (f (g d q)) -> m (Nest f g d q)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Rank1.<$> (g d p -> m (g d q)) -> f (g d p) -> m (f (g d q))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> f a -> f (f b)
Rank1.traverse ((forall a. p a -> m (q a)) -> g d p -> m (g d 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 :: * -> *) (q :: * -> *).
Applicative m =>
(forall a. p a -> m (q a)) -> g d p -> m (g d q)
Rank2.traverse p a -> m (q a)
forall a. p a -> m (q a)
f) f (g d p)
x

instance (Rank1.Functor f, Functor t g) => Functor t (Nest f g) where
   t
t <$> :: t
-> Nest f g (Domain t) (Domain t)
-> Nest f g (Codomain t) (Codomain t)
<$> Nest f (g (Domain t) (Domain t))
x = f (g (Codomain t) (Codomain t))
-> Nest f g (Codomain t) (Codomain t)
forall (f :: * -> *) (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
f (g d s) -> Nest f g d s
Nest ((t
t t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
forall t (g :: (* -> *) -> (* -> *) -> *).
Functor t g =>
t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
<$>) (g (Domain t) (Domain t) -> g (Codomain t) (Codomain t))
-> f (g (Domain t) (Domain t)) -> f (g (Codomain t) (Codomain t))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Rank1.<$> f (g (Domain t) (Domain t))
x)

instance (Rank1.Foldable f, Foldable t g) => Foldable t (Nest f g) where
   foldMap :: forall m.
(Codomain t ~ Const m, Monoid m) =>
t -> Nest f g (Domain t) (Domain t) -> m
foldMap t
t (Nest f (g (Domain t) (Domain t))
x) = (g (Domain t) (Domain t) -> m) -> f (g (Domain t) (Domain t)) -> m
forall m a. Monoid m => (a -> m) -> f a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
Rank1.foldMap (t -> g (Domain t) (Domain t) -> m
forall m.
(Codomain t ~ Const m, Monoid m) =>
t -> g (Domain t) (Domain t) -> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> g (Domain t) (Domain t) -> m
foldMap t
t) f (g (Domain t) (Domain t))
x

instance (Rank1.Traversable f, Traversable t g, Codomain t ~ Compose m f, Rank1.Applicative m) =>
         Traversable t (Nest f g) where
   traverse :: forall (m :: * -> *) (f :: * -> *).
(Codomain t ~ Compose m f) =>
t -> Nest f g (Domain t) (Domain t) -> m (Nest f g f f)
traverse t
t (Nest f (g (Domain t) (Domain t))
x) = f (g f f) -> Nest f g f f
forall (f :: * -> *) (g :: (* -> *) -> (* -> *) -> *) (d :: * -> *)
       (s :: * -> *).
f (g d s) -> Nest f g d s
Nest (f (g f f) -> Nest f g f f) -> m (f (g f f)) -> m (Nest f g f f)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Rank1.<$> (g (Domain t) (Domain t) -> m (g f f))
-> f (g (Domain t) (Domain t)) -> m (f (g f f))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> f a -> f (f b)
Rank1.traverse (t -> g (Domain t) (Domain t) -> m (g f f)
forall t (g :: (* -> *) -> (* -> *) -> *) (m :: * -> *)
       (f :: * -> *).
(Traversable t g, Codomain t ~ Compose m f) =>
t -> g (Domain t) (Domain t) -> m (g f f)
forall (m :: * -> *) (f :: * -> *).
(Codomain t ~ Compose m f) =>
t -> g (Domain t) (Domain t) -> m (g f f)
traverse t
t) f (g (Domain t) (Domain t))
x

deriving instance (Typeable s, Typeable d, Typeable f, Typeable g,
                   Data (f (g d s))) => Data (Nest f g d s)
deriving instance Eq (f (g d s)) => Eq (Nest f g d s)
deriving instance Ord (f (g d s)) => Ord (Nest f g d s)
deriving instance Show (f (g d s)) => Show (Nest f g d s)

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

instance (Rank2.Apply (g d), Rank2.Apply (h d)) => Rank2.Apply (Product g h d) where
   Pair g d (p ~> q)
g1 h d (p ~> q)
h1 <*> :: forall (p :: * -> *) (q :: * -> *).
Product g h d (p ~> q) -> Product g h d p -> Product g h d q
<*> ~(Pair g d p
g2 h d p
h2) = g d q -> h d q -> Product g h d q
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
g d s -> h d s -> Product g h d s
Pair (g d (p ~> q)
g1 g d (p ~> q) -> g d p -> g d q
forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Apply g =>
g (p ~> q) -> g p -> g q
forall (p :: * -> *) (q :: * -> *). g d (p ~> q) -> g d p -> g d q
Rank2.<*> g d p
g2) (h d (p ~> q)
h1 h d (p ~> q) -> h d p -> h d q
forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Apply g =>
g (p ~> q) -> g p -> g q
forall (p :: * -> *) (q :: * -> *). h d (p ~> q) -> h d p -> h d q
Rank2.<*> h d p
h2)
   liftA2 :: forall (p :: * -> *) (q :: * -> *) (r :: * -> *).
(forall a. p a -> q a -> r a)
-> Product g h d p -> Product g h d q -> Product g h d r
liftA2 forall a. p a -> q a -> r a
f (Pair g d p
g1 h d p
h1) ~(Pair g d q
g2 h d q
h2) = g d r -> h d r -> Product g h d r
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
g d s -> h d s -> Product g h d s
Pair ((forall a. p a -> q a -> r a) -> g d p -> g d q -> g d 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 :: * -> *) (q :: * -> *) (r :: * -> *).
(forall a. p a -> q a -> r a) -> g d p -> g d q -> g d r
Rank2.liftA2 p a -> q a -> r a
forall a. p a -> q a -> r a
f g d p
g1 g d q
g2) ((forall a. p a -> q a -> r a) -> h d p -> h d q -> h d 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 :: * -> *) (q :: * -> *) (r :: * -> *).
(forall a. p a -> q a -> r a) -> h d p -> h d q -> h d r
Rank2.liftA2 p a -> q a -> r a
forall a. p a -> q a -> r a
f h d p
h1 h d q
h2)
   liftA3 :: forall (p :: * -> *) (q :: * -> *) (r :: * -> *) (s :: * -> *).
(forall a. p a -> q a -> r a -> s a)
-> Product g h d p
-> Product g h d q
-> Product g h d r
-> Product g h d s
liftA3 forall a. p a -> q a -> r a -> s a
f (Pair g d p
g1 h d p
h1) ~(Pair g d q
g2 h d q
h2) ~(Pair g d r
g3 h d r
h3) = g d s -> h d s -> Product g h d s
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
g d s -> h d s -> Product g h d s
Pair ((forall a. p a -> q a -> r a -> s a)
-> g d p -> g d q -> g d r -> g d 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 :: * -> *) (q :: * -> *) (r :: * -> *) (s :: * -> *).
(forall a. p a -> q a -> r a -> s a)
-> g d p -> g d q -> g d r -> g d s
Rank2.liftA3 p a -> q a -> r a -> s a
forall a. p a -> q a -> r a -> s a
f g d p
g1 g d q
g2 g d r
g3) ((forall a. p a -> q a -> r a -> s a)
-> h d p -> h d q -> h d r -> h d 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 :: * -> *) (q :: * -> *) (r :: * -> *) (s :: * -> *).
(forall a. p a -> q a -> r a -> s a)
-> h d p -> h d q -> h d r -> h d s
Rank2.liftA3 p a -> q a -> r a -> s a
forall a. p a -> q a -> r a -> s a
f h d p
h1 h d q
h2 h d r
h3)

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

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

instance (Rank2.Traversable (g d), Rank2.Traversable (h d)) => Rank2.Traversable (Product g h d) where
   traverse :: forall (m :: * -> *) (p :: * -> *) (q :: * -> *).
Applicative m =>
(forall a. p a -> m (q a))
-> Product g h d p -> m (Product g h d q)
traverse forall a. p a -> m (q a)
f (Pair g d p
g h d p
h) = (g d q -> h d q -> Product g h d q)
-> m (g d q) -> m (h d q) -> m (Product g h d 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 d q -> h d q -> Product g h d q
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
g d s -> h d s -> Product g h d s
Pair ((forall a. p a -> m (q a)) -> g d p -> m (g d 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 :: * -> *) (q :: * -> *).
Applicative m =>
(forall a. p a -> m (q a)) -> g d p -> m (g d q)
Rank2.traverse p a -> m (q a)
forall a. p a -> m (q a)
f g d p
g) ((forall a. p a -> m (q a)) -> h d p -> m (h d 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 :: * -> *) (q :: * -> *).
Applicative m =>
(forall a. p a -> m (q a)) -> h d p -> m (h d q)
Rank2.traverse p a -> m (q a)
forall a. p a -> m (q a)
f h d p
h)

instance (Rank2.Distributive (g d), Rank2.Distributive (h d)) => Rank2.DistributiveTraversable (Product g h d)

instance (Rank2.Distributive (g d), Rank2.Distributive (h d)) => Rank2.Distributive (Product g h d) where
   cotraverse :: forall (m :: * -> *) (p :: * -> *) (q :: * -> *).
Functor m =>
(forall a. m (p a) -> q a)
-> m (Product g h d p) -> Product g h d q
cotraverse forall a. m (p a) -> q a
w m (Product g h d p)
f = Pair{fst :: g d q
fst= (forall a. m (p a) -> q a) -> m (g d p) -> g d 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 :: * -> *) (q :: * -> *).
Functor m =>
(forall a. m (p a) -> q a) -> m (g d p) -> g d q
Rank2.cotraverse m (p a) -> q a
forall a. m (p a) -> q a
w (Product g h d p -> g d p
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
Product g h d s -> g d s
fst (Product g h d p -> g d p) -> m (Product g h d p) -> m (g d p)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Rank1.<$> m (Product g h d p)
f),
                         snd :: h d q
snd= (forall a. m (p a) -> q a) -> m (h d p) -> h d 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 :: * -> *) (q :: * -> *).
Functor m =>
(forall a. m (p a) -> q a) -> m (h d p) -> h d q
Rank2.cotraverse m (p a) -> q a
forall a. m (p a) -> q a
w (Product g h d p -> h d p
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
Product g h d s -> h d s
snd (Product g h d p -> h d p) -> m (Product g h d p) -> m (h d p)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Rank1.<$> m (Product g h d p)
f)}

instance (Functor t g, Functor t h) => Functor t (Product g h) where
   t
t <$> :: t
-> Product g h (Domain t) (Domain t)
-> Product g h (Codomain t) (Codomain t)
<$> Pair g (Domain t) (Domain t)
left h (Domain t) (Domain t)
right = g (Codomain t) (Codomain t)
-> h (Codomain t) (Codomain t)
-> Product g h (Codomain t) (Codomain t)
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
g d s -> h d s -> Product g h d s
Pair (t
t t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
forall t (g :: (* -> *) -> (* -> *) -> *).
Functor t g =>
t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
<$> g (Domain t) (Domain t)
left) (t
t t -> h (Domain t) (Domain t) -> h (Codomain t) (Codomain t)
forall t (g :: (* -> *) -> (* -> *) -> *).
Functor t g =>
t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
<$> h (Domain t) (Domain t)
right)

instance (Foldable t g, Foldable t h) => Foldable t (Product g h) where
   foldMap :: forall m.
(Codomain t ~ Const m, Monoid m) =>
t -> Product g h (Domain t) (Domain t) -> m
foldMap t
t (Pair g (Domain t) (Domain t)
g h (Domain t) (Domain t)
h) = t -> g (Domain t) (Domain t) -> m
forall m.
(Codomain t ~ Const m, Monoid m) =>
t -> g (Domain t) (Domain t) -> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> g (Domain t) (Domain t) -> m
foldMap t
t g (Domain t) (Domain t)
g m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` t -> h (Domain t) (Domain t) -> m
forall m.
(Codomain t ~ Const m, Monoid m) =>
t -> h (Domain t) (Domain t) -> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> g (Domain t) (Domain t) -> m
foldMap t
t h (Domain t) (Domain t)
h

instance (Traversable t g, Traversable t h, Codomain t ~ Compose m f, Rank1.Applicative m) =>
         Traversable t (Product g h) where
   traverse :: forall (m :: * -> *) (f :: * -> *).
(Codomain t ~ Compose m f) =>
t -> Product g h (Domain t) (Domain t) -> m (Product g h f f)
traverse t
t (Pair g (Domain t) (Domain t)
left h (Domain t) (Domain t)
right) = (g f f -> h f f -> Product g h f f)
-> m (g f f) -> m (h f f) -> m (Product g h f f)
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 f f -> h f f -> Product g h f f
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
g d s -> h d s -> Product g h d s
Pair (t -> g (Domain t) (Domain t) -> m (g f f)
forall t (g :: (* -> *) -> (* -> *) -> *) (m :: * -> *)
       (f :: * -> *).
(Traversable t g, Codomain t ~ Compose m f) =>
t -> g (Domain t) (Domain t) -> m (g f f)
forall (m :: * -> *) (f :: * -> *).
(Codomain t ~ Compose m f) =>
t -> g (Domain t) (Domain t) -> m (g f f)
traverse t
t g (Domain t) (Domain t)
left) (t -> h (Domain t) (Domain t) -> m (h f f)
forall t (g :: (* -> *) -> (* -> *) -> *) (m :: * -> *)
       (f :: * -> *).
(Traversable t g, Codomain t ~ Compose m f) =>
t -> g (Domain t) (Domain t) -> m (g f f)
forall (m :: * -> *) (f :: * -> *).
(Codomain t ~ Compose m f) =>
t -> h (Domain t) (Domain t) -> m (h f f)
traverse t
t h (Domain t) (Domain t)
right)

deriving instance (Typeable d, Typeable s, Typeable g1, Typeable g2,
                   Data (g1 d s), Data (g2 d s)) => Data (Product g1 g2 d s)
deriving instance (Show (g1 d s), Show (g2 d s)) => Show (Product g1 g2 d s)
deriving instance (Eq (g d s), Eq (h d s)) => Eq (Product g h d s)
deriving instance (Ord (g d s), Ord (h d s)) => Ord (Product g h d s)

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

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

instance (Rank2.Traversable (g d), Rank2.Traversable (h d)) => Rank2.Traversable (Sum g h d) where
   traverse :: forall (m :: * -> *) (p :: * -> *) (q :: * -> *).
Applicative m =>
(forall a. p a -> m (q a)) -> Sum g h d p -> m (Sum g h d q)
traverse forall a. p a -> m (q a)
f (InL g d p
left) = g d q -> Sum g h d q
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
g d s -> Sum g h d s
InL (g d q -> Sum g h d q) -> m (g d q) -> m (Sum g h d q)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Rank1.<$> (forall a. p a -> m (q a)) -> g d p -> m (g d 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 :: * -> *) (q :: * -> *).
Applicative m =>
(forall a. p a -> m (q a)) -> g d p -> m (g d q)
Rank2.traverse p a -> m (q a)
forall a. p a -> m (q a)
f g d p
left
   traverse forall a. p a -> m (q a)
f (InR h d p
right) = h d q -> Sum g h d q
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
h d s -> Sum g h d s
InR (h d q -> Sum g h d q) -> m (h d q) -> m (Sum g h d q)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Rank1.<$> (forall a. p a -> m (q a)) -> h d p -> m (h d 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 :: * -> *) (q :: * -> *).
Applicative m =>
(forall a. p a -> m (q a)) -> h d p -> m (h d q)
Rank2.traverse p a -> m (q a)
forall a. p a -> m (q a)
f h d p
right

instance (Functor t g, Functor t h) => Functor t (Sum g h) where
   t
t <$> :: t
-> Sum g h (Domain t) (Domain t)
-> Sum g h (Codomain t) (Codomain t)
<$> InL g (Domain t) (Domain t)
left = g (Codomain t) (Codomain t) -> Sum g h (Codomain t) (Codomain t)
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
g d s -> Sum g h d s
InL (t
t t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
forall t (g :: (* -> *) -> (* -> *) -> *).
Functor t g =>
t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
<$> g (Domain t) (Domain t)
left)
   t
t <$> InR h (Domain t) (Domain t)
right = h (Codomain t) (Codomain t) -> Sum g h (Codomain t) (Codomain t)
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
h d s -> Sum g h d s
InR (t
t t -> h (Domain t) (Domain t) -> h (Codomain t) (Codomain t)
forall t (g :: (* -> *) -> (* -> *) -> *).
Functor t g =>
t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
<$> h (Domain t) (Domain t)
right)

instance (Foldable t g, Foldable t h, Codomain t ~ Const m) => Foldable t (Sum g h) where
   foldMap :: forall m.
(Codomain t ~ Const m, Monoid m) =>
t -> Sum g h (Domain t) (Domain t) -> m
foldMap t
t (InL g (Domain t) (Domain t)
left) = t -> g (Domain t) (Domain t) -> m
forall m.
(Codomain t ~ Const m, Monoid m) =>
t -> g (Domain t) (Domain t) -> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> g (Domain t) (Domain t) -> m
foldMap t
t g (Domain t) (Domain t)
left
   foldMap t
t (InR h (Domain t) (Domain t)
right) = t -> h (Domain t) (Domain t) -> m
forall m.
(Codomain t ~ Const m, Monoid m) =>
t -> h (Domain t) (Domain t) -> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> g (Domain t) (Domain t) -> m
foldMap t
t h (Domain t) (Domain t)
right

instance (Traversable t g, Traversable t h, Codomain t ~ Compose m f, Rank1.Applicative m) =>
         Traversable t (Sum g h) where
   traverse :: forall (m :: * -> *) (f :: * -> *).
(Codomain t ~ Compose m f) =>
t -> Sum g h (Domain t) (Domain t) -> m (Sum g h f f)
traverse t
t (InL g (Domain t) (Domain t)
left) = g f f -> Sum g h f f
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
g d s -> Sum g h d s
InL (g f f -> Sum g h f f) -> m (g f f) -> m (Sum g h f f)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Rank1.<$> t -> g (Domain t) (Domain t) -> m (g f f)
forall t (g :: (* -> *) -> (* -> *) -> *) (m :: * -> *)
       (f :: * -> *).
(Traversable t g, Codomain t ~ Compose m f) =>
t -> g (Domain t) (Domain t) -> m (g f f)
forall (m :: * -> *) (f :: * -> *).
(Codomain t ~ Compose m f) =>
t -> g (Domain t) (Domain t) -> m (g f f)
traverse t
t g (Domain t) (Domain t)
left
   traverse t
t (InR h (Domain t) (Domain t)
right) = h f f -> Sum g h f f
forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
h d s -> Sum g h d s
InR (h f f -> Sum g h f f) -> m (h f f) -> m (Sum g h f f)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Rank1.<$> t -> h (Domain t) (Domain t) -> m (h f f)
forall t (g :: (* -> *) -> (* -> *) -> *) (m :: * -> *)
       (f :: * -> *).
(Traversable t g, Codomain t ~ Compose m f) =>
t -> g (Domain t) (Domain t) -> m (g f f)
forall (m :: * -> *) (f :: * -> *).
(Codomain t ~ Compose m f) =>
t -> h (Domain t) (Domain t) -> m (h f f)
traverse t
t h (Domain t) (Domain t)
right

deriving instance (Typeable d, Typeable s, Typeable g1, Typeable g2,
                   Data (g1 d s), Data (g2 d s)) => Data (Sum g1 g2 d s)
deriving instance (Show (g1 d s), Show (g2 d s)) => Show (Sum g1 g2 d s)
deriving instance (Eq (g d s), Eq (h d s)) => Eq (Sum g h d s)
deriving instance (Ord (g d s), Ord (h d s)) => Ord (Sum g h d s)

-- | Alphabetical synonym for '<$>'
fmap :: Functor t g => t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
fmap :: forall t (g :: (* -> *) -> (* -> *) -> *).
Functor t g =>
t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
fmap = t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
forall t (g :: (* -> *) -> (* -> *) -> *).
Functor t g =>
t -> g (Domain t) (Domain t) -> g (Codomain t) (Codomain t)
(<$>)

-- | Equivalent of 'Data.Either.either'
eitherFromSum :: Sum g h d s -> Either (g d s) (h d s)
eitherFromSum :: forall (g :: (* -> *) -> (* -> *) -> *)
       (h :: (* -> *) -> (* -> *) -> *) (d :: * -> *) (s :: * -> *).
Sum g h d s -> Either (g d s) (h d s)
eitherFromSum (InL g d s
left) = g d s -> Either (g d s) (h d s)
forall a b. a -> Either a b
Left g d s
left
eitherFromSum (InR h d s
right) = h d s -> Either (g d s) (h d s)
forall a b. b -> Either a b
Right h d s
right