Safe Haskell	None
Language	GHC2024

Proarrow.Profunctor.Composition

Synopsis

data ((p :: j +-> k) :.: (q :: i +-> j)) (a :: k) (c :: i) where
- (:.:) :: forall {j} {k} {i} (p :: j +-> k) (a :: k) (b :: j) (q :: i +-> j) (c :: i). p a b -> q b c -> (p :.: q) a c
o :: forall {i} {j} {k} (p :: j +-> k) (q :: j +-> k) (r :: i +-> j) (s :: i +-> j). Prof p q -> Prof r s -> Prof (p :.: r) (q :.: s)
compComp :: forall {i} (p :: i +-> i) (q :: i +-> i) (b :: i) (c :: i) (a :: i). (Promonad p, Promonad q) => ((q :.: p) :~> (p :.: q)) -> (p :.: q) b c -> (p :.: q) a b -> (p :.: q) a c

Documentation

data ((p :: j +-> k) :.: (q :: i +-> j)) (a :: k) (c :: i) where Source Github #

Constructors

(:.:) :: forall {j} {k} {i} (p :: j +-> k) (a :: k) (b :: j) (q :: i +-> j) (c :: i). p a b -> q b c -> (p :.: q) a c

Instances

Instances details

(Strong m p, Strong m q) => Strong m (p :.: q :: d -> c -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Composition

Methods

act :: forall (a :: m) (b :: m) (x :: d) (y :: c). (a ~> b) -> (p :.: q) x y -> (p :.: q) (Act a x) (Act b y) Source Github #

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

Instance details

Defined in Proarrow.Profunctor.Composition

Methods

par0 :: (p :.: q) (Unit :: k) (Unit :: j2) Source Github #

par :: forall (x1 :: k) (x2 :: j2) (y1 :: k) (y2 :: j2). (p :.: q) x1 x2 -> (p :.: q) y1 y2 -> (p :.: q) (x1 ** y1) (x2 ** y2) Source Github #

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

Instance details

Defined in Proarrow.Profunctor.Composition

Methods

dimap :: forall (c :: k) (a :: k) (b :: j2) (d :: j2). (c ~> a) -> (b ~> d) -> (p :.: q) a b -> (p :.: q) c d Source Github #

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

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

(\\) :: forall (a :: k) (b :: j2) r. ((Ob a, Ob b) => r) -> (p :.: q) a b -> r Source Github #

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

Instance details

Defined in Proarrow.Profunctor.Composition

Methods

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

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

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

trivialCorep :: forall (a :: k). Ob a => (p :.: q) a ((p :.: q) %% a) Source Github #

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

Instance details

Defined in Proarrow.Profunctor.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 #

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

(Corepresentable j2, HasColimits j1 k, HasColimits j2 k) => HasColimits (j1 :.: j2 :: i -> a -> Type) k Source Github #

Instance details

Defined in Proarrow.Category.Colimit

Methods

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

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

(Representable j1, HasLimits j1 k, HasLimits j2 k) => HasLimits (j1 :.: j2 :: a -> i -> Type) k Source Github #

Instance details

Defined in Proarrow.Category.Limit

Methods

limit :: forall (d :: i +-> k). Representable d => (Limit (j1 :.: j2) d :.: (j1 :.: j2)) :~> d Source Github #

limitUniv :: forall (d :: i +-> k) (p :: a +-> k). (Representable d, Profunctor p) => ((p :.: (j1 :.: j2)) :~> d) -> p :~> Limit (j1 :.: j2) d Source Github #

(Proadjunction l1 r1, Proadjunction l2 r2) => Proadjunction (l1 :.: l2 :: i -> k -> Type) (r2 :.: r1 :: k -> i -> Type) Source Github #

Instance details

Defined in Proarrow.Adjunction

Methods

unit :: forall (a :: k). Ob a => ((r2 :.: r1) :.: (l1 :.: l2)) a a Source Github #

counit :: ((l1 :.: l2) :.: (r2 :.: r1)) :~> ((~>) :: CAT i) Source Github #

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

Instance details

Defined in Proarrow.Category.Equipment.Stateful

Associated Types

type WithWriter (p :.: q :: k -> k -> Type)
Instance details Defined in Proarrow.Category.Equipment.Stateful type WithWriter (p :.: q :: k -> k -> Type) = WithWriter q :.: WithWriter p

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

Instance details

Defined in Proarrow.Category.Equipment.Stateful

Associated Types

type WithReader (p :.: q :: k -> k -> Type)
Instance details Defined in Proarrow.Category.Equipment.Stateful type WithReader (p :.: q :: k -> k -> Type) = WithReader q :.: WithReader p

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

Instance details

Defined in Proarrow.Category.Monoidal.Distributive

Methods

cotraverse :: forall (p0 :: k +-> k). StrongDistributiveProfunctor p0 => (p0 :.: (p :.: q)) :~> ((p :.: q) :.: p0) Source Github #

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

Instance details

Defined in Proarrow.Category.Monoidal.Distributive

Methods

traverse :: forall (p0 :: k +-> k). StrongDistributiveProfunctor p0 => ((p :.: q) :.: p0) :~> (p0 :.: (p :.: q)) Source Github #

Proadjunction p q => Promonad (q :.: p :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Adjunction

Methods

id :: forall (a :: k). Ob a => (q :.: p) a a Source Github #

(.) :: forall (b :: k) (c :: k) (a :: k). (q :.: p) b c -> (q :.: p) a b -> (q :.: p) a c Source Github #

Proadjunction p q => Procomonad (p :.: q :: i -> i -> Type) Source Github #

Instance details

Defined in Proarrow.Adjunction

Methods

extract :: (p :.: q) :~> ((~>) :: CAT i) Source Github #

duplicate :: (p :.: q) :~> ((p :.: q) :.: (p :.: q)) Source Github #

(Profunctor f, Profunctor g, MonoidalProfunctor (Coprod f), MonoidalProfunctor (Coprod g)) => MonoidalProfunctor (Coprod (f :.: g) :: COPROD k -> COPROD j2 -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Composition

Methods

par0 :: Coprod (f :.: g) (Unit :: COPROD k) (Unit :: COPROD j2) Source Github #

par :: forall (x1 :: COPROD k) (x2 :: COPROD j2) (y1 :: COPROD k) (y2 :: COPROD j2). Coprod (f :.: g) x1 x2 -> Coprod (f :.: g) y1 y2 -> Coprod (f :.: g) (x1 ** y1) (x2 ** y2) Source Github #

Functor ((:.:) :: (j +-> k) -> (i +-> j) -> k -> i -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

Methods

map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> ((:.:) a :: (i +-> j) -> k -> i -> Type) ~> ((:.:) b :: (i +-> j) -> k -> i -> Type) Source Github #

Profunctor p => Functor ((:.:) p :: (i +-> j) -> k -> i -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Composition

Methods

map :: forall (a :: i +-> j) (b :: i +-> j). (a ~> b) -> (p :.: a) ~> (p :.: b) Source Github #

type Colimit (j1 :.: j2 :: i -> a -> Type) (d :: k +-> i) Source Github #

Instance details

Defined in Proarrow.Category.Colimit

type Colimit (j1 :.: j2 :: i -> a -> Type) (d :: k +-> i) = Colimit j2 (Colimit j1 d)

type Limit (j1 :.: j2 :: a -> i -> Type) (d :: i +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Limit

type Limit (j1 :.: j2 :: a -> i -> Type) (d :: i +-> k) = Limit j1 (Limit j2 d)

type (p :.: q :: k -> j1 -> Type) %% (a :: k) Source Github #

Instance details

Defined in Proarrow.Profunctor.Composition

type (p :.: q :: k -> j1 -> Type) %% (a :: k) = q %% (p %% a)

type (p :.: q :: k -> j1 -> Type) % (a :: j1) Source Github #

Instance details

Defined in Proarrow.Profunctor.Composition

type (p :.: q :: k -> j1 -> Type) % (a :: j1) = p % (q % a)

type WithReader (p :.: q :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Equipment.Stateful

type WithReader (p :.: q :: k -> k -> Type) = WithReader q :.: WithReader p

type WithWriter (p :.: q :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Equipment.Stateful

type WithWriter (p :.: q :: k -> k -> Type) = WithWriter q :.: WithWriter p

o :: forall {i} {j} {k} (p :: j +-> k) (q :: j +-> k) (r :: i +-> j) (s :: i +-> j). Prof p q -> Prof r s -> Prof (p :.: r) (q :.: s) Source Github #

Horizontal composition

compComp :: forall {i} (p :: i +-> i) (q :: i +-> i) (b :: i) (c :: i) (a :: i). (Promonad p, Promonad q) => ((q :.: p) :~> (p :.: q)) -> (p :.: q) b c -> (p :.: q) a b -> (p :.: q) a c Source Github #

p :.: q is a Promonad if p and q are and if there's a distributive law between p and q.