| Safe Haskell | None |
|---|---|
| Language | GHC2024 |
Proarrow.Core
Description
Synopsis
- type (+->) j k = k -> j -> Type
- type CAT k = k +-> k
- type OB k = k -> Constraint
- type Kind = Type
- class Any (a :: k)
- class Promonad ((~>) :: CAT k) => CategoryOf k where
- type Hom k = (~>) :: CAT k
- class (CategoryOf j, CategoryOf k) => Profunctor (p :: j +-> k) where
- type (:~>) (p :: k -> k1 -> Type) (q :: k -> k1 -> Type) = forall (a :: k) (b :: k1). p a b -> q a b
- (//) :: forall {k1} {k2} p (a :: k2) (b :: k1) r. Profunctor p => p a b -> ((Ob a, Ob b) => r) -> r
- dimapDefault :: forall {k} p (c :: k) (a :: k) (b :: k) (d :: k). Promonad p => p c a -> p b d -> p a b -> p c d
- class Profunctor p => Promonad (p :: k +-> k) where
- arr :: forall {k} p (a :: k) (b :: k). Promonad p => (a ~> b) -> p a b
- type Obj (a :: k) = a ~> a
- obj :: forall {k} (a :: k). (CategoryOf k, Ob a) => Obj a
- src :: forall {j} {k} (a :: k) (b :: j) p. Profunctor p => p a b -> Obj a
- tgt :: forall {k1} {k2} (a :: k2) (b :: k1) p. Profunctor p => p a b -> Obj b
- type family UN (w :: j -> k) (wa :: k) :: j
- type Is (w :: j -> k) (a :: k) = a ~ w (UN w a)
Type Infrastructure
Basic Type Definitions
type (+->) j k = k -> j -> Type infixr 0 Source Github #
The kind j +-> k of profunctors from category j to category k.
Note that this follows mathematical convention,
swapping the order compared to Haskell's contravariant-first ordering.
type OB k = k -> Constraint Source Github #
Object constraints for kind k.
Universal Constraint
class Any (a :: k) Source Github #
A constraint that's always satisfied, used as a default when no specific object constraints are needed.
Instances
| Any (a :: k) Source Github # | |
Defined in Proarrow.Core | |
Category Infrastructure
CategoryOf Class
class Promonad ((~>) :: CAT k) => CategoryOf k Source Github #
Establishes that k is a category by specifying the morphism type and object constraints.
Associated Types
type (~>) :: CAT k infixr 0 Source Github #
The type of morphisms in the category.
type Ob (a :: k) Source Github #
What constraints objects must satisfy.
Instances
| CategoryOf Nat Source Github # | The (augmented) simplex category is the category of finite ordinals and order preserving maps. | ||||||||
Defined in Proarrow.Category.Instance.Simplex Associated Types
| |||||||||
| CategoryOf Nat Source Github # | The category of qubits, to implement ZX calculus from quantum computing. | ||||||||
Defined in Proarrow.Category.Instance.ZX Associated Types
| |||||||||
| CategoryOf BOOL Source Github # | The category of 2 objects and one arrow between them, a.k.a. the walking arrow. | ||||||||
Defined in Proarrow.Category.Instance.Bool Associated Types
| |||||||||
| CategoryOf KIND Source Github # | The category of categories and profunctors between them. | ||||||||
Defined in Proarrow.Category.Instance.Cat Associated Types
| |||||||||
| CategoryOf CONSTRAINT Source Github # | The category of type class constraints. An arrow from constraint a to constraint b | means that a implies b, i.e. if a holds then b holds. | ||||||||
Defined in Proarrow.Category.Instance.Constraint Associated Types
| |||||||||
| CategoryOf COST Source Github # | Cost category. Categories enriched in the cost category are lawvere metric spaces. | ||||||||
Defined in Proarrow.Category.Instance.Cost Associated Types
| |||||||||
| CategoryOf FINREL Source Github # | |||||||||
Defined in Proarrow.Category.Instance.FinRel | |||||||||
| CategoryOf FINSET Source Github # | |||||||||
Defined in Proarrow.Category.Instance.FinSet | |||||||||
| CategoryOf LINEAR Source Github # | Category of linear functions. | ||||||||
Defined in Proarrow.Category.Instance.Linear | |||||||||
| CategoryOf POINTED Source Github # | The category of types with an added point and point-preserving morphisms. | ||||||||
Defined in Proarrow.Category.Instance.PointedHask | |||||||||
| CategoryOf VOID Source Github # | The category with no objects, the initial category. | ||||||||
Defined in Proarrow.Category.Instance.Zero Associated Types
| |||||||||
| CategoryOf DOT Source Github # | |||||||||
Defined in Proarrow.Tools.Diagrams.Dot | |||||||||
| CategoryOf () Source Github # | The category with one object, the terminal category. | ||||||||
Defined in Proarrow.Category.Instance.Unit Associated Types
| |||||||||
| CategoryOf Symbol Source Github # | |||||||||
Defined in Proarrow.Tools.Diagrams.Dot Associated Types
| |||||||||
| CategoryOf Type Source Github # | The category of Haskell types (a.k.a | ||||||||
Defined in Proarrow.Core Associated Types
| |||||||||
| HasPushouts k => CategoryOf (COSPAN k) Source Github # | |||||||||
Defined in Proarrow.Category.Instance.Cospan | |||||||||
| CategoryOf (CODISCRETE k) Source Github # | The codiscrete category has exactly one arrow between every object, every type of kind | ||||||||
Defined in Proarrow.Category.Instance.Discrete Associated Types
| |||||||||
| CategoryOf (DISCRETE k) Source Github # | The discrete category with only identity arrows, every type of kind | ||||||||
Defined in Proarrow.Category.Instance.Discrete | |||||||||
| CategoryOf k => CategoryOf (FAM k) Source Github # | The Fam construction a.k.a. the free coproduct completion of | ||||||||
Defined in Proarrow.Category.Instance.Fam | |||||||||
| CategoryOf (FIN n) Source Github # | The (thin) category of finite ordinals. An arrow from a to b means that a is less than or equal to b. | ||||||||
Defined in Proarrow.Category.Instance.Fin | |||||||||
| TracedMonoidal k => CategoryOf (INT k) Source Github # | The Int construction, a.k.a. the geometry of interaction, the free compact closed category on a traced monoidal category. | ||||||||
Defined in Proarrow.Category.Instance.IntConstruction Associated Types
| |||||||||
| Num a => CategoryOf (MatK a) Source Github # | The category of matrices with entries in a type | ||||||||
Defined in Proarrow.Category.Instance.Mat | |||||||||
| HasPullbacks k => CategoryOf (SPAN k) Source Github # | |||||||||
Defined in Proarrow.Category.Instance.Span | |||||||||
| CategoryOf k => CategoryOf (REV k) Source Github # | The reverse of the category of | ||||||||
Defined in Proarrow.Category.Monoidal.Rev | |||||||||
| CategoryOf k => CategoryOf (OPPOSITE k) Source Github # | The opposite category of the category of | ||||||||
Defined in Proarrow.Category.Opposite | |||||||||
| CategoryOf k => CategoryOf (COPROD k) Source Github # | The same category as the category of | ||||||||
Defined in Proarrow.Object.BinaryCoproduct | |||||||||
| CategoryOf k => CategoryOf (PROD k) Source Github # | The same category as the category of | ||||||||
Defined in Proarrow.Object.BinaryProduct | |||||||||
| CategoryOf k => CategoryOf (LIST k) Source Github # | The category of lists of arrows. | ||||||||
Defined in Proarrow.Profunctor.List | |||||||||
| Monoidal k => CategoryOf [k] Source Github # | The strictified monoidal category, making the unitors and associators identities. | ||||||||
Defined in Proarrow.Category.Monoidal.Strictified Associated Types
| |||||||||
| CategoryOf (ADJK a b) Source Github # | |||||||||
Defined in Proarrow.Category.Bicategory.Adj | |||||||||
| CategoryOf (PROFK j k) Source Github # | |||||||||
Defined in Proarrow.Category.Bicategory.Prof | |||||||||
| (Applicative f, CategoryOf k) => CategoryOf (AP f k) Source Github # | |||||||||
Defined in Proarrow.Category.Instance.Ap | |||||||||
| (CategoryOf j, CategoryOf k) => CategoryOf (COPRODUCT j k) Source Github # | The coproduct of two categories. | ||||||||
Defined in Proarrow.Category.Instance.Coproduct | |||||||||
| Promonad p => CategoryOf (KLEISLI p) Source Github # | Every promonad makes a category. | ||||||||
Defined in Proarrow.Category.Instance.Kleisli | |||||||||
| CategoryOf (j .-> k) Source Github # | The category of functors and natural transformations. | ||||||||
Defined in Proarrow.Category.Instance.Nat | |||||||||
| CategoryOf k => CategoryOf (SUBCAT ob) Source Github # | The subcategory with objects with instances of the given constraint | ||||||||
Defined in Proarrow.Category.Instance.Sub | |||||||||
| (j ~ '(), k ~ '()) => CategoryOf (Unit j k) Source Github # | |||||||||
Defined in Proarrow.Category.Bicategory.Terminal | |||||||||
| CategoryOf (j +-> k) Source Github # | The category of profunctors and natural transformations between them. | ||||||||
Defined in Proarrow.Category.Instance.Prof | |||||||||
| Monoid m => CategoryOf (MONOIDK m) Source Github # | A monoid as a one object category. | ||||||||
Defined in Proarrow.Monoid | |||||||||
| (CategoryOf k1, CategoryOf k2) => CategoryOf (k1, k2) Source Github # | The product of two categories. | ||||||||
Defined in Proarrow.Category.Instance.Product | |||||||||
| CategoryOf (k1 -> k2 -> k3 -> k4 -> Type) Source Github # | The category of functors with target category k2 -> k3 -> k4 -> Type. | ||||||||
Defined in Proarrow.Category.Instance.Nat | |||||||||
| CategoryOf (k1 -> k2 -> k3 -> Type) Source Github # | The category of functors with target category | ||||||||
Defined in Proarrow.Category.Instance.Nat | |||||||||
| CategoryOf (k1 -> Type) Source Github # | The category of functors with target category Hask. | ||||||||
Defined in Proarrow.Category.Instance.Nat | |||||||||
| (CategoryOf k, Ob i, Ob j) => CategoryOf (PLAINK k i j) Source Github # | |||||||||
Defined in Proarrow.Category.Bicategory.CategoryAsBi | |||||||||
| CategoryOf k => CategoryOf (MonK k i j) Source Github # | |||||||||
Defined in Proarrow.Category.Bicategory.MonoidalAsBi | |||||||||
| SelfAction k => CategoryOf (STT' k i j) Source Github # | |||||||||
Defined in Proarrow.Category.Equipment.Stateful | |||||||||
| Profunctor p => CategoryOf (COLLAGE p) Source Github # | The collage of a profunctor. | ||||||||
Defined in Proarrow.Category.Instance.Collage | |||||||||
| Adjunction adj => CategoryOf (DUPLOID adj) Source Github # | |||||||||
Defined in Proarrow.Category.Instance.Duploid | |||||||||
| Ok cs p => CategoryOf (FREE cs p) Source Github # | |||||||||
Defined in Proarrow.Category.Instance.Free | |||||||||
| ThinProfunctor p => CategoryOf (GRAPH p) Source Github # | The graph of a thin profunctor. Doing this for any profunctor would need dependent types. | ||||||||
Defined in Proarrow.Category.Instance.Graph | |||||||||
| (Bicategory kk, Ob0 kk k) => CategoryOf (ENDO kk k) Source Github # | |||||||||
Defined in Proarrow.Category.Monoidal.Endo | |||||||||
| (CategoryOf j, CategoryOf k) => CategoryOf (OPTIC j k c) Source Github # | |||||||||
Defined in Proarrow.Optic | |||||||||
| CategoryOf (DiscreteK ob j k) Source Github # | |||||||||
Defined in Proarrow.Category.Bicategory.Bidiscrete Associated Types
| |||||||||
| CategoryOf (kk j k2) => CategoryOf (COK kk j k2) Source Github # | |||||||||
Defined in Proarrow.Category.Bicategory.Co | |||||||||
| CategoryOf (kk k2 j) => CategoryOf (OPK kk j k2) Source Github # | |||||||||
Defined in Proarrow.Category.Bicategory.Op | |||||||||
| (CategoryOf (kk j k2), Bicategory kk) => CategoryOf (Path kk j k2) Source Github # | |||||||||
Defined in Proarrow.Category.Bicategory.Strictified Associated Types
| |||||||||
| CategoryOf (kk i j) => CategoryOf (HK kk i j) Source Github # | |||||||||
Defined in Proarrow.Category.Bicategory.Hom | |||||||||
| CategoryOf (kk i j) => CategoryOf (SUBCAT tag kk i j) Source Github # | The subcategory with objects with instances of the given constraint `IsOb tag`. | ||||||||
Defined in Proarrow.Category.Bicategory.Sub | |||||||||
| (CategoryOf (jj (Fst ik) (Fst jl)), CategoryOf (kk (Snd ik) (Snd jl))) => CategoryOf (PRODK jj kk ik jl) Source Github # | |||||||||
Defined in Proarrow.Category.Bicategory.Product | |||||||||
type Hom k = (~>) :: CAT k Source Github #
A type synonym for (~>) :: CAT k, the type of morphisms in the category of kind k.
Profunctors
Profunctor Class
class (CategoryOf j, CategoryOf k) => Profunctor (p :: j +-> k) where Source Github #
The core profunctor abstraction. A profunctor is contravariant in its first argument and covariant in its second argument.
Laws:
Methods
dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> p a b -> p c d Source Github #
Map contravariantly over the first argument and covariantly over the second.
lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> p a b -> p c b Source Github #
Left mapping (contravariant mapping over first argument).
rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> p a b -> p a d Source Github #
Right mapping (covariant mapping over second argument).
(\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> p a b -> r infixl 1 Source Github #
Constraint elimination, extracts object constraints from a profunctor heteromorphism.
Instances
| Profunctor Simplex Source Github # | |
Defined in Proarrow.Category.Instance.Simplex Methods dimap :: forall (c :: Nat) (a :: Nat) (b :: Nat) (d :: Nat). (c ~> a) -> (b ~> d) -> Simplex a b -> Simplex c d Source Github # lmap :: forall (c :: Nat) (a :: Nat) (b :: Nat). (c ~> a) -> Simplex a b -> Simplex c b Source Github # rmap :: forall (b :: Nat) (d :: Nat) (a :: Nat). (b ~> d) -> Simplex a b -> Simplex a d Source Github # (\\) :: forall (a :: Nat) (b :: Nat) r. ((Ob a, Ob b) => r) -> Simplex a b -> r Source Github # | |
| Profunctor ZX Source Github # | |
Defined in Proarrow.Category.Instance.ZX Methods dimap :: forall (c :: Nat) (a :: Nat) (b :: Nat) (d :: Nat). (c ~> a) -> (b ~> d) -> ZX a b -> ZX c d Source Github # lmap :: forall (c :: Nat) (a :: Nat) (b :: Nat). (c ~> a) -> ZX a b -> ZX c b Source Github # rmap :: forall (b :: Nat) (d :: Nat) (a :: Nat). (b ~> d) -> ZX a b -> ZX a d Source Github # (\\) :: forall (a :: Nat) (b :: Nat) r. ((Ob a, Ob b) => r) -> ZX a b -> r Source Github # | |
| Profunctor Booleans Source Github # | |
Defined in Proarrow.Category.Instance.Bool Methods dimap :: forall (c :: BOOL) (a :: BOOL) (b :: BOOL) (d :: BOOL). (c ~> a) -> (b ~> d) -> Booleans a b -> Booleans c d Source Github # lmap :: forall (c :: BOOL) (a :: BOOL) (b :: BOOL). (c ~> a) -> Booleans a b -> Booleans c b Source Github # rmap :: forall (b :: BOOL) (d :: BOOL) (a :: BOOL). (b ~> d) -> Booleans a b -> Booleans a d Source Github # (\\) :: forall (a :: BOOL) (b :: BOOL) r. ((Ob a, Ob b) => r) -> Booleans a b -> r Source Github # | |
| Profunctor Cat Source Github # | |
Defined in Proarrow.Category.Instance.Cat Methods dimap :: forall (c :: KIND) (a :: KIND) (b :: KIND) (d :: KIND). (c ~> a) -> (b ~> d) -> Cat a b -> Cat c d Source Github # lmap :: forall (c :: KIND) (a :: KIND) (b :: KIND). (c ~> a) -> Cat a b -> Cat c b Source Github # rmap :: forall (b :: KIND) (d :: KIND) (a :: KIND). (b ~> d) -> Cat a b -> Cat a d Source Github # (\\) :: forall (a :: KIND) (b :: KIND) r. ((Ob a, Ob b) => r) -> Cat a b -> r Source Github # | |
| Profunctor (:-) Source Github # | |
Defined in Proarrow.Category.Instance.Constraint Methods dimap :: forall (c :: CONSTRAINT) (a :: CONSTRAINT) (b :: CONSTRAINT) (d :: CONSTRAINT). (c ~> a) -> (b ~> d) -> (a :- b) -> c :- d Source Github # lmap :: forall (c :: CONSTRAINT) (a :: CONSTRAINT) (b :: CONSTRAINT). (c ~> a) -> (a :- b) -> c :- b Source Github # rmap :: forall (b :: CONSTRAINT) (d :: CONSTRAINT) (a :: CONSTRAINT). (b ~> d) -> (a :- b) -> a :- d Source Github # (\\) :: forall (a :: CONSTRAINT) (b :: CONSTRAINT) r. ((Ob a, Ob b) => r) -> (a :- b) -> r Source Github # | |
| Profunctor GTE Source Github # | |
Defined in Proarrow.Category.Instance.Cost Methods dimap :: forall (c :: COST) (a :: COST) (b :: COST) (d :: COST). (c ~> a) -> (b ~> d) -> GTE a b -> GTE c d Source Github # lmap :: forall (c :: COST) (a :: COST) (b :: COST). (c ~> a) -> GTE a b -> GTE c b Source Github # rmap :: forall (b :: COST) (d :: COST) (a :: COST). (b ~> d) -> GTE a b -> GTE a d Source Github # (\\) :: forall (a :: COST) (b :: COST) r. ((Ob a, Ob b) => r) -> GTE a b -> r Source Github # | |
| Profunctor FinRel Source Github # | |
Defined in Proarrow.Category.Instance.FinRel Methods dimap :: forall (c :: FINREL) (a :: FINREL) (b :: FINREL) (d :: FINREL). (c ~> a) -> (b ~> d) -> FinRel a b -> FinRel c d Source Github # lmap :: forall (c :: FINREL) (a :: FINREL) (b :: FINREL). (c ~> a) -> FinRel a b -> FinRel c b Source Github # rmap :: forall (b :: FINREL) (d :: FINREL) (a :: FINREL). (b ~> d) -> FinRel a b -> FinRel a d Source Github # (\\) :: forall (a :: FINREL) (b :: FINREL) r. ((Ob a, Ob b) => r) -> FinRel a b -> r Source Github # | |
| Profunctor FinSet Source Github # | |
Defined in Proarrow.Category.Instance.FinSet Methods dimap :: forall (c :: FINSET) (a :: FINSET) (b :: FINSET) (d :: FINSET). (c ~> a) -> (b ~> d) -> FinSet a b -> FinSet c d Source Github # lmap :: forall (c :: FINSET) (a :: FINSET) (b :: FINSET). (c ~> a) -> FinSet a b -> FinSet c b Source Github # rmap :: forall (b :: FINSET) (d :: FINSET) (a :: FINSET). (b ~> d) -> FinSet a b -> FinSet a d Source Github # (\\) :: forall (a :: FINSET) (b :: FINSET) r. ((Ob a, Ob b) => r) -> FinSet a b -> r Source Github # | |
| Profunctor Linear Source Github # | |
Defined in Proarrow.Category.Instance.Linear Methods dimap :: forall (c :: LINEAR) (a :: LINEAR) (b :: LINEAR) (d :: LINEAR). (c ~> a) -> (b ~> d) -> Linear a b -> Linear c d Source Github # lmap :: forall (c :: LINEAR) (a :: LINEAR) (b :: LINEAR). (c ~> a) -> Linear a b -> Linear c b Source Github # rmap :: forall (b :: LINEAR) (d :: LINEAR) (a :: LINEAR). (b ~> d) -> Linear a b -> Linear a d Source Github # (\\) :: forall (a :: LINEAR) (b :: LINEAR) r. ((Ob a, Ob b) => r) -> Linear a b -> r Source Github # | |
| Profunctor Pointed Source Github # | |
Defined in Proarrow.Category.Instance.PointedHask Methods dimap :: forall (c :: POINTED) (a :: POINTED) (b :: POINTED) (d :: POINTED). (c ~> a) -> (b ~> d) -> Pointed a b -> Pointed c d Source Github # lmap :: forall (c :: POINTED) (a :: POINTED) (b :: POINTED). (c ~> a) -> Pointed a b -> Pointed c b Source Github # rmap :: forall (b :: POINTED) (d :: POINTED) (a :: POINTED). (b ~> d) -> Pointed a b -> Pointed a d Source Github # (\\) :: forall (a :: POINTED) (b :: POINTED) r. ((Ob a, Ob b) => r) -> Pointed a b -> r Source Github # | |
| Profunctor Zero Source Github # | |
Defined in Proarrow.Category.Instance.Zero Methods dimap :: forall (c :: VOID) (a :: VOID) (b :: VOID) (d :: VOID). (c ~> a) -> (b ~> d) -> Zero a b -> Zero c d Source Github # lmap :: forall (c :: VOID) (a :: VOID) (b :: VOID). (c ~> a) -> Zero a b -> Zero c b Source Github # rmap :: forall (b :: VOID) (d :: VOID) (a :: VOID). (b ~> d) -> Zero a b -> Zero a d Source Github # (\\) :: forall (a :: VOID) (b :: VOID) r. ((Ob a, Ob b) => r) -> Zero a b -> r Source Github # | |
| Profunctor Dot Source Github # | |
Defined in Proarrow.Tools.Diagrams.Dot Methods dimap :: forall (c :: DOT) (a :: DOT) (b :: DOT) (d :: DOT). (c ~> a) -> (b ~> d) -> Dot a b -> Dot c d Source Github # lmap :: forall (c :: DOT) (a :: DOT) (b :: DOT). (c ~> a) -> Dot a b -> Dot c b Source Github # rmap :: forall (b :: DOT) (d :: DOT) (a :: DOT). (b ~> d) -> Dot a b -> Dot a d Source Github # (\\) :: forall (a :: DOT) (b :: DOT) r. ((Ob a, Ob b) => r) -> Dot a b -> r Source Github # | |
| Profunctor Unit Source Github # | |
Defined in Proarrow.Category.Instance.Unit Methods dimap :: forall (c :: ()) (a :: ()) (b :: ()) (d :: ()). (c ~> a) -> (b ~> d) -> Unit a b -> Unit c d Source Github # lmap :: forall (c :: ()) (a :: ()) (b :: ()). (c ~> a) -> Unit a b -> Unit c b Source Github # rmap :: forall (b :: ()) (d :: ()) (a :: ()). (b ~> d) -> Unit a b -> Unit a d Source Github # (\\) :: forall (a :: ()) (b :: ()) r. ((Ob a, Ob b) => r) -> Unit a b -> r Source Github # | |
| Profunctor SymRefl Source Github # | |
Defined in Proarrow.Tools.Diagrams.Dot Methods dimap :: forall (c :: Symbol) (a :: Symbol) (b :: Symbol) (d :: Symbol). (c ~> a) -> (b ~> d) -> SymRefl a b -> SymRefl c d Source Github # lmap :: forall (c :: Symbol) (a :: Symbol) (b :: Symbol). (c ~> a) -> SymRefl a b -> SymRefl c b Source Github # rmap :: forall (b :: Symbol) (d :: Symbol) (a :: Symbol). (b ~> d) -> SymRefl a b -> SymRefl a d Source Github # (\\) :: forall (a :: Symbol) (b :: Symbol) r. ((Ob a, Ob b) => r) -> SymRefl a b -> r Source Github # | |
| Profunctor (NonTrivialProfunctor ft :: BOOL -> BOOL -> Type) Source Github # | There are 4 non-trivial profunctors BOOL +-> BOOL, all with FLS->TRU, and optionally FLS->FLS and TRU->TRU. |
Defined in Proarrow.Category.Instance.Bool Methods dimap :: forall (c :: BOOL) (a :: BOOL) (b :: BOOL) (d :: BOOL). (c ~> a) -> (b ~> d) -> NonTrivialProfunctor ft a b -> NonTrivialProfunctor ft c d Source Github # lmap :: forall (c :: BOOL) (a :: BOOL) (b :: BOOL). (c ~> a) -> NonTrivialProfunctor ft a b -> NonTrivialProfunctor ft c b Source Github # rmap :: forall (b :: BOOL) (d :: BOOL) (a :: BOOL). (b ~> d) -> NonTrivialProfunctor ft a b -> NonTrivialProfunctor ft a d Source Github # (\\) :: forall (a :: BOOL) (b :: BOOL) r. ((Ob a, Ob b) => r) -> NonTrivialProfunctor ft a b -> r Source Github # | |
| Functor m => Profunctor (Kleisli m :: Type -> Type -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Arrow | |
| Functor w => Profunctor (ComonoidAsCat w :: Type -> Type -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods dimap :: (c ~> a) -> (b ~> d) -> ComonoidAsCat w a b -> ComonoidAsCat w c d Source Github # lmap :: (c ~> a) -> ComonoidAsCat w a b -> ComonoidAsCat w c b Source Github # rmap :: (b ~> d) -> ComonoidAsCat w a b -> ComonoidAsCat w a d Source Github # (\\) :: ((Ob a, Ob b) => r) -> ComonoidAsCat w a b -> r Source Github # | |
| Arrow arr => Profunctor (Arr arr :: Type -> Type -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Arrow | |
| CategoryOf k => Profunctor (Fold :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Fold Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Fold a b -> Fold c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Fold a b -> Fold c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Fold a b -> Fold a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> Fold a b -> r Source Github # | |
| CategoryOf k => Profunctor (Id :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Identity Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Id a b -> Id c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Id a b -> Id c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Id a b -> Id a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> Id a b -> r Source Github # | |
| Profunctor (Previewing a b :: Type -> Type -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Optic Methods dimap :: (c ~> a0) -> (b0 ~> d) -> Previewing a b a0 b0 -> Previewing a b c d Source Github # lmap :: (c ~> a0) -> Previewing a b a0 b0 -> Previewing a b c b0 Source Github # rmap :: (b0 ~> d) -> Previewing a b a0 b0 -> Previewing a b a0 d Source Github # (\\) :: ((Ob a0, Ob b0) => r) -> Previewing a b a0 b0 -> r Source Github # | |
| Profunctor (Replacing a b :: Type -> Type -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Optic Methods dimap :: (c ~> a0) -> (b0 ~> d) -> Replacing a b a0 b0 -> Replacing a b c d Source Github # lmap :: (c ~> a0) -> Replacing a b a0 b0 -> Replacing a b c b0 Source Github # rmap :: (b0 ~> d) -> Replacing a b a0 b0 -> Replacing a b a0 d Source Github # (\\) :: ((Ob a0, Ob b0) => r) -> Replacing a b a0 b0 -> r Source Github # | |
| Profunctor (->) Source Github # | |
| Profunctor p => Profunctor (Fix p :: j -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Fix Methods dimap :: forall (c :: j) (a :: j) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Fix p a b -> Fix p c d Source Github # lmap :: forall (c :: j) (a :: j) (b :: j). (c ~> a) -> Fix p a b -> Fix p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: j). (b ~> d) -> Fix p a b -> Fix p a d Source Github # (\\) :: forall (a :: j) (b :: j) r. ((Ob a, Ob b) => r) -> Fix p a b -> r Source Github # | |
| Profunctor p => Profunctor (FreePromonad p :: j -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Free Methods dimap :: forall (c :: j) (a :: j) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> FreePromonad p a b -> FreePromonad p c d Source Github # lmap :: forall (c :: j) (a :: j) (b :: j). (c ~> a) -> FreePromonad p a b -> FreePromonad p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: j). (b ~> d) -> FreePromonad p a b -> FreePromonad p a d Source Github # (\\) :: forall (a :: j) (b :: j) r. ((Ob a, Ob b) => r) -> FreePromonad p a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (DayUnit :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Day Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> DayUnit a b -> DayUnit c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> DayUnit a b -> DayUnit c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> DayUnit a b -> DayUnit a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> DayUnit a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (InitialProfunctor :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Initial Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> InitialProfunctor a b -> InitialProfunctor c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> InitialProfunctor a b -> InitialProfunctor c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> InitialProfunctor a b -> InitialProfunctor a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> InitialProfunctor a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (TerminalProfunctor :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Terminal Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> TerminalProfunctor a b -> TerminalProfunctor c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> TerminalProfunctor a b -> TerminalProfunctor c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> TerminalProfunctor a b -> TerminalProfunctor a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> TerminalProfunctor a b -> r Source Github # | |
| CategoryOf k => Profunctor (Cont r :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Promonad.Cont Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Cont r a b -> Cont r c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Cont r a b -> Cont r c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Cont r a b -> Cont r a d Source Github # (\\) :: forall (a :: k) (b :: k) r0. ((Ob a, Ob b) => r0) -> Cont r a b -> r0 Source Github # | |
| (Ob r, Monoidal k) => Profunctor (Reader ('OP r) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Promonad.Reader Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Reader ('OP r) a b -> Reader ('OP r) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Reader ('OP r) a b -> Reader ('OP r) c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Reader ('OP r) a b -> Reader ('OP r) a d Source Github # (\\) :: forall (a :: k) (b :: k) r0. ((Ob a, Ob b) => r0) -> Reader ('OP r) a b -> r0 Source Github # | |
| (Ob w, Monoidal k) => Profunctor (Writer w :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Promonad.Writer Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Writer w a b -> Writer w c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Writer w a b -> Writer w c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Writer w a b -> Writer w a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> Writer w a b -> r Source Github # | |
| (CategoryOf k, Profunctor dx) => Profunctor (AsPresheaf dx :: k -> () -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Fam Methods dimap :: forall (c :: k) (a :: k) (b :: ()) (d :: ()). (c ~> a) -> (b ~> d) -> AsPresheaf dx a b -> AsPresheaf dx c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: ()). (c ~> a) -> AsPresheaf dx a b -> AsPresheaf dx c b Source Github # rmap :: forall (b :: ()) (d :: ()) (a :: k). (b ~> d) -> AsPresheaf dx a b -> AsPresheaf dx a d Source Github # (\\) :: forall (a :: k) (b :: ()) r. ((Ob a, Ob b) => r) -> AsPresheaf dx a b -> r Source Github # | |
| Profunctor p => Profunctor (Adj p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Adjunction Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Adj p a b -> Adj p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Adj p a b -> Adj p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Adj p a b -> Adj p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Adj p a b -> r Source Github # | |
| Relation p => Profunctor (Converse p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Rel Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Converse p a b -> Converse p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Converse p a b -> Converse p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Converse p a b -> Converse p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Converse p a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k, Profunctor p) => Profunctor (UnOp p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Category.Opposite Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> UnOp p a b -> UnOp p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> UnOp p a b -> UnOp p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> UnOp p a b -> UnOp p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> UnOp p a b -> r Source Github # | |
| Profunctor p => Profunctor (FromProfunctor p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Functor Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> FromProfunctor p a b -> FromProfunctor p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> FromProfunctor p a b -> FromProfunctor p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> FromProfunctor p a b -> FromProfunctor p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> FromProfunctor p a b -> r Source Github # | |
| FunctorForRep f => Profunctor (Corep f :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Corepresentable Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Corep f a b -> Corep f c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Corep f a b -> Corep f c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Corep f a b -> Corep f a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Corep f a b -> r Source Github # | |
| Functor f => Profunctor (Costar f :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Costar Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Costar f a b -> Costar f c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Costar f a b -> Costar f c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Costar f a b -> Costar f a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Costar f a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (Coyoneda p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Coyoneda Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Coyoneda p a b -> Coyoneda p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Coyoneda p a b -> Coyoneda p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Coyoneda p a b -> Coyoneda p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Coyoneda p a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (HaskValue c :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.HaskValue Methods dimap :: forall (c0 :: k) (a :: k) (b :: j) (d :: j). (c0 ~> a) -> (b ~> d) -> HaskValue c a b -> HaskValue c c0 d Source Github # lmap :: forall (c0 :: k) (a :: k) (b :: j). (c0 ~> a) -> HaskValue c a b -> HaskValue c c0 b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> HaskValue c a b -> HaskValue c a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> HaskValue c a b -> r Source Github # | |
| Corepresentable p => Profunctor (CorepStar p :: k -> j -> Type) Source Github # | |
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 # | |
| FunctorForRep f => Profunctor (Rep f :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Representable 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 # | |
| Representable p => Profunctor (RepCostar p :: k -> j -> Type) Source Github # | |
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 # | |
| Functor f => Profunctor (Star f :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Star Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Star f a b -> Star f c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Star f a b -> Star f c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Star f a b -> Star f a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Star f a b -> r Source Github # | |
| Profunctor p => Profunctor (Wrapped p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Wrapped Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Wrapped p a b -> Wrapped p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Wrapped p a b -> Wrapped p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Wrapped p a b -> Wrapped p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Wrapped p a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (Yoneda p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Yoneda Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Yoneda p a b -> Yoneda p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Yoneda p a b -> Yoneda p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Yoneda p a b -> Yoneda p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Yoneda p a b -> r Source Github # | |
| Profunctor l => Profunctor (AsLeftAdjoint l :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Universal Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> AsLeftAdjoint l a b -> AsLeftAdjoint l c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> AsLeftAdjoint l a b -> AsLeftAdjoint l c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> AsLeftAdjoint l a b -> AsLeftAdjoint l a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> AsLeftAdjoint l a b -> r Source Github # | |
| Profunctor r => Profunctor (AsRightAdjoint r :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Universal Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> AsRightAdjoint r a b -> AsRightAdjoint r c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> AsRightAdjoint r a b -> AsRightAdjoint r c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> AsRightAdjoint r a b -> AsRightAdjoint r a d Source Github # (\\) :: forall (a :: k) (b :: j) r0. ((Ob a, Ob b) => r0) -> AsRightAdjoint r a b -> r0 Source Github # | |
| Profunctor p => Profunctor (FromAdjunction p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Universal Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> FromAdjunction p a b -> FromAdjunction p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> FromAdjunction p a b -> FromAdjunction p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> FromAdjunction p a b -> FromAdjunction p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> FromAdjunction p a b -> r Source Github # | |
| (Ob a, MonoidalAction m k) => Profunctor (Action a :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Action Methods dimap :: forall (c :: k) (a0 :: k) (b :: k) (d :: k). (c ~> a0) -> (b ~> d) -> Action a a0 b -> Action a c d Source Github # lmap :: forall (c :: k) (a0 :: k) (b :: k). (c ~> a0) -> Action a a0 b -> Action a c b Source Github # rmap :: forall (b :: k) (d :: k) (a0 :: k). (b ~> d) -> Action a a0 b -> Action a a0 d Source Github # (\\) :: forall (a0 :: k) (b :: k) r. ((Ob a0, Ob b) => r) -> Action a a0 b -> r Source Github # | |
| (Profunctor p, Monoidal k, Ob r) => Profunctor (ReaderT ('OP r) p :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Promonad.Reader Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> ReaderT ('OP r) p a b -> ReaderT ('OP r) p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> ReaderT ('OP r) p a b -> ReaderT ('OP r) p c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> ReaderT ('OP r) p a b -> ReaderT ('OP r) p a d Source Github # (\\) :: forall (a :: k) (b :: k) r0. ((Ob a, Ob b) => r0) -> ReaderT ('OP r) p a b -> r0 Source Github # | |
| (Profunctor p, Monoidal k, Ob s) => Profunctor (StateT s p :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Promonad.State Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> StateT s p a b -> StateT s p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> StateT s p a b -> StateT s p c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> StateT s p a b -> StateT s p a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> StateT s p a b -> r Source Github # | |
| (Profunctor p, Monoidal k, Ob w) => Profunctor (WriterT w p :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Promonad.Writer Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> WriterT w p a b -> WriterT w p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> WriterT w p a b -> WriterT w p c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> WriterT w p a b -> WriterT w p a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> WriterT w p a b -> r Source Github # | |
| Monad m => Profunctor (Classifying m a b :: Type -> Type -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Optic Methods dimap :: (c ~> a0) -> (b0 ~> d) -> Classifying m a b a0 b0 -> Classifying m a b c d Source Github # lmap :: (c ~> a0) -> Classifying m a b a0 b0 -> Classifying m a b c b0 Source Github # rmap :: (b0 ~> d) -> Classifying m a b a0 b0 -> Classifying m a b a0 d Source Github # (\\) :: ((Ob a0, Ob b0) => r) -> Classifying m a b a0 b0 -> r Source Github # | |
| Profunctor p => Profunctor (n :*.: p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Object.Copower Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> (n :*.: p) a b -> (n :*.: p) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> (n :*.: p) a b -> (n :*.: p) c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> (n :*.: p) a b -> (n :*.: p) a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> (n :*.: p) a b -> r Source Github # | |
| Profunctor p => Profunctor (p :^: n :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Object.Power Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> (p :^: n) a b -> (p :^: n) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> (p :^: n) a b -> (p :^: n) c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> (p :^: n) a b -> (p :^: n) a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> (p :^: n) a b -> r Source Github # | |
| (Profunctor p, Profunctor q) => Profunctor (p :+: q :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Coproduct Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> (p :+: q) a b -> (p :+: q) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> (p :+: q) a b -> (p :+: q) c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> (p :+: q) a b -> (p :+: q) a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> (p :+: q) a b -> r Source Github # | |
| (Profunctor p, Profunctor q) => Profunctor (Day p q :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Day Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Day p q a b -> Day p q c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Day p q a b -> Day p q c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Day p q a b -> Day p q a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Day p q a b -> r Source Github # | |
| (Monoidal j, Monoidal k, Profunctor p, Profunctor q) => Profunctor (DayExp p q :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Day Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> DayExp p q a b -> DayExp p q c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> DayExp p q a b -> DayExp p q c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> DayExp p q a b -> DayExp p q a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> DayExp p q a b -> r Source Github # | |
| (Profunctor p, Profunctor q) => Profunctor (p :~>: q :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Exponential Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> (p :~>: q) a b -> (p :~>: q) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> (p :~>: q) a b -> (p :~>: q) c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> (p :~>: q) a b -> (p :~>: q) a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> (p :~>: q) a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (Pastro m p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.PastroTambara Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Pastro m p a b -> Pastro m p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Pastro m p a b -> Pastro m p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Pastro m p a b -> Pastro m p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Pastro m p a b -> r Source Github # | |
| (MonoidalAction m j, MonoidalAction m k, Profunctor p) => Profunctor (Tambara m p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.PastroTambara Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Tambara m p a b -> Tambara m p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Tambara m p a b -> Tambara m p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Tambara m p a b -> Tambara m p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Tambara m p a b -> r Source Github # | |
| (Profunctor p, Profunctor q) => Profunctor (p :*: q :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Product Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> (p :*: q) a b -> (p :*: q) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> (p :*: q) a b -> (p :*: q) c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> (p :*: q) a b -> (p :*: q) a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> (p :*: q) a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (Yo a ('OP b) :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Yoneda Methods dimap :: forall (c :: k) (a0 :: k) (b0 :: j) (d :: j). (c ~> a0) -> (b0 ~> d) -> Yo a ('OP b) a0 b0 -> Yo a ('OP b) c d Source Github # lmap :: forall (c :: k) (a0 :: k) (b0 :: j). (c ~> a0) -> Yo a ('OP b) a0 b0 -> Yo a ('OP b) c b0 Source Github # rmap :: forall (b0 :: j) (d :: j) (a0 :: k). (b0 ~> d) -> Yo a ('OP b) a0 b0 -> Yo a ('OP b) a0 d Source Github # (\\) :: forall (a0 :: k) (b0 :: j) r. ((Ob a0, Ob b0) => r) -> Yo a ('OP b) a0 b0 -> r Source Github # | |
| (CategoryOf c, CategoryOf d) => Profunctor (ExOptic m a b :: d -> c -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Optic Methods dimap :: forall (c0 :: d) (a0 :: d) (b0 :: c) (d0 :: c). (c0 ~> a0) -> (b0 ~> d0) -> ExOptic m a b a0 b0 -> ExOptic m a b c0 d0 Source Github # lmap :: forall (c0 :: d) (a0 :: d) (b0 :: c). (c0 ~> a0) -> ExOptic m a b a0 b0 -> ExOptic m a b c0 b0 Source Github # rmap :: forall (b0 :: c) (d0 :: c) (a0 :: d). (b0 ~> d0) -> ExOptic m a b a0 b0 -> ExOptic m a b a0 d0 Source Github # (\\) :: forall (a0 :: d) (b0 :: c) r. ((Ob a0, Ob b0) => r) -> ExOptic m a b a0 b0 -> r Source Github # | |
| (Profunctor tk, Profunctor tj) => Profunctor (Day tk tj ps :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Category.Promonoidal Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Day tk tj ps a b -> Day tk tj ps c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Day tk tj ps a b -> Day tk tj ps c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Day tk tj ps a b -> Day tk tj ps a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Day tk tj ps a b -> r Source Github # | |
| Profunctor p => Profunctor (Re p s t :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Optic Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Re p s t a b -> Re p s t c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Re p s t a b -> Re p s t c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Re p s t a b -> Re p s t a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Re p s t a b -> r Source Github # | |
| (Ob a, Ob b, CategoryOf j, CategoryOf k, c :=> (Profunctor :: (j +-> k) -> Constraint)) => Profunctor (WrappedOptic c a b :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Optic Methods dimap :: forall (c0 :: k) (a0 :: k) (b0 :: j) (d :: j). (c0 ~> a0) -> (b0 ~> d) -> WrappedOptic c a b a0 b0 -> WrappedOptic c a b c0 d Source Github # lmap :: forall (c0 :: k) (a0 :: k) (b0 :: j). (c0 ~> a0) -> WrappedOptic c a b a0 b0 -> WrappedOptic c a b c0 b0 Source Github # rmap :: forall (b0 :: j) (d :: j) (a0 :: k). (b0 ~> d) -> WrappedOptic c a b a0 b0 -> WrappedOptic c a b a0 d Source Github # (\\) :: forall (a0 :: k) (b0 :: j) r. ((Ob a0, Ob b0) => r) -> WrappedOptic c a b a0 b0 -> r Source Github # | |
| (FunctorForRep f, FunctorForRep g) => Profunctor (Direp f g :: k1 -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Direpresentable Methods dimap :: forall (c :: k1) (a :: k1) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Direp f g a b -> Direp f g c d Source Github # lmap :: forall (c :: k1) (a :: k1) (b :: j). (c ~> a) -> Direp f g a b -> Direp f g c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k1). (b ~> d) -> Direp f g a b -> Direp f g a d Source Github # (\\) :: forall (a :: k1) (b :: j) r. ((Ob a, Ob b) => r) -> Direp f g a b -> r Source Github # | |
| (Profunctor p, Profunctor j2) => Profunctor (Ran ('OP j2) p :: k -> j1 -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Ran Methods dimap :: forall (c :: k) (a :: k) (b :: j1) (d :: j1). (c ~> a) -> (b ~> d) -> Ran ('OP j2) p a b -> Ran ('OP j2) p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j1). (c ~> a) -> Ran ('OP j2) p a b -> Ran ('OP j2) p c b Source Github # rmap :: forall (b :: j1) (d :: j1) (a :: k). (b ~> d) -> Ran ('OP j2) p a b -> Ran ('OP j2) p a d Source Github # (\\) :: forall (a :: k) (b :: j1) r. ((Ob a, Ob b) => r) -> Ran ('OP j2) p a b -> r Source Github # | |
| (Profunctor p, Profunctor j2) => Profunctor (Rift ('OP j2) p :: k -> j1 -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Rift Methods dimap :: forall (c :: k) (a :: k) (b :: j1) (d :: j1). (c ~> a) -> (b ~> d) -> Rift ('OP j2) p a b -> Rift ('OP j2) p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j1). (c ~> a) -> Rift ('OP j2) p a b -> Rift ('OP j2) p c b Source Github # rmap :: forall (b :: j1) (d :: j1) (a :: k). (b ~> d) -> Rift ('OP j2) p a b -> Rift ('OP j2) p a d Source Github # (\\) :: forall (a :: k) (b :: j1) r. ((Ob a, Ob b) => r) -> Rift ('OP j2) p a b -> r Source Github # | |
| (Profunctor p, Profunctor q) => Profunctor (p :.: q :: k -> j2 -> Type) Source Github # | |
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 # | |
| CategoryOf k => Profunctor (Hom :: (OPPOSITE k, k) -> () -> Type) Source Github # | |
Defined in Proarrow.Category.Colimit Methods dimap :: forall (c :: (OPPOSITE k, k)) (a :: (OPPOSITE k, k)) (b :: ()) (d :: ()). (c ~> a) -> (b ~> d) -> Hom a b -> Hom c d Source Github # lmap :: forall (c :: (OPPOSITE k, k)) (a :: (OPPOSITE k, k)) (b :: ()). (c ~> a) -> Hom a b -> Hom c b Source Github # rmap :: forall (b :: ()) (d :: ()) (a :: (OPPOSITE k, k)). (b ~> d) -> Hom a b -> Hom a d Source Github # (\\) :: forall (a :: (OPPOSITE k, k)) (b :: ()) r. ((Ob a, Ob b) => r) -> Hom a b -> r Source Github # | |
| Promonad p => Profunctor (KleisliFree p :: KLEISLI p -> j -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Kleisli Methods dimap :: forall (c :: KLEISLI p) (a :: KLEISLI p) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> KleisliFree p a b -> KleisliFree p c d Source Github # lmap :: forall (c :: KLEISLI p) (a :: KLEISLI p) (b :: j). (c ~> a) -> KleisliFree p a b -> KleisliFree p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: KLEISLI p). (b ~> d) -> KleisliFree p a b -> KleisliFree p a d Source Github # (\\) :: forall (a :: KLEISLI p) (b :: j) r. ((Ob a, Ob b) => r) -> KleisliFree p a b -> r Source Github # | |
| (Profunctor p, CategoryOf i, CategoryOf j) => Profunctor (Curry p :: (OPPOSITE j, k) -> i -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Cat Methods dimap :: forall (c :: (OPPOSITE j, k)) (a :: (OPPOSITE j, k)) (b :: i) (d :: i). (c ~> a) -> (b ~> d) -> Curry p a b -> Curry p c d Source Github # lmap :: forall (c :: (OPPOSITE j, k)) (a :: (OPPOSITE j, k)) (b :: i). (c ~> a) -> Curry p a b -> Curry p c b Source Github # rmap :: forall (b :: i) (d :: i) (a :: (OPPOSITE j, k)). (b ~> d) -> Curry p a b -> Curry p a d Source Github # (\\) :: forall (a :: (OPPOSITE j, k)) (b :: i) r. ((Ob a, Ob b) => r) -> Curry p a b -> r Source Github # | |
| (Profunctor p, Profunctor q) => Profunctor (p :&&&: q :: (i, j2) -> j1 -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Cat Methods dimap :: forall (c :: (i, j2)) (a :: (i, j2)) (b :: j1) (d :: j1). (c ~> a) -> (b ~> d) -> (p :&&&: q) a b -> (p :&&&: q) c d Source Github # lmap :: forall (c :: (i, j2)) (a :: (i, j2)) (b :: j1). (c ~> a) -> (p :&&&: q) a b -> (p :&&&: q) c b Source Github # rmap :: forall (b :: j1) (d :: j1) (a :: (i, j2)). (b ~> d) -> (p :&&&: q) a b -> (p :&&&: q) a d Source Github # (\\) :: forall (a :: (i, j2)) (b :: j1) r. ((Ob a, Ob b) => r) -> (p :&&&: q) a b -> r Source Github # | |
| Monoidal k => Profunctor (Tensor :: k -> LIST k -> Type) Source Github # | |
Defined in Proarrow.Category.Promonoidal Methods dimap :: forall (c :: k) (a :: k) (b :: LIST k) (d :: LIST k). (c ~> a) -> (b ~> d) -> Tensor a b -> Tensor c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: LIST k). (c ~> a) -> Tensor a b -> Tensor c b Source Github # rmap :: forall (b :: LIST k) (d :: LIST k) (a :: k). (b ~> d) -> Tensor a b -> Tensor a d Source Github # (\\) :: forall (a :: k) (b :: LIST k) r. ((Ob a, Ob b) => r) -> Tensor a b -> r Source Github # | |
| Profunctor p => Profunctor (CoprodDom p :: k -> COPROD j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Star Methods dimap :: forall (c :: k) (a :: k) (b :: COPROD j) (d :: COPROD j). (c ~> a) -> (b ~> d) -> CoprodDom p a b -> CoprodDom p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: COPROD j). (c ~> a) -> CoprodDom p a b -> CoprodDom p c b Source Github # rmap :: forall (b :: COPROD j) (d :: COPROD j) (a :: k). (b ~> d) -> CoprodDom p a b -> CoprodDom p a d Source Github # (\\) :: forall (a :: k) (b :: COPROD j) r. ((Ob a, Ob b) => r) -> CoprodDom p a b -> r Source Github # | |
| Monad m => Profunctor (Updating a b :: Type -> KlCat m -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Optic Methods dimap :: forall c a0 (b0 :: KlCat m) (d :: KlCat m). (c ~> a0) -> (b0 ~> d) -> Updating a b a0 b0 -> Updating a b c d Source Github # lmap :: forall c a0 (b0 :: KlCat m). (c ~> a0) -> Updating a b a0 b0 -> Updating a b c b0 Source Github # rmap :: forall (b0 :: KlCat m) (d :: KlCat m) a0. (b0 ~> d) -> Updating a b a0 b0 -> Updating a b a0 d Source Github # (\\) :: forall a0 (b0 :: KlCat m) r. ((Ob a0, Ob b0) => r) -> Updating a b a0 b0 -> r Source Github # | |
| HasPushouts k => Profunctor (Cospan :: COSPAN k -> COSPAN k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Cospan Methods dimap :: forall (c :: COSPAN k) (a :: COSPAN k) (b :: COSPAN k) (d :: COSPAN k). (c ~> a) -> (b ~> d) -> Cospan a b -> Cospan c d Source Github # lmap :: forall (c :: COSPAN k) (a :: COSPAN k) (b :: COSPAN k). (c ~> a) -> Cospan a b -> Cospan c b Source Github # rmap :: forall (b :: COSPAN k) (d :: COSPAN k) (a :: COSPAN k). (b ~> d) -> Cospan a b -> Cospan a d Source Github # (\\) :: forall (a :: COSPAN k) (b :: COSPAN k) r. ((Ob a, Ob b) => r) -> Cospan a b -> r Source Github # | |
| Profunctor (Codiscrete :: CODISCRETE k -> CODISCRETE k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Discrete Methods dimap :: forall (c :: CODISCRETE k) (a :: CODISCRETE k) (b :: CODISCRETE k) (d :: CODISCRETE k). (c ~> a) -> (b ~> d) -> Codiscrete a b -> Codiscrete c d Source Github # lmap :: forall (c :: CODISCRETE k) (a :: CODISCRETE k) (b :: CODISCRETE k). (c ~> a) -> Codiscrete a b -> Codiscrete c b Source Github # rmap :: forall (b :: CODISCRETE k) (d :: CODISCRETE k) (a :: CODISCRETE k). (b ~> d) -> Codiscrete a b -> Codiscrete a d Source Github # (\\) :: forall (a :: CODISCRETE k) (b :: CODISCRETE k) r. ((Ob a, Ob b) => r) -> Codiscrete a b -> r Source Github # | |
| Profunctor (Discrete :: DISCRETE k -> DISCRETE k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Discrete Methods dimap :: forall (c :: DISCRETE k) (a :: DISCRETE k) (b :: DISCRETE k) (d :: DISCRETE k). (c ~> a) -> (b ~> d) -> Discrete a b -> Discrete c d Source Github # lmap :: forall (c :: DISCRETE k) (a :: DISCRETE k) (b :: DISCRETE k). (c ~> a) -> Discrete a b -> Discrete c b Source Github # rmap :: forall (b :: DISCRETE k) (d :: DISCRETE k) (a :: DISCRETE k). (b ~> d) -> Discrete a b -> Discrete a d Source Github # (\\) :: forall (a :: DISCRETE k) (b :: DISCRETE k) r. ((Ob a, Ob b) => r) -> Discrete a b -> r Source Github # | |
| CategoryOf k => Profunctor (Fam :: FAM k -> FAM k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Fam Methods dimap :: forall (c :: FAM k) (a :: FAM k) (b :: FAM k) (d :: FAM k). (c ~> a) -> (b ~> d) -> Fam a b -> Fam c d Source Github # lmap :: forall (c :: FAM k) (a :: FAM k) (b :: FAM k). (c ~> a) -> Fam a b -> Fam c b Source Github # rmap :: forall (b :: FAM k) (d :: FAM k) (a :: FAM k). (b ~> d) -> Fam a b -> Fam a d Source Github # (\\) :: forall (a :: FAM k) (b :: FAM k) r. ((Ob a, Ob b) => r) -> Fam a b -> r Source Github # | |
| Profunctor (LTE :: FIN n -> FIN n -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Fin Methods dimap :: forall (c :: FIN n) (a :: FIN n) (b :: FIN n) (d :: FIN n). (c ~> a) -> (b ~> d) -> LTE a b -> LTE c d Source Github # lmap :: forall (c :: FIN n) (a :: FIN n) (b :: FIN n). (c ~> a) -> LTE a b -> LTE c b Source Github # rmap :: forall (b :: FIN n) (d :: FIN n) (a :: FIN n). (b ~> d) -> LTE a b -> LTE a d Source Github # (\\) :: forall (a :: FIN n) (b :: FIN n) r. ((Ob a, Ob b) => r) -> LTE a b -> r Source Github # | |
| TracedMonoidal k => Profunctor (IntConstruction :: INT k -> INT k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.IntConstruction Methods dimap :: forall (c :: INT k) (a :: INT k) (b :: INT k) (d :: INT k). (c ~> a) -> (b ~> d) -> IntConstruction a b -> IntConstruction c d Source Github # lmap :: forall (c :: INT k) (a :: INT k) (b :: INT k). (c ~> a) -> IntConstruction a b -> IntConstruction c b Source Github # rmap :: forall (b :: INT k) (d :: INT k) (a :: INT k). (b ~> d) -> IntConstruction a b -> IntConstruction a d Source Github # (\\) :: forall (a :: INT k) (b :: INT k) r. ((Ob a, Ob b) => r) -> IntConstruction a b -> r Source Github # | |
| Num a => Profunctor (Mat :: MatK a -> MatK a -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Mat Methods dimap :: forall (c :: MatK a) (a0 :: MatK a) (b :: MatK a) (d :: MatK a). (c ~> a0) -> (b ~> d) -> Mat a0 b -> Mat c d Source Github # lmap :: forall (c :: MatK a) (a0 :: MatK a) (b :: MatK a). (c ~> a0) -> Mat a0 b -> Mat c b Source Github # rmap :: forall (b :: MatK a) (d :: MatK a) (a0 :: MatK a). (b ~> d) -> Mat a0 b -> Mat a0 d Source Github # (\\) :: forall (a0 :: MatK a) (b :: MatK a) r. ((Ob a0, Ob b) => r) -> Mat a0 b -> r Source Github # | |
| HasPullbacks k => Profunctor (Span :: SPAN k -> SPAN k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Span Methods dimap :: forall (c :: SPAN k) (a :: SPAN k) (b :: SPAN k) (d :: SPAN k). (c ~> a) -> (b ~> d) -> Span a b -> Span c d Source Github # lmap :: forall (c :: SPAN k) (a :: SPAN k) (b :: SPAN k). (c ~> a) -> Span a b -> Span c b Source Github # rmap :: forall (b :: SPAN k) (d :: SPAN k) (a :: SPAN k). (b ~> d) -> Span a b -> Span a d Source Github # (\\) :: forall (a :: SPAN k) (b :: SPAN k) r. ((Ob a, Ob b) => r) -> Span a b -> r Source Github # | |
| CategoryOf k => Profunctor (Cocone :: LIST k -> COPROD k -> Type) Source Github # | |
Defined in Proarrow.Object.Pushout Methods dimap :: forall (c :: LIST k) (a :: LIST k) (b :: COPROD k) (d :: COPROD k). (c ~> a) -> (b ~> d) -> Cocone a b -> Cocone c d Source Github # lmap :: forall (c :: LIST k) (a :: LIST k) (b :: COPROD k). (c ~> a) -> Cocone a b -> Cocone c b Source Github # rmap :: forall (b :: COPROD k) (d :: COPROD k) (a :: LIST k). (b ~> d) -> Cocone a b -> Cocone a d Source Github # (\\) :: forall (a :: LIST k) (b :: COPROD k) r. ((Ob a, Ob b) => r) -> Cocone a b -> r Source Github # | |
| CategoryOf k => Profunctor (Cone :: PROD k -> LIST k -> Type) Source Github # | |
Defined in Proarrow.Object.Pullback Methods dimap :: forall (c :: PROD k) (a :: PROD k) (b :: LIST k) (d :: LIST k). (c ~> a) -> (b ~> d) -> Cone a b -> Cone c d Source Github # lmap :: forall (c :: PROD k) (a :: PROD k) (b :: LIST k). (c ~> a) -> Cone a b -> Cone c b Source Github # rmap :: forall (b :: LIST k) (d :: LIST k) (a :: PROD k). (b ~> d) -> Cone a b -> Cone a d Source Github # (\\) :: forall (a :: PROD k) (b :: LIST k) r. ((Ob a, Ob b) => r) -> Cone a b -> r Source Github # | |
| Monoidal k => Profunctor (Strictified :: [k] -> [k] -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Strictified Methods dimap :: forall (c :: [k]) (a :: [k]) (b :: [k]) (d :: [k]). (c ~> a) -> (b ~> d) -> Strictified a b -> Strictified c d Source Github # lmap :: forall (c :: [k]) (a :: [k]) (b :: [k]). (c ~> a) -> Strictified a b -> Strictified c b Source Github # rmap :: forall (b :: [k]) (d :: [k]) (a :: [k]). (b ~> d) -> Strictified a b -> Strictified a d Source Github # (\\) :: forall (a :: [k]) (b :: [k]) r. ((Ob a, Ob b) => r) -> Strictified a b -> r Source Github # | |
| Profunctor p => Profunctor (Rev p :: REV k -> REV j -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Rev Methods dimap :: forall (c :: REV k) (a :: REV k) (b :: REV j) (d :: REV j). (c ~> a) -> (b ~> d) -> Rev p a b -> Rev p c d Source Github # lmap :: forall (c :: REV k) (a :: REV k) (b :: REV j). (c ~> a) -> Rev p a b -> Rev p c b Source Github # rmap :: forall (b :: REV j) (d :: REV j) (a :: REV k). (b ~> d) -> Rev p a b -> Rev p a d Source Github # (\\) :: forall (a :: REV k) (b :: REV j) r. ((Ob a, Ob b) => r) -> Rev p a b -> r Source Github # | |
| Profunctor p => Profunctor (Op p :: OPPOSITE j -> OPPOSITE k -> Type) Source Github # | |
Defined in Proarrow.Category.Opposite Methods dimap :: forall (c :: OPPOSITE j) (a :: OPPOSITE j) (b :: OPPOSITE k) (d :: OPPOSITE k). (c ~> a) -> (b ~> d) -> Op p a b -> Op p c d Source Github # lmap :: forall (c :: OPPOSITE j) (a :: OPPOSITE j) (b :: OPPOSITE k). (c ~> a) -> Op p a b -> Op p c b Source Github # rmap :: forall (b :: OPPOSITE k) (d :: OPPOSITE k) (a :: OPPOSITE j). (b ~> d) -> Op p a b -> Op p a d Source Github # (\\) :: forall (a :: OPPOSITE j) (b :: OPPOSITE k) r. ((Ob a, Ob b) => r) -> Op p a b -> r Source Github # | |
| Profunctor p => Profunctor (Coprod p :: COPROD k -> COPROD j -> Type) Source Github # | |
Defined in Proarrow.Object.BinaryCoproduct Methods dimap :: forall (c :: COPROD k) (a :: COPROD k) (b :: COPROD j) (d :: COPROD j). (c ~> a) -> (b ~> d) -> Coprod p a b -> Coprod p c d Source Github # lmap :: forall (c :: COPROD k) (a :: COPROD k) (b :: COPROD j). (c ~> a) -> Coprod p a b -> Coprod p c b Source Github # rmap :: forall (b :: COPROD j) (d :: COPROD j) (a :: COPROD k). (b ~> d) -> Coprod p a b -> Coprod p a d Source Github # (\\) :: forall (a :: COPROD k) (b :: COPROD j) r. ((Ob a, Ob b) => r) -> Coprod p a b -> r Source Github # | |
| Profunctor p => Profunctor (Prod p :: PROD k -> PROD j -> Type) Source Github # | |
Defined in Proarrow.Object.BinaryProduct Methods dimap :: forall (c :: PROD k) (a :: PROD k) (b :: PROD j) (d :: PROD j). (c ~> a) -> (b ~> d) -> Prod p a b -> Prod p c d Source Github # lmap :: forall (c :: PROD k) (a :: PROD k) (b :: PROD j). (c ~> a) -> Prod p a b -> Prod p c b Source Github # rmap :: forall (b :: PROD j) (d :: PROD j) (a :: PROD k). (b ~> d) -> Prod p a b -> Prod p a d Source Github # (\\) :: forall (a :: PROD k) (b :: PROD j) r. ((Ob a, Ob b) => r) -> Prod p a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k, Ob ps) => Profunctor (PList ps :: LIST k -> LIST j -> Type) Source Github # | |
Defined in Proarrow.Category.Promonoidal Methods dimap :: forall (c :: LIST k) (a :: LIST k) (b :: LIST j) (d :: LIST j). (c ~> a) -> (b ~> d) -> PList ps a b -> PList ps c d Source Github # lmap :: forall (c :: LIST k) (a :: LIST k) (b :: LIST j). (c ~> a) -> PList ps a b -> PList ps c b Source Github # rmap :: forall (b :: LIST j) (d :: LIST j) (a :: LIST k). (b ~> d) -> PList ps a b -> PList ps a d Source Github # (\\) :: forall (a :: LIST k) (b :: LIST j) r. ((Ob a, Ob b) => r) -> PList ps a b -> r Source Github # | |
| Profunctor p => Profunctor (List p :: LIST k -> LIST j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.List Methods dimap :: forall (c :: LIST k) (a :: LIST k) (b :: LIST j) (d :: LIST j). (c ~> a) -> (b ~> d) -> List p a b -> List p c d Source Github # lmap :: forall (c :: LIST k) (a :: LIST k) (b :: LIST j). (c ~> a) -> List p a b -> List p c b Source Github # rmap :: forall (b :: LIST j) (d :: LIST j) (a :: LIST k). (b ~> d) -> List p a b -> List p a d Source Github # (\\) :: forall (a :: LIST k) (b :: LIST j) r. ((Ob a, Ob b) => r) -> List p a b -> r Source Github # | |
| CategoryOf k => Profunctor (Hom :: () -> (OPPOSITE k, k) -> Type) Source Github # | |
Defined in Proarrow.Category.Limit Methods dimap :: forall (c :: ()) (a :: ()) (b :: (OPPOSITE k, k)) (d :: (OPPOSITE k, k)). (c ~> a) -> (b ~> d) -> Hom a b -> Hom c d Source Github # lmap :: forall (c :: ()) (a :: ()) (b :: (OPPOSITE k, k)). (c ~> a) -> Hom a b -> Hom c b Source Github # rmap :: forall (b :: (OPPOSITE k, k)) (d :: (OPPOSITE k, k)) (a :: ()). (b ~> d) -> Hom a b -> Hom a d Source Github # (\\) :: forall (a :: ()) (b :: (OPPOSITE k, k)) r. ((Ob a, Ob b) => r) -> Hom a b -> r Source Github # | |
| Promonad p => Profunctor (KleisliForget p :: k -> KLEISLI p -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Kleisli Methods dimap :: forall (c :: k) (a :: k) (b :: KLEISLI p) (d :: KLEISLI p). (c ~> a) -> (b ~> d) -> KleisliForget p a b -> KleisliForget p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: KLEISLI p). (c ~> a) -> KleisliForget p a b -> KleisliForget p c b Source Github # rmap :: forall (b :: KLEISLI p) (d :: KLEISLI p) (a :: k). (b ~> d) -> KleisliForget p a b -> KleisliForget p a d Source Github # (\\) :: forall (a :: k) (b :: KLEISLI p) r. ((Ob a, Ob b) => r) -> KleisliForget p a b -> r Source Github # | |
| (Profunctor z, Profunctor s) => Profunctor (NNOUniv z s :: k -> (a, DISCRETE Nat) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Cat Methods dimap :: forall (c :: k) (a0 :: k) (b :: (a, DISCRETE Nat)) (d :: (a, DISCRETE Nat)). (c ~> a0) -> (b ~> d) -> NNOUniv z s a0 b -> NNOUniv z s c d Source Github # lmap :: forall (c :: k) (a0 :: k) (b :: (a, DISCRETE Nat)). (c ~> a0) -> NNOUniv z s a0 b -> NNOUniv z s c b Source Github # rmap :: forall (b :: (a, DISCRETE Nat)) (d :: (a, DISCRETE Nat)) (a0 :: k). (b ~> d) -> NNOUniv z s a0 b -> NNOUniv z s a0 d Source Github # (\\) :: forall (a0 :: k) (b :: (a, DISCRETE Nat)) r. ((Ob a0, Ob b) => r) -> NNOUniv z s a0 b -> r Source Github # | |
| (Profunctor p, CategoryOf j, CategoryOf k) => Profunctor (Uncurry p :: k -> (i, j) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Cat Methods dimap :: forall (c :: k) (a :: k) (b :: (i, j)) (d :: (i, j)). (c ~> a) -> (b ~> d) -> Uncurry p a b -> Uncurry p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: (i, j)). (c ~> a) -> Uncurry p a b -> Uncurry p c b Source Github # rmap :: forall (b :: (i, j)) (d :: (i, j)) (a :: k). (b ~> d) -> Uncurry p a b -> Uncurry p a d Source Github # (\\) :: forall (a :: k) (b :: (i, j)) r. ((Ob a, Ob b) => r) -> Uncurry p a b -> r Source Github # | |
| (Profunctor p, Profunctor q) => Profunctor (p :|||: q :: k -> COPRODUCT i j -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Fam Methods dimap :: forall (c :: k) (a :: k) (b :: COPRODUCT i j) (d :: COPRODUCT i j). (c ~> a) -> (b ~> d) -> (p :|||: q) a b -> (p :|||: q) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: COPRODUCT i j). (c ~> a) -> (p :|||: q) a b -> (p :|||: q) c b Source Github # rmap :: forall (b :: COPRODUCT i j) (d :: COPRODUCT i j) (a :: k). (b ~> d) -> (p :|||: q) a b -> (p :|||: q) a d Source Github # (\\) :: forall (a :: k) (b :: COPRODUCT i j) r. ((Ob a, Ob b) => r) -> (p :|||: q) a b -> r Source Github # | |
| (Profunctor l, Profunctor r, CategoryOf k) => Profunctor (l :&&: r :: k -> (x, y) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Fam Methods dimap :: forall (c :: k) (a :: k) (b :: (x, y)) (d :: (x, y)). (c ~> a) -> (b ~> d) -> (l :&&: r) a b -> (l :&&: r) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: (x, y)). (c ~> a) -> (l :&&: r) a b -> (l :&&: r) c b Source Github # rmap :: forall (b :: (x, y)) (d :: (x, y)) (a :: k). (b ~> d) -> (l :&&: r) a b -> (l :&&: r) a d Source Github # (\\) :: forall (a :: k) (b :: (x, y)) r0. ((Ob a, Ob b) => r0) -> (l :&&: r) a b -> r0 Source Github # | |
| Profunctor (Adj :: ADJK a b -> ADJK a b -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.Adj Methods dimap :: forall (c :: ADJK a b) (a0 :: ADJK a b) (b0 :: ADJK a b) (d :: ADJK a b). (c ~> a0) -> (b0 ~> d) -> Adj a0 b0 -> Adj c d Source Github # lmap :: forall (c :: ADJK a b) (a0 :: ADJK a b) (b0 :: ADJK a b). (c ~> a0) -> Adj a0 b0 -> Adj c b0 Source Github # rmap :: forall (b0 :: ADJK a b) (d :: ADJK a b) (a0 :: ADJK a b). (b0 ~> d) -> Adj a0 b0 -> Adj a0 d Source Github # (\\) :: forall (a0 :: ADJK a b) (b0 :: ADJK a b) r. ((Ob a0, Ob b0) => r) -> Adj a0 b0 -> r Source Github # | |
| Profunctor (Prof :: PROFK j k -> PROFK j k -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.Prof Methods dimap :: forall (c :: PROFK j k) (a :: PROFK j k) (b :: PROFK j k) (d :: PROFK j k). (c ~> a) -> (b ~> d) -> Prof a b -> Prof c d Source Github # lmap :: forall (c :: PROFK j k) (a :: PROFK j k) (b :: PROFK j k). (c ~> a) -> Prof a b -> Prof c b Source Github # rmap :: forall (b :: PROFK j k) (d :: PROFK j k) (a :: PROFK j k). (b ~> d) -> Prof a b -> Prof a d Source Github # (\\) :: forall (a :: PROFK j k) (b :: PROFK j k) r. ((Ob a, Ob b) => r) -> Prof a b -> r Source Github # | |
| Promonad p => Profunctor (Kleisli :: KLEISLI p -> KLEISLI p -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Kleisli Methods dimap :: forall (c :: KLEISLI p) (a :: KLEISLI p) (b :: KLEISLI p) (d :: KLEISLI p). (c ~> a) -> (b ~> d) -> Kleisli a b -> Kleisli c d Source Github # lmap :: forall (c :: KLEISLI p) (a :: KLEISLI p) (b :: KLEISLI p). (c ~> a) -> Kleisli a b -> Kleisli c b Source Github # rmap :: forall (b :: KLEISLI p) (d :: KLEISLI p) (a :: KLEISLI p). (b ~> d) -> Kleisli a b -> Kleisli a d Source Github # (\\) :: forall (a :: KLEISLI p) (b :: KLEISLI p) r. ((Ob a, Ob b) => r) -> Kleisli a b -> r Source Github # | |
| Profunctor (Nat' :: (j .-> k) -> (j .-> k) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods dimap :: forall (c :: j .-> k) (a :: j .-> k) (b :: j .-> k) (d :: j .-> k). (c ~> a) -> (b ~> d) -> Nat' a b -> Nat' c d Source Github # lmap :: forall (c :: j .-> k) (a :: j .-> k) (b :: j .-> k). (c ~> a) -> Nat' a b -> Nat' c b Source Github # rmap :: forall (b :: j .-> k) (d :: j .-> k) (a :: j .-> k). (b ~> d) -> Nat' a b -> Nat' a d Source Github # (\\) :: forall (a :: j .-> k) (b :: j .-> k) r. ((Ob a, Ob b) => r) -> Nat' a b -> r Source Github # | |
| Profunctor (Terminal :: Unit '() '() -> Unit '() '() -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.Terminal Methods dimap :: forall (c :: Unit '() '()) (a :: Unit '() '()) (b :: Unit '() '()) (d :: Unit '() '()). (c ~> a) -> (b ~> d) -> Terminal a b -> Terminal c d Source Github # lmap :: forall (c :: Unit '() '()) (a :: Unit '() '()) (b :: Unit '() '()). (c ~> a) -> Terminal a b -> Terminal c b Source Github # rmap :: forall (b :: Unit '() '()) (d :: Unit '() '()) (a :: Unit '() '()). (b ~> d) -> Terminal a b -> Terminal a d Source Github # (\\) :: forall (a :: Unit '() '()) (b :: Unit '() '()) r. ((Ob a, Ob b) => r) -> Terminal a b -> r Source Github # | |
| Profunctor (Prof :: (j +-> k) -> (j +-> k) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Prof Methods dimap :: forall (c :: j +-> k) (a :: j +-> k) (b :: j +-> k) (d :: j +-> k). (c ~> a) -> (b ~> d) -> Prof a b -> Prof c d Source Github # lmap :: forall (c :: j +-> k) (a :: j +-> k) (b :: j +-> k). (c ~> a) -> Prof a b -> Prof c b Source Github # rmap :: forall (b :: j +-> k) (d :: j +-> k) (a :: j +-> k). (b ~> d) -> Prof a b -> Prof a d Source Github # (\\) :: forall (a :: j +-> k) (b :: j +-> k) r. ((Ob a, Ob b) => r) -> Prof a b -> r Source Github # | |
| Profunctor (Nat :: (k1 -> k2 -> k3 -> k4 -> Type) -> (k1 -> k2 -> k3 -> k4 -> Type) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods dimap :: forall (c :: k1 -> k2 -> k3 -> k4 -> Type) (a :: k1 -> k2 -> k3 -> k4 -> Type) (b :: k1 -> k2 -> k3 -> k4 -> Type) (d :: k1 -> k2 -> k3 -> k4 -> Type). (c ~> a) -> (b ~> d) -> Nat a b -> Nat c d Source Github # lmap :: forall (c :: k1 -> k2 -> k3 -> k4 -> Type) (a :: k1 -> k2 -> k3 -> k4 -> Type) (b :: k1 -> k2 -> k3 -> k4 -> Type). (c ~> a) -> Nat a b -> Nat c b Source Github # rmap :: forall (b :: k1 -> k2 -> k3 -> k4 -> Type) (d :: k1 -> k2 -> k3 -> k4 -> Type) (a :: k1 -> k2 -> k3 -> k4 -> Type). (b ~> d) -> Nat a b -> Nat a d Source Github # (\\) :: forall (a :: k1 -> k2 -> k3 -> k4 -> Type) (b :: k1 -> k2 -> k3 -> k4 -> Type) r. ((Ob a, Ob b) => r) -> Nat a b -> r Source Github # | |
| Profunctor (Nat :: (k1 -> k2 -> k3 -> Type) -> (k1 -> k2 -> k3 -> Type) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods dimap :: forall (c :: k1 -> k2 -> k3 -> Type) (a :: k1 -> k2 -> k3 -> Type) (b :: k1 -> k2 -> k3 -> Type) (d :: k1 -> k2 -> k3 -> Type). (c ~> a) -> (b ~> d) -> Nat a b -> Nat c d Source Github # lmap :: forall (c :: k1 -> k2 -> k3 -> Type) (a :: k1 -> k2 -> k3 -> Type) (b :: k1 -> k2 -> k3 -> Type). (c ~> a) -> Nat a b -> Nat c b Source Github # rmap :: forall (b :: k1 -> k2 -> k3 -> Type) (d :: k1 -> k2 -> k3 -> Type) (a :: k1 -> k2 -> k3 -> Type). (b ~> d) -> Nat a b -> Nat a d Source Github # (\\) :: forall (a :: k1 -> k2 -> k3 -> Type) (b :: k1 -> k2 -> k3 -> Type) r. ((Ob a, Ob b) => r) -> Nat a b -> r Source Github # | |
| Profunctor (Nat :: (k1 -> Type) -> (k1 -> Type) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods dimap :: forall (c :: k1 -> Type) (a :: k1 -> Type) (b :: k1 -> Type) (d :: k1 -> Type). (c ~> a) -> (b ~> d) -> Nat a b -> Nat c d Source Github # lmap :: forall (c :: k1 -> Type) (a :: k1 -> Type) (b :: k1 -> Type). (c ~> a) -> Nat a b -> Nat c b Source Github # rmap :: forall (b :: k1 -> Type) (d :: k1 -> Type) (a :: k1 -> Type). (b ~> d) -> Nat a b -> Nat a d Source Github # (\\) :: forall (a :: k1 -> Type) (b :: k1 -> Type) r. ((Ob a, Ob b) => r) -> Nat a b -> r Source Github # | |
| Profunctor p => Profunctor (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Sub Methods dimap :: forall (c :: SUBCAT ob) (a :: SUBCAT ob) (b :: SUBCAT ob) (d :: SUBCAT ob). (c ~> a) -> (b ~> d) -> Sub p a b -> Sub p c d Source Github # lmap :: forall (c :: SUBCAT ob) (a :: SUBCAT ob) (b :: SUBCAT ob). (c ~> a) -> Sub p a b -> Sub p c b Source Github # rmap :: forall (b :: SUBCAT ob) (d :: SUBCAT ob) (a :: SUBCAT ob). (b ~> d) -> Sub p a b -> Sub p a d Source Github # (\\) :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) r. ((Ob a, Ob b) => r) -> Sub p a b -> r Source Github # | |
| (Applicative f, Profunctor p) => Profunctor (Ap p :: AP f k -> AP f j -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Ap Methods dimap :: forall (c :: AP f k) (a :: AP f k) (b :: AP f j) (d :: AP f j). (c ~> a) -> (b ~> d) -> Ap p a b -> Ap p c d Source Github # lmap :: forall (c :: AP f k) (a :: AP f k) (b :: AP f j). (c ~> a) -> Ap p a b -> Ap p c b Source Github # rmap :: forall (b :: AP f j) (d :: AP f j) (a :: AP f k). (b ~> d) -> Ap p a b -> Ap p a d Source Github # (\\) :: forall (a :: AP f k) (b :: AP f j) r. ((Ob a, Ob b) => r) -> Ap p a b -> r Source Github # | |
| Profunctor j => Profunctor (LimitAdj j :: COREPK b k -> REPK a k -> Type) Source Github # | |
Defined in Proarrow.Adjunction Methods dimap :: forall (c :: COREPK b k) (a0 :: COREPK b k) (b0 :: REPK a k) (d :: REPK a k). (c ~> a0) -> (b0 ~> d) -> LimitAdj j a0 b0 -> LimitAdj j c d Source Github # lmap :: forall (c :: COREPK b k) (a0 :: COREPK b k) (b0 :: REPK a k). (c ~> a0) -> LimitAdj j a0 b0 -> LimitAdj j c b0 Source Github # rmap :: forall (b0 :: REPK a k) (d :: REPK a k) (a0 :: COREPK b k). (b0 ~> d) -> LimitAdj j a0 b0 -> LimitAdj j a0 d Source Github # (\\) :: forall (a0 :: COREPK b k) (b0 :: REPK a k) r. ((Ob a0, Ob b0) => r) -> LimitAdj j a0 b0 -> r Source Github # | |
| Monoid m => Profunctor (Mon :: MONOIDK m -> MONOIDK m -> Type) Source Github # | |
Defined in Proarrow.Monoid Methods dimap :: forall (c :: MONOIDK m) (a :: MONOIDK m) (b :: MONOIDK m) (d :: MONOIDK m). (c ~> a) -> (b ~> d) -> Mon a b -> Mon c d Source Github # lmap :: forall (c :: MONOIDK m) (a :: MONOIDK m) (b :: MONOIDK m). (c ~> a) -> Mon a b -> Mon c b Source Github # rmap :: forall (b :: MONOIDK m) (d :: MONOIDK m) (a :: MONOIDK m). (b ~> d) -> Mon a b -> Mon a d Source Github # (\\) :: forall (a :: MONOIDK m) (b :: MONOIDK m) r. ((Ob a, Ob b) => r) -> Mon a b -> r Source Github # | |
| (Profunctor p, Profunctor q) => Profunctor (p :++: q :: COPRODUCT k1 k2 -> COPRODUCT j1 j2 -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Coproduct Methods dimap :: forall (c :: COPRODUCT k1 k2) (a :: COPRODUCT k1 k2) (b :: COPRODUCT j1 j2) (d :: COPRODUCT j1 j2). (c ~> a) -> (b ~> d) -> (p :++: q) a b -> (p :++: q) c d Source Github # lmap :: forall (c :: COPRODUCT k1 k2) (a :: COPRODUCT k1 k2) (b :: COPRODUCT j1 j2). (c ~> a) -> (p :++: q) a b -> (p :++: q) c b Source Github # rmap :: forall (b :: COPRODUCT j1 j2) (d :: COPRODUCT j1 j2) (a :: COPRODUCT k1 k2). (b ~> d) -> (p :++: q) a b -> (p :++: q) a d Source Github # (\\) :: forall (a :: COPRODUCT k1 k2) (b :: COPRODUCT j1 j2) r. ((Ob a, Ob b) => r) -> (p :++: q) a b -> r Source Github # | |
| (Profunctor p, Profunctor q) => Profunctor (p :**: q :: (k1, k2) -> (j1, j2) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Product Methods dimap :: forall (c :: (k1, k2)) (a :: (k1, k2)) (b :: (j1, j2)) (d :: (j1, j2)). (c ~> a) -> (b ~> d) -> (p :**: q) a b -> (p :**: q) c d Source Github # lmap :: forall (c :: (k1, k2)) (a :: (k1, k2)) (b :: (j1, j2)). (c ~> a) -> (p :**: q) a b -> (p :**: q) c b Source Github # rmap :: forall (b :: (j1, j2)) (d :: (j1, j2)) (a :: (k1, k2)). (b ~> d) -> (p :**: q) a b -> (p :**: q) a d Source Github # (\\) :: forall (a :: (k1, k2)) (b :: (j1, j2)) r. ((Ob a, Ob b) => r) -> (p :**: q) a b -> r Source Github # | |
| (Bicategory kk, Ob0 kk h, Ob0 kk i, Ob0 kk j, Ob0 kk k) => Profunctor (Sq' :: (kk j h, SUBCAT Tight kk h i) -> (kk k i, SUBCAT Tight kk j k) -> Type) Source Github # | |
Defined in Proarrow.Squares Methods dimap :: forall (c0 :: (kk j h, SUBCAT Tight kk h i)) (a :: (kk j h, SUBCAT Tight kk h i)) (b :: (kk k i, SUBCAT Tight kk j k)) (d :: (kk k i, SUBCAT Tight kk j k)). (c0 ~> a) -> (b ~> d) -> Sq' a b -> Sq' c0 d Source Github # lmap :: forall (c0 :: (kk j h, SUBCAT Tight kk h i)) (a :: (kk j h, SUBCAT Tight kk h i)) (b :: (kk k i, SUBCAT Tight kk j k)). (c0 ~> a) -> Sq' a b -> Sq' c0 b Source Github # rmap :: forall (b :: (kk k i, SUBCAT Tight kk j k)) (d :: (kk k i, SUBCAT Tight kk j k)) (a :: (kk j h, SUBCAT Tight kk h i)). (b ~> d) -> Sq' a b -> Sq' a d Source Github # (\\) :: forall (a :: (kk j h, SUBCAT Tight kk h i)) (b :: (kk k i, SUBCAT Tight kk j k)) r. ((Ob a, Ob b) => r) -> Sq' a b -> r Source Github # | |
| (CategoryOf k, Ob i, Ob j) => Profunctor (Category :: PLAINK k i j -> PLAINK k i j -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.CategoryAsBi Methods dimap :: forall (c :: PLAINK k i j) (a :: PLAINK k i j) (b :: PLAINK k i j) (d :: PLAINK k i j). (c ~> a) -> (b ~> d) -> Category a b -> Category c d Source Github # lmap :: forall (c :: PLAINK k i j) (a :: PLAINK k i j) (b :: PLAINK k i j). (c ~> a) -> Category a b -> Category c b Source Github # rmap :: forall (b :: PLAINK k i j) (d :: PLAINK k i j) (a :: PLAINK k i j). (b ~> d) -> Category a b -> Category a d Source Github # (\\) :: forall (a :: PLAINK k i j) (b :: PLAINK k i j) r. ((Ob a, Ob b) => r) -> Category a b -> r Source Github # | |
| CategoryOf k => Profunctor (Mon2 :: MonK k i j -> MonK k i j -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.MonoidalAsBi Methods dimap :: forall (c :: MonK k i j) (a :: MonK k i j) (b :: MonK k i j) (d :: MonK k i j). (c ~> a) -> (b ~> d) -> Mon2 a b -> Mon2 c d Source Github # lmap :: forall (c :: MonK k i j) (a :: MonK k i j) (b :: MonK k i j). (c ~> a) -> Mon2 a b -> Mon2 c b Source Github # rmap :: forall (b :: MonK k i j) (d :: MonK k i j) (a :: MonK k i j). (b ~> d) -> Mon2 a b -> Mon2 a d Source Github # (\\) :: forall (a :: MonK k i j) (b :: MonK k i j) r. ((Ob a, Ob b) => r) -> Mon2 a b -> r Source Github # | |
| SelfAction k => Profunctor (StT :: STT' k i j -> STT' k i j -> Type) Source Github # | |
Defined in Proarrow.Category.Equipment.Stateful Methods dimap :: forall (c :: STT' k i j) (a :: STT' k i j) (b :: STT' k i j) (d :: STT' k i j). (c ~> a) -> (b ~> d) -> StT a b -> StT c d Source Github # lmap :: forall (c :: STT' k i j) (a :: STT' k i j) (b :: STT' k i j). (c ~> a) -> StT a b -> StT c b Source Github # rmap :: forall (b :: STT' k i j) (d :: STT' k i j) (a :: STT' k i j). (b ~> d) -> StT a b -> StT a d Source Github # (\\) :: forall (a :: STT' k i j) (b :: STT' k i j) r. ((Ob a, Ob b) => r) -> StT a b -> r Source Github # | |
| Profunctor p => Profunctor (Collage :: COLLAGE p -> COLLAGE p -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Collage Methods dimap :: forall (c :: COLLAGE p) (a :: COLLAGE p) (b :: COLLAGE p) (d :: COLLAGE p). (c ~> a) -> (b ~> d) -> Collage a b -> Collage c d Source Github # lmap :: forall (c :: COLLAGE p) (a :: COLLAGE p) (b :: COLLAGE p). (c ~> a) -> Collage a b -> Collage c b Source Github # rmap :: forall (b :: COLLAGE p) (d :: COLLAGE p) (a :: COLLAGE p). (b ~> d) -> Collage a b -> Collage a d Source Github # (\\) :: forall (a :: COLLAGE p) (b :: COLLAGE p) r. ((Ob a, Ob b) => r) -> Collage a b -> r Source Github # | |
| Adjunction adj => Profunctor (Duploid :: DUPLOID adj -> DUPLOID adj -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Duploid Methods dimap :: forall (c :: DUPLOID adj) (a :: DUPLOID adj) (b :: DUPLOID adj) (d :: DUPLOID adj). (c ~> a) -> (b ~> d) -> Duploid a b -> Duploid c d Source Github # lmap :: forall (c :: DUPLOID adj) (a :: DUPLOID adj) (b :: DUPLOID adj). (c ~> a) -> Duploid a b -> Duploid c b Source Github # rmap :: forall (b :: DUPLOID adj) (d :: DUPLOID adj) (a :: DUPLOID adj). (b ~> d) -> Duploid a b -> Duploid a d Source Github # (\\) :: forall (a :: DUPLOID adj) (b :: DUPLOID adj) r. ((Ob a, Ob b) => r) -> Duploid a b -> r Source Github # | |
| Ok cs p => Profunctor (Free :: FREE cs p -> FREE cs p -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Free Methods dimap :: forall (c :: FREE cs p) (a :: FREE cs p) (b :: FREE cs p) (d :: FREE cs p). (c ~> a) -> (b ~> d) -> Free a b -> Free c d Source Github # lmap :: forall (c :: FREE cs p) (a :: FREE cs p) (b :: FREE cs p). (c ~> a) -> Free a b -> Free c b Source Github # rmap :: forall (b :: FREE cs p) (d :: FREE cs p) (a :: FREE cs p). (b ~> d) -> Free a b -> Free a d Source Github # (\\) :: forall (a :: FREE cs p) (b :: FREE cs p) r. ((Ob a, Ob b) => r) -> Free a b -> r Source Github # | |
| ThinProfunctor p => Profunctor (Graph :: GRAPH p -> GRAPH p -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Graph Methods dimap :: forall (c :: GRAPH p) (a :: GRAPH p) (b :: GRAPH p) (d :: GRAPH p). (c ~> a) -> (b ~> d) -> Graph a b -> Graph c d Source Github # lmap :: forall (c :: GRAPH p) (a :: GRAPH p) (b :: GRAPH p). (c ~> a) -> Graph a b -> Graph c b Source Github # rmap :: forall (b :: GRAPH p) (d :: GRAPH p) (a :: GRAPH p). (b ~> d) -> Graph a b -> Graph a d Source Github # (\\) :: forall (a :: GRAPH p) (b :: GRAPH p) r. ((Ob a, Ob b) => r) -> Graph a b -> r Source Github # | |
| (Bicategory kk, Ob0 kk k) => Profunctor (Endo :: ENDO kk k -> ENDO kk k -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Endo Methods dimap :: forall (c :: ENDO kk k) (a :: ENDO kk k) (b :: ENDO kk k) (d :: ENDO kk k). (c ~> a) -> (b ~> d) -> Endo a b -> Endo c d Source Github # lmap :: forall (c :: ENDO kk k) (a :: ENDO kk k) (b :: ENDO kk k). (c ~> a) -> Endo a b -> Endo c b Source Github # rmap :: forall (b :: ENDO kk k) (d :: ENDO kk k) (a :: ENDO kk k). (b ~> d) -> Endo a b -> Endo a d Source Github # (\\) :: forall (a :: ENDO kk k) (b :: ENDO kk k) r. ((Ob a, Ob b) => r) -> Endo a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (Optic_ :: OPTIC j k c -> OPTIC j k c -> Type) Source Github # | |
Defined in Proarrow.Optic Methods dimap :: forall (c0 :: OPTIC j k c) (a :: OPTIC j k c) (b :: OPTIC j k c) (d :: OPTIC j k c). (c0 ~> a) -> (b ~> d) -> Optic_ a b -> Optic_ c0 d Source Github # lmap :: forall (c0 :: OPTIC j k c) (a :: OPTIC j k c) (b :: OPTIC j k c). (c0 ~> a) -> Optic_ a b -> Optic_ c0 b Source Github # rmap :: forall (b :: OPTIC j k c) (d :: OPTIC j k c) (a :: OPTIC j k c). (b ~> d) -> Optic_ a b -> Optic_ a d Source Github # (\\) :: forall (a :: OPTIC j k c) (b :: OPTIC j k c) r. ((Ob a, Ob b) => r) -> Optic_ a b -> r Source Github # | |
| Profunctor (Bidiscrete :: DiscreteK ob j k -> DiscreteK ob j k -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.Bidiscrete Methods dimap :: forall (c0 :: DiscreteK ob j k) (a :: DiscreteK ob j k) (b :: DiscreteK ob j k) (d :: DiscreteK ob j k). (c0 ~> a) -> (b ~> d) -> Bidiscrete a b -> Bidiscrete c0 d Source Github # lmap :: forall (c0 :: DiscreteK ob j k) (a :: DiscreteK ob j k) (b :: DiscreteK ob j k). (c0 ~> a) -> Bidiscrete a b -> Bidiscrete c0 b Source Github # rmap :: forall (b :: DiscreteK ob j k) (d :: DiscreteK ob j k) (a :: DiscreteK ob j k). (b ~> d) -> Bidiscrete a b -> Bidiscrete a d Source Github # (\\) :: forall (a :: DiscreteK ob j k) (b :: DiscreteK ob j k) r. ((Ob a, Ob b) => r) -> Bidiscrete a b -> r Source Github # | |
| CategoryOf (kk j k2) => Profunctor (Co :: COK kk j k2 -> COK kk j k2 -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.Co Methods dimap :: forall (c :: COK kk j k2) (a :: COK kk j k2) (b :: COK kk j k2) (d :: COK kk j k2). (c ~> a) -> (b ~> d) -> Co a b -> Co c d Source Github # lmap :: forall (c :: COK kk j k2) (a :: COK kk j k2) (b :: COK kk j k2). (c ~> a) -> Co a b -> Co c b Source Github # rmap :: forall (b :: COK kk j k2) (d :: COK kk j k2) (a :: COK kk j k2). (b ~> d) -> Co a b -> Co a d Source Github # (\\) :: forall (a :: COK kk j k2) (b :: COK kk j k2) r. ((Ob a, Ob b) => r) -> Co a b -> r Source Github # | |
| CategoryOf (kk k2 j) => Profunctor (Op :: OPK kk j k2 -> OPK kk j k2 -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.Op Methods dimap :: forall (c :: OPK kk j k2) (a :: OPK kk j k2) (b :: OPK kk j k2) (d :: OPK kk j k2). (c ~> a) -> (b ~> d) -> Op a b -> Op c d Source Github # lmap :: forall (c :: OPK kk j k2) (a :: OPK kk j k2) (b :: OPK kk j k2). (c ~> a) -> Op a b -> Op c b Source Github # rmap :: forall (b :: OPK kk j k2) (d :: OPK kk j k2) (a :: OPK kk j k2). (b ~> d) -> Op a b -> Op a d Source Github # (\\) :: forall (a :: OPK kk j k2) (b :: OPK kk j k2) r. ((Ob a, Ob b) => r) -> Op a b -> r Source Github # | |
| (CategoryOf (kk j k2), Bicategory kk) => Profunctor (Strictified :: Path kk j k2 -> Path kk j k2 -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.Strictified Methods dimap :: forall (c :: Path kk j k2) (a :: Path kk j k2) (b :: Path kk j k2) (d :: Path kk j k2). (c ~> a) -> (b ~> d) -> Strictified a b -> Strictified c d Source Github # lmap :: forall (c :: Path kk j k2) (a :: Path kk j k2) (b :: Path kk j k2). (c ~> a) -> Strictified a b -> Strictified c b Source Github # rmap :: forall (b :: Path kk j k2) (d :: Path kk j k2) (a :: Path kk j k2). (b ~> d) -> Strictified a b -> Strictified a d Source Github # (\\) :: forall (a :: Path kk j k2) (b :: Path kk j k2) r. ((Ob a, Ob b) => r) -> Strictified a b -> r Source Github # | |
| Profunctor ((~>) :: CAT (kk i j)) => Profunctor (HomW :: HK kk i j -> HK kk i j -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.Hom Methods dimap :: forall (c :: HK kk i j) (a :: HK kk i j) (b :: HK kk i j) (d :: HK kk i j). (c ~> a) -> (b ~> d) -> HomW a b -> HomW c d Source Github # lmap :: forall (c :: HK kk i j) (a :: HK kk i j) (b :: HK kk i j). (c ~> a) -> HomW a b -> HomW c b Source Github # rmap :: forall (b :: HK kk i j) (d :: HK kk i j) (a :: HK kk i j). (b ~> d) -> HomW a b -> HomW a d Source Github # (\\) :: forall (a :: HK kk i j) (b :: HK kk i j) r. ((Ob a, Ob b) => r) -> HomW a b -> r Source Github # | |
| Profunctor ((~>) :: CAT (kk i j)) => Profunctor (Sub :: SUBCAT tag kk i j -> SUBCAT tag kk i j -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.Sub Methods dimap :: forall (c :: SUBCAT tag kk i j) (a :: SUBCAT tag kk i j) (b :: SUBCAT tag kk i j) (d :: SUBCAT tag kk i j). (c ~> a) -> (b ~> d) -> Sub a b -> Sub c d Source Github # lmap :: forall (c :: SUBCAT tag kk i j) (a :: SUBCAT tag kk i j) (b :: SUBCAT tag kk i j). (c ~> a) -> Sub a b -> Sub c b Source Github # rmap :: forall (b :: SUBCAT tag kk i j) (d :: SUBCAT tag kk i j) (a :: SUBCAT tag kk i j). (b ~> d) -> Sub a b -> Sub a d Source Github # (\\) :: forall (a :: SUBCAT tag kk i j) (b :: SUBCAT tag kk i j) r. ((Ob a, Ob b) => r) -> Sub a b -> r Source Github # | |
| (Bicategory kk, Ob s, Ob t, Ob0 kk h, Ob0 kk i, Ob0 kk j, Ob0 kk k2) => Profunctor (P kk kk (HK kk) s t :: HK kk h j +-> HK kk i k2) Source Github # | |
Defined in Proarrow.Category.Bicategory.Hom Methods dimap :: forall (c :: HK kk i k2) (a :: HK kk i k2) (b :: HK kk h j) (d :: HK kk h j). (c ~> a) -> (b ~> d) -> P kk kk (HK kk) s t a b -> P kk kk (HK kk) s t c d Source Github # lmap :: forall (c :: HK kk i k2) (a :: HK kk i k2) (b :: HK kk h j). (c ~> a) -> P kk kk (HK kk) s t a b -> P kk kk (HK kk) s t c b Source Github # rmap :: forall (b :: HK kk h j) (d :: HK kk h j) (a :: HK kk i k2). (b ~> d) -> P kk kk (HK kk) s t a b -> P kk kk (HK kk) s t a d Source Github # (\\) :: forall (a :: HK kk i k2) (b :: HK kk h j) r. ((Ob a, Ob b) => r) -> P kk kk (HK kk) s t a b -> r Source Github # | |
| (CategoryOf (jj (Fst ik) (Fst jl)), CategoryOf (kk (Snd ik) (Snd jl))) => Profunctor (Prod :: PRODK jj kk ik jl -> PRODK jj kk ik jl -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.Product Methods dimap :: forall (c :: PRODK jj kk ik jl) (a :: PRODK jj kk ik jl) (b :: PRODK jj kk ik jl) (d :: PRODK jj kk ik jl). (c ~> a) -> (b ~> d) -> Prod a b -> Prod c d Source Github # lmap :: forall (c :: PRODK jj kk ik jl) (a :: PRODK jj kk ik jl) (b :: PRODK jj kk ik jl). (c ~> a) -> Prod a b -> Prod c b Source Github # rmap :: forall (b :: PRODK jj kk ik jl) (d :: PRODK jj kk ik jl) (a :: PRODK jj kk ik jl). (b ~> d) -> Prod a b -> Prod a d Source Github # (\\) :: forall (a :: PRODK jj kk ik jl) (b :: PRODK jj kk ik jl) r. ((Ob a, Ob b) => r) -> Prod a b -> r Source Github # | |
Natural Transformations
type (:~>) (p :: k -> k1 -> Type) (q :: k -> k1 -> Type) = forall (a :: k) (b :: k1). p a b -> q a b infixr 0 Source Github #
Natural transformation between profunctors.
Profunctor Utilities
(//) :: forall {k1} {k2} p (a :: k2) (b :: k1) r. Profunctor p => p a b -> ((Ob a, Ob b) => r) -> r infixr 0 Source Github #
Flipped version of (\\).
Default Implementation
dimapDefault :: forall {k} p (c :: k) (a :: k) (b :: k) (d :: k). Promonad p => p c a -> p b d -> p a b -> p c d Source Github #
Default implementation of dimap for promonads using composition.
Promonads
Promonad Class
class Profunctor p => Promonad (p :: k +-> k) where Source Github #
A promonad is a category-like profunctor with identity morphisms and composition.
This is also known as a category structure, or an identity-on-objects functor.
Laws:
Methods
id :: forall (a :: k). Ob a => p a a Source Github #
Identity morphisms.
(.) :: forall (b :: k) (c :: k) (a :: k). p b c -> p a b -> p a c infixr 9 Source Github #
Composition (note the parameter order matches function composition).
Instances
| Promonad Simplex Source Github # | |
| Promonad ZX Source Github # | |
| Promonad Booleans Source Github # | |
| Promonad Cat Source Github # | |
| Promonad (:-) Source Github # | |
Defined in Proarrow.Category.Instance.Constraint Methods id :: forall (a :: CONSTRAINT). Ob a => a :- a Source Github # (.) :: forall (b :: CONSTRAINT) (c :: CONSTRAINT) (a :: CONSTRAINT). (b :- c) -> (a :- b) -> a :- c Source Github # | |
| Promonad GTE Source Github # | |
| Promonad FinRel Source Github # | |
| Promonad FinSet Source Github # | |
| Promonad Linear Source Github # | |
| Promonad Pointed Source Github # | |
| Promonad Zero Source Github # | |
| Promonad Dot Source Github # | |
| Promonad Unit Source Github # | |
| Promonad SymRefl Source Github # | |
| Monad m => Promonad (Kleisli m :: Type -> Type -> Type) Source Github # | |
| Comonoid w => Promonad (ComonoidAsCat w :: Type -> Type -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods id :: Ob a => ComonoidAsCat w a a Source Github # (.) :: ComonoidAsCat w b c -> ComonoidAsCat w a b -> ComonoidAsCat w a c Source Github # | |
| Arrow arr => Promonad (Arr arr :: Type -> Type -> Type) Source Github # | |
| CategoryOf k => Promonad (Id :: k -> k -> Type) Source Github # | |
| Promonad (->) Source Github # | |
| Promonad p => Promonad (Fix p :: k -> k -> Type) Source Github # | |
| Profunctor p => Promonad (FreePromonad p :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Free Methods id :: forall (a :: k). Ob a => FreePromonad p a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). FreePromonad p b c -> FreePromonad p a b -> FreePromonad p a c Source Github # | |
| CategoryOf k => Promonad (TerminalProfunctor :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Terminal Methods id :: forall (a :: k). Ob a => TerminalProfunctor a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). TerminalProfunctor b c -> TerminalProfunctor a b -> TerminalProfunctor a c Source Github # | |
| CategoryOf k => Promonad (Cont r :: k -> k -> Type) Source Github # | |
| (Comonoid r, Monoidal k) => Promonad (Reader ('OP r) :: k -> k -> Type) Source Github # | |
| (Monoid w, Monoidal k) => Promonad (Writer w :: k -> k -> Type) Source Github # | |
| Adjunction p => Promonad (Adj p :: Type -> Type -> Type) Source Github # | |
| Promonad (Costar ((,) Int)) Source Github # | |
| Monad m => Promonad (Star (Prelude m) :: Type -> Type -> Type) Source Github # | |
| Promonad p => Promonad (FromProfunctor p :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Functor Methods id :: forall (a :: k). Ob a => FromProfunctor p a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). FromProfunctor p b c -> FromProfunctor p a b -> FromProfunctor p a c Source Github # | |
| (Monoid c, CategoryOf k) => Promonad (HaskValue c :: k -> k -> Type) Source Github # | |
| Promonad p => Promonad (Wrapped p :: k -> k -> Type) Source Github # | |
| (Comonoid r, SelfAction k, Strong k p, Promonad p) => Promonad (ReaderT ('OP r) p :: k -> k -> Type) Source Github # | |
| (Ob s, SelfAction k, Strong k p, Promonad p) => Promonad (StateT s p :: k -> k -> Type) Source Github # | |
| (Monoid w, SelfAction k, Strong k p, Promonad p) => Promonad (WriterT w p :: k -> k -> Type) Source Github # | |
| Proadjunction p q => Promonad (q :.: p :: k -> k -> Type) Source Github # | |
| (p ~ j, Profunctor p) => Promonad (Ran ('OP j) p :: k -> k -> Type) Source Github # | |
| (p ~ j, Profunctor p) => Promonad (Rift ('OP j) p :: k -> k -> Type) Source Github # | |
| HasPushouts k => Promonad (Cospan :: COSPAN k -> COSPAN k -> Type) Source Github # | |
| Promonad (Codiscrete :: CODISCRETE k -> CODISCRETE k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Discrete Methods id :: forall (a :: CODISCRETE k). Ob a => Codiscrete a a Source Github # (.) :: forall (b :: CODISCRETE k) (c :: CODISCRETE k) (a :: CODISCRETE k). Codiscrete b c -> Codiscrete a b -> Codiscrete a c Source Github # | |
| Promonad (Discrete :: DISCRETE k -> DISCRETE k -> Type) Source Github # | |
| CategoryOf k => Promonad (Fam :: FAM k -> FAM k -> Type) Source Github # | |
| Promonad (LTE :: FIN n -> FIN n -> Type) Source Github # | |
| TracedMonoidal k => Promonad (IntConstruction :: INT k -> INT k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.IntConstruction Methods id :: forall (a :: INT k). Ob a => IntConstruction a a Source Github # (.) :: forall (b :: INT k) (c :: INT k) (a :: INT k). IntConstruction b c -> IntConstruction a b -> IntConstruction a c Source Github # | |
| Num a => Promonad (Mat :: MatK a -> MatK a -> Type) Source Github # | |
| HasPullbacks k => Promonad (Span :: SPAN k -> SPAN k -> Type) Source Github # | |
| Monoidal k => Promonad (Strictified :: [k] -> [k] -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Strictified Methods id :: forall (a :: [k]). Ob a => Strictified a a Source Github # (.) :: forall (b :: [k]) (c :: [k]) (a :: [k]). Strictified b c -> Strictified a b -> Strictified a c Source Github # | |
| Promonad p => Promonad (Rev p :: REV j -> REV j -> Type) Source Github # | |
| Promonad c => Promonad (Op c :: OPPOSITE j -> OPPOSITE j -> Type) Source Github # | |
| Promonad p => Promonad (Coprod p :: COPROD j -> COPROD j -> Type) Source Github # | |
| Promonad p => Promonad (Prod p :: PROD j -> PROD j -> Type) Source Github # | |
| Promonad p => Promonad (List p :: LIST j -> LIST j -> Type) Source Github # | |
| Promonad (Adj :: ADJK a b -> ADJK a b -> Type) Source Github # | |
| Promonad (Prof :: PROFK j k -> PROFK j k -> Type) Source Github # | |
| Promonad p => Promonad (Kleisli :: KLEISLI p -> KLEISLI p -> Type) Source Github # | |
| Promonad (Nat' :: (j .-> k) -> (j .-> k) -> Type) Source Github # | |
| Promonad (Terminal :: Unit '() '() -> Unit '() '() -> Type) Source Github # | |
| Promonad (Prof :: (j +-> k) -> (j +-> k) -> Type) Source Github # | |
| Promonad (Nat :: (j -> Type) -> (j -> Type) -> Type) Source Github # | |
| Promonad (Nat :: (k1 -> k2 -> k3 -> k4 -> Type) -> (k1 -> k2 -> k3 -> k4 -> Type) -> Type) Source Github # | |
| Promonad (Nat :: (k1 -> k2 -> k3 -> Type) -> (k1 -> k2 -> k3 -> Type) -> Type) Source Github # | |
| Promonad p => Promonad (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |
| Promonad (Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Coyoneda Methods id :: forall (a :: j +-> k). Ob a => Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) a a Source Github # (.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) b c -> Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) a b -> Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) a c Source Github # | |
| (MonoidalAction m j, MonoidalAction m k) => Promonad (Costar (Tambara m :: (j +-> k) -> k -> j -> Type) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.PastroTambara Methods id :: forall (a :: j +-> k). Ob a => Costar (Tambara m :: (j +-> k) -> k -> j -> Type) a a Source Github # (.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Costar (Tambara m :: (j +-> k) -> k -> j -> Type) b c -> Costar (Tambara m :: (j +-> k) -> k -> j -> Type) a b -> Costar (Tambara m :: (j +-> k) -> k -> j -> Type) a c Source Github # | |
| Profunctor p => Promonad (Costar ((:*:) p) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github # | |
| Promonad (Costar (Yoneda :: (j +-> k) -> k -> j -> Type) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Yoneda Methods id :: forall (a :: j +-> k). Ob a => Costar (Yoneda :: (j +-> k) -> k -> j -> Type) a a Source Github # (.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Costar (Yoneda :: (j +-> k) -> k -> j -> Type) b c -> Costar (Yoneda :: (j +-> k) -> k -> j -> Type) a b -> Costar (Yoneda :: (j +-> k) -> k -> j -> Type) a c Source Github # | |
| (MonoidalAction m j, MonoidalAction m k) => Promonad (Star (Pastro m :: (j +-> k) -> k -> j -> Type) :: (k -> j -> Type) -> (j +-> k) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.PastroTambara Methods id :: forall (a :: j +-> k). Ob a => Star (Pastro m :: (j +-> k) -> k -> j -> Type) a a Source Github # (.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Star (Pastro m :: (j +-> k) -> k -> j -> Type) b c -> Star (Pastro m :: (j +-> k) -> k -> j -> Type) a b -> Star (Pastro m :: (j +-> k) -> k -> j -> Type) a c Source Github # | |
| (Comonoid r, Monoidal k) => Promonad (Star (ReaderT ('OP r)) :: (k +-> k) -> (k +-> k) -> Type) Source Github # | ReaderT is a monad on profunctors, i.e. we have |
| (Monoid w, Monoidal k) => Promonad (Star (WriterT w) :: (k +-> k) -> (k +-> k) -> Type) Source Github # | WriterT is a monad on profunctors, i.e. we have |
| Procomonad j => Promonad (Star (Ran ('OP j) :: (i +-> k) -> k -> i -> Type) :: (k -> i -> Type) -> (i +-> k) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Ran Methods id :: forall (a :: k -> i -> Type). Ob a => Star (Ran ('OP j) :: (i +-> k) -> k -> i -> Type) a a Source Github # (.) :: forall (b :: k -> i -> Type) (c :: k -> i -> Type) (a :: k -> i -> Type). Star (Ran ('OP j) :: (i +-> k) -> k -> i -> Type) b c -> Star (Ran ('OP j) :: (i +-> k) -> k -> i -> Type) a b -> Star (Ran ('OP j) :: (i +-> k) -> k -> i -> Type) a c Source Github # | |
| Profunctor p => Promonad (Star ((:+:) p) :: (k -> j -> Type) -> (j +-> k) -> Type) Source Github # | |
| Promonad (Star (Coyoneda :: (j +-> k) -> k -> j -> Type) :: (k -> j -> Type) -> (j +-> k) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Coyoneda Methods id :: forall (a :: k -> j -> Type). Ob a => Star (Coyoneda :: (j +-> k) -> k -> j -> Type) a a Source Github # (.) :: forall (b :: k -> j -> Type) (c :: k -> j -> Type) (a :: k -> j -> Type). Star (Coyoneda :: (j +-> k) -> k -> j -> Type) b c -> Star (Coyoneda :: (j +-> k) -> k -> j -> Type) a b -> Star (Coyoneda :: (j +-> k) -> k -> j -> Type) a c Source Github # | |
| Promonad (Star (Yoneda :: (j +-> k) -> k -> j -> Type) :: (k -> j -> Type) -> (j +-> k) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Yoneda Methods id :: forall (a :: k -> j -> Type). Ob a => Star (Yoneda :: (j +-> k) -> k -> j -> Type) a a Source Github # (.) :: forall (b :: k -> j -> Type) (c :: k -> j -> Type) (a :: k -> j -> Type). Star (Yoneda :: (j +-> k) -> k -> j -> Type) b c -> Star (Yoneda :: (j +-> k) -> k -> j -> Type) a b -> Star (Yoneda :: (j +-> k) -> k -> j -> Type) a c Source Github # | |
| Procomonad j2 => Promonad (Star (Rift ('OP j2) :: (j1 +-> k) -> k -> j1 -> Type) :: (k -> j1 -> Type) -> (j1 +-> k) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Rift Methods id :: forall (a :: k -> j1 -> Type). Ob a => Star (Rift ('OP j2) :: (j1 +-> k) -> k -> j1 -> Type) a a Source Github # (.) :: forall (b :: k -> j1 -> Type) (c :: k -> j1 -> Type) (a :: k -> j1 -> Type). Star (Rift ('OP j2) :: (j1 +-> k) -> k -> j1 -> Type) b c -> Star (Rift ('OP j2) :: (j1 +-> k) -> k -> j1 -> Type) a b -> Star (Rift ('OP j2) :: (j1 +-> k) -> k -> j1 -> Type) a c Source Github # | |
| Promonad (Star (FreePromonad :: (k -> k -> Type) -> k -> k -> Type) :: (k -> k -> Type) -> (k -> k -> Type) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Free Methods id :: forall (a :: k -> k -> Type). Ob a => Star (FreePromonad :: (k -> k -> Type) -> k -> k -> Type) a a Source Github # (.) :: forall (b :: k -> k -> Type) (c :: k -> k -> Type) (a :: k -> k -> Type). Star (FreePromonad :: (k -> k -> Type) -> k -> k -> Type) b c -> Star (FreePromonad :: (k -> k -> Type) -> k -> k -> Type) a b -> Star (FreePromonad :: (k -> k -> Type) -> k -> k -> Type) a c Source Github # | |
| Monoidal k => Promonad (Star (Ap :: (k -> Type) -> k -> Type) :: (k -> Type) -> (k -> Type) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Free Methods id :: forall (a :: k -> Type). Ob a => Star (Ap :: (k -> Type) -> k -> Type) a a Source Github # (.) :: forall (b :: k -> Type) (c :: k -> Type) (a :: k -> Type). Star (Ap :: (k -> Type) -> k -> Type) b c -> Star (Ap :: (k -> Type) -> k -> Type) a b -> Star (Ap :: (k -> Type) -> k -> Type) a c Source Github # | |
| (Applicative f, Promonad p) => Promonad (Ap p :: AP f k -> AP f k -> Type) Source Github # | |
| Monoid m => Promonad (Mon :: MONOIDK m -> MONOIDK m -> Type) Source Github # | |
| (Promonad p, Promonad q) => Promonad (p :++: q :: COPRODUCT j1 j2 -> COPRODUCT j1 j2 -> Type) Source Github # | The coproduct of two promonads. |
| (Promonad p, Promonad q) => Promonad (p :**: q :: (j1, j2) -> (j1, j2) -> Type) Source Github # | The product promonad of promonads |
| (CategoryOf k, Ob i, Ob j) => Promonad (Category :: PLAINK k i j -> PLAINK k i j -> Type) Source Github # | |
| CategoryOf k => Promonad (Mon2 :: MonK k i j -> MonK k i j -> Type) Source Github # | |
| SelfAction k => Promonad (StT :: STT' k i j -> STT' k i j -> Type) Source Github # | |
| Profunctor p => Promonad (Collage :: COLLAGE p -> COLLAGE p -> Type) Source Github # | |
| Adjunction adj => Promonad (Duploid :: DUPLOID adj -> DUPLOID adj -> Type) Source Github # | ATTENTION: a duploid is not associative, so not really a promonad/category! |
| Ok cs p => Promonad (Free :: FREE cs p -> FREE cs p -> Type) Source Github # | |
| ThinProfunctor p => Promonad (Graph :: GRAPH p -> GRAPH p -> Type) Source Github # | |
| (Bicategory kk, Ob0 kk k) => Promonad (Endo :: ENDO kk k -> ENDO kk k -> Type) Source Github # | |
| (CategoryOf j, CategoryOf k) => Promonad (Optic_ :: OPTIC j k c -> OPTIC j k c -> Type) Source Github # | |
| Promonad (Bidiscrete :: DiscreteK ob j k -> DiscreteK ob j k -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.Bidiscrete Methods id :: forall (a :: DiscreteK ob j k). Ob a => Bidiscrete a a Source Github # (.) :: forall (b :: DiscreteK ob j k) (c0 :: DiscreteK ob j k) (a :: DiscreteK ob j k). Bidiscrete b c0 -> Bidiscrete a b -> Bidiscrete a c0 Source Github # | |
| CategoryOf (kk j k2) => Promonad (Co :: COK kk j k2 -> COK kk j k2 -> Type) Source Github # | |
| CategoryOf (kk k2 j) => Promonad (Op :: OPK kk j k2 -> OPK kk j k2 -> Type) Source Github # | |
| (CategoryOf (kk j k2), Bicategory kk) => Promonad (Strictified :: Path kk j k2 -> Path kk j k2 -> Type) Source Github # | |
Defined in Proarrow.Category.Bicategory.Strictified Methods id :: forall (a :: Path kk j k2). Ob a => Strictified a a Source Github # (.) :: forall (b :: Path kk j k2) (c :: Path kk j k2) (a :: Path kk j k2). Strictified b c -> Strictified a b -> Strictified a c Source Github # | |
| Promonad ((~>) :: CAT (kk i j)) => Promonad (HomW :: HK kk i j -> HK kk i j -> Type) Source Github # | |
| Promonad ((~>) :: CAT (kk i j)) => Promonad (Sub :: SUBCAT tag kk i j -> SUBCAT tag kk i j -> Type) Source Github # | |
| (CategoryOf (jj (Fst ik) (Fst jl)), CategoryOf (kk (Snd ik) (Snd jl))) => Promonad (Prod :: PRODK jj kk ik jl -> PRODK jj kk ik jl -> Type) Source Github # | |
Promonad Utilities
arr :: forall {k} p (a :: k) (b :: k). Promonad p => (a ~> b) -> p a b Source Github #
Lifts morphisms from the base category into the promonad.
Object Identities
obj :: forall {k} (a :: k). (CategoryOf k, Ob a) => Obj a Source Github #
The identity morphism for a given object.
Compared to id this makes the kind argument implicit,
allowing to write obj @a instead of id @k @a.
src :: forall {j} {k} (a :: k) (b :: j) p. Profunctor p => p a b -> Obj a Source Github #
Extract source identity morphism from a profunctor heteromorphism.
tgt :: forall {k1} {k2} (a :: k2) (b :: k1) p. Profunctor p => p a b -> Obj b Source Github #
Extract target identity morphism from a profunctor heteromorphism.
Type Family Utilities
Kind Unwrapping
type family UN (w :: j -> k) (wa :: k) :: j Source Github #
A helper type family to unwrap a wrapped kind. This is needed because the field selector functions of newtypes have to be lower case and therefore cannot be used at the type level.
Instances
| type UN 'FR ('FR n :: FINREL) Source Github # | |
Defined in Proarrow.Category.Instance.FinRel | |
| type UN 'FS ('FS n :: FINSET) Source Github # | |
Defined in Proarrow.Category.Instance.FinSet | |
| type UN 'K ('K k :: KIND) Source Github # | |
Defined in Proarrow.Category.Instance.Cat | |
| type UN 'CNSTRNT ('CNSTRNT a :: CONSTRAINT) Source Github # | |
Defined in Proarrow.Category.Instance.Constraint | |
| type UN 'L ('L a :: LINEAR) Source Github # | |
Defined in Proarrow.Category.Instance.Linear | |
| type UN 'P ('P a :: POINTED) Source Github # | |
Defined in Proarrow.Category.Instance.PointedHask | |
| type UN ('M :: Nat -> MatK a) ('M n :: MatK a) Source Github # | |
| type UN ('CS :: j -> COSPAN j) ('CS k :: COSPAN j) Source Github # | |
| type UN ('CD :: j -> CODISCRETE j) ('CD a :: CODISCRETE j) Source Github # | |
Defined in Proarrow.Category.Instance.Discrete | |
| type UN ('D :: j -> DISCRETE j) ('D a :: DISCRETE j) Source Github # | |
| type UN ('SP :: j -> SPAN j) ('SP k :: SPAN j) Source Github # | |
| type UN ('R :: j -> REV j) ('R a :: REV j) Source Github # | |
| type UN ('OP :: j -> OPPOSITE j) ('OP k :: OPPOSITE j) Source Github # | |
| type UN ('COPR :: j -> COPROD j) ('COPR k :: COPROD j) Source Github # | |
| type UN ('PR :: j -> PROD j) ('PR k :: PROD j) Source Github # | |
| type UN ('F :: j -> FK j) ('F a :: FK j) Source Github # | |
| type UN ('A :: j -> AP f j) ('A k :: AP f j) Source Github # | |
| type UN ('KL :: j -> KLEISLI p) ('KL k :: KLEISLI p) Source Github # | |
| type UN ('SUB :: j -> SUBCAT ob) ('SUB k :: SUBCAT ob) Source Github # | |
| type UN ('EMB :: j -> FREE cs p) ('EMB a :: FREE cs p) Source Github # | |
| type UN ('MK :: j1 -> MonK j1 i j2) ('MK k :: MonK j1 i j2) Source Github # | |
| type UN 'D ('D ss :: DOT) Source Github # | |
Defined in Proarrow.Tools.Diagrams.Dot | |
| type UN ('L :: [k] -> LIST k) ('L as :: LIST k) Source Github # | |
| type UN ('DEP_ :: (x +-> k) -> FAM k) ('DEP_ dx :: FAM k) Source Github # | |
| type UN ('PK :: (j +-> k) -> PROFK j k) ('PK p :: PROFK j k) Source Github # | |
| type UN ('NT :: (j -> k) -> j .-> k) ('NT f :: j .-> k) Source Github # | |
| type UN ('ST :: (k +-> k) -> STT' k i j) ('ST p :: STT' k i j) Source Github # | |
| type UN ('E :: kk k k -> ENDO kk k) ('E p :: ENDO kk k) Source Github # | |
| type UN ('CO :: kk j k2 -> COK kk j k2) ('CO k3 :: COK kk j k2) Source Github # | |
| type UN ('OP :: kk k2 j -> OPK kk j k2) ('OP k3 :: OPK kk j k2) Source Github # | |
| type UN ('HomK :: kk i j -> HK kk i j) ('HomK k3 :: HK kk i j) Source Github # | |
| type UN ('SUB :: kk i j -> SUBCAT tag kk i j) ('SUB p :: SUBCAT tag kk i j) Source Github # | |
| type UN ('AK :: Path ABK i j -> ADJK i j) ('AK ps :: ADJK i j) Source Github # | |