Documentation

Methods

index :: Kleisli m a b -> a ~> (Kleisli m % b) Source Github #

tabulate :: Ob b => (a ~> (Kleisli m % b)) -> Kleisli m a b Source Github #

repMap :: (a ~> b) -> (Kleisli m % a) ~> (Kleisli m % b) Source Github #

repUniv :: Ob a => Kleisli m (Kleisli m % a) a Source Github #

ArrowApply arr => Representable (Arr arr :: Type -> Type -> Type) Source Github #

Instance details

Methods

index :: Arr arr a b -> a ~> (Arr arr % b) Source Github #

tabulate :: Ob b => (a ~> (Arr arr % b)) -> Arr arr a b Source Github #

repMap :: (a ~> b) -> (Arr arr % a) ~> (Arr arr % b) Source Github #

repUniv :: Ob a => Arr arr (Arr arr % a) a Source Github #

CategoryOf k => Representable (Id :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Identity

Methods

index :: forall (a :: k) (b :: k). Id a b -> a ~> ((Id :: k -> k -> Type) % b) Source Github #

tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> ((Id :: k -> k -> Type) % b)) -> Id a b Source Github #

repMap :: forall (a :: k) (b :: k). (a ~> b) -> ((Id :: k -> k -> Type) % a) ~> ((Id :: k -> k -> Type) % b) Source Github #

repUniv :: forall (a :: k). Ob a => Id ((Id :: k -> k -> Type) % a) a Source Github #

Representable (->) Source Github #

Instance details

Associated Types

type (->) % (a :: Type)
Instance details Defined in Proarrow.Profunctor.Representable type (->) % (a :: Type) = a

Methods

index :: (a -> b) -> a ~> ((->) % b) Source Github #

tabulate :: Ob b => (a ~> ((->) % b)) -> a -> b Source Github #

repMap :: (a ~> b) -> ((->) % a) ~> ((->) % b) Source Github #

repUniv :: Ob a => ((->) % a) -> a Source Github #

(HasTerminalObject k, CategoryOf j) => Representable (TerminalProfunctor :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Limit.Terminal

Methods

index :: forall (a :: k) (b :: j). TerminalProfunctor a b -> a ~> ((TerminalProfunctor :: k -> j -> Type) % b) Source Github #

tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> ((TerminalProfunctor :: k -> j -> Type) % b)) -> TerminalProfunctor a b Source Github #

repMap :: forall (a :: j) (b :: j). (a ~> b) -> ((TerminalProfunctor :: k -> j -> Type) % a) ~> ((TerminalProfunctor :: k -> j -> Type) % b) Source Github #

repUniv :: forall (a :: j). Ob a => TerminalProfunctor ((TerminalProfunctor :: k -> j -> Type) % a) a Source Github #

(Ob r, SymMonoidal k, Closed k) => Representable (Reader ('OP r) :: k -> k -> Type) Source Github #

The reader monad given the Promonad instance.

Instance details

Defined in Proarrow.Promonad.Reader

Methods

index :: forall (a :: k) (b :: k). Reader ('OP r) a b -> a ~> (Reader ('OP r) % b) Source Github #

tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> (Reader ('OP r) % b)) -> Reader ('OP r) a b Source Github #

repMap :: forall (a :: k) (b :: k). (a ~> b) -> (Reader ('OP r) % a) ~> (Reader ('OP r) % b) Source Github #

repUniv :: forall (a :: k). Ob a => Reader ('OP r) (Reader ('OP r) % a) a Source Github #

(Ob w, Monoidal k) => Representable (Writer w :: k -> k -> Type) Source Github #

The writer monad given the Promonad instance.

Instance details

Defined in Proarrow.Promonad.Writer

Methods

index :: forall (a :: k) (b :: k). Writer w a b -> a ~> (Writer w % b) Source Github #

tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> (Writer w % b)) -> Writer w a b Source Github #

repMap :: forall (a :: k) (b :: k). (a ~> b) -> (Writer w % a) ~> (Writer w % b) Source Github #

repUniv :: forall (a :: k). Ob a => Writer w (Writer w % a) a Source Github #

Representable (Costar ((,) a) :: Type -> Type -> Type) Source Github #

The right adjoint of (,) a is ((->) a).

Instance details

Defined in Proarrow.Adjunction

Methods

index :: Costar ((,) a) a0 b -> a0 ~> (Costar ((,) a) % b) Source Github #

tabulate :: Ob b => (a0 ~> (Costar ((,) a) % b)) -> Costar ((,) a) a0 b Source Github #

repMap :: (a0 ~> b) -> (Costar ((,) a) % a0) ~> (Costar ((,) a) % b) Source Github #

repUniv :: Ob a0 => Costar ((,) a) (Costar ((,) a) % a0) a0 Source Github #

Representable p => Representable (Adj p :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Adjunction

Methods

index :: forall (a :: k) (b :: j). Adj p a b -> a ~> (Adj p % b) Source Github #

tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (Adj p % b)) -> Adj p a b Source Github #

repMap :: forall (a :: j) (b :: j). (a ~> b) -> (Adj p % a) ~> (Adj p % b) Source Github #

repUniv :: forall (a :: j). Ob a => Adj p (Adj p % a) a Source Github #

Functor f => Representable (Star f :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Star

Methods

index :: forall (a :: k) (b :: j). Star f a b -> a ~> (Star f % b) Source Github #

tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (Star f % b)) -> Star f a b Source Github #

repMap :: forall (a :: j) (b :: j). (a ~> b) -> (Star f % a) ~> (Star f % b) Source Github #

repUniv :: forall (a :: j). Ob a => Star f (Star f % a) a Source Github #

Representable p => Representable (Wrapped p :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Wrapped

Methods

index :: forall (a :: k) (b :: j). Wrapped p a b -> a ~> (Wrapped p % b) Source Github #

tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (Wrapped p % b)) -> Wrapped p a b Source Github #

repMap :: forall (a :: j) (b :: j). (a ~> b) -> (Wrapped p % a) ~> (Wrapped p % b) Source Github #

repUniv :: forall (a :: j). Ob a => Wrapped p (Wrapped p % a) a Source Github #

Corepresentable p => Representable (CorepStar p :: k -> j -> Type) Source Github #

Instance details

Methods

index :: forall (a :: k) (b :: j). CorepStar p a b -> a ~> (CorepStar p % b) Source Github #

tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (CorepStar p % b)) -> CorepStar p a b Source Github #

repMap :: forall (a :: j) (b :: j). (a ~> b) -> (CorepStar p % a) ~> (CorepStar p % b) Source Github #

repUniv :: forall (a :: j). Ob a => CorepStar p (CorepStar p % a) a Source Github #

FunctorForRep f => Representable (Rep f :: k -> j -> Type) Source Github #

Instance details

Methods

index :: forall (a :: k) (b :: j). Rep f a b -> a ~> (Rep f % b) Source Github #

tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (Rep f % b)) -> Rep f a b Source Github #

repMap :: forall (a :: j) (b :: j). (a ~> b) -> (Rep f % a) ~> (Rep f % b) Source Github #

repUniv :: forall (a :: j). Ob a => Rep f (Rep f % a) a Source Github #

(forall (b :: j). Ob b => TermUniversal b l, Corepresentable l) => Representable (AsLeftAdjoint l :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Universal

Methods

index :: forall (a :: k) (b :: j). AsLeftAdjoint l a b -> a ~> (AsLeftAdjoint l % b) Source Github #

tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (AsLeftAdjoint l % b)) -> AsLeftAdjoint l a b Source Github #

repMap :: forall (a :: j) (b :: j). (a ~> b) -> (AsLeftAdjoint l % a) ~> (AsLeftAdjoint l % b) Source Github #

repUniv :: forall (a :: j). Ob a => AsLeftAdjoint l (AsLeftAdjoint l % a) a Source Github #

Representable r => Representable (AsRightAdjoint r :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Universal

Methods

index :: forall (a :: k) (b :: j). AsRightAdjoint r a b -> a ~> (AsRightAdjoint r % b) Source Github #

tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (AsRightAdjoint r % b)) -> AsRightAdjoint r a b Source Github #

repMap :: forall (a :: j) (b :: j). (a ~> b) -> (AsRightAdjoint r % a) ~> (AsRightAdjoint r % b) Source Github #

repUniv :: forall (a :: j). Ob a => AsRightAdjoint r (AsRightAdjoint r % a) a Source Github #

Representable p => Representable (FromAdjunction p :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Universal

Methods

index :: forall (a :: k) (b :: j). FromAdjunction p a b -> a ~> (FromAdjunction p % b) Source Github #

tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (FromAdjunction p % b)) -> FromAdjunction p a b Source Github #

repMap :: forall (a :: j) (b :: j). (a ~> b) -> (FromAdjunction p % a) ~> (FromAdjunction p % b) Source Github #

repUniv :: forall (a :: j). Ob a => FromAdjunction p (FromAdjunction p % a) a Source Github #

(Powered v k, Ob n) => Representable (GenArrow ('OP n) :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Limit.Power

Methods

index :: forall (a :: k) (b :: k). GenArrow ('OP n) a b -> a ~> ((GenArrow ('OP n) :: k -> k -> Type) % b) Source Github #

tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> ((GenArrow ('OP n) :: k -> k -> Type) % b)) -> GenArrow ('OP n) a b Source Github #

repMap :: forall (a :: k) (b :: k). (a ~> b) -> ((GenArrow ('OP n) :: k -> k -> Type) % a) ~> ((GenArrow ('OP n) :: k -> k -> Type) % b) Source Github #

repUniv :: forall (a :: k). Ob a => GenArrow ('OP n) ((GenArrow ('OP n) :: k -> k -> Type) % a) a Source Github #

(Representable p, Ob r, SymMonoidal k, Closed k) => Representable (ReaderT ('OP r) p :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Promonad.Reader

Methods

index :: forall (a :: k) (b :: k). ReaderT ('OP r) p a b -> a ~> (ReaderT ('OP r) p % b) Source Github #

tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> (ReaderT ('OP r) p % b)) -> ReaderT ('OP r) p a b Source Github #

repMap :: forall (a :: k) (b :: k). (a ~> b) -> (ReaderT ('OP r) p % a) ~> (ReaderT ('OP r) p % b) Source Github #

repUniv :: forall (a :: k). Ob a => ReaderT ('OP r) p (ReaderT ('OP r) p % a) a Source Github #

(Representable p, Ob s, SymMonoidal k, Closed k) => Representable (StateT s p :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Promonad.State

Methods

index :: forall (a :: k) (b :: k). StateT s p a b -> a ~> (StateT s p % b) Source Github #

tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> (StateT s p % b)) -> StateT s p a b Source Github #

repMap :: forall (a :: k) (b :: k). (a ~> b) -> (StateT s p % a) ~> (StateT s p % b) Source Github #

repUniv :: forall (a :: k). Ob a => StateT s p (StateT s p % a) a Source Github #

(Representable p, Ob w, Monoidal k) => Representable (WriterT w p :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Promonad.Writer

Methods

index :: forall (a :: k) (b :: k). WriterT w p a b -> a ~> (WriterT w p % b) Source Github #

tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> (WriterT w p % b)) -> WriterT w p a b Source Github #

repMap :: forall (a :: k) (b :: k). (a ~> b) -> (WriterT w p % a) ~> (WriterT w p % b) Source Github #

repUniv :: forall (a :: k). Ob a => WriterT w p (WriterT w p % a) a Source Github #

(HasBinaryProducts k, Representable p, Representable q) => Representable (p :*: q :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Limit.BinaryProduct

Methods

index :: forall (a :: k) (b :: j). (p :*: q) a b -> a ~> ((p :*: q) % b) Source Github #

tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> ((p :*: q) % b)) -> (p :*: q) a b Source Github #

repMap :: forall (a :: j) (b :: j). (a ~> b) -> ((p :*: q) % a) ~> ((p :*: q) % b) Source Github #

repUniv :: forall (a :: j). Ob a => (p :*: q) ((p :*: q) % a) a Source Github #

(HasLimits j2 k, Representable d) => Representable (Ran ('OP j2) d :: k -> j1 -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Ran

Methods

index :: forall (a :: k) (b :: j1). Ran ('OP j2) d a b -> a ~> (Ran ('OP j2) d % b) Source Github #

tabulate :: forall (b :: j1) (a :: k). Ob b => (a ~> (Ran ('OP j2) d % b)) -> Ran ('OP j2) d a b Source Github #

repMap :: forall (a :: j1) (b :: j1). (a ~> b) -> (Ran ('OP j2) d % a) ~> (Ran ('OP j2) d % b) Source Github #

repUniv :: forall (a :: j1). Ob a => Ran ('OP j2) d (Ran ('OP j2) d % a) a Source Github #

(Representable p, Representable q) => Representable (p :.: q :: k -> j2 -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Composition

Methods

index :: forall (a :: k) (b :: j2). (p :.: q) a b -> a ~> ((p :.: q) % b) Source Github #

tabulate :: forall (b :: j2) (a :: k). Ob b => (a ~> ((p :.: q) % b)) -> (p :.: q) a b Source Github #

repMap :: forall (a :: j2) (b :: j2). (a ~> b) -> ((p :.: q) % a) ~> ((p :.: q) % b) Source Github #

repUniv :: forall (a :: j2). Ob a => (p :.: q) ((p :.: q) % a) a Source Github #

HasCofree ob => Representable (Corep (Forget ob) :: SUBCAT ob -> k -> Type) Source Github #

By creating the right adjoint to the forgetful functor, we obtain the forgetful-cofree adjunction.

Instance details

Defined in Proarrow.Profunctor.Cofree

Methods

index :: forall (a :: SUBCAT ob) (b :: k). Corep (Forget ob) a b -> a ~> (Corep (Forget ob) % b) Source Github #

tabulate :: forall (b :: k) (a :: SUBCAT ob). Ob b => (a ~> (Corep (Forget ob) % b)) -> Corep (Forget ob) a b Source Github #

repMap :: forall (a :: k) (b :: k). (a ~> b) -> (Corep (Forget ob) % a) ~> (Corep (Forget ob) % b) Source Github #

repUniv :: forall (a :: k). Ob a => Corep (Forget ob) (Corep (Forget ob) % a) a Source Github #

Monoidal k => Representable (Tensor :: k -> LIST k -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Promonoidal

Methods

index :: forall (a :: k) (b :: LIST k). Tensor a b -> a ~> ((Tensor :: k -> LIST k -> Type) % b) Source Github #

tabulate :: forall (b :: LIST k) (a :: k). Ob b => (a ~> ((Tensor :: k -> LIST k -> Type) % b)) -> Tensor a b Source Github #

repMap :: forall (a :: LIST k) (b :: LIST k). (a ~> b) -> ((Tensor :: k -> LIST k -> Type) % a) ~> ((Tensor :: k -> LIST k -> Type) % b) Source Github #

repUniv :: forall (a :: LIST k). Ob a => Tensor ((Tensor :: k -> LIST k -> Type) % a) a Source Github #

Corepresentable p => Representable (Op p :: OPPOSITE j -> OPPOSITE k -> Type) Source Github #

Instance details

Methods

index :: forall (a :: OPPOSITE j) (b :: OPPOSITE k). Op p a b -> a ~> (Op p % b) Source Github #

tabulate :: forall (b :: OPPOSITE k) (a :: OPPOSITE j). Ob b => (a ~> (Op p % b)) -> Op p a b Source Github #

repMap :: forall (a :: OPPOSITE k) (b :: OPPOSITE k). (a ~> b) -> (Op p % a) ~> (Op p % b) Source Github #

repUniv :: forall (a :: OPPOSITE k). Ob a => Op p (Op p % a) a Source Github #

Representable p => Representable (Coprod p :: COPROD k -> COPROD j -> Type) Source Github #

Instance details

Defined in Proarrow.Colimit.BinaryCoproduct

Methods

index :: forall (a :: COPROD k) (b :: COPROD j). Coprod p a b -> a ~> (Coprod p % b) Source Github #

tabulate :: forall (b :: COPROD j) (a :: COPROD k). Ob b => (a ~> (Coprod p % b)) -> Coprod p a b Source Github #

repMap :: forall (a :: COPROD j) (b :: COPROD j). (a ~> b) -> (Coprod p % a) ~> (Coprod p % b) Source Github #

repUniv :: forall (a :: COPROD j). Ob a => Coprod p (Coprod p % a) a Source Github #

Representable p => Representable (Prod p :: PROD k -> PROD j -> Type) Source Github #

Instance details

Defined in Proarrow.Limit.BinaryProduct

Methods

index :: forall (a :: PROD k) (b :: PROD j). Prod p a b -> a ~> (Prod p % b) Source Github #

tabulate :: forall (b :: PROD j) (a :: PROD k). Ob b => (a ~> (Prod p % b)) -> Prod p a b Source Github #

repMap :: forall (a :: PROD j) (b :: PROD j). (a ~> b) -> (Prod p % a) ~> (Prod p % b) Source Github #

repUniv :: forall (a :: PROD j). Ob a => Prod p (Prod p % a) a Source Github #

Representable p => Representable (List p :: LIST k -> LIST j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.List

Methods

index :: forall (a :: LIST k) (b :: LIST j). List p a b -> a ~> (List p % b) Source Github #

tabulate :: forall (b :: LIST j) (a :: LIST k). Ob b => (a ~> (List p % b)) -> List p a b Source Github #

repMap :: forall (a :: LIST j) (b :: LIST j). (a ~> b) -> (List p % a) ~> (List p % b) Source Github #

repUniv :: forall (a :: LIST j). Ob a => List p (List p % a) a Source Github #

HasBinaryProducts k => Representable (Corep (Diag :: k +-> (k, k)) :: k -> (k, k) -> Type) Source Github #

The right adjoint to the diagonal functor.

Instance details

Defined in Proarrow.Limit.BinaryProduct

Methods

index :: forall (a :: k) (b :: (k, k)). Corep (Diag :: k +-> (k, k)) a b -> a ~> (Corep (Diag :: k +-> (k, k)) % b) Source Github #

tabulate :: forall (b :: (k, k)) (a :: k). Ob b => (a ~> (Corep (Diag :: k +-> (k, k)) % b)) -> Corep (Diag :: k +-> (k, k)) a b Source Github #

repMap :: forall (a :: (k, k)) (b :: (k, k)). (a ~> b) -> (Corep (Diag :: k +-> (k, k)) % a) ~> (Corep (Diag :: k +-> (k, k)) % b) Source Github #

repUniv :: forall (a :: (k, k)). Ob a => Corep (Diag :: k +-> (k, k)) (Corep (Diag :: k +-> (k, k)) % a) a Source Github #

(Representable p, forall (a :: k). ob a => ob (p % a)) => Representable (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Sub

Methods

index :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). Sub p a b -> a ~> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % b) Source Github #

tabulate :: forall (b :: SUBCAT ob) (a :: SUBCAT ob). Ob b => (a ~> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % b)) -> Sub p a b Source Github #

repMap :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (a ~> b) -> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % a) ~> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % b) Source Github #

repUniv :: forall (a :: SUBCAT ob). Ob a => Sub p ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % a) a Source Github #

HasLimits j k => Representable (LimitAdj j :: COREPK b k -> REPK a k -> Type) Source Github #

Colimit j ⊣ Limit j

Instance details

Defined in Proarrow.Adjunction

Methods

index :: forall (a0 :: COREPK b k) (b0 :: REPK a k). LimitAdj j a0 b0 -> a0 ~> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % b0) Source Github #

tabulate :: forall (b0 :: REPK a k) (a0 :: COREPK b k). Ob b0 => (a0 ~> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % b0)) -> LimitAdj j a0 b0 Source Github #

repMap :: forall (a0 :: REPK a k) (b0 :: REPK a k). (a0 ~> b0) -> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % a0) ~> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % b0) Source Github #

repUniv :: forall (a0 :: REPK a k). Ob a0 => LimitAdj j ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % a0) a0 Source Github #

(Representable p, Representable q) => Representable (p :++: q :: COPRODUCT k1 k2 -> COPRODUCT j1 j2 -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Coproduct

Methods

index :: forall (a :: COPRODUCT k1 k2) (b :: COPRODUCT j1 j2). (p :++: q) a b -> a ~> ((p :++: q) % b) Source Github #

tabulate :: forall (b :: COPRODUCT j1 j2) (a :: COPRODUCT k1 k2). Ob b => (a ~> ((p :++: q) % b)) -> (p :++: q) a b Source Github #

repMap :: forall (a :: COPRODUCT j1 j2) (b :: COPRODUCT j1 j2). (a ~> b) -> ((p :++: q) % a) ~> ((p :++: q) % b) Source Github #

repUniv :: forall (a :: COPRODUCT j1 j2). Ob a => (p :++: q) ((p :++: q) % a) a Source Github #

(Representable p, Representable q) => Representable (p :**: q :: (k1, k2) -> (j1, j2) -> Type) Source Github #

Instance details

Methods

index :: forall (a :: (k1, k2)) (b :: (j1, j2)). (p :**: q) a b -> a ~> ((p :**: q) % b) Source Github #

tabulate :: forall (b :: (j1, j2)) (a :: (k1, k2)). Ob b => (a ~> ((p :**: q) % b)) -> (p :**: q) a b Source Github #

repMap :: forall (a :: (j1, j2)) (b :: (j1, j2)). (a ~> b) -> ((p :**: q) % a) ~> ((p :**: q) % b) Source Github #

repUniv :: forall (a :: (j1, j2)). Ob a => (p :**: q) ((p :**: q) % a) a Source Github #

repObj :: forall {j} {k} (p :: j +-> k) (a :: j). (Representable p, Ob a) => Obj (p % a) Source Github #

withObRep :: forall {j} {k} (p :: j +-> k) (a :: j) r. (Representable p, Ob a) => (Ob (p % a) => r) -> r Source Github #

dimapRep :: forall {j} {k} p (a :: k) (b :: j) (c :: k) (d :: j). Representable p => (c ~> a) -> (b ~> d) -> p a b -> p c d Source Github #

tabulated :: forall {j} {k} p (a :: k) (a' :: k) (b :: j) (b' :: j). (Representable p, Ob b) => Iso (a ~> (p % b)) (a' ~> (p % b')) (p a b) (p a' b') Source Github #

type RepresentablePresheaf (f :: Presheaf k) = Representable f Source Github #

A representable presheaf is a contravariant representable functor in the Haskell sense.

type Key (f :: Presheaf k) = f % '() Source Github #

tabulatedPresheaf :: forall {k} f (a :: k) (a' :: k). (RepresentablePresheaf f, Ob a) => Iso (a ~> Key f) (a' ~> Key f) (f a '()) (f a' '()) Source Github #

data CorepStar (p :: k +-> j) (a :: k) (b :: j) where Source Github #

Constructors

CorepStar
Fields :: forall {j} {k} (b :: j) (a :: k) (p :: k +-> j). Ob b => { unCorepStar :: a ~> (p %% b) } -> CorepStar p a b

Instances

Instances details

(Corepresentable g, Corepresentable f, Profunctor j, f ~ (g \|> j)) => RelativeMonad (j :: k1 +-> i) (CorepStar g :.: CorepStar f :: k1 -> i -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Ran Methods relReturn :: forall (a :: i). Ob a => j a ((CorepStar g :.: CorepStar f) % a) Source Github # relBind :: forall (b :: i) (a :: i). Ob b => j a ((CorepStar g :.: CorepStar f) % b) -> ((CorepStar g :.: CorepStar f) % a) ~> ((CorepStar g :.: CorepStar f) % b) Source Github #
Corepresentable p => Profunctor (CorepStar p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Representable Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> CorepStar p a b -> CorepStar p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> CorepStar p a b -> CorepStar p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> CorepStar p a b -> CorepStar p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> CorepStar p a b -> r Source Github #
Corepresentable p => Representable (CorepStar p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Representable Methods index :: forall (a :: k) (b :: j). CorepStar p a b -> a ~> (CorepStar p % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (CorepStar p % b)) -> CorepStar p a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> (CorepStar p % a) ~> (CorepStar p % b) Source Github # repUniv :: forall (a :: j). Ob a => CorepStar p (CorepStar p % a) a Source Github #
Corepresentable p => Proadjunction (CorepStar p :: k -> j -> Type) (p :: k +-> j) Source Github #
Instance details Defined in Proarrow.Adjunction Methods unit :: forall (a :: j). Ob a => (p :.: CorepStar p) a a Source Github # counit :: (CorepStar p :.: p) :~> ((~>) :: CAT k) Source Github #
type (CorepStar p :: k -> j -> Type) % (a :: j) Source Github #
Instance details Defined in Proarrow.Profunctor.Representable type (CorepStar p :: k -> j -> Type) % (a :: j) = p %% a

mapCorepStar :: forall {k} {j} (p :: k +-> j) (q :: k +-> j). (Corepresentable p, Corepresentable q) => (p ~> q) -> CorepStar q ~> CorepStar p Source Github #

data RepCostar (p :: k +-> j) (a :: k) (b :: j) where Source Github #

Constructors

RepCostar
Fields :: forall {k} {j} (a :: k) (p :: k +-> j) (b :: j). Ob a => { unRepCostar :: (p % a) ~> b } -> RepCostar p a b

Instances

Instances details

Representable p => Proadjunction (p :: k +-> j) (RepCostar p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Adjunction Methods unit :: forall (a :: k). Ob a => (RepCostar p :.: p) a a Source Github # counit :: (p :.: RepCostar p) :~> ((~>) :: CAT j) Source Github #
(Representable g, Representable f, Profunctor j, f ~ (j <\| g)) => RelativeComonad (j :: k2 +-> i) (RepCostar f :.: RepCostar g :: k2 -> i -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Rift Methods relExtract :: forall (a :: k2). Ob a => j ((RepCostar f :.: RepCostar g) %% a) a Source Github # relExtend :: forall (a :: k2) (b :: k2). Ob a => j ((RepCostar f :.: RepCostar g) %% a) b -> ((RepCostar f :.: RepCostar g) %% a) ~> ((RepCostar f :.: RepCostar g) %% b) Source Github #
(Representable p, Thin j) => ThinProfunctor (RepCostar p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Representable Methods arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow (RepCostar p) a b) => RepCostar p a b Source Github # withArr :: forall (a :: k) (b :: j) r. RepCostar p a b -> ((HasArrow (RepCostar p) a b, Ob a, Ob b) => r) -> r Source Github #
Representable p => Profunctor (RepCostar p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Representable Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> RepCostar p a b -> RepCostar p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> RepCostar p a b -> RepCostar p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> RepCostar p a b -> RepCostar p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> RepCostar p a b -> r Source Github #
Representable p => Corepresentable (RepCostar p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Representable Methods coindex :: forall (a :: k) (b :: j). RepCostar p a b -> (RepCostar p %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((RepCostar p %% a) ~> b) -> RepCostar p a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (RepCostar p %% a) ~> (RepCostar p %% b) Source Github # corepUniv :: forall (a :: k). Ob a => RepCostar p a (RepCostar p %% a) Source Github #
type (RepCostar p :: k -> j -> Type) %% (a :: k) Source Github #
Instance details Defined in Proarrow.Profunctor.Representable type (RepCostar p :: k -> j -> Type) %% (a :: k) = p % a
type HasArrow (RepCostar p :: k -> j -> Type) (a :: k) (b :: j) Source Github #
Instance details Defined in Proarrow.Profunctor.Representable type HasArrow (RepCostar p :: k -> j -> Type) (a :: k) (b :: j) = HasArrow (Hom j) (p % a) b

mapRepCostar :: forall {k} {j} (p :: k +-> j) (q :: k +-> j). (Representable p, Representable q) => (p ~> q) -> RepCostar q ~> RepCostar p Source Github #

flipRep :: forall {k1} (p :: k1 +-> k1). Representable p => (((~>) :: CAT k1) :~> p) -> RepCostar p :~> ((~>) :: CAT k1) Source Github #

unflipRep :: forall {k1} (p :: k1 +-> k1). Representable p => (RepCostar p :~> ((~>) :: CAT k1)) -> ((~>) :: CAT k1) :~> p Source Github #

flipCorep :: forall {k1} (p :: k1 +-> k1). Corepresentable p => (((~>) :: CAT k1) :~> p) -> CorepStar p :~> ((~>) :: CAT k1) Source Github #

unflipCorep :: forall {k1} (p :: k1 +-> k1). Corepresentable p => (CorepStar p :~> ((~>) :: CAT k1)) -> ((~>) :: CAT k1) :~> p Source Github #

data Rep (f :: j +-> k) (a :: k) (b :: j) where Source Github #

Constructors

Rep
Fields :: forall {j} {k} (b :: j) (f :: j +-> k) (a :: k). Ob b => { unRep :: a ~> (f @ b) } -> Rep f a b

Instances

Instances details

Monoidal k => MonoidalAction (Tensor :: k -> (k, k) -> Type) Source Github #

Instance details

Methods

unitor :: forall (x :: k). Ob x => Act (Tensor :: k -> (k, k) -> Type) (Unit :: k) x ~> x Source Github #

unitorInv :: forall (x :: k). Ob x => x ~> Act (Tensor :: k -> (k, k) -> Type) (Unit :: k) x Source Github #

multiplicator :: forall (a :: k) (b :: k) (x :: k). (Ob a, Ob b, Ob x) => Act (Tensor :: k -> (k, k) -> Type) (a ** b) x ~> Act (Tensor :: k -> (k, k) -> Type) a (Act (Tensor :: k -> (k, k) -> Type) b x) Source Github #

multiplicatorInv :: forall (a :: k) (b :: k) (x :: k). (Ob a, Ob b, Ob x) => Act (Tensor :: k -> (k, k) -> Type) a (Act (Tensor :: k -> (k, k) -> Type) b x) ~> Act (Tensor :: k -> (k, k) -> Type) (a ** b) x Source Github #

Costrong (Tensor :: DOT -> (DOT, DOT) -> Type) Dot Source Github #

Instance details

Defined in Proarrow.Tools.Diagrams.Dot

Methods

coact :: forall (a :: DOT) (x :: DOT) (y :: DOT). (Ob a, Ob x, Ob y) => Dot (Act (Tensor :: DOT -> (DOT, DOT) -> Type) a x) (Act (Tensor :: DOT -> (DOT, DOT) -> Type) a y) -> Dot x y Source Github #

MonadFix m => Costrong (Tensor :: Type -> (Type, Type) -> Type) (Kleisli m :: Type -> Type -> Type) Source Github #

Instance details

Methods

coact :: (Ob a, Ob x, Ob y) => Kleisli m (Act (Tensor :: Type -> (Type, Type) -> Type) a x) (Act (Tensor :: Type -> (Type, Type) -> Type) a y) -> Kleisli m x y Source Github #

ArrowLoop arr => Costrong (Tensor :: Type -> (Type, Type) -> Type) (Arr arr :: Type -> Type -> Type) Source Github #

Instance details

Methods

coact :: (Ob a, Ob x, Ob y) => Arr arr (Act (Tensor :: Type -> (Type, Type) -> Type) a x) (Act (Tensor :: Type -> (Type, Type) -> Type) a y) -> Arr arr x y Source Github #

Monad m => Strong (Tensor :: Type -> (Type, Type) -> Type) (Kleisli m :: Type -> Type -> Type) Source Github #

Instance details

Methods

act :: Ob a => Kleisli m x y -> Kleisli m (Act (Tensor :: Type -> (Type, Type) -> Type) a x) (Act (Tensor :: Type -> (Type, Type) -> Type) a y) Source Github #

Arrow arr => Strong (Tensor :: Type -> (Type, Type) -> Type) (Arr arr :: Type -> Type -> Type) Source Github #

Instance details

Methods

act :: Ob a => Arr arr x y -> Arr arr (Act (Tensor :: Type -> (Type, Type) -> Type) a x) (Act (Tensor :: Type -> (Type, Type) -> Type) a y) Source Github #

Costrong (Tensor :: Type -> (Type, Type) -> Type) (->) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Strength

Methods

coact :: (Ob a, Ob x, Ob y) => (Act (Tensor :: Type -> (Type, Type) -> Type) a x -> Act (Tensor :: Type -> (Type, Type) -> Type) a y) -> x -> y Source Github #

Strong (Tensor :: Type -> (Type, Type) -> Type) (Replacing a b :: Type -> Type -> Type) Source Github #

Instance details

Methods

act :: Ob a0 => Replacing a b x y -> Replacing a b (Act (Tensor :: Type -> (Type, Type) -> Type) a0 x) (Act (Tensor :: Type -> (Type, Type) -> Type) a0 y) Source Github #

Strong (Tensor :: Type -> (Type, Type) -> Type) (Cont r :: Type -> Type -> Type) Source Github #

Instance details

Defined in Proarrow.Promonad.Cont

Methods

act :: Ob a => Cont r x y -> Cont r (Act (Tensor :: Type -> (Type, Type) -> Type) a x) (Act (Tensor :: Type -> (Type, Type) -> Type) a y) Source Github #

(Ob r, SymMonoidal k) => Strong (Tensor :: k -> (k, k) -> Type) (Reader ('OP r) :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Promonad.Reader

Methods

act :: forall (a :: k) (x :: k) (y :: k). Ob a => Reader ('OP r) x y -> Reader ('OP r) (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> Type) a y) Source Github #

(Ob w, SymMonoidal k) => Strong (Tensor :: k -> (k, k) -> Type) (Writer w :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Promonad.Writer

Methods

act :: forall (a :: k) (x :: k) (y :: k). Ob a => Writer w x y -> Writer w (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> Type) a y) Source Github #

(Strong (Tensor :: k -> (k, k) -> Type) p, Ob r, SymMonoidal k) => Strong (Tensor :: k -> (k, k) -> Type) (ReaderT ('OP r) p :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Promonad.Reader

Methods

act :: forall (a :: k) (x :: k) (y :: k). Ob a => ReaderT ('OP r) p x y -> ReaderT ('OP r) p (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> Type) a y) Source Github #

(Strong (Tensor :: k -> (k, k) -> Type) p, Ob s, SymMonoidal k) => Strong (Tensor :: k -> (k, k) -> Type) (StateT s p :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Promonad.State

Methods

act :: forall (a :: k) (x :: k) (y :: k). Ob a => StateT s p x y -> StateT s p (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> Type) a y) Source Github #

(Strong (Tensor :: k -> (k, k) -> Type) p, Ob w, SymMonoidal k) => Strong (Tensor :: k -> (k, k) -> Type) (WriterT w p :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Promonad.Writer

Methods

act :: forall (a :: k) (x :: k) (y :: k). Ob a => WriterT w p x y -> WriterT w p (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> Type) a y) Source Github #

(FunctorForRep f, Thin k) => ThinProfunctor (Rep f :: k -> j -> Type) Source Github #

Instance details

Methods

arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow (Rep f) a b) => Rep f a b Source Github #

withArr :: forall (a :: k) (b :: j) r. Rep f a b -> ((HasArrow (Rep f) a b, Ob a, Ob b) => r) -> r Source Github #

MonoidalProfunctor (Rep Fun) Source Github #

Instance details

Defined in Proarrow.Category.Instance.FinRel

Methods

one :: Rep Fun (Unit :: FINREL) (Unit :: FINSET) Source Github #

(**) :: forall (x1 :: FINREL) (x2 :: FINSET) (y1 :: FINREL) (y2 :: FINSET). Rep Fun x1 x2 -> Rep Fun y1 y2 -> Rep Fun (x1 ** y1) (x2 ** y2) Source Github #

MonoidalProfunctor (Rep Forget) Source Github #

Forget is a lax monoidal functor

Instance details

Methods

one :: Rep Forget (Unit :: Type) (Unit :: LINEAR) Source Github #

(**) :: forall x1 (x2 :: LINEAR) y1 (y2 :: LINEAR). Rep Forget x1 x2 -> Rep Forget y1 y2 -> Rep Forget (x1 ** y1) (x2 ** y2) Source Github #

(Monoidal k, Monoid r) => MonoidalProfunctor (Rep (Constant r) :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Monoid

Methods

one :: Rep (Constant r) (Unit :: k) (Unit :: k) Source Github #

(**) :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). Rep (Constant r) x1 x2 -> Rep (Constant r) y1 y2 -> Rep (Constant r) (x1 ** y1) (x2 ** y2) Source Github #

CategoryOf k => MonoidalAction (Rep (NoAction :: ((), k) +-> k) :: k -> ((), k) -> Type) Source Github #

Instance details

Methods

unitor :: forall (x :: k). Ob x => Act (Rep (NoAction :: ((), k) +-> k)) (Unit :: ()) x ~> x Source Github #

unitorInv :: forall (x :: k). Ob x => x ~> Act (Rep (NoAction :: ((), k) +-> k)) (Unit :: ()) x Source Github #

multiplicator :: forall (a :: ()) (b :: ()) (x :: k). (Ob a, Ob b, Ob x) => Act (Rep (NoAction :: ((), k) +-> k)) (a ** b) x ~> Act (Rep (NoAction :: ((), k) +-> k)) a (Act (Rep (NoAction :: ((), k) +-> k)) b x) Source Github #

multiplicatorInv :: forall (a :: ()) (b :: ()) (x :: k). (Ob a, Ob b, Ob x) => Act (Rep (NoAction :: ((), k) +-> k)) a (Act (Rep (NoAction :: ((), k) +-> k)) b x) ~> Act (Rep (NoAction :: ((), k) +-> k)) (a ** b) x Source Github #

FunctorForRep f => Profunctor (Rep f :: k -> j -> Type) Source Github #

Instance details

Methods

dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Rep f a b -> Rep f c d Source Github #

lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Rep f a b -> Rep f c b Source Github #

rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Rep f a b -> Rep f a d Source Github #

(\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Rep f a b -> r Source Github #

Corepresentable (Rep Forget) Source Github #

By creating the left adjoint to the forgetful functor, we obtain the free-forgetful adjunction between Hask and LINEAR

Instance details

Associated Types

type (Rep Forget) %% (a :: Type)
Instance details Defined in Proarrow.Category.Instance.Linear type (Rep Forget) %% (a :: Type) = 'L (Ur a)

Methods

coindex :: forall a (b :: LINEAR). Rep Forget a b -> (Rep Forget %% a) ~> b Source Github #

cotabulate :: forall a (b :: LINEAR). Ob a => ((Rep Forget %% a) ~> b) -> Rep Forget a b Source Github #

corepMap :: (a ~> b) -> (Rep Forget %% a) ~> (Rep Forget %% b) Source Github #

corepUniv :: Ob a => Rep Forget a (Rep Forget %% a) Source Github #

FunctorForRep f => Representable (Rep f :: k -> j -> Type) Source Github #

Instance details

Methods

index :: forall (a :: k) (b :: j). Rep f a b -> a ~> (Rep f % b) Source Github #

tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (Rep f % b)) -> Rep f a b Source Github #

repMap :: forall (a :: j) (b :: j). (a ~> b) -> (Rep f % a) ~> (Rep f % b) Source Github #

repUniv :: forall (a :: j). Ob a => Rep f (Rep f % a) a Source Github #

FunctorForRep f => HasColimits (Rep f :: i -> a -> Type) k Source Github #

Instance details

Defined in Proarrow.Colimit

Methods

colimit :: forall (d :: k +-> i). Corepresentable d => (Rep f :.: Colimit (Rep f) d) :~> d Source Github #

colimitUniv :: forall (d :: k +-> i) (p :: k +-> a). (Corepresentable d, Profunctor p) => ((Rep f :.: p) :~> d) -> p :~> Colimit (Rep f) d Source Github #

FunctorForRep f => Proadjunction (Rep f :: k -> j -> Type) (Corep f :: j -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Adjunction

Methods

unit :: forall (a :: j). Ob a => (Corep f :.: Rep f) a a Source Github #

counit :: (Rep f :.: Corep f) :~> ((~>) :: CAT k) Source Github #

HasBinaryCoproducts k => Corepresentable (Rep (Diag :: k +-> (k, k)) :: (k, k) -> k -> Type) Source Github #

The left adjoint to the diagonal functor.

Instance details

Defined in Proarrow.Colimit.BinaryCoproduct

Methods

coindex :: forall (a :: (k, k)) (b :: k). Rep (Diag :: k +-> (k, k)) a b -> (Rep (Diag :: k +-> (k, k)) %% a) ~> b Source Github #

cotabulate :: forall (a :: (k, k)) (b :: k). Ob a => ((Rep (Diag :: k +-> (k, k)) %% a) ~> b) -> Rep (Diag :: k +-> (k, k)) a b Source Github #

corepMap :: forall (a :: (k, k)) (b :: (k, k)). (a ~> b) -> (Rep (Diag :: k +-> (k, k)) %% a) ~> (Rep (Diag :: k +-> (k, k)) %% b) Source Github #

corepUniv :: forall (a :: (k, k)). Ob a => Rep (Diag :: k +-> (k, k)) a (Rep (Diag :: k +-> (k, k)) %% a) Source Github #

HasCoproducts k => MonoidalAction (CoprodAction :: k -> (COPROD k, k) -> Type) Source Github #

Instance details

Methods

unitor :: forall (x :: k). Ob x => Act (CoprodAction :: k -> (COPROD k, k) -> Type) (Unit :: COPROD k) x ~> x Source Github #

unitorInv :: forall (x :: k). Ob x => x ~> Act (CoprodAction :: k -> (COPROD k, k) -> Type) (Unit :: COPROD k) x Source Github #

multiplicator :: forall (a :: COPROD k) (b :: COPROD k) (x :: k). (Ob a, Ob b, Ob x) => Act (CoprodAction :: k -> (COPROD k, k) -> Type) (a ** b) x ~> Act (CoprodAction :: k -> (COPROD k, k) -> Type) a (Act (CoprodAction :: k -> (COPROD k, k) -> Type) b x) Source Github #

multiplicatorInv :: forall (a :: COPROD k) (b :: COPROD k) (x :: k). (Ob a, Ob b, Ob x) => Act (CoprodAction :: k -> (COPROD k, k) -> Type) a (Act (CoprodAction :: k -> (COPROD k, k) -> Type) b x) ~> Act (CoprodAction :: k -> (COPROD k, k) -> Type) (a ** b) x Source Github #

HasProducts k => MonoidalAction (ProdAction :: k -> (PROD k, k) -> Type) Source Github #

Instance details

Methods

unitor :: forall (x :: k). Ob x => Act (ProdAction :: k -> (PROD k, k) -> Type) (Unit :: PROD k) x ~> x Source Github #

unitorInv :: forall (x :: k). Ob x => x ~> Act (ProdAction :: k -> (PROD k, k) -> Type) (Unit :: PROD k) x Source Github #

multiplicator :: forall (a :: PROD k) (b :: PROD k) (x :: k). (Ob a, Ob b, Ob x) => Act (ProdAction :: k -> (PROD k, k) -> Type) (a ** b) x ~> Act (ProdAction :: k -> (PROD k, k) -> Type) a (Act (ProdAction :: k -> (PROD k, k) -> Type) b x) Source Github #

multiplicatorInv :: forall (a :: PROD k) (b :: PROD k) (x :: k). (Ob a, Ob b, Ob x) => Act (ProdAction :: k -> (PROD k, k) -> Type) a (Act (ProdAction :: k -> (PROD k, k) -> Type) b x) ~> Act (ProdAction :: k -> (PROD k, k) -> Type) (a ** b) x Source Github #

Costrong (CoprodAction :: LINEAR -> (COPROD LINEAR, LINEAR) -> Type) Linear Source Github #

Instance details

Methods

coact :: forall (a :: COPROD LINEAR) (x :: LINEAR) (y :: LINEAR). (Ob a, Ob x, Ob y) => Linear (Act (CoprodAction :: LINEAR -> (COPROD LINEAR, LINEAR) -> Type) a x) (Act (CoprodAction :: LINEAR -> (COPROD LINEAR, LINEAR) -> Type) a y) -> Linear x y Source Github #

Cartesian k => Costrong (ProdAction :: k -> (PROD k, k) -> Type) (Fold :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Fold

Methods

coact :: forall (a :: PROD k) (x :: k) (y :: k). (Ob a, Ob x, Ob y) => Fold (Act (ProdAction :: k -> (PROD k, k) -> Type) a x) (Act (ProdAction :: k -> (PROD k, k) -> Type) a y) -> Fold x y Source Github #

MonadPlus m => Strong (CoprodAction :: Type -> (COPROD Type, Type) -> Type) (Kleisli m :: Type -> Type -> Type) Source Github #

Instance details

Methods

act :: forall (a :: COPROD Type) x y. Ob a => Kleisli m x y -> Kleisli m (Act (CoprodAction :: Type -> (COPROD Type, Type) -> Type) a x) (Act (CoprodAction :: Type -> (COPROD Type, Type) -> Type) a y) Source Github #

BiCCC k => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (Fold :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Fold

Methods

act :: forall (a :: COPROD k) (x :: k) (y :: k). Ob a => Fold x y -> Fold (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a x) (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a y) Source Github #

Strong (CoprodAction :: Type -> (COPROD Type, Type) -> Type) (Previewing a b :: Type -> Type -> Type) Source Github #

Instance details

Methods

act :: forall (a0 :: COPROD Type) x y. Ob a0 => Previewing a b x y -> Previewing a b (Act (CoprodAction :: Type -> (COPROD Type, Type) -> Type) a0 x) (Act (CoprodAction :: Type -> (COPROD Type, Type) -> Type) a0 y) Source Github #

Strong (CoprodAction :: Type -> (COPROD Type, Type) -> Type) (Replacing a b :: Type -> Type -> Type) Source Github #

Instance details

Methods

act :: forall (a0 :: COPROD Type) x y. Ob a0 => Replacing a b x y -> Replacing a b (Act (CoprodAction :: Type -> (COPROD Type, Type) -> Type) a0 x) (Act (CoprodAction :: Type -> (COPROD Type, Type) -> Type) a0 y) Source Github #

Strong (ProdAction :: Type -> (PROD Type, Type) -> Type) (Previewing a b :: Type -> Type -> Type) Source Github #

Instance details

Methods

act :: forall (a0 :: PROD Type) x y. Ob a0 => Previewing a b x y -> Previewing a b (Act (ProdAction :: Type -> (PROD Type, Type) -> Type) a0 x) (Act (ProdAction :: Type -> (PROD Type, Type) -> Type) a0 y) Source Github #

Strong (CoprodAction :: Type -> (COPROD Type, Type) -> Type) (Rep (Constant (First c)) :: Type -> Type -> Type) Source Github #

Instance details

Methods

act :: forall (a :: COPROD Type) x y. Ob a => Rep (Constant (First c)) x y -> Rep (Constant (First c)) (Act (CoprodAction :: Type -> (COPROD Type, Type) -> Type) a x) (Act (CoprodAction :: Type -> (COPROD Type, Type) -> Type) a y) Source Github #

Functor f => Strong (ProdAction :: Type -> (PROD Type, Type) -> Type) (Star (Prelude f) :: Type -> Type -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Star

Methods

act :: forall (a :: PROD Type) x y. Ob a => Star (Prelude f) x y -> Star (Prelude f) (Act (ProdAction :: Type -> (PROD Type, Type) -> Type) a x) (Act (ProdAction :: Type -> (PROD Type, Type) -> Type) a y) Source Github #

(Cartesian k, Ob c) => Strong (ProdAction :: k -> (PROD k, k) -> Type) (Rep (Constant c) :: k -> k -> Type) Source Github #

Instance details

Methods

act :: forall (a :: PROD k) (x :: k) (y :: k). Ob a => Rep (Constant c) x y -> Rep (Constant c) (Act (ProdAction :: k -> (PROD k, k) -> Type) a x) (Act (ProdAction :: k -> (PROD k, k) -> Type) a y) Source Github #

Num a => MonoidalProfunctor (Rep (App :: MatK a +-> Type) :: Type -> MatK a -> Type) Source Github #

Instance details

Methods

one :: Rep (App :: MatK a +-> Type) (Unit :: Type) (Unit :: MatK a) Source Github #

(**) :: forall x1 (x2 :: MatK a) y1 (y2 :: MatK a). Rep (App :: MatK a +-> Type) x1 x2 -> Rep (App :: MatK a +-> Type) y1 y2 -> Rep (App :: MatK a +-> Type) (x1 ** y1) (x2 ** y2) Source Github #

(Closed k, SymMonoidal k, Ob r) => Corepresentable (Rep (Not r) :: k -> OPPOSITE k -> Type) Source Github #

The Op-Op adjunction, giving rise to the continuation monad.

Instance details

Defined in Proarrow.Category.Monoidal.Closed

Methods

coindex :: forall (a :: k) (b :: OPPOSITE k). Rep (Not r) a b -> (Rep (Not r) %% a) ~> b Source Github #

cotabulate :: forall (a :: k) (b :: OPPOSITE k). Ob a => ((Rep (Not r) %% a) ~> b) -> Rep (Not r) a b Source Github #

corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Rep (Not r) %% a) ~> (Rep (Not r) %% b) Source Github #

corepUniv :: forall (a :: k). Ob a => Rep (Not r) a (Rep (Not r) %% a) Source Github #

Monad m => Strong (Tensor :: KlCat m -> (KlCat m, KlCat m) -> Type) (Updating a b :: KlCat m -> KlCat m -> Type) Source Github #

Instance details

Methods

act :: forall (a0 :: KlCat m) (x :: KlCat m) (y :: KlCat m). Ob a0 => Updating a b x y -> Updating a b (Act (Tensor :: KlCat m -> (KlCat m, KlCat m) -> Type) a0 x) (Act (Tensor :: KlCat m -> (KlCat m, KlCat m) -> Type) a0 y) Source Github #

RealFloat a => MonoidalProfunctor (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) :: MatK (Complex a) -> MatK (Complex a) -> Type) Source Github #

Instance details

Methods

one :: Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) (Unit :: MatK (Complex a)) (Unit :: MatK (Complex a)) Source Github #

(**) :: forall (x1 :: MatK (Complex a)) (x2 :: MatK (Complex a)) (y1 :: MatK (Complex a)) (y2 :: MatK (Complex a)). Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) x1 x2 -> Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) y1 y2 -> Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) (x1 ** y1) (x2 ** y2) Source Github #

MonoidalProfunctor (Coprod (Rep Fun)) Source Github #

Instance details

Defined in Proarrow.Category.Instance.FinRel

Methods

one :: Coprod (Rep Fun) (Unit :: COPROD FINREL) (Unit :: COPROD FINSET) Source Github #

(**) :: forall (x1 :: COPROD FINREL) (x2 :: COPROD FINSET) (y1 :: COPROD FINREL) (y2 :: COPROD FINSET). Coprod (Rep Fun) x1 x2 -> Coprod (Rep Fun) y1 y2 -> Coprod (Rep Fun) (x1 ** y1) (x2 ** y2) Source Github #

(HasCoproducts k, Ob r) => MonoidalProfunctor (Coprod (Rep (Constant r)) :: COPROD k -> COPROD k -> Type) Source Github #

Instance details

Defined in Proarrow.Monoid

Methods

one :: Coprod (Rep (Constant r)) (Unit :: COPROD k) (Unit :: COPROD k) Source Github #

(**) :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod (Rep (Constant r)) x1 x2 -> Coprod (Rep (Constant r)) y1 y2 -> Coprod (Rep (Constant r)) (x1 ** y1) (x2 ** y2) Source Github #

MonoidalAction t => MonoidalAction (Rep (OpAction t) :: OPPOSITE k -> (OPPOSITE m, OPPOSITE k) -> Type) Source Github #

Instance details

Methods

unitor :: forall (x :: OPPOSITE k). Ob x => Act (Rep (OpAction t)) (Unit :: OPPOSITE m) x ~> x Source Github #

unitorInv :: forall (x :: OPPOSITE k). Ob x => x ~> Act (Rep (OpAction t)) (Unit :: OPPOSITE m) x Source Github #

multiplicator :: forall (a :: OPPOSITE m) (b :: OPPOSITE m) (x :: OPPOSITE k). (Ob a, Ob b, Ob x) => Act (Rep (OpAction t)) (a ** b) x ~> Act (Rep (OpAction t)) a (Act (Rep (OpAction t)) b x) Source Github #

multiplicatorInv :: forall (a :: OPPOSITE m) (b :: OPPOSITE m) (x :: OPPOSITE k). (Ob a, Ob b, Ob x) => Act (Rep (OpAction t)) a (Act (Rep (OpAction t)) b x) ~> Act (Rep (OpAction t)) (a ** b) x Source Github #

RealFloat a => Corepresentable (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) :: MatK (Complex a) -> MatK (Complex a) -> Type) Source Github #

Conjugation is a self-adjoint functor

Instance details

Methods

coindex :: forall (a0 :: MatK (Complex a)) (b :: MatK (Complex a)). Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) a0 b -> (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% a0) ~> b Source Github #

cotabulate :: forall (a0 :: MatK (Complex a)) (b :: MatK (Complex a)). Ob a0 => ((Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% a0) ~> b) -> Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) a0 b Source Github #

corepMap :: forall (a0 :: MatK (Complex a)) (b :: MatK (Complex a)). (a0 ~> b) -> (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% a0) ~> (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% b) Source Github #

corepUniv :: forall (a0 :: MatK (Complex a)). Ob a0 => Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) a0 (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% a0) Source Github #

RealFloat a => Involution (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) :: MatK (Complex a) -> MatK (Complex a) -> Type) Source Github #

Instance details

Methods

involuted :: forall (a0 :: MatK (Complex a)) (a' :: MatK (Complex a)). (Ob a0, Ob a') => Iso a0 a' (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) % (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) % a0)) (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) % (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) % a')) Source Github #

MonoidalAction ApplyAction Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

Methods

unitor :: Ob x => Act ApplyAction (Unit :: Type -> Type) x ~> x Source Github #

unitorInv :: Ob x => x ~> Act ApplyAction (Unit :: Type -> Type) x Source Github #

multiplicator :: forall (a :: Type -> Type) (b :: Type -> Type) x. (Ob a, Ob b, Ob x) => Act ApplyAction (a ** b) x ~> Act ApplyAction a (Act ApplyAction b x) Source Github #

multiplicatorInv :: forall (a :: Type -> Type) (b :: Type -> Type) x. (Ob a, Ob b, Ob x) => Act ApplyAction a (Act ApplyAction b x) ~> Act ApplyAction (a ** b) x Source Github #

Strong ApplyAction (Replacing a b :: Type -> Type -> Type) Source Github #

Instance details

Methods

act :: forall (a0 :: Type -> Type) x y. Ob a0 => Replacing a b x y -> Replacing a b (Act ApplyAction a0 x) (Act ApplyAction a0 y) Source Github #

Monad m => Strong (AlgAction m :: Type -> (SUBCAT (Algebra m), Type) -> Type) (Classifying m a b :: Type -> Type -> Type) Source Github #

Instance details

Methods

act :: forall (a0 :: SUBCAT (Algebra m)) x y. Ob a0 => Classifying m a b x y -> Classifying m a b (Act (AlgAction m) a0 x) (Act (AlgAction m) a0 y) Source Github #

HasFree ob => Corepresentable (Rep (Forget ob) :: k -> SUBCAT ob -> Type) Source Github #

By creating the left adjoint to the forgetful functor, we obtain the free-forgetful adjunction.

Instance details

Defined in Proarrow.Profunctor.Free

Methods

coindex :: forall (a :: k) (b :: SUBCAT ob). Rep (Forget ob) a b -> (Rep (Forget ob) %% a) ~> b Source Github #

cotabulate :: forall (a :: k) (b :: SUBCAT ob). Ob a => ((Rep (Forget ob) %% a) ~> b) -> Rep (Forget ob) a b Source Github #

corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Rep (Forget ob) %% a) ~> (Rep (Forget ob) %% b) Source Github #

corepUniv :: forall (a :: k). Ob a => Rep (Forget ob) a (Rep (Forget ob) %% a) Source Github #

(Monoidal k2, Monoidal (SUBCAT ob), MonoidalAction t) => MonoidalAction (SubAction ob t :: k1 -> (SUBCAT ob, k1) -> Type) Source Github #

Instance details

Methods

unitor :: forall (x :: k1). Ob x => Act (SubAction ob t) (Unit :: SUBCAT ob) x ~> x Source Github #

unitorInv :: forall (x :: k1). Ob x => x ~> Act (SubAction ob t) (Unit :: SUBCAT ob) x Source Github #

multiplicator :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (x :: k1). (Ob a, Ob b, Ob x) => Act (SubAction ob t) (a ** b) x ~> Act (SubAction ob t) a (Act (SubAction ob t) b x) Source Github #

multiplicatorInv :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (x :: k1). (Ob a, Ob b, Ob x) => Act (SubAction ob t) a (Act (SubAction ob t) b x) ~> Act (SubAction ob t) (a ** b) x Source Github #

Applicative f => Strong (SubAction Traversable ApplyAction) (Star (Prelude f) :: Type -> Type -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Star

Methods

act :: forall (a :: SUBCAT Traversable) x y. Ob a => Star (Prelude f) x y -> Star (Prelude f) (Act (SubAction Traversable ApplyAction) a x) (Act (SubAction Traversable ApplyAction) a y) Source Github #

type Colimit (Rep f :: i -> a -> Type) (d :: k +-> i) Source Github #

Instance details

Defined in Proarrow.Colimit

type Colimit (Rep f :: i -> a -> Type) (d :: k +-> i) = Corep f :.: d

type (Rep Forget) %% (a :: Type) Source Github #

Instance details

type (Rep Forget) %% (a :: Type) = 'L (Ur a)

type (Rep f :: k -> j -> Type) % (a :: j) Source Github #

Instance details

type (Rep f :: k -> j -> Type) % (a :: j) = f @ a

type HasArrow (Rep f :: k -> j -> Type) (a :: k) (b :: j) Source Github #

Instance details

type HasArrow (Rep f :: k -> j -> Type) (a :: k) (b :: j) = HasArrow (Hom k) a (f @ b)

type (Rep (Not r) :: k -> OPPOSITE k -> Type) %% (a :: k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Closed

type (Rep (Not r) :: k -> OPPOSITE k -> Type) %% (a :: k) = 'OP (a ~~> r)

type (Rep (Forget ob) :: k -> SUBCAT ob -> Type) %% (a :: k) Source Github #

Instance details

Defined in Proarrow.Profunctor.Free

type (Rep (Forget ob) :: k -> SUBCAT ob -> Type) %% (a :: k) = 'SUB (Free ob a) :: SUBCAT ob

type (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) :: MatK (Complex a) -> MatK (Complex a) -> Type) %% (n :: MatK (Complex a)) Source Github #

Instance details