-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Functors, theirs compositions and transformations
--   
--   Attempt to define categorical abstractions in more robust and useful
--   way.
@package morphisms-functors
@version 0.1.3

module Control.Functor.Contravariant

-- | <pre>
--   When providing a new instance, you should ensure it satisfies the two laws:
--   * Identity morphism: contramap identity ≡ identity
--   * Composition of morphisms: contramap f . contramap g ≡ contramap (g . f)
--   </pre>
class Contravariant (t :: * -> *)

-- | Infix version of <a>contramap</a>
(>$<) :: Contravariant t => (a -> b) -> t b -> t a

-- | Prefix version of <a>&gt;$&lt;</a>
contramap :: Contravariant t => (a -> b) -> t b -> t a

-- | Replace all locations in the output with the same value
(>$) :: Contravariant t => b -> t b -> t a

-- | Flipped version of <a>&gt;$</a>
($<) :: Contravariant t => t b -> b -> t a

-- | Fill the input of evaluation
full :: Contravariant t => t () -> t a

module Control.Functor.Covariant

-- | <pre>
--   When providing a new instance, you should ensure it satisfies the two laws:
--   * Identity morphism: comap identity ≡ identity
--   * Composition of morphisms: comap (f . g) ≡ comap f . comap g
--   </pre>
class Covariant (t :: * -> *)

-- | Infix version of <a>comap</a>
(<$>) :: Covariant t => (a -> b) -> t a -> t b

-- | Prefix version of <a>&lt;$&gt;</a>
comap :: Covariant t => (a -> b) -> t a -> t b

-- | Replace all locations in the input with the same value
(<$) :: Covariant t => a -> t b -> t a

-- | Flipped version of <a>&lt;$</a>
($>) :: Covariant t => t a -> b -> t b

-- | Discards the result of evaluation
void :: Covariant t => t a -> t ()

module Control.Functor.Composition
data Variant
Co :: Variant
Contra :: Variant
type (:.:) t u a = (Covariant t, Covariant u) => t (u a)
type (:.%) t u a = (Covariant t, Contravariant u) => t (u a)
type (%.:) t u a = (Contravariant t, Covariant u) => t (u a)
type (%.%) t u a = (Contravariant t, Contravariant u) => t (u a)

module Control.Functor.Composition.Extendable

-- | <pre>
--   When providing a new instance, you should ensure it satisfies the three laws:
--   * Duplication interchange: comap (comap f) . duplicate ≡ duplicate . comap f
--   * Extension interchange: extend f ≡ comap f . duplicate
--   </pre>
class Covariant t => Extendable t

-- | Infix and flipped version of <a>extend</a>, the dual of
--   <tt>&gt;&gt;=</tt>
(=>>) :: Extendable t => t a -> (t a -> b) -> t b

-- | Flipped version of <tt>&gt;&gt;=</tt>, the dual of <tt>=&lt;&lt;</tt>
(<<=) :: Extendable t => (t a -> b) -> t a -> t b

-- | Prefix and flipped version of <a>=&gt;&gt;</a>, the dual of
--   <tt>bind</tt>
extend :: Extendable t => (t a -> b) -> t a -> t b

-- | Clone existing structure, the dual of <tt>join</tt>
duplicate :: Extendable t => t a -> (t :.: t) a

module Control.Functor.Composition.Distributive

-- | <pre>
--   Let f :: Distributive g =&gt; (a -&gt; g b)
--   </pre>
--   
--   <pre>
--   When providing a new instance, you should ensure it satisfies the two laws:
--   * Identity morphism: distribute . distribute ≡ identity
--   * Interchange collection: collect f ≡ distribute . comap f
--   </pre>
class Covariant u => Distributive u

-- | Infix version of <a>collect</a>
(>>-) :: (Distributive u, Covariant t) => t a -> (a -> u b) -> (u :.: t) b

-- | Prefix version of <a>&gt;&gt;-</a>
collect :: (Distributive u, Covariant t) => (a -> u b) -> t a -> (u :.: t) b

-- | The dual of <tt>sequence</tt>
distribute :: (Distributive u, Covariant t) => (t :.: u) a -> (u :.: t) a

module Control.Functor.Composition.Bindable

-- | <pre>
--   When providing a new instance, you should ensure it satisfies the one law:
--   * Interchange: t &gt;&gt;= f = join (f &lt;$&gt; t)
--   </pre>
class Covariant t => Bindable t

-- | Infix and flipped version of <a>bind</a>, the dual of
--   <tt>=&gt;&gt;</tt>
(>>=) :: Bindable t => t a -> (a -> t b) -> t b

-- | Flipped version of <a>&gt;&gt;=</a>, the dual of <tt>&lt;&lt;=</tt>
(=<<) :: Bindable t => (a -> t b) -> t a -> t b

-- | Prefix and flipped version of <a>&gt;&gt;=</a>, the dual of
--   <tt>extend</tt>
bind :: Bindable t => (a -> t b) -> t a -> t b

-- | Merge effects/contexts, the dual of <tt>duplicate</tt>
join :: Bindable t => (t :.: t) a -> t a

module Control.Functor.Composition.Adjoint

-- | <pre>
--   When providing a new instance, you should ensure it satisfies the four laws:
--   * Left adjunction identity: phi counit ≡ identity
--   * Right adjunction identity: psi unit ≡ identity
--   * Left adjunction interchange: phi f ≡ comap f . eta
--   * Right adjunction interchange: psi f ≡ epsilon . comap f
--   </pre>
class (Covariant t, Covariant u) => Adjoint t u

-- | Left adjunction
phi :: Adjoint t u => (t a -> b) -> a -> u b

-- | Right adjunction
psi :: Adjoint t u => (a -> u b) -> t a -> b
eta :: Adjoint t u => a -> (u :.: t) a
epsilon :: Adjoint t u => (t :.: u) a -> a
type -| = Adjoint

module Control.Functor.Applicative

-- | <pre>
--   When providing a new instance, you should ensure it satisfies the three laws:
--   * Composition: (.) &lt;$&gt; u &lt;*&gt; v &lt;*&gt; w ≡ u &lt;*&gt; (v &lt;*&gt; w)
--   * Left interchange: x &lt;*&gt; (f &lt;$&gt; y) ≡ (. f) &lt;$&gt; x &lt;*&gt; y
--   * Right interchange: f &lt;$&gt; (x &lt;*&gt; y) ≡ (f .) &lt;$&gt; x &lt;*&gt; y
--   </pre>
class Covariant t => Applicative t

-- | Infix version of <a>apply</a>
(<*>) :: Applicative t => t (a -> b) -> t a -> t b

-- | Prefix version of <a>&lt;*&gt;</a>
apply :: Applicative t => t (a -> b) -> t a -> t b

-- | Sequence actions, discarding the value of the first argument
(*>) :: Applicative t => t a -> t b -> t b

-- | Sequence actions, discarding the value of the second argument
(<*) :: Applicative t => t a -> t b -> t a

-- | Repeat an action indefinitely
forever :: Applicative t => t a -> t b

module Control.Functor.Alternative

-- | <pre>
--   When providing a new instance, you should ensure it satisfies the two laws:
--   * Associativity of &lt;+&gt;: (x &lt;+&gt; y) &lt;+&gt; z ≡ x &lt;+&gt; (y &lt;+&gt; z)
--   * Left-distributes &lt;$&gt; over &lt;+&gt;: f &lt;$&gt; (x &lt;+&gt; y) ≡ (f &lt;$&gt; x) &lt;+&gt; (f &lt;$&gt; y)
--   </pre>
class Covariant t => Alternative t

-- | Infix version of <a>alter</a>
(<+>) :: Alternative t => t a -> t a -> t a

-- | Prefix version of <a>&lt;+&gt;</a>
alter :: Alternative t => t a -> t a -> t a

module Control.Functor.Exclusive
class Alternative t => Exclusive t
exclusive :: Exclusive t => t a

module Control.Functor.Extractable
class Extractable (t :: * -> *)
extract :: Extractable t => t a -> a

module Control.Functor.Composition.Comonad

-- | <pre>
--   Let f :: (Pointable t, Bindable t) =&gt; t a -&gt; b
--   Let g :: (Pointable t, Bindable t) =&gt; t a -&gt; b
--   </pre>
--   
--   <pre>
--   When using this constraint, you should ensure it satisfies the three laws:
--   * Left identity: extend extract ≡ identity
--   * Right identity: extract . extend f ≡ f
--   * Associativity: extend f . extend g ≡ extend (f . extend g)
--   </pre>
type Comonad t = (Extractable t, Extendable t)

module Control.Functor.Invariant

-- | <pre>
--   When providing a new instance, you should ensure it satisfies the two laws:
--   Identity morphisms: invmap identity identity = identity
--   Composition of morphisms: invmap g j . invmap f h = invmap (g . f) (h . j)
--   </pre>
class Invariant (t :: * -> *)

-- | Infix version of <a>invmap</a>
(<$<) :: Invariant t => (a -> b) -> (b -> a) -> t a -> t b

-- | Prefix version of <a>&lt;$&lt;</a>
invmap :: Invariant t => (a -> b) -> (b -> a) -> t a -> t b

-- | Flipped version of <a>&lt;$&lt;</a>
(>$>) :: Invariant t => (b -> a) -> (a -> b) -> t a -> t b

module Control.Functor.Pointable
class Pointable (t :: * -> *)
point :: Pointable t => a -> t a

module Control.Functor.Composition.Traversable

-- | <pre>
--   Let f :: (Applicative t, Applicative g) =&gt; t a -&gt; u a
--   Let p :: (Pointable t, Pointable g) =&gt; t a -&gt; u a
--   </pre>
--   
--   <pre>
--   When providing a new instance, you should ensure it satisfies the four laws:
--   * Naturality of traversing: g . traverse f ≡ traverse (g . f)
--   * Naturality of sequencing: f . sequence = sequence . comap f
--   * Preserving point: p (point x) ≡ point x
--   * Preserving apply: f (x &lt;*&gt; y) ≡ f x &lt;*&gt; f y
--   </pre>
class Covariant t => Traversable t

-- | Infix version of <a>traverse</a>
(->>) :: (Traversable t, Pointable u, Applicative u) => t a -> (a -> u b) -> (u :.: t) b

-- | Prefix version of <a>-&gt;&gt;</a>
traverse :: (Traversable t, Pointable u, Applicative u) => (a -> u b) -> t a -> (u :.: t) b

-- | The dual of <tt>distribute</tt>
sequence :: (Traversable t, Pointable u, Applicative u) => (t :.: u) a -> (u :.: t) a

module Control.Functor.Composition.Monad

-- | <pre>
--   Let f :: (Pointable t, Bindable t) =&gt; a -&gt; t a
--   Let g :: (Pointable t, Bindable t) =&gt; a -&gt; t a
--   Let h :: (Pointable t, Bindable t) =&gt; t a
--   </pre>
--   
--   <pre>
--   When using this constraint, you should ensure it satisfies the three laws:
--   * Left identity: point a &gt;&gt;= f ≡ f a
--   * Right identity: h &gt;&gt;= point ≡ h
--   * Associativity: h &gt;&gt;= (\x -&gt; f x &gt;&gt;= g) ≡ (h &gt;&gt;= f) &gt;&gt;= g
--   </pre>
type Monad t = (Pointable t, Bindable t)

module Control.Functor.Basic.TTT
newtype TTT ct cu cv cw t u v w a
TTT :: t (u (v (w a))) -> TTT ct cu cv cw t u v w a
[ttt] :: TTT ct cu cv cw t u v w a -> t (u (v (w a)))
instance (Control.Functor.Basic.TTT.Adjunctive t u, Control.Functor.Basic.TTT.Adjunctive t' u', Control.Functor.Basic.TTT.Adjunctive t'' u'', Control.Functor.Basic.TTT.Adjunctive t''' u''') => Control.Functor.Composition.Adjoint.Adjoint (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t t' t'' t''') (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co u u' u'' u''')
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v, Control.Functor.Covariant.Covariant w) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v w)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v, Control.Functor.Contravariant.Contravariant w) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra t u v w)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Contravariant.Contravariant v, Control.Functor.Covariant.Covariant w) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co t u v w)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Covariant.Covariant v, Control.Functor.Covariant.Covariant w) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v w)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v, Control.Functor.Covariant.Covariant w) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v w)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Covariant.Covariant v, Control.Functor.Covariant.Covariant w) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v w)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Contravariant.Contravariant v, Control.Functor.Covariant.Covariant w) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co t u v w)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Contravariant.Contravariant v, Control.Functor.Contravariant.Contravariant w) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra t u v w)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Covariant.Covariant v, Control.Functor.Contravariant.Contravariant w) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra t u v w)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Contravariant.Contravariant v, Control.Functor.Covariant.Covariant w) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co t u v w)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v, Control.Functor.Contravariant.Contravariant w) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra t u v w)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Contravariant.Contravariant v, Control.Functor.Covariant.Covariant w) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co t u v w)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Contravariant.Contravariant v, Control.Functor.Contravariant.Contravariant w) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra t u v w)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Contravariant.Contravariant v, Control.Functor.Contravariant.Contravariant w) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra t u v w)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Covariant.Covariant v, Control.Functor.Contravariant.Contravariant w) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra t u v w)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Contravariant.Contravariant v, Control.Functor.Contravariant.Contravariant w) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra t u v w)
instance (Control.Functor.Applicative.Applicative t, Control.Functor.Applicative.Applicative u, Control.Functor.Applicative.Applicative v, Control.Functor.Applicative.Applicative w) => Control.Functor.Applicative.Applicative (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v w)
instance (Control.Functor.Alternative.Alternative t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v, Control.Functor.Covariant.Covariant w) => Control.Functor.Alternative.Alternative (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v w)
instance (Control.Functor.Exclusive.Exclusive t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v, Control.Functor.Covariant.Covariant w) => Control.Functor.Exclusive.Exclusive (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v w)
instance (Control.Functor.Pointable.Pointable t, Control.Functor.Pointable.Pointable u, Control.Functor.Pointable.Pointable v, Control.Functor.Pointable.Pointable w) => Control.Functor.Pointable.Pointable (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v w)
instance (Control.Functor.Extractable.Extractable t, Control.Functor.Extractable.Extractable u, Control.Functor.Extractable.Extractable v, Control.Functor.Extractable.Extractable w) => Control.Functor.Extractable.Extractable (Control.Functor.Basic.TTT.TTT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v w)

module Control.Functor.Basic.TT
newtype TT ct cu cv t u v a
TT :: t (u (v a)) -> TT ct cu cv t u v a
[tt] :: TT ct cu cv t u v a -> t (u (v a))
instance (Control.Functor.Basic.TT.Adjunctive t w, Control.Functor.Basic.TT.Adjunctive v x, Control.Functor.Basic.TT.Adjunctive u y) => Control.Functor.Composition.Adjoint.Adjoint (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t v u) (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co w x y)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Contravariant.Contravariant v) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra t u v)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Covariant.Covariant v) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co t u v)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Covariant.Covariant v) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co t u v)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Contravariant.Contravariant v) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra t u v)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Contravariant.Contravariant v) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra t u v)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Contravariant.Contravariant v) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra t u v)
instance (Control.Functor.Applicative.Applicative t, Control.Functor.Applicative.Applicative u, Control.Functor.Applicative.Applicative v) => Control.Functor.Applicative.Applicative (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v)
instance (Control.Functor.Alternative.Alternative t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v) => Control.Functor.Alternative.Alternative (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v)
instance (Control.Functor.Exclusive.Exclusive t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v) => Control.Functor.Exclusive.Exclusive (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v)
instance (Control.Functor.Pointable.Pointable t, Control.Functor.Pointable.Pointable u, Control.Functor.Pointable.Pointable v) => Control.Functor.Pointable.Pointable (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v)
instance (Control.Functor.Extractable.Extractable t, Control.Functor.Extractable.Extractable u, Control.Functor.Extractable.Extractable v) => Control.Functor.Extractable.Extractable (Control.Functor.Basic.TT.TT 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u v)

module Control.Functor.Basic.T
newtype T ct cu t u a
T :: t (u a) -> T ct cu t u a
[t] :: T ct cu t u a -> t (u a)
instance (Control.Functor.Basic.T.Adjunctive t u, Control.Functor.Basic.T.Adjunctive v w) => Control.Functor.Composition.Adjoint.Adjoint (Control.Functor.Basic.T.T 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t v) (Control.Functor.Basic.T.T 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co u w)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Covariant.Covariant u) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.T.T 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Contravariant.Contravariant u) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.T.T 'Control.Functor.Composition.Co 'Control.Functor.Composition.Contra t u)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Covariant.Covariant u) => Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.T.T 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Co t u)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Contravariant.Contravariant u) => Control.Functor.Covariant.Covariant (Control.Functor.Basic.T.T 'Control.Functor.Composition.Contra 'Control.Functor.Composition.Contra t u)
instance (Control.Functor.Applicative.Applicative t, Control.Functor.Applicative.Applicative u) => Control.Functor.Applicative.Applicative (Control.Functor.Basic.T.T 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u)
instance (Control.Functor.Alternative.Alternative t, Control.Functor.Covariant.Covariant u) => Control.Functor.Alternative.Alternative (Control.Functor.Basic.T.T 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u)
instance (Control.Functor.Exclusive.Exclusive t, Control.Functor.Covariant.Covariant u) => Control.Functor.Exclusive.Exclusive (Control.Functor.Basic.T.T 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u)
instance (Control.Functor.Pointable.Pointable t, Control.Functor.Pointable.Pointable u) => Control.Functor.Pointable.Pointable (Control.Functor.Basic.T.T 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u)
instance (Control.Functor.Extractable.Extractable t, Control.Functor.Extractable.Extractable u) => Control.Functor.Extractable.Extractable (Control.Functor.Basic.T.T 'Control.Functor.Composition.Co 'Control.Functor.Composition.Co t u)

module Control.Functor.Basic.Identity
newtype Identity a
Identity :: a -> Identity a
instance Control.Functor.Covariant.Covariant Control.Functor.Basic.Identity.Identity
instance Control.Functor.Applicative.Applicative Control.Functor.Basic.Identity.Identity
instance Control.Functor.Pointable.Pointable Control.Functor.Basic.Identity.Identity
instance Control.Functor.Extractable.Extractable Control.Functor.Basic.Identity.Identity
instance Control.Functor.Composition.Traversable.Traversable Control.Functor.Basic.Identity.Identity
instance Control.Functor.Composition.Distributive.Distributive Control.Functor.Basic.Identity.Identity
instance Control.Functor.Composition.Bindable.Bindable Control.Functor.Basic.Identity.Identity
instance Control.Functor.Composition.Extendable.Extendable Control.Functor.Basic.Identity.Identity
instance Control.Functor.Composition.Adjoint.Adjoint Control.Functor.Basic.Identity.Identity Control.Functor.Basic.Identity.Identity

module Control.Functor.Basic.Constant
newtype Constant a b
Constant :: a -> Constant a b
instance Control.Functor.Covariant.Covariant (Control.Functor.Basic.Constant.Constant a)
instance Control.Functor.Contravariant.Contravariant (Control.Functor.Basic.Constant.Constant a)
instance Control.Functor.Composition.Traversable.Traversable (Control.Functor.Basic.Constant.Constant a)

module Control.Transformation.Natural
type Natural t u = forall a. (Covariant t, Covariant u) => t a -> u a
type (~>) t u = Natural t u