Safe Haskell	None
Language	GHC2024

Proarrow.Profunctor.Instance.Composition

Description

Profunctor composition :.:, the coend exists b. (p a b, q b c) with the coend hidden in the existential of the constructor. This is the horizontal composition of profunctors; Promonads are the monoids with respect to it.

Synopsis

data ((p :: j +-> k) :.: (q :: i +-> j)) (a :: k) (c :: i) where
- (:.:) :: forall {j} {k} {i} (b :: j) (a :: k) (c :: i) (p :: j +-> k) (q :: i +-> j). ~(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). (p :~> q) -> (r :~> s) -> (p :.: r) :~> (q :.: s)
compComp :: forall {i} (p :: CAT i) (q :: CAT 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} (b :: j) (a :: k) (c :: i) (p :: j +-> k) (q :: i +-> j). ~(p a b) -> ~(q b c) -> (p :.: q) a c

Instances

Instances details

(ProdFl w1 w2 f f', ProdFl w1 w2 g g', Flavor w1, Flavor w2) => ProdFl (w1 :: FLAVOR j1 k1) (w2 :: FLAVOR j2 k2) (f :.: g :: (k1, k2) -> (k1, k2) -> Type) (g' :.: f' :: (j1, j2) -> (j1, j2) -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Prod Methods withProdP :: forall (s :: (k1, k2)) (a :: (k1, k2)) (b :: (j1, j2)) (t :: (j1, j2)) r. (f :.: g) s a -> (g' :.: f') b t -> (forall (p1 :: k1 +-> k1) (p2 :: k2 +-> k2) (q1 :: j1 +-> j1) (q2 :: j2 +-> j2). (w1 p1 q1, w2 p2 q2, Profunctor p1, Profunctor p2, Profunctor q1, Profunctor q2) => p1 ((Fst :: (k1, k2) +-> k1) @ s) ((Fst :: (k1, k2) +-> k1) @ a) -> p2 ((Snd :: (k1, k2) +-> k2) @ s) ((Snd :: (k1, k2) +-> k2) @ a) -> q1 ((Fst :: (j1, j2) +-> j1) @ b) ((Fst :: (j1, j2) +-> j1) @ t) -> q2 ((Snd :: (j1, j2) +-> j2) @ b) ((Snd :: (j1, j2) +-> j2) @ t) -> r) -> r Source Github #
(SumFl w1 w2 f f', SumFl w1 w2 g g', Flavor w1, Flavor w2) => SumFl (w1 :: FLAVOR j1 k1) (w2 :: FLAVOR j2 k2) (f :.: g :: COPRODUCT k1 k2 -> COPRODUCT k1 k2 -> Type) (g' :.: f' :: COPRODUCT j1 j2 -> COPRODUCT j1 j2 -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Sum Methods withSumL :: forall (s :: k1) (a :: COPRODUCT k1 k2) (b :: COPRODUCT j1 j2) (t :: j1) r. (f :.: g) ('L s :: COPRODUCT k1 k2) a -> (g' :.: f') b ('L t :: COPRODUCT j1 j2) -> (forall (p1 :: k1 +-> k1) (q1 :: j1 +-> j1) (a' :: k1) (b' :: j1). (w1 p1 q1, Profunctor p1, Profunctor q1, a ~ ('L a' :: COPRODUCT k1 k2), b ~ ('L b' :: COPRODUCT j1 j2)) => p1 s a' -> q1 b' t -> r) -> r Source Github # withSumR :: forall (s :: k2) (a :: COPRODUCT k1 k2) (b :: COPRODUCT j1 j2) (t :: j2) r. (f :.: g) ('R s :: COPRODUCT k1 k2) a -> (g' :.: f') b ('R t :: COPRODUCT j1 j2) -> (forall (p2 :: k2 +-> k2) (q2 :: j2 +-> j2) (a' :: k2) (b' :: j2). (w2 p2 q2, Profunctor p2, Profunctor q2, a ~ ('R a' :: COPRODUCT k1 k2), b ~ ('R b' :: COPRODUCT j1 j2)) => p2 s a' -> q2 b' t -> r) -> r Source Github #
(DayFl w1 w2 f f', DayFl w1 w2 g g') => DayFl (w1 :: FLAVOR i1 i2) (w2 :: FLAVOR i1 i2) (f :.: g :: i2 -> i2 -> Type) (g' :.: f' :: i1 -> i1 -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Day
(Strong t p, Strong t q) => Strong (t :: (m, i) +-> i) (p :.: q :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Strength Methods act :: forall (a :: m) (x :: i) (y :: i). Ob a => (p :.: q) x y -> (p :.: q) (Act t a x) (Act t a y) 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 #
(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 #
(ActFl act f g, ActFl act f' g') => ActFl (act :: (m, i) +-> i) (f :.: f' :: i -> i -> Type) (g' :.: g :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Action Methods withActP :: forall (s :: i) (a :: i) (b :: i) (t :: i) r. (f :.: f') s a -> (g' :.: g) b t -> (forall (x :: m). Ob x => (s ~> Act act x a) -> (Act act x b ~> t) -> r) -> r Source Github #
(FoldFl p1 q1, FoldFl p2 q2, Monoidal k) => FoldFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods foldMapP :: forall (m :: k) (s :: k) (a :: k). Monoid m => Beside p1 p2 s a -> (a ~> m) -> s ~> m Source Github #
(FoldFl p1 q1, FoldFl p2 q2, HasBinaryCoproducts k) => FoldFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods foldMapP :: forall (m :: k) (s :: k) (a :: k). Monoid m => BesideSum p1 p2 s a -> (a ~> m) -> s ~> m Source Github #
(Finitary w, Finitary s, FiniteCat j) => Finitary (w :.: s :: k -> i -> Type) Source Github #	The composite of finitary profunctors over a finite middle category is finitary. An element at `a`/`c` is a pair `(u, v)` over some middle object `x`, and pairs are identified along the arrows of the middle category: `(rmap f u, v) = (u, lmap f v)`, the coend `∫^x w a x × s x c`. The classes are computed by `classes` and numbered in order, each shown by its first pair.
Instance details Defined in Proarrow.Category.Enriched.Finitary.Topos Methods size :: forall (a :: k) (b :: i). (Ob a, Ob b) => Natural Source Github # toIndex :: forall (a :: k) (b :: i). (Ob a, Ob b) => (w :.: s) a b -> Natural Source Github # fromIndex :: forall (a :: k) (b :: i). (Ob a, Ob b) => Natural -> (w :.: s) a b Source Github # elements :: forall (a :: k) (b :: i). (Ob a, Ob b) => [(w :.: s) a b] Source Github #
DecideComp (ThinCompStrategy p q) p q => DecidableProfunctor (p :.: q :: k -> j2 -> Type) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin.Composition Methods decide :: forall (a :: k) (b :: j2). (Ob a, Ob b) => Decision (p :.: q) a b (Holds (p :.: q) a b) Source Github # toHolds :: forall (a :: k) (b :: j2) r. (p :.: q) a b -> ((Holds (p :.: q) a b ~ 'TRU, Ob a, Ob b) => r) -> r Source Github #
ComposeThin (ThinCompStrategy p q) p q => ThinProfunctor (p :.: q :: k -> j2 -> Type) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin.Composition Methods arr :: forall (a :: k) (b :: j2). (Ob a, Ob b, HasArrow (p :.: q) a b) => (p :.: q) a b Source Github # withArr :: forall (a :: k) (b :: j2) r. (p :.: q) a b -> ((HasArrow (p :.: q) a b, Ob a, Ob b) => r) -> r Source Github #
(MonoidalProfunctor p, MonoidalProfunctor q) => MonoidalProfunctor (p :.: q :: k -> j2 -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods one :: (p :.: q) (Unit :: k) (Unit :: j2) Source Github # () :: 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.Instance.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 #
(FunctorForRep p, FunctorForRep q) => FunctorForRep (p :.: q :: k -> j2 -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Composition Methods fmap :: forall (a :: j2) (b :: j2). (a ~> b) -> ((p :.: q) @ a) ~> ((p :.: q) @ b) Source Github #
(Corepresentable p, Corepresentable q) => Corepresentable (p :.: q :: k -> j2 -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Corepresentable 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 # corepUniv :: 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.Representable 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 #
(Corepresentable j2, HasColimits j1 k, HasColimits j2 k) => HasColimits (j1 :.: j2 :: i -> a -> Type) k Source Github #
Instance details Defined in Proarrow.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.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 #
(AlgLensFl m f g, AlgLensFl m f' g') => AlgLensFl (m :: k +-> k) (f :.: f' :: k -> k -> Type) (g' :.: g :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Action Methods withAlgP :: forall (s :: k) (a :: k) (b :: k) (t :: k) r. (f :.: f') s a -> (g' :.: g) b t -> (forall (x :: k). Ob x => ((m % x) ~> x) -> (s ~> (x a)) -> ((x b) ~> t) -> r) -> r Source Github #
(ClassifyFl l f g, ClassifyFl l f' g') => ClassifyFl (l :: i +-> i) (f :.: f' :: i -> i -> Type) (g' :.: g :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Action
(AffineFoldFl f g, AffineFoldFl f' g') => AffineFoldFl (f :.: f' :: k -> k -> Type) (g' :.: g :: j -> j -> Type) Source Github #
Instance details Defined in Proarrow.Optic.AffineFold Methods previewP :: forall (s :: k) (a :: k). Bicartesian k => (f :.: f') s a -> s ~> (a \|\| (TerminalObject :: k)) Source Github #
(FoldFl f g, FoldFl f' g') => FoldFl (f :.: f' :: k -> k -> Type) (g' :.: g :: j -> j -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Fold Methods foldMapP :: forall (m :: k) (s :: k) (a :: k). Monoid m => (f :.: f') s a -> (a ~> m) -> s ~> m Source Github #
(GetterFl f g, GetterFl f' g') => GetterFl (f :.: f' :: k -> k -> Type) (g' :.: g :: j -> j -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Getter Methods getP :: forall (s :: k) (a :: k). (f :.: f') s a -> s ~> a Source Github #
(SetterFl p1 q1, SetterFl p2 q2, Monoidal k) => SetterFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods overP :: forall (s :: k) (a :: k) (b :: k) (t :: k). Beside p1 p2 s a -> CoBeside q1 q2 b t -> (a ~> b) -> s ~> t Source Github #
(SetterFl p1 q1, SetterFl p2 q2, HasBinaryCoproducts k) => SetterFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods overP :: forall (s :: k) (a :: k) (b :: k) (t :: k). BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> (a ~> b) -> s ~> t Source Github #
(MonTravFl p1 q1, MonTravFl p2 q2, Monoidal k) => MonTravFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods monTravP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). StrongDistributiveProfunctor r => Beside p1 p2 s a -> CoBeside q1 q2 b t -> r a b -> r s t Source Github #
(MonTravFl p1 q1, MonTravFl p2 q2, HasBinaryCoproducts k) => MonTravFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods monTravP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). StrongDistributiveProfunctor r => BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> r a b -> r s t Source Github #
(TravFl p1 q1, TravFl p2 q2, Monoidal k) => TravFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods travP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). (StrongDistributiveProfunctor r, Strong (ProdAction :: k -> (PROD k, k) -> Type) r) => Beside p1 p2 s a -> CoBeside q1 q2 b t -> r a b -> r s t Source Github #
(TravFl p1 q1, TravFl p2 q2, HasBinaryCoproducts k) => TravFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods travP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). (StrongDistributiveProfunctor r, Strong (ProdAction :: k -> (PROD k, k) -> Type) r) => BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> r a b -> r s t Source Github #
(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 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Adjunction Methods proextract :: (p :.: q) :~> ((~>) :: CAT k) Source Github # produplicate :: (p :.: q) :~> ((p :.: q) :.: (p :.: q)) Source Github #
(AffineTravFl f g, AffineTravFl f' g') => AffineTravFl (f :.: f' :: i -> i -> Type) (g' :.: g :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Optic.AffineTraversal Methods affineMatch :: forall (s :: i) (a :: i) (b :: i) (t :: i). Bicartesian i => (f :.: f') s a -> (g' :.: g) b t -> s ~> (t \|\| a) Source Github # affineSet :: forall (s :: i) (a :: i) (b :: i) (t :: i). Bicartesian i => (f :.: f') s a -> (g' :.: g) b t -> (s && b) ~> t Source Github #
(GlassFl f g, GlassFl f' g') => GlassFl (f :.: f' :: k -> k -> Type) (g' :.: g :: k -> k -> Type) Source Github #	Composition threads the selector through: the outer glass is given the consumer `\sel -> inner (sel s, \sel' -> k (sel' . sel))`.
Instance details Defined in Proarrow.Optic.Glass Methods glassP :: forall (s :: k) (a :: k) (b :: k) (t :: k). CCC k => (f :.: f') s a -> (g' :.: g) b t -> (s && Mod s a b) ~> t Source Github #
(GrateFl f g, GrateFl f' g') => GrateFl (f :.: f' :: i -> i -> Type) (g' :.: g :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Grate Methods zipWithP :: forall (s :: i) (a :: i) (b :: i) (t :: i). (Closed i, SymMonoidal i) => (f :.: f') s a -> (g' :.: g) b t -> forall (x :: i). Ob x => ((x ~~> a) ~> b) -> (x ~~> s) ~> t Source Github #
(CotravFl f g, CotravFl f' g') => CotravFl (f :.: f' :: i -> i -> Type) (g' :.: g :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods cotravP :: forall r (s :: i) (a :: i) (b :: i) (t :: i). Cotraversable r => (f :.: f') s a -> (g' :.: g) b t -> r a b -> r s t Source Github #
(KaleidoFl f g, KaleidoFl f' g') => KaleidoFl (f :.: f' :: i -> i -> Type) (g' :.: g :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods kaleidoP :: forall r (s :: i) (a :: i) (b :: i) (t :: i). Kaleidoscopic r => (f :.: f') s a -> (g' :.: g) b t -> r a b -> r s t Source Github #
(LensFl f g, LensFl f' g') => LensFl (f :.: f' :: i -> i -> Type) (g' :.: g :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Lens Methods putP :: forall (s :: i) (a :: i) (b :: i) (t :: i). HasBinaryProducts i => (f :.: f') s a -> (g' :.: g) b t -> (s && b) ~> t Source Github #
(MonLensFl f g, MonLensFl f' g') => MonLensFl (f :.: f' :: k -> k -> Type) (g' :.: g :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalLens Methods withMonLensP :: forall (s :: k) (a :: k) (b :: k) (t :: k) r. SymMonoidal k => (f :.: f') s a -> (g' :.: g) b t -> (forall (m :: k). Ob m => ComonoidOn m -> (s ~> (m a)) -> ((m b) ~> t) -> r) -> r Source Github #
(PowerGrateFl f g, PowerGrateFl f' g') => PowerGrateFl (f :.: f' :: i -> i -> Type) (g' :.: g :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Optic.PowerGrate Methods powerGrateP :: forall r (s :: i) (a :: i) (b :: i) (t :: i). MonoidalProfunctor r => (f :.: f') s a -> (g' :.: g) b t -> r a b -> r s t Source Github #
(PrismFl f g, PrismFl f' g') => PrismFl (f :.: f' :: i -> i -> Type) (g' :.: g :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Prism Methods matchingP :: forall (s :: i) (a :: i) (b :: i) (t :: i). HasBinaryCoproducts i => (f :.: f') s a -> (g' :.: g) b t -> s ~> (t \|\| a) Source Github #
(SetterFl f g, SetterFl f' g') => SetterFl (f :.: f' :: i -> i -> Type) (g' :.: g :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Setter Methods overP :: forall (s :: i) (a :: i) (b :: i) (t :: i). (f :.: f') s a -> (g' :.: g) b t -> (a ~> b) -> s ~> t Source Github #
(TracerFl f g, TracerFl f' g') => TracerFl (f :.: f' :: k -> k -> Type) (g' :.: g :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Tracer Methods withTracerP :: forall (s :: k) (a :: k) (b :: k) (t :: k) r. Monoidal k => (f :.: f') s a -> (g' :.: g) b t -> (forall (m :: k). Ob m => ((m s) ~> a) -> (b ~> (m t)) -> r) -> r Source Github #
(MonTravFl f g, MonTravFl f' g') => MonTravFl (f :.: f' :: i -> i -> Type) (g' :.: g :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods monTravP :: forall r (s :: i) (a :: i) (b :: i) (t :: i). StrongDistributiveProfunctor r => (f :.: f') s a -> (g' :.: g) b t -> r a b -> r s t Source Github #
(TravFl f g, TravFl f' g') => TravFl (f :.: f' :: i -> i -> Type) (g' :.: g :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods travP :: forall r (s :: i) (a :: i) (b :: i) (t :: i). (StrongDistributiveProfunctor r, Strong (ProdAction :: i -> (PROD i, i) -> Type) r) => (f :.: f') s a -> (g' :.: g) b t -> r a b -> r s t 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.Colimit.BinaryCoproduct Methods one :: Coprod (f :.: g) (Unit :: COPROD k) (Unit :: COPROD j2) Source Github # () :: 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.Instance.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.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.Limit type Limit (j1 :.: j2 :: a -> i -> Type) (d :: i +-> k) = Limit j1 (Limit j2 d)
type (p :.: q :: k -> j1 -> Type) @ (b :: j1) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Composition type (p :.: q :: k -> j1 -> Type) @ (b :: j1) = p @ (q @ b)
type (p :.: q :: k -> j1 -> Type) %% (a :: k) Source Github #
Instance details Defined in Proarrow.Profunctor.Corepresentable 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.Representable type (p :.: q :: k -> j1 -> Type) % (a :: j1) = p % (q % a)
type HasArrow (p :.: q :: k -> j1 -> Type) (a :: k) (c :: j1) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin.Composition type HasArrow (p :.: q :: k -> j1 -> Type) (a :: k) (c :: j1) = HasArrowComp (ThinCompStrategy p q) p q a c
type Holds (p :.: q :: k -> j1 -> Type) (a :: k) (c :: j1) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin.Composition type Holds (p :.: q :: k -> j1 -> Type) (a :: k) (c :: j1) = HoldsComp (ThinCompStrategy p q) p q a c

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

Horizontal composition

compComp :: forall {i} (p :: CAT i) (q :: CAT 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.