Safe Haskell	None
Language	GHC2024

Proarrow.Profunctor

Synopsis

type (+->) j k = k -> j -> Type
class (CategoryOf j, CategoryOf k) => Profunctor (p :: j +-> k) where
- dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> p a b -> p c d
- lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> p a b -> p c b
- rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> p a b -> p a d
- (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> p a b -> r
(//) :: forall {k1} {k2} p (a :: k2) (b :: k1) r. Profunctor p => p a b -> ((Ob a, Ob b) => r) -> r

Documentation

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.

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:

```
dimap id id = id
```

dimap (f . g) (h . i) = dimap g h . dimap f i

Minimal complete definition

dimap | lmap, rmap

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.

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

Instances

Instances details

Profunctor Simplex Source Github #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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.
Instance details 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 #
Instance details Defined in Proarrow.Profunctor.Arrow Methods dimap :: (c ~> a) -> (b ~> d) -> Kleisli m a b -> Kleisli m c d Source Github # lmap :: (c ~> a) -> Kleisli m a b -> Kleisli m c b Source Github # rmap :: (b ~> d) -> Kleisli m a b -> Kleisli m a d Source Github # (\\) :: ((Ob a, Ob b) => r) -> Kleisli m a b -> r Source Github #
Functor w => Profunctor (ComonoidAsCat w :: Type -> Type -> Type) Source Github #
Instance details 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 #
Instance details Defined in Proarrow.Profunctor.Arrow Methods dimap :: (c ~> a) -> (b ~> d) -> Arr arr a b -> Arr arr c d Source Github # lmap :: (c ~> a) -> Arr arr a b -> Arr arr c b Source Github # rmap :: (b ~> d) -> Arr arr a b -> Arr arr a d Source Github # (\\) :: ((Ob a, Ob b) => r) -> Arr arr a b -> r Source Github #
CategoryOf k => Profunctor (Fold :: k -> k -> Type) Source Github #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details Defined in Proarrow.Core Methods dimap :: (c ~> a) -> (b ~> d) -> (a -> b) -> c -> d Source Github # lmap :: (c ~> a) -> (a -> b) -> c -> b Source Github # rmap :: (b ~> d) -> (a -> b) -> a -> d Source Github # (\\) :: ((Ob a, Ob b) => r) -> (a -> b) -> r Source Github #
Profunctor p => Profunctor (Fix p :: j -> j -> Type) Source Github #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details Defined in Proarrow.Profunctor.Representable Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> CorepStar p a b -> CorepStar p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> CorepStar p a b -> CorepStar p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> CorepStar p a b -> CorepStar p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> CorepStar p a b -> r Source Github #
FunctorForRep f => Profunctor (Rep f :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Representable Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> 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 #
Instance details Defined in Proarrow.Profunctor.Representable Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> RepCostar p a b -> RepCostar p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> RepCostar p a b -> RepCostar p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> RepCostar p a b -> RepCostar p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> RepCostar p a b -> r Source Github #
Functor f => Profunctor (Star f :: k -> j -> Type) Source Github #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details Defined in Proarrow.Profunctor.Composition Methods dimap :: forall (c :: k) (a :: k) (b :: j2) (d :: j2). (c ~> a) -> (b ~> d) -> (p :.: q) a b -> (p :.: q) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j2). (c ~> a) -> (p :.: q) a b -> (p :.: q) c b Source Github # rmap :: forall (b :: j2) (d :: j2) (a :: k). (b ~> d) -> (p :.: q) a b -> (p :.: q) a d Source Github # (\\) :: forall (a :: k) (b :: j2) r. ((Ob a, Ob b) => r) -> (p :.: q) a b -> r Source Github #
CategoryOf k => Profunctor (Hom :: (OPPOSITE k, k) -> () -> Type) Source Github #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #
Instance details 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 #

(//) :: 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 (\\).