    {-# LANGUAGE PolyKinds #-}
    {-# LANGUAGE RankNTypes #-}
    {-# LANGUAGE Trustworthy #-}
    -----------------------------------------------------------------------------
    -- |
    -- Copyright   :  (C) 2014-2015 Edward Kmett
    -- License     :  BSD-style (see the file LICENSE)
    --
    -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
    -- Stability   :  experimental
    -- Portability :  portable
    --
    ----------------------------------------------------------------------------

    module Data.Profunctor.Cayley where

    import Control.Applicative
    import Control.Arrow
    import Control.Category
    import Control.Comonad
    import Data.Profunctor
    import Data.Profunctor.Monad
    import Data.Profunctor.Traversing
    import Data.Profunctor.Unsafe
    import Prelude hiding ((.), id)

    -- | Static arrows. Lifted by 'Applicative'.
    --
    -- 'Cayley' has a polymorphic kind since @5.6@.

    -- Cayley :: (k3 -> Type) -> (k1 -> k2 -> k3) -> (k1 -> k2 -> Type)
    newtype Cayley f p a b = Cayley { forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley :: f (p a b) }

    instance Functor f => ProfunctorFunctor (Cayley f) where
      promap :: forall (p :: * -> * -> *) (q :: * -> * -> *).
    Profunctor p =>
    (p :-> q) -> Cayley f p :-> Cayley f q
    promap p :-> q
    f (Cayley f (p a b)
    p) = f (q a b) -> Cayley f q a b
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley ((p a b -> q a b) -> f (p a b) -> f (q a b)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p a b -> q a b
    p :-> q
    f f (p a b)
    p)

    -- | Cayley transforms Monads in @Hask@ into monads on @Prof@
    instance (Functor f, Monad f) => ProfunctorMonad (Cayley f) where
      proreturn :: forall (p :: * -> * -> *). Profunctor p => p :-> Cayley f p
    proreturn = f (p a b) -> Cayley f p a b
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p a b) -> Cayley f p a b)
    -> (p a b -> f (p a b)) -> p a b -> Cayley f p a b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . p a b -> f (p a b)
    forall a. a -> f a
    forall (m :: * -> *) a. Monad m => a -> m a
    return
      projoin :: forall (p :: * -> * -> *).
    Profunctor p =>
    Cayley f (Cayley f p) :-> Cayley f p
    projoin (Cayley f (Cayley f p a b)
    m) = f (p a b) -> Cayley f p a b
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p a b) -> Cayley f p a b) -> f (p a b) -> Cayley f p a b
    forall a b. (a -> b) -> a -> b
    $ f (Cayley f p a b)
    m f (Cayley f p a b) -> (Cayley f p a b -> f (p a b)) -> f (p a b)
    forall a b. f a -> (a -> f b) -> f b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= Cayley f p a b -> f (p a b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley

    -- | Cayley transforms Comonads in @Hask@ into comonads on @Prof@
    instance Comonad f => ProfunctorComonad (Cayley f) where
      proextract :: forall (p :: * -> * -> *). Profunctor p => Cayley f p :-> p
    proextract = f (p a b) -> p a b
    forall a. f a -> a
    forall (w :: * -> *) a. Comonad w => w a -> a
    extract (f (p a b) -> p a b)
    -> (Cayley f p a b -> f (p a b)) -> Cayley f p a b -> p a b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p a b -> f (p a b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley
      produplicate :: forall (p :: * -> * -> *).
    Profunctor p =>
    Cayley f p :-> Cayley f (Cayley f p)
    produplicate (Cayley f (p a b)
    w) = f (Cayley f p a b) -> Cayley f (Cayley f p) a b
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (Cayley f p a b) -> Cayley f (Cayley f p) a b)
    -> f (Cayley f p a b) -> Cayley f (Cayley f p) a b
    forall a b. (a -> b) -> a -> b
    $ (f (p a b) -> Cayley f p a b) -> f (p a b) -> f (Cayley f p a b)
    forall a b. (f a -> b) -> f a -> f b
    forall (w :: * -> *) a b. Comonad w => (w a -> b) -> w a -> w b
    extend f (p a b) -> Cayley f p a b
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley f (p a b)
    w

    instance (Functor f, Profunctor p) => Profunctor (Cayley f p) where
      dimap :: forall a b c d.
    (a -> b) -> (c -> d) -> Cayley f p b c -> Cayley f p a d
    dimap a -> b
    f c -> d
    g = f (p a d) -> Cayley f p a d
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p a d) -> Cayley f p a d)
    -> (Cayley f p b c -> f (p a d))
    -> Cayley f p b c
    -> Cayley f p a d
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p b c -> p a d) -> f (p b c) -> f (p a d)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((a -> b) -> (c -> d) -> p b c -> p a d
    forall a b c d. (a -> b) -> (c -> d) -> p b c -> p a d
    forall (p :: * -> * -> *) a b c d.
    Profunctor p =>
    (a -> b) -> (c -> d) -> p b c -> p a d
    dimap a -> b
    f c -> d
    g) (f (p b c) -> f (p a d))
    -> (Cayley f p b c -> f (p b c)) -> Cayley f p b c -> f (p a d)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p b c -> f (p b c)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley
      lmap :: forall a b c. (a -> b) -> Cayley f p b c -> Cayley f p a c
    lmap a -> b
    f = f (p a c) -> Cayley f p a c
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p a c) -> Cayley f p a c)
    -> (Cayley f p b c -> f (p a c))
    -> Cayley f p b c
    -> Cayley f p a c
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p b c -> p a c) -> f (p b c) -> f (p a c)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((a -> b) -> p b c -> p a c
    forall a b c. (a -> b) -> p b c -> p a c
    forall (p :: * -> * -> *) a b c.
    Profunctor p =>
    (a -> b) -> p b c -> p a c
    lmap a -> b
    f) (f (p b c) -> f (p a c))
    -> (Cayley f p b c -> f (p b c)) -> Cayley f p b c -> f (p a c)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p b c -> f (p b c)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley
      rmap :: forall b c a. (b -> c) -> Cayley f p a b -> Cayley f p a c
    rmap b -> c
    g = f (p a c) -> Cayley f p a c
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p a c) -> Cayley f p a c)
    -> (Cayley f p a b -> f (p a c))
    -> Cayley f p a b
    -> Cayley f p a c
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p a b -> p a c) -> f (p a b) -> f (p a c)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((b -> c) -> p a b -> p a c
    forall b c a. (b -> c) -> p a b -> p a c
    forall (p :: * -> * -> *) b c a.
    Profunctor p =>
    (b -> c) -> p a b -> p a c
    rmap b -> c
    g) (f (p a b) -> f (p a c))
    -> (Cayley f p a b -> f (p a b)) -> Cayley f p a b -> f (p a c)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p a b -> f (p a b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley
      q b c
    w #. :: forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> Cayley f p a b -> Cayley f p a c
    #. Cayley f (p a b)
    fp = f (p a c) -> Cayley f p a c
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p a c) -> Cayley f p a c) -> f (p a c) -> Cayley f p a c
    forall a b. (a -> b) -> a -> b
    $ (p a b -> p a c) -> f (p a b) -> f (p a c)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (q b c
    w q b c -> p a b -> p a c
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> p a b -> p a c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #.) f (p a b)
    fp
      Cayley f (p b c)
    fp .# :: forall a b c (q :: * -> * -> *).
    Coercible b a =>
    Cayley f p b c -> q a b -> Cayley f p a c
    .# q a b
    w = f (p a c) -> Cayley f p a c
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p a c) -> Cayley f p a c) -> f (p a c) -> Cayley f p a c
    forall a b. (a -> b) -> a -> b
    $ (p b c -> p a c) -> f (p b c) -> f (p a c)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (p b c -> q a b -> p a c
    forall a b c (q :: * -> * -> *).
    Coercible b a =>
    p b c -> q a b -> p a c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible b a) =>
    p b c -> q a b -> p a c
    .# q a b
    w) f (p b c)
    fp

    instance (Functor f, Strong p) => Strong (Cayley f p) where
      first' :: forall a b c. Cayley f p a b -> Cayley f p (a, c) (b, c)
    first'  = f (p (a, c) (b, c)) -> Cayley f p (a, c) (b, c)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (a, c) (b, c)) -> Cayley f p (a, c) (b, c))
    -> (Cayley f p a b -> f (p (a, c) (b, c)))
    -> Cayley f p a b
    -> Cayley f p (a, c) (b, c)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p a b -> p (a, c) (b, c)) -> f (p a b) -> f (p (a, c) (b, c))
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p a b -> p (a, c) (b, c)
    forall a b c. p a b -> p (a, c) (b, c)
    forall (p :: * -> * -> *) a b c.
    Strong p =>
    p a b -> p (a, c) (b, c)
    first' (f (p a b) -> f (p (a, c) (b, c)))
    -> (Cayley f p a b -> f (p a b))
    -> Cayley f p a b
    -> f (p (a, c) (b, c))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p a b -> f (p a b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley
      second' :: forall a b c. Cayley f p a b -> Cayley f p (c, a) (c, b)
    second' = f (p (c, a) (c, b)) -> Cayley f p (c, a) (c, b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (c, a) (c, b)) -> Cayley f p (c, a) (c, b))
    -> (Cayley f p a b -> f (p (c, a) (c, b)))
    -> Cayley f p a b
    -> Cayley f p (c, a) (c, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p a b -> p (c, a) (c, b)) -> f (p a b) -> f (p (c, a) (c, b))
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p a b -> p (c, a) (c, b)
    forall a b c. p a b -> p (c, a) (c, b)
    forall (p :: * -> * -> *) a b c.
    Strong p =>
    p a b -> p (c, a) (c, b)
    second' (f (p a b) -> f (p (c, a) (c, b)))
    -> (Cayley f p a b -> f (p a b))
    -> Cayley f p a b
    -> f (p (c, a) (c, b))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p a b -> f (p a b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley

    instance (Functor f, Costrong p) => Costrong (Cayley f p) where
      unfirst :: forall a d b. Cayley f p (a, d) (b, d) -> Cayley f p a b
    unfirst (Cayley f (p (a, d) (b, d))
    fp) = f (p a b) -> Cayley f p a b
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley ((p (a, d) (b, d) -> p a b) -> f (p (a, d) (b, d)) -> f (p a b)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p (a, d) (b, d) -> p a b
    forall a d b. p (a, d) (b, d) -> p a b
    forall (p :: * -> * -> *) a d b.
    Costrong p =>
    p (a, d) (b, d) -> p a b
    unfirst f (p (a, d) (b, d))
    fp)
      unsecond :: forall d a b. Cayley f p (d, a) (d, b) -> Cayley f p a b
    unsecond (Cayley f (p (d, a) (d, b))
    fp) = f (p a b) -> Cayley f p a b
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley ((p (d, a) (d, b) -> p a b) -> f (p (d, a) (d, b)) -> f (p a b)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p (d, a) (d, b) -> p a b
    forall d a b. p (d, a) (d, b) -> p a b
    forall (p :: * -> * -> *) d a b.
    Costrong p =>
    p (d, a) (d, b) -> p a b
    unsecond f (p (d, a) (d, b))
    fp)

    instance (Functor f, Choice p) => Choice (Cayley f p) where
      left' :: forall a b c.
    Cayley f p a b -> Cayley f p (Either a c) (Either b c)
    left'   = f (p (Either a c) (Either b c))
    -> Cayley f p (Either a c) (Either b c)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (Either a c) (Either b c))
     -> Cayley f p (Either a c) (Either b c))
    -> (Cayley f p a b -> f (p (Either a c) (Either b c)))
    -> Cayley f p a b
    -> Cayley f p (Either a c) (Either b c)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p a b -> p (Either a c) (Either b c))
    -> f (p a b) -> f (p (Either a c) (Either b c))
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p a b -> p (Either a c) (Either b c)
    forall a b c. p a b -> p (Either a c) (Either b c)
    forall (p :: * -> * -> *) a b c.
    Choice p =>
    p a b -> p (Either a c) (Either b c)
    left' (f (p a b) -> f (p (Either a c) (Either b c)))
    -> (Cayley f p a b -> f (p a b))
    -> Cayley f p a b
    -> f (p (Either a c) (Either b c))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p a b -> f (p a b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley
      right' :: forall a b c.
    Cayley f p a b -> Cayley f p (Either c a) (Either c b)
    right'  = f (p (Either c a) (Either c b))
    -> Cayley f p (Either c a) (Either c b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (Either c a) (Either c b))
     -> Cayley f p (Either c a) (Either c b))
    -> (Cayley f p a b -> f (p (Either c a) (Either c b)))
    -> Cayley f p a b
    -> Cayley f p (Either c a) (Either c b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p a b -> p (Either c a) (Either c b))
    -> f (p a b) -> f (p (Either c a) (Either c b))
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p a b -> p (Either c a) (Either c b)
    forall a b c. p a b -> p (Either c a) (Either c b)
    forall (p :: * -> * -> *) a b c.
    Choice p =>
    p a b -> p (Either c a) (Either c b)
    right' (f (p a b) -> f (p (Either c a) (Either c b)))
    -> (Cayley f p a b -> f (p a b))
    -> Cayley f p a b
    -> f (p (Either c a) (Either c b))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p a b -> f (p a b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley

    instance (Functor f, Cochoice p) => Cochoice (Cayley f p) where
      unleft :: forall a d b.
    Cayley f p (Either a d) (Either b d) -> Cayley f p a b
    unleft (Cayley f (p (Either a d) (Either b d))
    fp) = f (p a b) -> Cayley f p a b
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley ((p (Either a d) (Either b d) -> p a b)
    -> f (p (Either a d) (Either b d)) -> f (p a b)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p (Either a d) (Either b d) -> p a b
    forall a d b. p (Either a d) (Either b d) -> p a b
    forall (p :: * -> * -> *) a d b.
    Cochoice p =>
    p (Either a d) (Either b d) -> p a b
    unleft f (p (Either a d) (Either b d))
    fp)
      {-# INLINE unleft #-}
      unright :: forall d a b.
    Cayley f p (Either d a) (Either d b) -> Cayley f p a b
    unright (Cayley f (p (Either d a) (Either d b))
    fp) = f (p a b) -> Cayley f p a b
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley ((p (Either d a) (Either d b) -> p a b)
    -> f (p (Either d a) (Either d b)) -> f (p a b)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p (Either d a) (Either d b) -> p a b
    forall d a b. p (Either d a) (Either d b) -> p a b
    forall (p :: * -> * -> *) d a b.
    Cochoice p =>
    p (Either d a) (Either d b) -> p a b
    unright f (p (Either d a) (Either d b))
    fp)
      {-# INLINE unright #-}

    instance (Functor f, Closed p) => Closed (Cayley f p) where
      closed :: forall a b x. Cayley f p a b -> Cayley f p (x -> a) (x -> b)
    closed = f (p (x -> a) (x -> b)) -> Cayley f p (x -> a) (x -> b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (x -> a) (x -> b)) -> Cayley f p (x -> a) (x -> b))
    -> (Cayley f p a b -> f (p (x -> a) (x -> b)))
    -> Cayley f p a b
    -> Cayley f p (x -> a) (x -> b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p a b -> p (x -> a) (x -> b))
    -> f (p a b) -> f (p (x -> a) (x -> b))
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p a b -> p (x -> a) (x -> b)
    forall a b x. p a b -> p (x -> a) (x -> b)
    forall (p :: * -> * -> *) a b x.
    Closed p =>
    p a b -> p (x -> a) (x -> b)
    closed (f (p a b) -> f (p (x -> a) (x -> b)))
    -> (Cayley f p a b -> f (p a b))
    -> Cayley f p a b
    -> f (p (x -> a) (x -> b))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p a b -> f (p a b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley

    instance (Functor f, Traversing p) => Traversing (Cayley f p) where
      traverse' :: forall (f :: * -> *) a b.
    Traversable f =>
    Cayley f p a b -> Cayley f p (f a) (f b)
    traverse' = f (p (f a) (f b)) -> Cayley f p (f a) (f b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (f a) (f b)) -> Cayley f p (f a) (f b))
    -> (Cayley f p a b -> f (p (f a) (f b)))
    -> Cayley f p a b
    -> Cayley f p (f a) (f b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p a b -> p (f a) (f b)) -> f (p a b) -> f (p (f a) (f b))
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p a b -> p (f a) (f b)
    forall (f :: * -> *) a b. Traversable f => p a b -> p (f a) (f b)
    forall (p :: * -> * -> *) (f :: * -> *) a b.
    (Traversing p, Traversable f) =>
    p a b -> p (f a) (f b)
    traverse' (f (p a b) -> f (p (f a) (f b)))
    -> (Cayley f p a b -> f (p a b))
    -> Cayley f p a b
    -> f (p (f a) (f b))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p a b -> f (p a b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley

    instance (Functor f, Mapping p) => Mapping (Cayley f p) where
      map' :: forall (f :: * -> *) a b.
    Functor f =>
    Cayley f p a b -> Cayley f p (f a) (f b)
    map' = f (p (f a) (f b)) -> Cayley f p (f a) (f b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (f a) (f b)) -> Cayley f p (f a) (f b))
    -> (Cayley f p a b -> f (p (f a) (f b)))
    -> Cayley f p a b
    -> Cayley f p (f a) (f b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p a b -> p (f a) (f b)) -> f (p a b) -> f (p (f a) (f b))
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p a b -> p (f a) (f b)
    forall (f :: * -> *) a b. Functor f => p a b -> p (f a) (f b)
    forall (p :: * -> * -> *) (f :: * -> *) a b.
    (Mapping p, Functor f) =>
    p a b -> p (f a) (f b)
    map' (f (p a b) -> f (p (f a) (f b)))
    -> (Cayley f p a b -> f (p a b))
    -> Cayley f p a b
    -> f (p (f a) (f b))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p a b -> f (p a b)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley

    instance (Applicative f, Category p) => Category (Cayley f p) where
      id :: forall (a :: k). Cayley f p a a
    id = f (p a a) -> Cayley f p a a
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p a a) -> Cayley f p a a) -> f (p a a) -> Cayley f p a a
    forall a b. (a -> b) -> a -> b
    $ p a a -> f (p a a)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure p a a
    forall (a :: k). p a a
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
    id
      Cayley f (p b c)
    fpbc . :: forall (b :: k) (c :: k) (a :: k).
    Cayley f p b c -> Cayley f p a b -> Cayley f p a c
    . Cayley f (p a b)
    fpab = f (p a c) -> Cayley f p a c
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p a c) -> Cayley f p a c) -> f (p a c) -> Cayley f p a c
    forall a b. (a -> b) -> a -> b
    $ (p b c -> p a b -> p a c) -> f (p b c) -> f (p a b) -> f (p a c)
    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
    liftA2 p b c -> p a b -> p a c
    forall (b :: k) (c :: k) (a :: k). p b c -> p a b -> p a c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    (.) f (p b c)
    fpbc f (p a b)
    fpab

    instance (Applicative f, Arrow p) => Arrow (Cayley f p) where
      arr :: forall b c. (b -> c) -> Cayley f p b c
    arr b -> c
    f = f (p b c) -> Cayley f p b c
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p b c) -> Cayley f p b c) -> f (p b c) -> Cayley f p b c
    forall a b. (a -> b) -> a -> b
    $ p b c -> f (p b c)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (p b c -> f (p b c)) -> p b c -> f (p b c)
    forall a b. (a -> b) -> a -> b
    $ (b -> c) -> p b c
    forall b c. (b -> c) -> p b c
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr b -> c
    f
      first :: forall b c d. Cayley f p b c -> Cayley f p (b, d) (c, d)
    first = f (p (b, d) (c, d)) -> Cayley f p (b, d) (c, d)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (b, d) (c, d)) -> Cayley f p (b, d) (c, d))
    -> (Cayley f p b c -> f (p (b, d) (c, d)))
    -> Cayley f p b c
    -> Cayley f p (b, d) (c, d)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p b c -> p (b, d) (c, d)) -> f (p b c) -> f (p (b, d) (c, d))
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p b c -> p (b, d) (c, d)
    forall b c d. p b c -> p (b, d) (c, d)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (b, d) (c, d)
    first (f (p b c) -> f (p (b, d) (c, d)))
    -> (Cayley f p b c -> f (p b c))
    -> Cayley f p b c
    -> f (p (b, d) (c, d))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p b c -> f (p b c)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley
      second :: forall b c d. Cayley f p b c -> Cayley f p (d, b) (d, c)
    second = f (p (d, b) (d, c)) -> Cayley f p (d, b) (d, c)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (d, b) (d, c)) -> Cayley f p (d, b) (d, c))
    -> (Cayley f p b c -> f (p (d, b) (d, c)))
    -> Cayley f p b c
    -> Cayley f p (d, b) (d, c)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p b c -> p (d, b) (d, c)) -> f (p b c) -> f (p (d, b) (d, c))
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p b c -> p (d, b) (d, c)
    forall b c d. p b c -> p (d, b) (d, c)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (d, b) (d, c)
    second (f (p b c) -> f (p (d, b) (d, c)))
    -> (Cayley f p b c -> f (p b c))
    -> Cayley f p b c
    -> f (p (d, b) (d, c))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p b c -> f (p b c)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley
      Cayley f (p b c)
    ab *** :: forall b c b' c'.
    Cayley f p b c -> Cayley f p b' c' -> Cayley f p (b, b') (c, c')
    *** Cayley f (p b' c')
    cd = f (p (b, b') (c, c')) -> Cayley f p (b, b') (c, c')
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (b, b') (c, c')) -> Cayley f p (b, b') (c, c'))
    -> f (p (b, b') (c, c')) -> Cayley f p (b, b') (c, c')
    forall a b. (a -> b) -> a -> b
    $ (p b c -> p b' c' -> p (b, b') (c, c'))
    -> f (p b c) -> f (p b' c') -> f (p (b, b') (c, c'))
    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
    liftA2 p b c -> p b' c' -> p (b, b') (c, c')
    forall b c b' c'. p b c -> p b' c' -> p (b, b') (c, c')
    forall (a :: * -> * -> *) b c b' c'.
    Arrow a =>
    a b c -> a b' c' -> a (b, b') (c, c')
    (***) f (p b c)
    ab f (p b' c')
    cd
      Cayley f (p b c)
    ab &&& :: forall b c c'.
    Cayley f p b c -> Cayley f p b c' -> Cayley f p b (c, c')
    &&& Cayley f (p b c')
    ac = f (p b (c, c')) -> Cayley f p b (c, c')
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p b (c, c')) -> Cayley f p b (c, c'))
    -> f (p b (c, c')) -> Cayley f p b (c, c')
    forall a b. (a -> b) -> a -> b
    $ (p b c -> p b c' -> p b (c, c'))
    -> f (p b c) -> f (p b c') -> f (p b (c, c'))
    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
    liftA2 p b c -> p b c' -> p b (c, c')
    forall b c c'. p b c -> p b c' -> p b (c, c')
    forall (a :: * -> * -> *) b c c'.
    Arrow a =>
    a b c -> a b c' -> a b (c, c')
    (&&&) f (p b c)
    ab f (p b c')
    ac

    instance (Applicative f, ArrowChoice p) => ArrowChoice (Cayley f p) where
      left :: forall b c d.
    Cayley f p b c -> Cayley f p (Either b d) (Either c d)
    left  = f (p (Either b d) (Either c d))
    -> Cayley f p (Either b d) (Either c d)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (Either b d) (Either c d))
     -> Cayley f p (Either b d) (Either c d))
    -> (Cayley f p b c -> f (p (Either b d) (Either c d)))
    -> Cayley f p b c
    -> Cayley f p (Either b d) (Either c d)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p b c -> p (Either b d) (Either c d))
    -> f (p b c) -> f (p (Either b d) (Either c d))
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p b c -> p (Either b d) (Either c d)
    forall b c d. p b c -> p (Either b d) (Either c d)
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    left (f (p b c) -> f (p (Either b d) (Either c d)))
    -> (Cayley f p b c -> f (p b c))
    -> Cayley f p b c
    -> f (p (Either b d) (Either c d))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p b c -> f (p b c)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley
      right :: forall b c d.
    Cayley f p b c -> Cayley f p (Either d b) (Either d c)
    right = f (p (Either d b) (Either d c))
    -> Cayley f p (Either d b) (Either d c)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (Either d b) (Either d c))
     -> Cayley f p (Either d b) (Either d c))
    -> (Cayley f p b c -> f (p (Either d b) (Either d c)))
    -> Cayley f p b c
    -> Cayley f p (Either d b) (Either d c)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p b c -> p (Either d b) (Either d c))
    -> f (p b c) -> f (p (Either d b) (Either d c))
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p b c -> p (Either d b) (Either d c)
    forall b c d. p b c -> p (Either d b) (Either d c)
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either d b) (Either d c)
    right (f (p b c) -> f (p (Either d b) (Either d c)))
    -> (Cayley f p b c -> f (p b c))
    -> Cayley f p b c
    -> f (p (Either d b) (Either d c))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p b c -> f (p b c)
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley
      Cayley f (p b c)
    ab +++ :: forall b c b' c'.
    Cayley f p b c
    -> Cayley f p b' c' -> Cayley f p (Either b b') (Either c c')
    +++ Cayley f (p b' c')
    cd = f (p (Either b b') (Either c c'))
    -> Cayley f p (Either b b') (Either c c')
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (Either b b') (Either c c'))
     -> Cayley f p (Either b b') (Either c c'))
    -> f (p (Either b b') (Either c c'))
    -> Cayley f p (Either b b') (Either c c')
    forall a b. (a -> b) -> a -> b
    $ (p b c -> p b' c' -> p (Either b b') (Either c c'))
    -> f (p b c) -> f (p b' c') -> f (p (Either b b') (Either c c'))
    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
    liftA2 p b c -> p b' c' -> p (Either b b') (Either c c')
    forall b c b' c'. p b c -> p b' c' -> p (Either b b') (Either c c')
    forall (a :: * -> * -> *) b c b' c'.
    ArrowChoice a =>
    a b c -> a b' c' -> a (Either b b') (Either c c')
    (+++) f (p b c)
    ab f (p b' c')
    cd
      Cayley f (p b d)
    ac ||| :: forall b d c.
    Cayley f p b d -> Cayley f p c d -> Cayley f p (Either b c) d
    ||| Cayley f (p c d)
    bc = f (p (Either b c) d) -> Cayley f p (Either b c) d
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p (Either b c) d) -> Cayley f p (Either b c) d)
    -> f (p (Either b c) d) -> Cayley f p (Either b c) d
    forall a b. (a -> b) -> a -> b
    $ (p b d -> p c d -> p (Either b c) d)
    -> f (p b d) -> f (p c d) -> f (p (Either b c) d)
    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
    liftA2 p b d -> p c d -> p (Either b c) d
    forall b d c. p b d -> p c d -> p (Either b c) d
    forall (a :: * -> * -> *) b d c.
    ArrowChoice a =>
    a b d -> a c d -> a (Either b c) d
    (|||) f (p b d)
    ac f (p c d)
    bc

    instance (Applicative f, ArrowLoop p) => ArrowLoop (Cayley f p) where
      loop :: forall b d c. Cayley f p (b, d) (c, d) -> Cayley f p b c
    loop = f (p b c) -> Cayley f p b c
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p b c) -> Cayley f p b c)
    -> (Cayley f p (b, d) (c, d) -> f (p b c))
    -> Cayley f p (b, d) (c, d)
    -> Cayley f p b c
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . (p (b, d) (c, d) -> p b c) -> f (p (b, d) (c, d)) -> f (p b c)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap p (b, d) (c, d) -> p b c
    forall b d c. p (b, d) (c, d) -> p b c
    forall (a :: * -> * -> *) b d c.
    ArrowLoop a =>
    a (b, d) (c, d) -> a b c
    loop (f (p (b, d) (c, d)) -> f (p b c))
    -> (Cayley f p (b, d) (c, d) -> f (p (b, d) (c, d)))
    -> Cayley f p (b, d) (c, d)
    -> f (p b c)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    . Cayley f p (b, d) (c, d) -> f (p (b, d) (c, d))
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    Cayley f p a b -> f (p a b)
    runCayley

    instance (Applicative f, ArrowZero p) => ArrowZero (Cayley f p) where
      zeroArrow :: forall b c. Cayley f p b c
    zeroArrow = f (p b c) -> Cayley f p b c
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p b c) -> Cayley f p b c) -> f (p b c) -> Cayley f p b c
    forall a b. (a -> b) -> a -> b
    $ p b c -> f (p b c)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure p b c
    forall b c. p b c
    forall (a :: * -> * -> *) b c. ArrowZero a => a b c
    zeroArrow

    instance (Applicative f, ArrowPlus p) => ArrowPlus (Cayley f p) where
      Cayley f (p b c)
    f <+> :: forall b c. Cayley f p b c -> Cayley f p b c -> Cayley f p b c
    <+> Cayley f (p b c)
    g = f (p b c) -> Cayley f p b c
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley ((p b c -> p b c -> p b c) -> f (p b c) -> f (p b c) -> f (p b c)
    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
    liftA2 p b c -> p b c -> p b c
    forall b c. p b c -> p b c -> p b c
    forall (a :: * -> * -> *) b c.
    ArrowPlus a =>
    a b c -> a b c -> a b c
    (<+>) f (p b c)
    f f (p b c)
    g)

    mapCayley :: (forall a. f a -> g a) -> Cayley f p x y -> Cayley g p x y
    mapCayley :: forall {k} {k} {k} (f :: k -> *) (g :: k -> *) (p :: k -> k -> k)
           (x :: k) (y :: k).
    (forall (a :: k). f a -> g a) -> Cayley f p x y -> Cayley g p x y
    mapCayley forall (a :: k). f a -> g a
    f (Cayley f (p x y)
    g) = g (p x y) -> Cayley g p x y
    forall {k} {k} {k} (f :: k -> *) (p :: k -> k -> k) (a :: k)
           (b :: k).
    f (p a b) -> Cayley f p a b
    Cayley (f (p x y) -> g (p x y)
    forall (a :: k). f a -> g a
    f f (p x y)
    g)

    -- instance Adjunction f g => ProfunctorAdjunction (Cayley f) (Cayley g) where

    {-
    newtype Uncayley p a = Uncayley (p () a)

    instance Profunctor p => Functor (Uncayley p) where
      fmap f (Uncayley p) = Uncayley (rmap f p)

    smash :: Strong p => Cayley (Uncayley p) (->) a b -> p a b
    smash (Cayley (Uncayley pab)) = dimap ((,)()) (uncurry id) (first' pab)

    unsmash :: Closed p => p a b -> Cayley (Uncayley p) (->) a b
    unsmash = Cayley . Uncayley . curry' . lmap snd

    type Iso s t a b = forall p f. (Profunctor p, Functor f) => p a (f b) -> p s (f t)

    -- pastro and street's strong tambara module
    class (Strong p, Closed p) => Stronger p

    -- only a true iso for Stronger p and q, no?
    _Smash :: (Strong p, Closed q) => Iso
      (Cayley (Uncayley p) (->) a b)
      (Cayley (Uncayley q) (->) c d)
      (p a b)
      (q c d)
    _Smash = dimap hither (fmap yon) where
      hither (Cayley (Uncayley pab)) = dimap ((,)()) (uncurry id) (first' pab)
      yon = Cayley . Uncayley . curry' . lmap snd

    fsmash :: (forall x y. p x y -> q x y) -> Cayley (Uncayley p) (->) a b -> Cayley (Uncayley q) (->) a b
    fsmash f (Cayley (Uncayley puab)) = Cayley (Uncayley (f puab))

    -- | proposition 4.3 from pastro and street is that fsmash and funsmash form an equivalence of categories
    funsmash :: (Closed p, Strong q) => (forall x y. Cayley (Uncayley p) (->) x y -> Cayley (Uncayley q) (->) x y) -> p a b -> q a b
    funsmash k = smash . k . unsmash
    -}