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


-- | The double category of Hask functors and profunctors
--   
--   A library for working with natural transformations of type
--   
--   <pre>
--   forall a b. p a b -&gt; q (f a) (g b)
--   </pre>
@package squares
@version 0.1


-- | Utilities for type level lists.
module Data.Type.List

-- | Type level list append
type family (as :: [k]) ++ (bs :: [k]) :: [k]


module Data.Profunctor.Composition.List

-- | N-ary composition of profunctors.
data PList (ps :: [* -> * -> *]) (a :: *) (b :: *)
[Hom] :: {unHom :: a -> b} -> PList '[] a b
[P] :: {unP :: p a b} -> PList '[p] a b
[PComp] :: p a x -> PList (q : qs) x b -> PList (p : (q : qs)) a b

-- | Calculate the simplified type of the composition of a list of
--   profunctors.
type family PlainP (ps :: [* -> * -> *]) :: * -> * -> *

-- | Functions for working with <a>PList</a>s.
class IsPList ps

-- | Combine 2 nested <a>PList</a>s into one <a>PList</a>.
pappend :: (IsPList ps, Profunctor (PList qs)) => Procompose (PList qs) (PList ps) :-> PList (ps ++ qs)

-- | Split one <a>PList</a> into 2 nested <a>PList</a>s.
punappend :: IsPList ps => PList (ps ++ qs) :-> Procompose (PList qs) (PList ps)

-- | Convert a <a>PList</a> to its simplified form.
toPlainP :: IsPList ps => PList ps :-> PlainP ps

-- | Create a <a>PList</a> from its simplified form.
fromPlainP :: IsPList ps => PlainP ps :-> PList ps
instance Data.Profunctor.Composition.List.IsPList '[]
instance Data.Profunctor.Unsafe.Profunctor p => Data.Profunctor.Composition.List.IsPList '[p]
instance Data.Profunctor.Composition.List.IsPList (q : qs) => Data.Profunctor.Composition.List.IsPList (p : q : qs)
instance Data.Profunctor.Unsafe.Profunctor (Data.Profunctor.Composition.List.PList '[])
instance Data.Profunctor.Unsafe.Profunctor p => Data.Profunctor.Unsafe.Profunctor (Data.Profunctor.Composition.List.PList '[p])
instance (Data.Profunctor.Unsafe.Profunctor p, Data.Profunctor.Unsafe.Profunctor (Data.Profunctor.Composition.List.PList (q : qs))) => Data.Profunctor.Unsafe.Profunctor (Data.Profunctor.Composition.List.PList (p : q : qs))


module Data.Functor.Compose.List

-- | N-ary composition of functors.
--   
--   <pre>
--   FList '[] a ~ a
--   FList '[f, g, h] a ~ h (g (f a))
--   </pre>
data FList (fs :: [* -> *]) (a :: *)
[Id] :: {unId :: a} -> FList '[] a
[F] :: {unF :: f a} -> FList '[f] a
[FComp] :: {unFComp :: FList (g : gs) (f a)} -> FList (f : (g : gs)) a

-- | Calculate the simplified type of the composition of a list of
--   functors.
type family PlainF (fs :: [* -> *]) (a :: *) :: *

-- | Functions for working with <a>FList</a>s.
class IsFList fs

-- | Combine 2 nested <a>FList</a>s into one <a>FList</a>.
fappend :: (IsFList fs, Functor (FList gs)) => FList gs (FList fs a) -> FList (fs ++ gs) a

-- | Split one <a>FList</a> into 2 nested <a>FList</a>s.
funappend :: (IsFList fs, Functor (FList gs)) => FList (fs ++ gs) a -> FList gs (FList fs a)

-- | Convert an <a>FList</a> to its simplified form.
toPlainF :: IsFList fs => FList fs a -> PlainF fs a

-- | Create an <a>FList</a> from its simplified form.
fromPlainF :: IsFList fs => PlainF fs a -> FList fs a

-- | Natural transformations between two functors. (Why is this still not
--   in base??)
type f ~> g = forall a. f a -> g a
instance Data.Functor.Compose.List.IsFList '[]
instance Data.Functor.Compose.List.IsFList '[f]
instance Data.Functor.Compose.List.IsFList (g : gs) => Data.Functor.Compose.List.IsFList (f : g : gs)
instance GHC.Base.Functor (Data.Functor.Compose.List.FList '[])
instance GHC.Base.Functor f => GHC.Base.Functor (Data.Functor.Compose.List.FList '[f])
instance (GHC.Base.Functor f, GHC.Base.Functor (Data.Functor.Compose.List.FList (g : gs))) => GHC.Base.Functor (Data.Functor.Compose.List.FList (f : g : gs))


module Data.Square

-- | <pre>
--   +-----+
--   |     |
--   |     |
--   |     |
--   +-----+
--   </pre>
--   
--   <pre>
--   forall a b. (a -&gt; b) -&gt; (a -&gt; b)
--   </pre>
--   
--   The empty square is the identity transformation.
emptySquare :: Square '[] '[] '[] '[]

-- | <pre>
--   +-----+
--   |     |
--   p-----p
--   |     |
--   +-----+
--   </pre>
--   
--   <pre>
--   forall a b. p a b -&gt; p a b
--   </pre>
--   
--   Profunctors are drawn as horizontal lines.
--   
--   Note that <a>emptySquare</a> is <a>proId</a> for the profunctor
--   <tt>(-&gt;)</tt>. We don't draw a line for <tt>(-&gt;)</tt> because it
--   is the identity for profunctor composition.
proId :: Profunctor p => Square '[p] '[p] '[] '[]

-- | <pre>
--   +--f--+
--   |  |  |
--   |  v  |
--   |  |  |
--   +--f--+
--   </pre>
--   
--   <pre>
--   forall a b. (a -&gt; b) -&gt; (f a -&gt; f b)
--   </pre>
--   
--   Functors are drawn with vertical lines with arrow heads. You will
--   recognize the above type as <a>fmap</a>!
--   
--   We don't draw lines for the identity functor, because it is the
--   identity for functor composition.
funId :: Functor f => Square '[] '[] '[f] '[f]

-- | <pre>
--   +--f--+
--   |  |  |
--   |  @  |
--   |  |  |
--   +--g--+
--   </pre>
--   
--   <pre>
--   forall a b. (a -&gt; b) -&gt; (f a -&gt; g b)
--   </pre>
--   
--   Non-identity transformations are drawn with an <tt>@</tt> in the
--   middle. Natural transformations between haskell functors are usualy
--   given the type <tt>forall a. f a -&gt; g a</tt>. The type above you
--   get when <a>fmap</a>ping before or after. (It doesn't matter which,
--   because of naturality!)
funNat :: (Functor f, Functor g) => (f ~> g) -> Square '[] '[] '[f] '[g]

-- | <pre>
--   +-----+
--   |     |
--   p--@--q
--   |     |
--   +-----+
--   </pre>
--   
--   <pre>
--   forall a b. p a b -&gt; q a b
--   </pre>
--   
--   Natural transformations between profunctors.
proNat :: (Profunctor p, Profunctor q) => (p :-> q) -> Square '[p] '[q] '[] '[]

-- | <pre>
--   +--f--+
--   |  v  |
--   p--@--q
--   |  v  |
--   +--g--+
--   </pre>
--   
--   <pre>
--   forall a b. p a b -&gt; q (f a) (g b)
--   </pre>
--   
--   The complete definition of a square is a combination of natural
--   transformations between functors and natural transformations between
--   profunctors.
--   
--   To make type inferencing easier the above type is wrapped by a
--   newtype.
newtype SquareNT p q f g
Square :: (forall a b. p a b -> q (f a) (g b)) -> SquareNT p q f g
[unSquare] :: SquareNT p q f g -> forall a b. p a b -> q (f a) (g b)

-- | To make composing squares associative, this library uses squares with
--   lists of functors and profunctors, which are composed together.
--   
--   <pre>
--   FList '[] a ~ a
--   FList '[f, g, h] a ~ h (g (f a))
--   PList '[] a b ~ a -&gt; b
--   PList '[p, q, r] a b ~ (p a x, q x y, r y b)
--   </pre>
type Square ps qs fs gs = SquareNT (PList ps) (PList qs) (FList fs) (FList gs)

-- | A helper function to add the wrappers needed for <a>PList</a> and
--   <a>FList</a>.
mkSquare :: (IsPList ps, IsPList qs, IsFList fs, IsFList gs, Profunctor (PList qs)) => (forall a b. PlainP ps a b -> PlainP qs (PlainF fs a) (PlainF gs b)) -> Square ps qs fs gs

-- | A helper function to remove the wrappers needed for <a>PList</a> and
--   <a>FList</a>.
runSquare :: (IsPList ps, IsPList qs, IsFList fs, IsFList gs, Profunctor (PList qs)) => Square ps qs fs gs -> PlainP ps a b -> PlainP qs (PlainF fs a) (PlainF gs b)

-- | <pre>
--   +--f--+     +--h--+       +--f--h--+
--   |  v  |     |  v  |       |  v  v  |
--   p--@--q ||| q--@--r  ==&gt;  p--@--@--r
--   |  v  |     |  v  |       |  v  v  |
--   +--g--+     +--i--+       +--g--i--+
--   </pre>
--   
--   Horizontal composition of squares. <a>proId</a> is the identity of
--   `(|||)`. This is regular function composition of the underlying
--   functions.
(|||) :: (Profunctor (PList rs), IsFList fs, IsFList gs, Functor (FList hs), Functor (FList is)) => Square ps qs fs gs -> Square qs rs hs is -> Square ps rs (fs ++ hs) (gs ++ is)
infixl 6 |||

-- | <pre>
--   +--f--+
--   |  v  |
--   p--@--q              +--f--+
--   |  v  |              |  v  |
--   +--g--+              p--@--q
--     ===        ==&gt;     |  v  |
--   +--g--+              r--@--s
--   |  v  |              |  v  |
--   r--@--s              +--h--+
--   |  v  |
--   +--h--+
--   </pre>
--   
--   Vertical composition of squares. <a>funId</a> is the identity of
--   `(===)`.
(===) :: (IsPList ps, IsPList qs, Profunctor (PList ss)) => Square ps qs fs gs -> Square rs ss gs hs -> Square (ps ++ rs) (qs ++ ss) fs hs
infixl 5 ===

-- | <pre>
--   +--f--+
--   |  v  |
--   |  \-&gt;f
--   |     |
--   +-----+
--   </pre>
--   
--   A functor <tt>f</tt> can be bent to the right to become the profunctor
--   <tt><a>Star</a> f</tt>.
toRight :: Functor f => Square '[] '[Star f] '[f] '[]

-- | <pre>
--   +--f--+
--   |  v  |
--   f&lt;-/  |
--   |     |
--   +-----+
--   </pre>
--   
--   A functor <tt>f</tt> can be bent to the left to become the profunctor
--   <tt><a>Costar</a> f</tt>.
toLeft :: Functor f => Square '[Costar f] '[] '[f] '[]

-- | <pre>
--   +-----+
--   |     |
--   |  /-&lt;f
--   |  v  |
--   +--f--+
--   </pre>
--   
--   The profunctor <tt><a>Costar</a> f</tt> can be bent down to become the
--   functor <tt>f</tt> again.
fromRight :: Functor f => Square '[] '[Costar f] '[] '[f]

-- | <pre>
--   +-----+
--   |     |
--   f&gt;-\  |
--   |  v  |
--   +--f--+
--   </pre>
--   
--   The profunctor <tt><a>Star</a> f</tt> can be bent down to become the
--   functor <tt>f</tt> again.
fromLeft :: Functor f => Square '[Star f] '[] '[] '[f]

-- | <pre>
--   +-----+
--   f&gt;-\  |         fromLeft
--   |  v  |         ===
--   f&lt;-/  |         toLeft
--   +-----+
--   </pre>
--   
--   <a>fromLeft</a> and <a>toLeft</a> can be composed vertically to bend
--   <tt><a>Star</a> f</tt> back to <tt><a>Costar</a> f</tt>.
uLeft :: Functor f => Square '[Star f, Costar f] '[] '[] '[]

-- | <pre>
--   +-----+
--   |  /-&lt;f         fromRight
--   |  v  |         ===
--   |  \-&gt;f         toRight
--   +-----+
--   </pre>
--   
--   <a>fromRight</a> and <a>toRight</a> can be composed vertically to bend
--   <tt><a>Costar</a> f</tt> to <tt><a>Star</a> f</tt>.
uRight :: Functor f => Square '[] '[Costar f, Star f] '[] '[]

-- | <pre>
--   +f-f-f+     +--f--+     spiderLemma n =
--   |v v v|     f&gt; v &lt;f       fromLeft ||| funId ||| fromRight
--   | \|/ |     | \|/ |       ===
--   p--@--q ==&gt; p--@--q       n
--   | /|\ |     | /|\ |       ===
--   |v v v|     g&lt; v &gt;g       toLeft ||| funId ||| toRight
--   +g-g-g+     +--g--+
--   </pre>
--   
--   The spider lemma is an example how bending wires can also be seen as
--   sliding functors around corners.
spiderLemma :: (Profunctor p, Profunctor q, Functor f1, Functor f2, Functor f3, Functor g1, Functor g2, Functor g3) => Square '[p] '[q] '[f1, f2, f3] '[g1, g2, g3] -> Square '[Star f1, p, Costar g1] '[Costar f3, q, Star g3] '[f2] '[g2]

-- | <pre>
--   spiderLemma' n = (toRight === proId === fromRight) ||| n ||| (toLeft === proId === fromLeft)
--   </pre>
--   
--   The spider lemma in the other direction.
spiderLemma' :: (Profunctor p, Profunctor q, Functor f1, Functor f2, Functor f3, Functor g1, Functor g2, Functor g3) => Square '[Star f1, p, Costar g1] '[Costar f3, q, Star g3] '[f2] '[g2] -> Square '[p] '[q] '[f1, f2, f3] '[g1, g2, g3]

-- | <pre>
--   H²-f--H
--   |  v  |
--   p--@--q     H = Hask, H² = Hask x Hask
--   |  v  |
--   H²-g--H
--   </pre>
type Square21 ps1 ps2 qs f g = SquareNT (PList ps1 :**: PList ps2) (PList qs) (UncurryF f) (UncurryF g)

-- | Combine two profunctors from Hask to a profunctor from Hask x Hask
data ( p1 :**: p2 ) a b
[:**:] :: p1 a1 b1 -> p2 a2 b2 -> (p1 :**: p2) '(a1, a2) '(b1, b2)

-- | Uncurry the kind of a bifunctor.
--   
--   <pre>
--   type UncurryF :: (a -&gt; b -&gt; Type) -&gt; (a, b) -&gt; Type
--   </pre>
data UncurryF f a
[UncurryF] :: {curryF :: f a b} -> UncurryF f '(a, b)

-- | <pre>
--   1--a--H
--   |  v  |
--   U--@--q     1 = Hask^0 = (), H = Hask
--   |  v  |
--   1--b--H
--   </pre>
type Square01 qs a b = SquareNT Unit (PList qs) (ValueF a) (ValueF b)

-- | The boring profunctor from and to the unit category.
data Unit a b
[Unit] :: Unit  '()  '()

-- | Values as a functor from the unit category.
data ValueF x u
[ValueF] :: a -> ValueF a  '()


module Data.Traversable.Square

-- | <pre>
--   +--t--+
--   |  v  |
--   f&gt;-T-&gt;f
--   |  v  |
--   +--t--+
--   </pre>
--   
--   <a>traverse</a> as a square.
--   
--   Naturality law:
--   
--   <pre>
--   +-----t--+     +--t-----+
--   |     v  |     |  v     |
--   f&gt;-@-&gt;T-&gt;g === f&gt;-T-&gt;@-&gt;g
--   |     v  |     |  v     |
--   +-----t--+     +--t-----+
--   </pre>
--   
--   Identity law:
--   
--   <pre>
--   +--t--+     +--t--+
--   |  v  |     |  |  |
--   |  T  | === |  v  |
--   |  v  |     |  |  |
--   +--t--+     +--t--+
--   </pre>
--   
--   Composition law:
--   
--   <pre>
--   +--t--+     +--t--+
--   |  v  |     |  v  |
--   f&gt;-T-&gt;f     f&gt;\|/&gt;f
--   |  v  | === |  T  |
--   g&gt;-T-&gt;g     g&gt;/|\&gt;g
--   |  v  |     |  v  |
--   +--t--+     +--t--+
--   </pre>
traverse :: (Traversable t, Applicative f) => Square '[Star f] '[Star f] '[t] '[t]

-- | <pre>
--   +-f-t---+
--   | v v   |
--   | \-@-\ |
--   |   v v |
--   +---t-f-+
--   </pre>
--   
--   <pre>
--   sequence = toRight ||| traverse ||| fromLeft
--   </pre>
sequence :: (Traversable t, Applicative f) => Square '[] '[] '[f, t] '[t, f]


module Data.Profunctor.Square

-- | <pre>
--   +-a⊗_-+
--   |  v  |
--   p--@--p
--   |  v  |
--   +-a⊗_-+
--   </pre>
second :: Strong p => Square '[p] '[p] '[(,) a] '[(,) a]

-- | <pre>
--   +-a⊕_-+
--   |  v  |
--   p--@--p
--   |  v  |
--   +-a⊕_-+
--   </pre>
right :: Choice p => Square '[p] '[p] '[Either a] '[Either a]

-- | <pre>
--   +-a→_-+
--   |  v  |
--   p--@--p
--   |  v  |
--   +-a→_-+
--   </pre>
closed :: Closed p => Square '[p] '[p] '[(->) a] '[(->) a]

-- | <pre>
--   +--f--+
--   |  v  |
--   p--@--p
--   |  v  |
--   +--f--+
--   </pre>
map :: (Mapping p, Functor f) => Square '[p] '[p] '[f] '[f]

-- | <pre>
--    +-----+
--    |     |
--   (→)-@  |
--    |     |
--    +-----+
--   </pre>
fromHom :: Square '[(->)] '[] '[] '[]

-- | <pre>
--   +-----+
--   |     |
--   |  @-(→)
--   |     |
--   +-----+
--   </pre>
toHom :: Square '[] '[(->)] '[] '[]

-- | <pre>
--    +-----+
--    |   /-p
--   q.p-@  |
--    |   \-q
--    +-----+
--   </pre>
fromProcompose :: (Profunctor p, Profunctor q) => Square '[Procompose q p] '[p, q] '[] '[]

-- | <pre>
--   +-----+
--   p-\   |
--   |  @-q.p
--   q-/   |
--   +-----+
--   </pre>
toProcompose :: (Profunctor p, Profunctor q) => Square '[p, q] '[Procompose q p] '[] '[]


module Data.Functor.Square

-- | <pre>
--   +--I--+
--   |  v  |
--   |  @  |
--   |     |
--   +-----+
--   </pre>
fromIdentity :: Square '[] '[] '[Identity] '[]

-- | <pre>
--   +-----+
--   |     |
--   |  @  |
--   |  v  |
--   +--I--+
--   </pre>
toIdentity :: Square '[] '[] '[] '[Identity]

-- | <pre>
--   +-g.f-+
--   |  v  |
--   | /@\ |
--   | v v |
--   +-f-g-+
--   </pre>
fromCompose :: (Functor f, Functor g) => Square '[] '[] '[Compose g f] '[f, g]

-- | <pre>
--   +-f-g-+
--   | v v |
--   | \@/ |
--   |  v  |
--   +-g.f-+
--   </pre>
toCompose :: (Functor f, Functor g) => Square '[] '[] '[f, g] '[Compose g f]


module Data.Functor.Rep.Square

-- | <pre>
--   +-k→_-+
--   |  v  |
--   |  @  |
--   |  v  |
--   +--f--+
--   </pre>
tabulate :: Representable f => Square '[] '[] '[(->) (Rep f)] '[f]

-- | <pre>
--   +--f--+
--   |  v  |
--   |  @  |
--   |  v  |
--   +-k→_-+
--   </pre>
index :: Representable f => Square '[] '[] '[f] '[(->) (Rep f)]


module Data.Functor.Adjunction.Square

-- | <pre>
--   +-----+
--   |     |
--   f&lt;-@-&gt;g
--   |     |
--   +-----+
--   </pre>
--   
--   <pre>
--   leftAdjunct = unit === (toLeft ||| toRight)
--   </pre>
leftAdjunct :: Adjunction f g => Square '[Costar f] '[Star g] '[] '[]

-- | <pre>
--   +-----+
--   |     |
--   g&gt;-@-&lt;f
--   |     |
--   +-----+
--   </pre>
--   
--   <pre>
--   rightAdjunct = (fromLeft ||| fromRight) === counit
--   </pre>
rightAdjunct :: Adjunction f g => Square '[Star g] '[Costar f] '[] '[]

-- | <pre>
--   +-----+
--   |     |
--   | /@\ |
--   | v v |
--   +-f-g-+
--   </pre>
--   
--   <pre>
--   unit = fromRight ||| leftAdj ||| fromLeft
--   </pre>
unit :: Adjunction f g => Square '[] '[] '[] '[f, g]

-- | <pre>
--   +-g-f-+
--   | v v |
--   | \@/ |
--   |     |
--   +-----+
--   </pre>
--   
--   <pre>
--   counit = toRight ||| rightAdjoint ||| toLeft
--   </pre>
counit :: Adjunction f g => Square '[] '[] '[g, f] '[]


module Data.Distributive.Square

-- | <pre>
--   +--t--+
--   |  v  |
--   f&lt;-@-&lt;f
--   |  v  |
--   +--t--+
--   </pre>
--   
--   <pre>
--   cotraverse = (funId ||| fromRight) === distribute === (toLeft ||| funId)
--   </pre>
cotraverse :: (Distributive t, Functor f) => Square '[Costar f] '[Costar f] '[t] '[t]

-- | <pre>
--   +---t-f-+
--   |   v v |
--   | /-@-/ |
--   | v v   |
--   +-f-t---+
--   </pre>
--   
--   <pre>
--   distribute = fromRight ||| cotraverse ||| toLeft
--   </pre>
distribute :: (Distributive t, Functor f) => Square '[] '[] '[t, f] '[f, t]


module Control.Monad.Square

-- | <pre>
--   +-----+
--   |     |
--   |  R  |
--   |  v  |
--   +--m--+
--   </pre>
return :: Monad m => Square '[] '[] '[] '[m]

-- | <pre>
--   +--m--+
--   |  v  |
--   m&gt;-B  |
--   |  v  |
--   +--m--+
--   </pre>
--   
--   `(&gt;&gt;=)` as a square (or to be precise its flipped version
--   `(=&lt;&lt;)`)
--   
--   Left identity law:
--   
--   <pre>
--   +-----+
--   |  R  |     +-----+
--   |  v  |     |     |
--   m&gt;-B  | === m&gt;-\  |
--   |  v  |     |  v  |
--   +--m--+     +--m--+
--   </pre>
--   
--   Right identity law:
--   
--   <pre>
--   +---m-+
--   | R v |     +--m--+
--   | v | |     |  |  |
--   | \-B | === |  v  |
--   |   v |     |  |  |
--   +---m-+     +--m--+
--   </pre>
--   
--   Associativity law:
--   
--   <pre>
--   +--m--+     +---m-+
--   |  v  |     m&gt;\ v |
--   m&gt;-B  |     | v | |
--   |  v  | === m&gt;B | |
--   m&gt;-B  |     | \-B |
--   |  v  |     |   v |
--   +--m--+     +---m-+
--   </pre>
bind :: Monad m => Square '[Star m] '[] '[m] '[m]

-- | <pre>
--   +-m-m-+
--   | v v |
--   | \-@ |
--   |   v |
--   +---m-+
--   </pre>
--   
--   <pre>
--   join = toRight ||| bind
--   </pre>
join :: Monad m => Square '[] '[] '[m, m] '[m]

-- | <pre>
--   +-----+
--   m&gt;-\  |
--   m&gt;-@  |
--   |  \-&gt;m
--   +-----+
--   </pre>
--   
--   Kleisli composition `(M.&gt;=&gt;)`
--   
--   <pre>
--   (&gt;=&gt;) = fromLeft === bind === toRight
--   </pre>
(>=>) :: Monad m => Square '[Star m, Star m] '[Star m] '[] '[]


module Control.Comonad.Square

-- | <pre>
--   +--w--+
--   |  v  |
--   |  X  |
--   |     |
--   +-----+
--   </pre>
extract :: Comonad w => Square '[] '[] '[w] '[]

-- | <pre>
--   +--w--+
--   |  v  |
--   w&lt;-E  |
--   |  v  |
--   +--w--+
--   </pre>
--   
--   <a>extend</a> as a square
--   
--   Right identity law:
--   
--   <pre>
--   +--w--+
--   |  v  |     +--w--+
--   w&lt;-E  |     |  v  |
--   |  v  | === w&lt;-/  |
--   |  X  |     |     |
--   +-----+     +-----+
--   </pre>
--   
--   Left identity law:
--   
--   <pre>
--   +---w-+
--   |   v |     +--w--+
--   | /-E |     |  |  |
--   | v | | === |  v  |
--   | X v |     |  |  |
--   +---w-+     +--w--+
--   </pre>
--   
--   Associativity law:
--   
--   <pre>
--   +--w--+     +---w-+
--   |  v  |     |   v |
--   w&lt;-E  |     | /-E |
--   |  v  | === w&lt;E | |
--   w&lt;-E  |     | | | |
--   |  v  |     w&lt;/ v |
--   +--w--+     +---w-+
--   </pre>
extend :: Comonad w => Square '[Costar w] '[] '[w] '[w]

-- | <pre>
--   +---w-+
--   |   v |
--   | /-@ |
--   | v v |
--   +-w-w-+
--   </pre>
--   
--   <pre>
--   duplicate = fromRight ||| extend
--   </pre>
duplicate :: Comonad w => Square '[] '[] '[w] '[w, w]

-- | <pre>
--   +-----+
--   |  /-&lt;w
--   w&lt;-@  |
--   w&lt;-/  |
--   +-----+
--   </pre>
--   
--   Cokleisli composition `(W.&lt;=&lt;)`
--   
--   <pre>
--   (&lt;=&lt;) = fromRight === extend === toLeft
--   </pre>
(<=<) :: Comonad w => Square '[Costar w, Costar w] '[Costar w] '[] '[]


module Control.Arrow.Square

-- | <pre>
--   +-----+
--   |     |
--   |  @--a
--   |     |
--   +-----+
--   </pre>
arr :: (Arrow a, Profunctor a) => Square '[] '[a] '[] '[]

-- | <pre>
--   +-----+
--   a--\  |
--   |  @--a
--   a--/  |
--   +-----+
--   </pre>
(>>>) :: (Arrow a, Profunctor a) => Square '[a, a] '[a] '[] '[]

-- | <pre>
--   +-_⊗d-+
--   |  v  |
--   a--@--a
--   |  v  |
--   +-_⊗d-+
--   </pre>
second :: (Arrow a, Profunctor a) => Square '[a] '[a] '[(,) d] '[(,) d]

-- | <pre>
--   H²-⊗--H
--   |  v  |
--   a²-@--a
--   |  v  |
--   H²-⊗--H
--   </pre>
(***) :: Arrow a => Square21 '[a] '[a] '[a] (,) (,)

-- | <pre>
--   +-_⊕d-+
--   |  v  |
--   a--@--a
--   |  v  |
--   +-_⊕d-+
--   </pre>
right :: (ArrowChoice a, Profunctor a) => Square '[a] '[a] '[Either d] '[Either d]

-- | <pre>
--   H²-⊕--H
--   |  v  |
--   a²-@--a
--   |  v  |
--   H²-⊕--H
--   </pre>
(+++) :: ArrowChoice a => Square21 '[a] '[a] '[a] Either Either


module Data.Foldable.Square

-- | <pre>
--   +--f--+
--   |  v  |
--   !m-@-!m
--   |  ?  |
--   +--?--+
--   </pre>
--   
--   <a>foldMap</a> as a square. Note that because <a>Forget</a> ignores
--   its output parameter, this square can have any list of functors as
--   output type.
foldMap :: (Foldable f, Monoid m, IsFList gs) => Square '[Forget m] '[Forget m] '[f] gs