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

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.Covariant.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.Covariant.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.Covariant.Exclusive
class Alternative t => Exclusive t
exclusive :: Exclusive t => t a

module Control.Functor.Covariant.Extractable
class Covariant t => Extractable t
extract :: Extractable t => t a -> a

module Control.Functor.Covariant.Pointable
class Covariant t => Pointable t
point :: Pointable t => a -> t a

module Control.Functor.Covariant.Transformation.Liftable
class Liftable (t :: (* -> *) -> * -> *)
lift :: (Liftable t, Covariant u) => u a -> t u a

module Control.Functor.Covariant.Transformation.Lowerable
class Lowerable (t :: (* -> *) -> * -> *)
lower :: (Lowerable t, Covariant u) => t u a -> u a

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.Polyvariant.Bicontravariant
class Bicontravariant t
bicontramap :: Bicontravariant t => (b -> a) -> (d -> c) -> t a c -> t b d

module Control.Functor.Polyvariant.Bicovariant
class Bicovariant t
bicomap :: Bicovariant t => (a -> b) -> (c -> d) -> t a c -> t b d

module Control.Functor.Polyvariant.Orpvariant
class Orpvariant t
orpmap :: Orpvariant t => (a -> b) -> (c -> d) -> t a d -> t b c

module Control.Functor.Polyvariant.Provariant
class Provariant t
promap :: Provariant t => (a -> b) -> (c -> d) -> t b c -> t a d

module Control.Functor.Polyvariant.Quadcontravariant
class Quadcontravariant t
quadcontramap :: Quadcontravariant t => (b -> a) -> (d -> c) -> (f -> e) -> (h -> g) -> t a c e g -> t b d f h

module Control.Functor.Polyvariant.Quadcovariant
class Quadcovariant t
quadcomap :: Quadcovariant t => (a -> b) -> (c -> d) -> (e -> f) -> (g -> h) -> t a c e g -> t b d f h

module Control.Functor.Polyvariant.Tricontravariant
class Tricontravariant t
tricontramap :: Tricontravariant t => (b -> a) -> (d -> c) -> (f -> e) -> t a c e -> t b d f

module Control.Functor.Polyvariant.Tricovariant
class Tricovariant t
tricomap :: Tricovariant t => (a -> b) -> (c -> d) -> (e -> f) -> t a c e -> t b d f

module Control.Variance
data Variant
Co :: Variant
Contra :: Variant
type (:.:) t u a = t (u a)

module Control.Functor.Covariant.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.Covariant.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

-- | Right-to-left Cokleisli composition
(=<=) :: Extendable t => (t b -> c) -> (t a -> b) -> t a -> c

-- | Left-to-right Cokleisli composition
(=>=) :: Extendable t => (t a -> b) -> (t b -> c) -> t a -> c

module Control.Functor.Covariant.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 providing a new instance, 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>
class (Extractable t, Extendable t) => Comonad t

module Control.Functor.Covariant.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.Covariant.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

-- | Left-to-right Kleisli composition
(>=>) :: Bindable t => (a -> t b) -> (b -> t c) -> (a -> t c)

-- | Right-to-left Kleisli composition
(<=<) :: Bindable t => (b -> t c) -> (a -> t b) -> (a -> t c)

module Control.Functor.Covariant.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 providing a new instance, 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>
class (Pointable t, Bindable t) => Monad t

module Control.Functor.Covariant.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

module Data.Functor.Arrow.Opposite
newtype Opposite a b
Opposite :: b -> a -> Opposite a b
[opposite] :: Opposite a b -> b -> a
instance Control.Functor.Contravariant.Contravariant (Data.Functor.Arrow.Opposite.Opposite a)
instance Control.Functor.Polyvariant.Orpvariant.Orpvariant Data.Functor.Arrow.Opposite.Opposite

module Data.Functor.Arrow.Straight
newtype Straight a b
Straight :: a -> b -> Straight a b
[straight] :: Straight a b -> a -> b
instance Control.Functor.Covariant.Covariant (Data.Functor.Arrow.Straight.Straight a)
instance Control.Functor.Covariant.Applicative.Applicative (Data.Functor.Arrow.Straight.Straight a)
instance Control.Functor.Polyvariant.Provariant.Provariant Data.Functor.Arrow.Straight.Straight

module Data.Functor.Codensity
data Codensity (t :: * -> *) (a :: *)
Codensity :: (a -> t b) -> t b -> Codensity
[codensity] :: Codensity -> (a -> t b) -> t b
instance Control.Functor.Covariant.Covariant (Data.Functor.Codensity.Codensity t)
instance Control.Functor.Covariant.Pointable.Pointable (Data.Functor.Codensity.Codensity t)

module Data.Functor.Composition.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 (Data.Functor.Composition.T.Adjunctive t u, Data.Functor.Composition.T.Adjunctive v w) => Control.Functor.Covariant.Composition.Adjoint.Adjoint (Data.Functor.Composition.T.T 'Control.Variance.Co 'Control.Variance.Co t v) (Data.Functor.Composition.T.T 'Control.Variance.Co 'Control.Variance.Co u w)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Covariant.Covariant u) => Control.Functor.Covariant.Covariant (Data.Functor.Composition.T.T 'Control.Variance.Co 'Control.Variance.Co t u)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Contravariant.Contravariant u) => Control.Functor.Contravariant.Contravariant (Data.Functor.Composition.T.T 'Control.Variance.Co 'Control.Variance.Contra t u)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Covariant.Covariant u) => Control.Functor.Contravariant.Contravariant (Data.Functor.Composition.T.T 'Control.Variance.Contra 'Control.Variance.Co t u)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Contravariant.Contravariant u) => Control.Functor.Covariant.Covariant (Data.Functor.Composition.T.T 'Control.Variance.Contra 'Control.Variance.Contra t u)
instance (Control.Functor.Covariant.Applicative.Applicative t, Control.Functor.Covariant.Applicative.Applicative u) => Control.Functor.Covariant.Applicative.Applicative (Data.Functor.Composition.T.T 'Control.Variance.Co 'Control.Variance.Co t u)
instance (Control.Functor.Covariant.Alternative.Alternative t, Control.Functor.Covariant.Covariant u) => Control.Functor.Covariant.Alternative.Alternative (Data.Functor.Composition.T.T 'Control.Variance.Co 'Control.Variance.Co t u)
instance (Control.Functor.Covariant.Exclusive.Exclusive t, Control.Functor.Covariant.Covariant u) => Control.Functor.Covariant.Exclusive.Exclusive (Data.Functor.Composition.T.T 'Control.Variance.Co 'Control.Variance.Co t u)
instance (Control.Functor.Covariant.Pointable.Pointable t, Control.Functor.Covariant.Pointable.Pointable u) => Control.Functor.Covariant.Pointable.Pointable (Data.Functor.Composition.T.T 'Control.Variance.Co 'Control.Variance.Co t u)
instance (Control.Functor.Covariant.Extractable.Extractable t, Control.Functor.Covariant.Extractable.Extractable u) => Control.Functor.Covariant.Extractable.Extractable (Data.Functor.Composition.T.T 'Control.Variance.Co 'Control.Variance.Co t u)

module Data.Functor.Composition.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 (Data.Functor.Composition.TT.Adjunctive t w, Data.Functor.Composition.TT.Adjunctive v x, Data.Functor.Composition.TT.Adjunctive u y) => Control.Functor.Covariant.Composition.Adjoint.Adjoint (Data.Functor.Composition.TT.TT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t v u) (Data.Functor.Composition.TT.TT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co w x y)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v) => Control.Functor.Covariant.Covariant (Data.Functor.Composition.TT.TT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t u v)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Contravariant.Contravariant v) => Control.Functor.Contravariant.Contravariant (Data.Functor.Composition.TT.TT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Contra t u v)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Covariant.Covariant v) => Control.Functor.Contravariant.Contravariant (Data.Functor.Composition.TT.TT 'Control.Variance.Co 'Control.Variance.Contra 'Control.Variance.Co t u v)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v) => Control.Functor.Contravariant.Contravariant (Data.Functor.Composition.TT.TT 'Control.Variance.Contra 'Control.Variance.Co 'Control.Variance.Co t u v)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Covariant.Covariant v) => Control.Functor.Covariant.Covariant (Data.Functor.Composition.TT.TT 'Control.Variance.Contra 'Control.Variance.Contra 'Control.Variance.Co t u v)
instance (Control.Functor.Covariant.Covariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Contravariant.Contravariant v) => Control.Functor.Covariant.Covariant (Data.Functor.Composition.TT.TT 'Control.Variance.Co 'Control.Variance.Contra 'Control.Variance.Contra t u v)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Covariant.Covariant u, Control.Functor.Contravariant.Contravariant v) => Control.Functor.Covariant.Covariant (Data.Functor.Composition.TT.TT 'Control.Variance.Contra 'Control.Variance.Co 'Control.Variance.Contra t u v)
instance (Control.Functor.Contravariant.Contravariant t, Control.Functor.Contravariant.Contravariant u, Control.Functor.Contravariant.Contravariant v) => Control.Functor.Contravariant.Contravariant (Data.Functor.Composition.TT.TT 'Control.Variance.Contra 'Control.Variance.Contra 'Control.Variance.Contra t u v)
instance (Control.Functor.Covariant.Applicative.Applicative t, Control.Functor.Covariant.Applicative.Applicative u, Control.Functor.Covariant.Applicative.Applicative v) => Control.Functor.Covariant.Applicative.Applicative (Data.Functor.Composition.TT.TT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t u v)
instance (Control.Functor.Covariant.Alternative.Alternative t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v) => Control.Functor.Covariant.Alternative.Alternative (Data.Functor.Composition.TT.TT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t u v)
instance (Control.Functor.Covariant.Exclusive.Exclusive t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v) => Control.Functor.Covariant.Exclusive.Exclusive (Data.Functor.Composition.TT.TT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t u v)
instance (Control.Functor.Covariant.Pointable.Pointable t, Control.Functor.Covariant.Pointable.Pointable u, Control.Functor.Covariant.Pointable.Pointable v) => Control.Functor.Covariant.Pointable.Pointable (Data.Functor.Composition.TT.TT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t u v)
instance (Control.Functor.Covariant.Extractable.Extractable t, Control.Functor.Covariant.Extractable.Extractable u, Control.Functor.Covariant.Extractable.Extractable v) => Control.Functor.Covariant.Extractable.Extractable (Data.Functor.Composition.TT.TT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t u v)

module Data.Functor.Composition.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 (Data.Functor.Composition.TTT.Adjunctive t u, Data.Functor.Composition.TTT.Adjunctive t' u', Data.Functor.Composition.TTT.Adjunctive t'' u'', Data.Functor.Composition.TTT.Adjunctive t''' u''') => Control.Functor.Covariant.Composition.Adjoint.Adjoint (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t t' t'' t''') (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Contra 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Contra 'Control.Variance.Co 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Contra 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Contra 'Control.Variance.Contra 'Control.Variance.Co 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Contra 'Control.Variance.Contra 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Contra 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Contra 'Control.Variance.Co 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Contra 'Control.Variance.Co 'Control.Variance.Contra 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Contra 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Contra 'Control.Variance.Contra 'Control.Variance.Contra 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Contra 'Control.Variance.Contra 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Contra 'Control.Variance.Co 'Control.Variance.Contra 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Contra 'Control.Variance.Contra 'Control.Variance.Co 'Control.Variance.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 (Data.Functor.Composition.TTT.TTT 'Control.Variance.Contra 'Control.Variance.Contra 'Control.Variance.Contra 'Control.Variance.Contra t u v w)
instance (Control.Functor.Covariant.Applicative.Applicative t, Control.Functor.Covariant.Applicative.Applicative u, Control.Functor.Covariant.Applicative.Applicative v, Control.Functor.Covariant.Applicative.Applicative w) => Control.Functor.Covariant.Applicative.Applicative (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t u v w)
instance (Control.Functor.Covariant.Alternative.Alternative t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v, Control.Functor.Covariant.Covariant w) => Control.Functor.Covariant.Alternative.Alternative (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t u v w)
instance (Control.Functor.Covariant.Exclusive.Exclusive t, Control.Functor.Covariant.Covariant u, Control.Functor.Covariant.Covariant v, Control.Functor.Covariant.Covariant w) => Control.Functor.Covariant.Exclusive.Exclusive (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t u v w)
instance (Control.Functor.Covariant.Pointable.Pointable t, Control.Functor.Covariant.Pointable.Pointable u, Control.Functor.Covariant.Pointable.Pointable v, Control.Functor.Covariant.Pointable.Pointable w) => Control.Functor.Covariant.Pointable.Pointable (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t u v w)
instance (Control.Functor.Covariant.Extractable.Extractable t, Control.Functor.Covariant.Extractable.Extractable u, Control.Functor.Covariant.Extractable.Extractable v, Control.Functor.Covariant.Extractable.Extractable w) => Control.Functor.Covariant.Extractable.Extractable (Data.Functor.Composition.TTT.TTT 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co 'Control.Variance.Co t u v w)

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

module Data.Functor.Extension.Kan
data Ran (t :: * -> *) (u :: * -> *) (a :: *)
Ran :: (a -> t b) -> u b -> Ran
[ran] :: Ran -> (a -> t b) -> u b
data Lan (t :: * -> *) (u :: * -> *) (a :: *)
Lan :: (t b -> a) -> u b -> Lan
[lan] :: Lan -> (t b -> a) -> u b
instance Control.Functor.Contravariant.Contravariant (Data.Functor.Extension.Kan.Lan t u)
instance Control.Functor.Covariant.Covariant (Data.Functor.Extension.Kan.Ran t u)

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

module Data.Functor.Product
data Product a b
(:&:) :: a -> b -> Product a b
type :&: = Product
instance Control.Functor.Covariant.Covariant (Data.Functor.Product.Product a)
instance Control.Functor.Covariant.Extractable.Extractable (Data.Functor.Product.Product a)
instance Control.Functor.Polyvariant.Bicovariant.Bicovariant Data.Functor.Product.Product

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

module Data.Functor.Yoneda
newtype Yoneda (t :: * -> *) (a :: *)
Yoneda :: forall b. (a -> b) -> t b -> Yoneda
[yoneda] :: Yoneda -> forall b. (a -> b) -> t b
instance Control.Functor.Covariant.Covariant (Data.Functor.Yoneda.Yoneda t)
instance Control.Functor.Covariant.Applicative.Applicative t => Control.Functor.Covariant.Applicative.Applicative (Data.Functor.Yoneda.Yoneda t)
instance Control.Functor.Covariant.Alternative.Alternative t => Control.Functor.Covariant.Alternative.Alternative (Data.Functor.Yoneda.Yoneda t)
instance Control.Functor.Covariant.Exclusive.Exclusive t => Control.Functor.Covariant.Exclusive.Exclusive (Data.Functor.Yoneda.Yoneda t)
instance Control.Functor.Covariant.Pointable.Pointable t => Control.Functor.Covariant.Pointable.Pointable (Data.Functor.Yoneda.Yoneda t)
instance Control.Functor.Covariant.Extractable.Extractable t => Control.Functor.Covariant.Extractable.Extractable (Data.Functor.Yoneda.Yoneda t)
instance Control.Functor.Covariant.Transformation.Liftable.Liftable Data.Functor.Yoneda.Yoneda
instance Control.Functor.Covariant.Transformation.Lowerable.Lowerable Data.Functor.Yoneda.Yoneda
instance Control.Functor.Covariant.Composition.Traversable.Traversable t => Control.Functor.Covariant.Composition.Traversable.Traversable (Data.Functor.Yoneda.Yoneda t)
instance Control.Functor.Covariant.Composition.Distributive.Distributive t => Control.Functor.Covariant.Composition.Distributive.Distributive (Data.Functor.Yoneda.Yoneda t)
instance (Control.Functor.Covariant.Extractable.Extractable t, Control.Functor.Covariant.Pointable.Pointable t, Control.Functor.Covariant.Extractable.Extractable u, Control.Functor.Covariant.Pointable.Pointable u) => Control.Functor.Covariant.Composition.Adjoint.Adjoint (Data.Functor.Yoneda.Yoneda t) (Data.Functor.Yoneda.Yoneda u)
instance Control.Functor.Covariant.Composition.Bindable.Bindable t => Control.Functor.Covariant.Composition.Bindable.Bindable (Data.Functor.Yoneda.Yoneda t)
instance Control.Functor.Covariant.Composition.Extendable.Extendable t => Control.Functor.Covariant.Composition.Extendable.Extendable (Data.Functor.Yoneda.Yoneda t)

module Data.Functor