{-# Language Haskell2010, DeriveDataTypeable, FlexibleInstances, KindSignatures, MultiParamTypeClasses, RankNTypes,
             GeneralizedNewtypeDeriving, 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 Data.String (IsString)
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
   -- | Apply the transformation to all descendants
   (<$>) :: 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)

-- | Ground type ignoring the wrappers
newtype Const2 (a :: Type) (deep :: Type -> Type) (shallow :: Type -> Type) = Const2{forall a (deep :: * -> *) (shallow :: * -> *).
Const2 a deep shallow -> a
getConst2 :: a}
   deriving (Const2 a deep shallow -> Const2 a deep shallow -> Bool
(Const2 a deep shallow -> Const2 a deep shallow -> Bool)
-> (Const2 a deep shallow -> Const2 a deep shallow -> Bool)
-> Eq (Const2 a deep shallow)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a (deep :: * -> *) (shallow :: * -> *).
Eq a =>
Const2 a deep shallow -> Const2 a deep shallow -> Bool
$c== :: forall a (deep :: * -> *) (shallow :: * -> *).
Eq a =>
Const2 a deep shallow -> Const2 a deep shallow -> Bool
== :: Const2 a deep shallow -> Const2 a deep shallow -> Bool
$c/= :: forall a (deep :: * -> *) (shallow :: * -> *).
Eq a =>
Const2 a deep shallow -> Const2 a deep shallow -> Bool
/= :: Const2 a deep shallow -> Const2 a deep shallow -> Bool
Eq, Eq (Const2 a deep shallow)
Eq (Const2 a deep shallow) =>
(Const2 a deep shallow -> Const2 a deep shallow -> Ordering)
-> (Const2 a deep shallow -> Const2 a deep shallow -> Bool)
-> (Const2 a deep shallow -> Const2 a deep shallow -> Bool)
-> (Const2 a deep shallow -> Const2 a deep shallow -> Bool)
-> (Const2 a deep shallow -> Const2 a deep shallow -> Bool)
-> (Const2 a deep shallow
    -> Const2 a deep shallow -> Const2 a deep shallow)
-> (Const2 a deep shallow
    -> Const2 a deep shallow -> Const2 a deep shallow)
-> Ord (Const2 a deep shallow)
Const2 a deep shallow -> Const2 a deep shallow -> Bool
Const2 a deep shallow -> Const2 a deep shallow -> Ordering
Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
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 a (deep :: * -> *) (shallow :: * -> *).
Ord a =>
Eq (Const2 a deep shallow)
forall a (deep :: * -> *) (shallow :: * -> *).
Ord a =>
Const2 a deep shallow -> Const2 a deep shallow -> Bool
forall a (deep :: * -> *) (shallow :: * -> *).
Ord a =>
Const2 a deep shallow -> Const2 a deep shallow -> Ordering
forall a (deep :: * -> *) (shallow :: * -> *).
Ord a =>
Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
$ccompare :: forall a (deep :: * -> *) (shallow :: * -> *).
Ord a =>
Const2 a deep shallow -> Const2 a deep shallow -> Ordering
compare :: Const2 a deep shallow -> Const2 a deep shallow -> Ordering
$c< :: forall a (deep :: * -> *) (shallow :: * -> *).
Ord a =>
Const2 a deep shallow -> Const2 a deep shallow -> Bool
< :: Const2 a deep shallow -> Const2 a deep shallow -> Bool
$c<= :: forall a (deep :: * -> *) (shallow :: * -> *).
Ord a =>
Const2 a deep shallow -> Const2 a deep shallow -> Bool
<= :: Const2 a deep shallow -> Const2 a deep shallow -> Bool
$c> :: forall a (deep :: * -> *) (shallow :: * -> *).
Ord a =>
Const2 a deep shallow -> Const2 a deep shallow -> Bool
> :: Const2 a deep shallow -> Const2 a deep shallow -> Bool
$c>= :: forall a (deep :: * -> *) (shallow :: * -> *).
Ord a =>
Const2 a deep shallow -> Const2 a deep shallow -> Bool
>= :: Const2 a deep shallow -> Const2 a deep shallow -> Bool
$cmax :: forall a (deep :: * -> *) (shallow :: * -> *).
Ord a =>
Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
max :: Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
$cmin :: forall a (deep :: * -> *) (shallow :: * -> *).
Ord a =>
Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
min :: Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
Ord, Int -> Const2 a deep shallow -> ShowS
[Const2 a deep shallow] -> ShowS
Const2 a deep shallow -> String
(Int -> Const2 a deep shallow -> ShowS)
-> (Const2 a deep shallow -> String)
-> ([Const2 a deep shallow] -> ShowS)
-> Show (Const2 a deep shallow)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a (deep :: * -> *) (shallow :: * -> *).
Show a =>
Int -> Const2 a deep shallow -> ShowS
forall a (deep :: * -> *) (shallow :: * -> *).
Show a =>
[Const2 a deep shallow] -> ShowS
forall a (deep :: * -> *) (shallow :: * -> *).
Show a =>
Const2 a deep shallow -> String
$cshowsPrec :: forall a (deep :: * -> *) (shallow :: * -> *).
Show a =>
Int -> Const2 a deep shallow -> ShowS
showsPrec :: Int -> Const2 a deep shallow -> ShowS
$cshow :: forall a (deep :: * -> *) (shallow :: * -> *).
Show a =>
Const2 a deep shallow -> String
show :: Const2 a deep shallow -> String
$cshowList :: forall a (deep :: * -> *) (shallow :: * -> *).
Show a =>
[Const2 a deep shallow] -> ShowS
showList :: [Const2 a deep shallow] -> ShowS
Show, String -> Const2 a deep shallow
(String -> Const2 a deep shallow)
-> IsString (Const2 a deep shallow)
forall a. (String -> a) -> IsString a
forall a (deep :: * -> *) (shallow :: * -> *).
IsString a =>
String -> Const2 a deep shallow
$cfromString :: forall a (deep :: * -> *) (shallow :: * -> *).
IsString a =>
String -> Const2 a deep shallow
fromString :: String -> Const2 a deep shallow
IsString, Integer -> Const2 a deep shallow
Const2 a deep shallow -> Const2 a deep shallow
Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
(Const2 a deep shallow
 -> Const2 a deep shallow -> Const2 a deep shallow)
-> (Const2 a deep shallow
    -> Const2 a deep shallow -> Const2 a deep shallow)
-> (Const2 a deep shallow
    -> Const2 a deep shallow -> Const2 a deep shallow)
-> (Const2 a deep shallow -> Const2 a deep shallow)
-> (Const2 a deep shallow -> Const2 a deep shallow)
-> (Const2 a deep shallow -> Const2 a deep shallow)
-> (Integer -> Const2 a deep shallow)
-> Num (Const2 a deep shallow)
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
forall a (deep :: * -> *) (shallow :: * -> *).
Num a =>
Integer -> Const2 a deep shallow
forall a (deep :: * -> *) (shallow :: * -> *).
Num a =>
Const2 a deep shallow -> Const2 a deep shallow
forall a (deep :: * -> *) (shallow :: * -> *).
Num a =>
Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
$c+ :: forall a (deep :: * -> *) (shallow :: * -> *).
Num a =>
Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
+ :: Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
$c- :: forall a (deep :: * -> *) (shallow :: * -> *).
Num a =>
Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
- :: Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
$c* :: forall a (deep :: * -> *) (shallow :: * -> *).
Num a =>
Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
* :: Const2 a deep shallow
-> Const2 a deep shallow -> Const2 a deep shallow
$cnegate :: forall a (deep :: * -> *) (shallow :: * -> *).
Num a =>
Const2 a deep shallow -> Const2 a deep shallow
negate :: Const2 a deep shallow -> Const2 a deep shallow
$cabs :: forall a (deep :: * -> *) (shallow :: * -> *).
Num a =>
Const2 a deep shallow -> Const2 a deep shallow
abs :: Const2 a deep shallow -> Const2 a deep shallow
$csignum :: forall a (deep :: * -> *) (shallow :: * -> *).
Num a =>
Const2 a deep shallow -> Const2 a deep shallow
signum :: Const2 a deep shallow -> Const2 a deep shallow
$cfromInteger :: forall a (deep :: * -> *) (shallow :: * -> *).
Num a =>
Integer -> Const2 a deep shallow
fromInteger :: Integer -> Const2 a deep shallow
Num)

-- | 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