Safe Haskell	None
Language	GHC2024

Proarrow.Core

Contents

Type Infrastructure
- Basic Type Definitions
- Universal Constraint
Category Infrastructure
- CategoryOf Class
Profunctors
Promonads
- Promonad Class
- Promonad Utilities
Object Identities
Type Family Utilities
- Kind Unwrapping

Description

The foundational module, defining the kind-indexed category machinery everything else builds on. A kind k carries at most one category structure, chosen by the CategoryOf class: its morphism type (~>) and its object constraint Ob (not every type of the kind need be an object). A category's identity and composition live in Promonad, and Profunctor -- with the profunctor kind j +-> k -- is this library's central generalization of functors. Ob constraints are typically not threaded through signatures but recovered from morphisms with (\\) and (//), since an arrow is proof that its endpoints are objects.

Import Proarrow for the curated everyday vocabulary; this module is where that design is defined, and the place to start when building your own categories.

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 (~>) :: CAT k
- type Ob (a :: k)
type Hom k = (~>) :: CAT k
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
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
- id :: forall (a :: k). Ob a => p a a
- (.) :: forall (b :: k) (c :: k) (a :: k). p b c -> p a b -> p a c
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 where ...
type Is (w :: j -> k) (a :: k) = a ~ w (UN w a)
type WrappedOb (w :: j -> k) (a :: k) = (Is w a, Ob (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 CAT k = k +-> k Source Github #

The kind of categories on kind k.

type OB k = k -> Constraint Source Github #

Object constraints for kind k.

type Kind = Type Source Github #

Alias for Type for clarity in kind signatures.

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

Instances details

Any (a :: k) Source Github #
Instance details 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.

type Ob (a :: k) = Any a

Instances

Instances details

CategoryOf Nat Source Github #

The (augmented) simplex category is the category of finite ordinals and order preserving maps.

Instance details

Defined in Proarrow.Category.Instance.Simplex

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Simplex type (~>) = Simplex
type Ob (a :: Nat)
Instance details Defined in Proarrow.Category.Instance.Simplex type Ob (a :: Nat) = IsNat a

CategoryOf Nat Source Github #

The category of qubits, to implement ZX calculus from quantum computing.

Instance details

Defined in Proarrow.Category.Instance.ZX

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.ZX type (~>) = ZX
type Ob (a :: Nat)
Instance details Defined in Proarrow.Category.Instance.ZX type Ob (a :: Nat) = KnownNat a

CategoryOf BOOL Source Github #

The category of 2 objects and one arrow between them, a.k.a. the walking arrow.

Instance details

Defined in Proarrow.Category.Instance.Bool

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Bool type (~>) = Booleans
type Ob (b :: BOOL)
Instance details Defined in Proarrow.Category.Instance.Bool type Ob (b :: BOOL) = IsBool b

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.

Instance details

Defined in Proarrow.Category.Instance.Constraint

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Constraint type (~>) = (:-)
type Ob (a :: CONSTRAINT)
Instance details Defined in Proarrow.Category.Instance.Constraint type Ob (a :: CONSTRAINT) = Is 'CNSTRNT a

CategoryOf COST Source Github #

Cost category. Categories enriched in the cost category are lawvere metric spaces.

Instance details

Defined in Proarrow.Category.Instance.Cost

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Cost type (~>) = GTE
type Ob (a :: COST)
Instance details Defined in Proarrow.Category.Instance.Cost type Ob (a :: COST) = IsCost a

CategoryOf FINHASK Source Github #

The category of finite Haskell types, with morphisms stored extensionally as finite lookup tables.

Instance details

Defined in Proarrow.Category.Instance.FinHask

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.FinHask type (~>) = FinHask
type Ob (a :: FINHASK)
Instance details Defined in Proarrow.Category.Instance.FinHask type Ob (a :: FINHASK) = (Is 'FH a, Finite (UN 'FH a), Ord (UN 'FH a), Show (UN 'FH a))

CategoryOf FINREL Source Github #

The skeleton of the category of finite sets and relations: objects are natural numbers and an arrow FR n ~> FR m is an n by m boolean matrix.

Instance details

Defined in Proarrow.Category.Instance.FinRel

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.FinRel type (~>) = FinRel
type Ob (a :: FINREL)
Instance details Defined in Proarrow.Category.Instance.FinRel type Ob (a :: FINREL) = (Is 'FR a, SNatI (UN 'FR a))

CategoryOf FINSET Source Github #

The skeleton of the category of finite sets: objects are natural numbers and an arrow FS n ~> FS m is a function given by its table.

Instance details

Defined in Proarrow.Category.Instance.FinSet

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.FinSet type (~>) = FinSet
type Ob (a :: FINSET)
Instance details Defined in Proarrow.Category.Instance.FinSet type Ob (a :: FINSET) = (Is 'FS a, SNatI (UN 'FS a))

CategoryOf LINEAR Source Github #

Category of linear functions.

Instance details

Defined in Proarrow.Category.Instance.Linear

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Linear type (~>) = Linear
type Ob (a :: LINEAR)
Instance details Defined in Proarrow.Category.Instance.Linear type Ob (a :: LINEAR) = Is 'L a

CategoryOf POINTED Source Github #

The category of types with an added point and point-preserving morphisms.

Instance details

Defined in Proarrow.Category.Instance.PointedHask

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.PointedHask type (~>) = Pointed
type Ob (a :: POINTED)
Instance details Defined in Proarrow.Category.Instance.PointedHask type Ob (a :: POINTED) = a ~ 'P (UN 'P a)

CategoryOf VOID Source Github #

The category with no objects, the initial category.

Instance details

Defined in Proarrow.Category.Instance.Zero

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Zero type (~>) = Zero
type Ob (a :: VOID)
Instance details Defined in Proarrow.Category.Instance.Zero type Ob (a :: VOID) = Bottom

CategoryOf DOT Source Github #

The category string diagrams are built in: an object D ws is the list of wire labels along a boundary, and an arrow accumulates the Graphviz data connecting its input wires to its output wires.

Instance details

Defined in Proarrow.Tools.Diagrams.Dot

Associated Types

type (~>)
Instance details Defined in Proarrow.Tools.Diagrams.Dot type (~>) = Dot
type Ob (a :: DOT)
Instance details Defined in Proarrow.Tools.Diagrams.Dot type Ob (a :: DOT) = (Is 'D a, IsList (UN 'D a))

CategoryOf () Source Github #

The category with one object, the terminal category.

Instance details

Defined in Proarrow.Category.Instance.Unit

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Unit type (~>) = Unit
type Ob (a :: ())
Instance details Defined in Proarrow.Category.Instance.Unit type Ob (a :: ()) = a ~ '()

CategoryOf Symbol Source Github #

The discrete category on type-level Symbols, labelling the wires of a string diagram.

Instance details

Defined in Proarrow.Tools.Diagrams.Dot

Associated Types

type (~>)
Instance details Defined in Proarrow.Tools.Diagrams.Dot type (~>) = SymRefl
type Ob (s :: Symbol)
Instance details Defined in Proarrow.Tools.Diagrams.Dot type Ob (s :: Symbol) = KnownSymbol s

CategoryOf Type Source Github #

The category of Haskell types (a.k.a Hask), where the arrows are functions.

Instance details

Defined in Proarrow.Core

Associated Types

type (~>)
Instance details Defined in Proarrow.Core type (~>) = (->)
type Ob (a :: Type)
Instance details Defined in Proarrow.Core type Ob (a :: Type) = Any a

HasPushouts k => CategoryOf (COSPAN k) Source Github #

The category of cospans in k: an arrow CS a ~> CS b is a pair of arrows a ~> x and b ~> x into a common object, and composition glues along a pushout.

Instance details

Defined in Proarrow.Category.Instance.Cospan

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Cospan type (~>) = Cospan :: COSPAN k -> COSPAN k -> Type

CategoryOf (CODISCRETE k) Source Github #

The codiscrete category has exactly one arrow between every object, every type of kind k is an object.

Instance details

Defined in Proarrow.Category.Instance.Discrete

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Discrete type (~>) = Codiscrete :: CODISCRETE k -> CODISCRETE k -> Type

CategoryOf (DISCRETE k) Source Github #

The discrete category with only identity arrows, every type of kind k is an object.

Instance details

Defined in Proarrow.Category.Instance.Discrete

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Discrete type (~>) = Discrete :: DISCRETE k -> DISCRETE k -> Type

CategoryOf k => CategoryOf (FAM k) Source Github #

The Fam construction a.k.a. the free coproduct completion of k

Instance details

Defined in Proarrow.Category.Instance.Fam

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Fam type (~>) = Fam :: FAM k -> FAM k -> Type

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.

Instance details

Defined in Proarrow.Category.Instance.Fin

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Fin type (~>) = LTE :: FIN n -> FIN n -> Type

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.

Instance details

Defined in Proarrow.Category.Instance.IntConstruction

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.IntConstruction type (~>) = IntConstruction :: INT k -> INT k -> Type

Num a => CategoryOf (MatK a) Source Github #

The category of matrices with entries in a type a, where the objects are natural numbers and the arrows n ~> m are matrices of dimension n by m.

Instance details

Defined in Proarrow.Category.Instance.Mat

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Mat type (~>) = Mat :: MatK a -> MatK a -> Type

CategoryOf k => CategoryOf (OPPOSITE k) Source Github #

The opposite category of the category of k.

Instance details

Defined in Proarrow.Category.Instance.Opposite

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Opposite type (~>) = Op ((~>) :: CAT k)

HasPullbacks k => CategoryOf (SPAN k) Source Github #

The category of spans in k: an arrow SP a ~> SP b is a pair of arrows x ~> a and x ~> b out of a common object, and composition glues along a pullback.

Instance details

Defined in Proarrow.Category.Instance.Span

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Span type (~>) = Span :: SPAN k -> SPAN k -> Type

CategoryOf k => CategoryOf (ENDO k) Source Github #

The category of endoprofunctors on k and natural transformations between them.

Instance details

Defined in Proarrow.Category.Monoidal.Endo

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Monoidal.Endo type (~>) = Endo :: ENDO k -> ENDO k -> Type

CategoryOf k => CategoryOf (REV k) Source Github #

The reverse of the category of k, i.e. with the tensor flipped.

Instance details

Defined in Proarrow.Category.Monoidal.Rev

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Monoidal.Rev type (~>) = Rev ((~>) :: CAT k)

CategoryOf k => CategoryOf (COPROD k) Source Github #

The same category as the category of k, but with coproducts as the tensor.

Instance details

Defined in Proarrow.Colimit.BinaryCoproduct

Associated Types

type (~>)
Instance details Defined in Proarrow.Colimit.BinaryCoproduct type (~>) = Coprod ((~>) :: CAT k)

CategoryOf k => CategoryOf (PROD k) Source Github #

The same category as the category of k, but with products as the tensor.

Instance details

Defined in Proarrow.Limit.BinaryProduct

Associated Types

type (~>)
Instance details Defined in Proarrow.Limit.BinaryProduct type (~>) = Prod ((~>) :: CAT k)

CategoryOf k => CategoryOf (LIST k) Source Github #

The category of lists of arrows.

Instance details

Defined in Proarrow.Profunctor.Instance.List

Associated Types

type (~>)
Instance details Defined in Proarrow.Profunctor.Instance.List type (~>) = List ((~>) :: CAT k)

Monoidal k => CategoryOf [k] Source Github #

The strictified monoidal category, making the unitors and associators identities.

Instance details

Defined in Proarrow.Category.Monoidal.Strictified

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Monoidal.Strictified type (~>) = Strictified :: [k] -> [k] -> Type

(Applicative f, CategoryOf k) => CategoryOf (AP f k) Source Github #

The category with the objects of k and the arrows of k wrapped in the applicative functor f; composition combines the effects with liftA2.

Instance details

Defined in Proarrow.Category.Instance.Ap

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Ap type (~>) = Ap ((~>) :: CAT k) :: AP f k -> AP f k -> Type

(CategoryOf j, CategoryOf k) => CategoryOf (COPRODUCT j k) Source Github #

The coproduct of two categories.

Instance details

Defined in Proarrow.Category.Instance.Coproduct

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Coproduct type (~>) = ((~>) :: CAT j) :++: ((~>) :: CAT k)

BiCCC k => CategoryOf (FBC p) Source Github #

The bicartesian closed category freely generated over the objects of k and the generators p: arrows are Terms, interpreted back into k by interp.

Instance details

Defined in Proarrow.Category.Instance.FreeBiCCC

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.FreeBiCCC type (~>) = Term :: FBC p -> FBC p -> Type

Promonad p => CategoryOf (KLEISLI p) Source Github #

Every promonad makes a category.

Instance details

Defined in Proarrow.Category.Instance.Kleisli

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Kleisli type (~>) = Kleisli :: KLEISLI p -> KLEISLI p -> Type

CategoryOf (j .-> k) Source Github #

The category of functors and natural transformations.

Instance details

Defined in Proarrow.Category.Instance.Nat

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Nat type (~>) = Nat' :: (j .-> k) -> (j .-> k) -> Type

CategoryOf k => CategoryOf (SUBCAT ob) Source Github #

The subcategory with objects with instances of the given constraint ob.

Instance details

Defined in Proarrow.Category.Instance.Sub

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Sub type (~>) = Sub ((~>) :: CAT k) :: SUBCAT ob -> SUBCAT ob -> Type

CategoryOf (j +-> k) Source Github #

The category of profunctors and natural transformations between them.

Instance details

Defined in Proarrow.Category.Instance.Prof

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Prof type (~>) = Prof :: (j +-> k) -> (j +-> k) -> Type

Monoid m => CategoryOf (MONOIDK m) Source Github #

A monoid as a one object category.

Instance details

Defined in Proarrow.Monoid

Associated Types

type (~>)
Instance details Defined in Proarrow.Monoid type (~>) = Mon :: MONOIDK m -> MONOIDK m -> Type

(CategoryOf k1, CategoryOf k2) => CategoryOf (k1, k2) Source Github #

The product of two categories.

Instance details

Defined in Proarrow.Category.Instance.Product

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Product type (~>) = ((~>) :: CAT k1) :**: ((~>) :: CAT k2)

CategoryOf (k1 -> k2 -> k3 -> k4 -> Type) Source Github #

The category of functors with target category k2 -> k3 -> k4 -> Type.

Instance details

Defined in Proarrow.Category.Instance.Nat

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Nat type (~>) = Nat :: (k1 -> k2 -> k3 -> k4 -> Type) -> (k1 -> k2 -> k3 -> k4 -> Type) -> Type

CategoryOf (k1 -> k2 -> k3 -> Type) Source Github #

The category of functors with target category k2 -> k3 -> Type. Note that CategoryOf (k1 -> k2 -> Type) is reserved for profunctors.

Instance details

Defined in Proarrow.Category.Instance.Nat

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Nat type (~>) = Nat :: (k1 -> k2 -> k3 -> Type) -> (k1 -> k2 -> k3 -> Type) -> Type

CategoryOf (k1 -> Type) Source Github #

The category of functors with target category Hask.

Instance details

Defined in Proarrow.Category.Instance.Nat

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Nat type (~>) = Nat :: (k1 -> Type) -> (k1 -> Type) -> Type

Profunctor p => CategoryOf (COLLAGE p) Source Github #

The collage of a profunctor.

Instance details

Defined in Proarrow.Category.Instance.Collage

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Collage type (~>) = Collage :: COLLAGE p -> COLLAGE p -> Type

Adjunction adj => CategoryOf (DUPLOID adj) Source Github #

The duploid of an adjunction, with polarized objects. Deliberately unlawful: composition is polarity-biased and not associative (see the warning on the Promonad instance above).

Instance details

Defined in Proarrow.Category.Instance.Duploid

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Duploid type (~>) = Duploid :: DUPLOID adj -> DUPLOID adj -> Type

CategoryOf (FREE cs p) Source Github #

The category freely generated from the heteromorphisms of p, together with formal structure arrows for each of the classes in cs.

Instance details

Defined in Proarrow.Category.Instance.Free

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Free type (~>) = Free :: FREE cs p -> FREE cs p -> Type

ThinProfunctor p => CategoryOf (GRAPH p) Source Github #

The graph of a thin profunctor. Doing this for any profunctor would need dependent types.

Instance details

Defined in Proarrow.Category.Instance.Graph

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Graph type (~>) = Graph :: GRAPH p -> GRAPH p -> Type

(CategoryOf j, CategoryOf k) => CategoryOf (OPTIC j k c) Source Github #

Optics form a category: an object OPT s t pairs the object s an optic reads from (contravariant) with the object t it writes back (covariant), an arrow OPT a b ~> OPT s t is a c-flavored optic with focus a/b inside s/t, and composition is optic composition.

Instance details

Defined in Proarrow.Optic

Associated Types

type (~>)
Instance details Defined in Proarrow.Optic type (~>) = Optic_ :: OPTIC j k c -> OPTIC j k c -> Type

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:

```
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 (:-) 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 FinHask Source Github #
Instance details Defined in Proarrow.Category.Instance.FinHask Methods dimap :: forall (c :: FINHASK) (a :: FINHASK) (b :: FINHASK) (d :: FINHASK). (c ~> a) -> (b ~> d) -> FinHask a b -> FinHask c d Source Github # lmap :: forall (c :: FINHASK) (a :: FINHASK) (b :: FINHASK). (c ~> a) -> FinHask a b -> FinHask c b Source Github # rmap :: forall (b :: FINHASK) (d :: FINHASK) (a :: FINHASK). (b ~> d) -> FinHask a b -> FinHask a d Source Github # (\\) :: forall (a :: FINHASK) (b :: FINHASK) r. ((Ob a, Ob b) => r) -> FinHask 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 #
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.Instance.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.Instance.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 #
Monoidal k => Profunctor (CoTwo :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> CoTwo a b -> CoTwo c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> CoTwo a b -> CoTwo c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> CoTwo a b -> CoTwo a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> CoTwo a b -> r Source Github #
Monoidal k => Profunctor (Two :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Two a b -> Two c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Two a b -> Two c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Two a b -> Two a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> Two a b -> r Source Github #
Monoidal k => Profunctor (CoUnitW :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> CoUnitW a b -> CoUnitW c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> CoUnitW a b -> CoUnitW c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> CoUnitW a b -> CoUnitW a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> CoUnitW a b -> r Source Github #
HasInitialObject k => Profunctor (CoZeroW :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> CoZeroW a b -> CoZeroW c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> CoZeroW a b -> CoZeroW c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> CoZeroW a b -> CoZeroW a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> CoZeroW a b -> r Source Github #
Monoidal k => Profunctor (UnitW :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> UnitW a b -> UnitW c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> UnitW a b -> UnitW c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> UnitW a b -> UnitW a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> UnitW a b -> r Source Github #
HasInitialObject k => Profunctor (ZeroW :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> ZeroW a b -> ZeroW c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> ZeroW a b -> ZeroW c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> ZeroW a b -> ZeroW a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> ZeroW a b -> r Source Github #
CategoryOf k => Profunctor (Fold :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.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.Instance.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 (->) 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 (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 #
Profunctor p => Profunctor (Fix p :: j -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.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 #
(CategoryOf j, CategoryOf k) => Profunctor (DayUnit :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.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.Instance.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.Instance.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 #
(HasBinaryCoproducts k, Ob a) => Profunctor (MatchP a :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.AffineTraversal Methods dimap :: forall (c :: k) (a0 :: k) (b :: k) (d :: k). (c ~> a0) -> (b ~> d) -> MatchP a a0 b -> MatchP a c d Source Github # lmap :: forall (c :: k) (a0 :: k) (b :: k). (c ~> a0) -> MatchP a a0 b -> MatchP a c b Source Github # rmap :: forall (b :: k) (d :: k) (a0 :: k). (b ~> d) -> MatchP a a0 b -> MatchP a a0 d Source Github # (\\) :: forall (a0 :: k) (b :: k) r. ((Ob a0, Ob b) => r) -> MatchP a a0 b -> r Source Github #
(Monoidal k, KnownNat n) => Profunctor (CoPow n :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> CoPow n a b -> CoPow n c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> CoPow n a b -> CoPow n c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> CoPow n a b -> CoPow n a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> CoPow n a b -> r Source Github #
(Monoidal k, KnownNat n) => Profunctor (Pow n :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Pow n a b -> Pow n c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Pow n a b -> Pow n c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Pow n a b -> Pow n a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> Pow n a b -> r Source Github #
Comonoid m => Profunctor (CoLensW m :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalLens Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> CoLensW m a b -> CoLensW m c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> CoLensW m a b -> CoLensW m c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> CoLensW m a b -> CoLensW m a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> CoLensW m a b -> r Source Github #
Comonoid m => Profunctor (LensW m :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalLens Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> LensW m a b -> LensW m c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> LensW m a b -> LensW m c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> LensW m a b -> LensW m a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> LensW m a b -> r Source Github #
(Monoidal k, Ob a) => Profunctor (CoTensorW a :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalTraversal Methods dimap :: forall (c :: k) (a0 :: k) (b :: k) (d :: k). (c ~> a0) -> (b ~> d) -> CoTensorW a a0 b -> CoTensorW a c d Source Github # lmap :: forall (c :: k) (a0 :: k) (b :: k). (c ~> a0) -> CoTensorW a a0 b -> CoTensorW a c b Source Github # rmap :: forall (b :: k) (d :: k) (a0 :: k). (b ~> d) -> CoTensorW a a0 b -> CoTensorW a a0 d Source Github # (\\) :: forall (a0 :: k) (b :: k) r. ((Ob a0, Ob b) => r) -> CoTensorW a a0 b -> r Source Github #
(Monoidal k, Ob a) => Profunctor (TensorW a :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalTraversal Methods dimap :: forall (c :: k) (a0 :: k) (b :: k) (d :: k). (c ~> a0) -> (b ~> d) -> TensorW a a0 b -> TensorW a c d Source Github # lmap :: forall (c :: k) (a0 :: k) (b :: k). (c ~> a0) -> TensorW a a0 b -> TensorW a c b Source Github # rmap :: forall (b :: k) (d :: k) (a0 :: k). (b ~> d) -> TensorW a a0 b -> TensorW a a0 d Source Github # (\\) :: forall (a0 :: k) (b :: k) r. ((Ob a0, Ob b) => r) -> TensorW a a0 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 #
(CategoryOf j, CategoryOf k, Profunctor p) => Profunctor (UnOp p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.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 #
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 #
(Profunctor p, CategoryOf j, CategoryOf k) => Profunctor (Uncoprod p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Colimit.BinaryCoproduct Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Uncoprod p a b -> Uncoprod p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Uncoprod p a b -> Uncoprod p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Uncoprod p a b -> Uncoprod p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Uncoprod 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 #
(Bicartesian k, CategoryOf j, Ob a) => Profunctor (PreviewP a :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Optic.AffineFold Methods dimap :: forall (c :: k) (a0 :: k) (b :: j) (d :: j). (c ~> a0) -> (b ~> d) -> PreviewP a a0 b -> PreviewP a c d Source Github # lmap :: forall (c :: k) (a0 :: k) (b :: j). (c ~> a0) -> PreviewP a a0 b -> PreviewP a c b Source Github # rmap :: forall (b :: j) (d :: j) (a0 :: k). (b ~> d) -> PreviewP a a0 b -> PreviewP a a0 d Source Github # (\\) :: forall (a0 :: k) (b :: j) r. ((Ob a0, Ob b) => r) -> PreviewP a a0 b -> r Source Github #
(CategoryOf j, CategoryOf k, Ob m) => Profunctor (Forget m :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Fold Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Forget m a b -> Forget m c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Forget m a b -> Forget m c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Forget m a b -> Forget m a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Forget m 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 #
Profunctor p => Profunctor (Adj p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Adj 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 #
Functor f => Profunctor (Costar f :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.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.Instance.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.Instance.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 #
Functor f => Profunctor (Star f :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.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.Instance.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.Instance.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 #
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 #
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 #
Profunctor j2 => Profunctor (AnyColimit j2 :: k -> j1 -> Type) Source Github #
Instance details Defined in Proarrow.Colimit Methods dimap :: forall (c :: k) (a :: k) (b :: j1) (d :: j1). (c ~> a) -> (b ~> d) -> AnyColimit j2 a b -> AnyColimit j2 c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j1). (c ~> a) -> AnyColimit j2 a b -> AnyColimit j2 c b Source Github # rmap :: forall (b :: j1) (d :: j1) (a :: k). (b ~> d) -> AnyColimit j2 a b -> AnyColimit j2 a d Source Github # (\\) :: forall (a :: k) (b :: j1) r. ((Ob a, Ob b) => r) -> AnyColimit j2 a b -> r Source Github #
Profunctor j2 => Profunctor (AnyLimit j2 :: k -> j1 -> Type) Source Github #
Instance details Defined in Proarrow.Limit Methods dimap :: forall (c :: k) (a :: k) (b :: j1) (d :: j1). (c ~> a) -> (b ~> d) -> AnyLimit j2 a b -> AnyLimit j2 c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j1). (c ~> a) -> AnyLimit j2 a b -> AnyLimit j2 c b Source Github # rmap :: forall (b :: j1) (d :: j1) (a :: k). (b ~> d) -> AnyLimit j2 a b -> AnyLimit j2 a d Source Github # (\\) :: forall (a :: k) (b :: j1) r. ((Ob a, Ob b) => r) -> AnyLimit j2 a b -> r Source Github #
(Ob n, Enriched v k, CategoryOf k) => Profunctor (GenArrow ('OP n) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Enriched Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> GenArrow ('OP n) a b -> GenArrow ('OP n) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> GenArrow ('OP n) a b -> GenArrow ('OP n) c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> GenArrow ('OP n) a b -> GenArrow ('OP n) a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> GenArrow ('OP n) a b -> r Source Github #
(Closed k, SymMonoidal k, Ob a, Ob b) => Profunctor (Grating a b :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Grate Methods dimap :: forall (c :: k) (a0 :: k) (b0 :: k) (d :: k). (c ~> a0) -> (b0 ~> d) -> Grating a b a0 b0 -> Grating a b c d Source Github # lmap :: forall (c :: k) (a0 :: k) (b0 :: k). (c ~> a0) -> Grating a b a0 b0 -> Grating a b c b0 Source Github # rmap :: forall (b0 :: k) (d :: k) (a0 :: k). (b0 ~> d) -> Grating a b a0 b0 -> Grating a b a0 d Source Github # (\\) :: forall (a0 :: k) (b0 :: k) r. ((Ob a0, Ob b0) => r) -> Grating a b a0 b0 -> r Source Github #
(HasBinaryProducts k, Ob a, Ob b) => Profunctor (Shop a b :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Lens Methods dimap :: forall (c :: k) (a0 :: k) (b0 :: k) (d :: k). (c ~> a0) -> (b0 ~> d) -> Shop a b a0 b0 -> Shop a b c d Source Github # lmap :: forall (c :: k) (a0 :: k) (b0 :: k). (c ~> a0) -> Shop a b a0 b0 -> Shop a b c b0 Source Github # rmap :: forall (b0 :: k) (d :: k) (a0 :: k). (b0 ~> d) -> Shop a b a0 b0 -> Shop a b a0 d Source Github # (\\) :: forall (a0 :: k) (b0 :: k) r. ((Ob a0, Ob b0) => r) -> Shop a b a0 b0 -> r Source Github #
(Monoidal k, Ob a, Ob b) => Profunctor (MonShop a b :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalLens Methods dimap :: forall (c :: k) (a0 :: k) (b0 :: k) (d :: k). (c ~> a0) -> (b0 ~> d) -> MonShop a b a0 b0 -> MonShop a b c d Source Github # lmap :: forall (c :: k) (a0 :: k) (b0 :: k). (c ~> a0) -> MonShop a b a0 b0 -> MonShop a b c b0 Source Github # rmap :: forall (b0 :: k) (d :: k) (a0 :: k). (b0 ~> d) -> MonShop a b a0 b0 -> MonShop a b a0 d Source Github # (\\) :: forall (a0 :: k) (b0 :: k) r. ((Ob a0, Ob b0) => r) -> MonShop a b a0 b0 -> r Source Github #
(HasBinaryCoproducts k, Ob a, Ob b) => Profunctor (Market a b :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Prism Methods dimap :: forall (c :: k) (a0 :: k) (b0 :: k) (d :: k). (c ~> a0) -> (b0 ~> d) -> Market a b a0 b0 -> Market a b c d Source Github # lmap :: forall (c :: k) (a0 :: k) (b0 :: k). (c ~> a0) -> Market a b a0 b0 -> Market a b c b0 Source Github # rmap :: forall (b0 :: k) (d :: k) (a0 :: k). (b0 ~> d) -> Market a b a0 b0 -> Market a b a0 d Source Github # (\\) :: forall (a0 :: k) (b0 :: k) r. ((Ob a0, Ob b0) => r) -> Market a b a0 b0 -> r Source Github #
(Profunctor p1, Profunctor p2, Monoidal k) => Profunctor (Beside p1 p2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Beside p1 p2 a b -> Beside p1 p2 c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Beside p1 p2 a b -> Beside p1 p2 c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Beside p1 p2 a b -> Beside p1 p2 a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> Beside p1 p2 a b -> r Source Github #
(Profunctor p1, Profunctor p2, CategoryOf k) => Profunctor (BesideSum p1 p2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> BesideSum p1 p2 a b -> BesideSum p1 p2 c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> BesideSum p1 p2 a b -> BesideSum p1 p2 c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> BesideSum p1 p2 a b -> BesideSum p1 p2 a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> BesideSum p1 p2 a b -> r Source Github #
(Profunctor q1, Profunctor q2, Monoidal k) => Profunctor (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> CoBeside q1 q2 a b -> CoBeside q1 q2 c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> CoBeside q1 q2 a b -> CoBeside q1 q2 c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> CoBeside q1 q2 a b -> CoBeside q1 q2 a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> CoBeside q1 q2 a b -> r Source Github #
(Profunctor q1, Profunctor q2, CategoryOf k) => Profunctor (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> CoBesideSum q1 q2 a b -> CoBesideSum q1 q2 c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> CoBesideSum q1 q2 a b -> CoBesideSum q1 q2 c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> CoBesideSum q1 q2 a b -> CoBesideSum q1 q2 a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> CoBesideSum q1 q2 a 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 #
Profunctor p => Profunctor (n :*.: p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Colimit.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.Limit.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.Instance.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.Instance.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.Instance.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.Instance.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 p) => Profunctor (Pastro t p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.PastroTambara Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Pastro t p a b -> Pastro t p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Pastro t p a b -> Pastro t p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Pastro t p a b -> Pastro t p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Pastro t p a b -> r Source Github #
Profunctor p => Profunctor (Tambara w p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.PastroTambara Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Tambara w p a b -> Tambara w p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Tambara w p a b -> Tambara w p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Tambara w p a b -> Tambara w p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Tambara w p a b -> r Source Github #
(Profunctor p, Profunctor q) => Profunctor (p :*: q :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.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.Instance.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 #
(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 #
(CategoryOf j, CategoryOf k) => Profunctor (ExOptic w a b :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Optic Methods dimap :: forall (c :: k) (a0 :: k) (b0 :: j) (d :: j). (c ~> a0) -> (b0 ~> d) -> ExOptic w a b a0 b0 -> ExOptic w a b c d Source Github # lmap :: forall (c :: k) (a0 :: k) (b0 :: j). (c ~> a0) -> ExOptic w a b a0 b0 -> ExOptic w a b c b0 Source Github # rmap :: forall (b0 :: j) (d :: j) (a0 :: k). (b0 ~> d) -> ExOptic w a b a0 b0 -> ExOptic w a b a0 d Source Github # (\\) :: forall (a0 :: k) (b0 :: j) r. ((Ob a0, Ob b0) => r) -> ExOptic w a b a0 b0 -> 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 #
(FunctorForRep f, FunctorForRep g) => Profunctor (Direp f g :: k1 -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Direp 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.Instance.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.Instance.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.Instance.Composition Methods dimap :: forall (c :: k) (a :: k) (b :: j2) (d :: j2). (c ~> a) -> (b ~> d) -> (p :.: q) a b -> (p :.: q) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j2). (c ~> a) -> (p :.: q) a b -> (p :.: q) c b Source Github # rmap :: forall (b :: j2) (d :: j2) (a :: k). (b ~> d) -> (p :.: q) a b -> (p :.: q) a d Source Github # (\\) :: forall (a :: k) (b :: j2) r. ((Ob a, Ob b) => r) -> (p :.: q) a b -> r Source Github #
CategoryOf k => Profunctor (Hom :: (OPPOSITE k, k) -> () -> Type) Source Github #
Instance details Defined in Proarrow.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 #
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.Instance.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 #
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 (Endo :: ENDO k -> ENDO k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Endo Methods dimap :: forall (c :: ENDO k) (a :: ENDO k) (b :: ENDO k) (d :: ENDO k). (c ~> a) -> (b ~> d) -> Endo a b -> Endo c d Source Github # lmap :: forall (c :: ENDO k) (a :: ENDO k) (b :: ENDO k). (c ~> a) -> Endo a b -> Endo c b Source Github # rmap :: forall (b :: ENDO k) (d :: ENDO k) (a :: ENDO k). (b ~> d) -> Endo a b -> Endo a d Source Github # (\\) :: forall (a :: ENDO k) (b :: ENDO k) r. ((Ob a, Ob b) => r) -> Endo a b -> r Source Github #
CategoryOf k => Profunctor (Cocone :: LIST k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Cocone 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.Profunctor.Instance.Cone 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 (Op p :: OPPOSITE j -> OPPOSITE k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.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 (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 (Coprod p :: COPROD k -> COPROD j -> Type) Source Github #
Instance details Defined in Proarrow.Colimit.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.Limit.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.Instance.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.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 #
BiCCC k => Profunctor (Term :: FBC p -> FBC p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.FreeBiCCC Methods dimap :: forall (c :: FBC p) (a :: FBC p) (b :: FBC p) (d :: FBC p). (c ~> a) -> (b ~> d) -> Term a b -> Term c d Source Github # lmap :: forall (c :: FBC p) (a :: FBC p) (b :: FBC p). (c ~> a) -> Term a b -> Term c b Source Github # rmap :: forall (b :: FBC p) (d :: FBC p) (a :: FBC p). (b ~> d) -> Term a b -> Term a d Source Github # (\\) :: forall (a :: FBC p) (b :: FBC p) r. ((Ob a, Ob b) => r) -> Term 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 (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 #
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 #
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 #
(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 #

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:

Left identity: id . f = f
Right identity: f . id = f
Associativity: (h . g) . f = h . (g . f)

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

Instances details

Promonad Simplex Source Github #
Instance details Defined in Proarrow.Category.Instance.Simplex Methods id :: forall (a :: Nat). Ob a => Simplex a a Source Github # (.) :: forall (b :: Nat) (c :: Nat) (a :: Nat). Simplex b c -> Simplex a b -> Simplex a c Source Github #
Promonad ZX Source Github #
Instance details Defined in Proarrow.Category.Instance.ZX Methods id :: forall (a :: Nat). Ob a => ZX a a Source Github # (.) :: forall (b :: Nat) (c :: Nat) (a :: Nat). ZX b c -> ZX a b -> ZX a c Source Github #
Promonad Booleans Source Github #
Instance details Defined in Proarrow.Category.Instance.Bool Methods id :: forall (a :: BOOL). Ob a => Booleans a a Source Github # (.) :: forall (b :: BOOL) (c :: BOOL) (a :: BOOL). Booleans b c -> Booleans a b -> Booleans a c Source Github #
Promonad (:-) Source Github #
Instance details 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 #
Instance details Defined in Proarrow.Category.Instance.Cost Methods id :: forall (a :: COST). Ob a => GTE a a Source Github # (.) :: forall (b :: COST) (c :: COST) (a :: COST). GTE b c -> GTE a b -> GTE a c Source Github #
Promonad FinHask Source Github #
Instance details Defined in Proarrow.Category.Instance.FinHask Methods id :: forall (a :: FINHASK). Ob a => FinHask a a Source Github # (.) :: forall (b :: FINHASK) (c :: FINHASK) (a :: FINHASK). FinHask b c -> FinHask a b -> FinHask a c Source Github #
Promonad FinRel Source Github #
Instance details Defined in Proarrow.Category.Instance.FinRel Methods id :: forall (a :: FINREL). Ob a => FinRel a a Source Github # (.) :: forall (b :: FINREL) (c :: FINREL) (a :: FINREL). FinRel b c -> FinRel a b -> FinRel a c Source Github #
Promonad FinSet Source Github #
Instance details Defined in Proarrow.Category.Instance.FinSet Methods id :: forall (a :: FINSET). Ob a => FinSet a a Source Github # (.) :: forall (b :: FINSET) (c :: FINSET) (a :: FINSET). FinSet b c -> FinSet a b -> FinSet a c Source Github #
Promonad Linear Source Github #
Instance details Defined in Proarrow.Category.Instance.Linear Methods id :: forall (a :: LINEAR). Ob a => Linear a a Source Github # (.) :: forall (b :: LINEAR) (c :: LINEAR) (a :: LINEAR). Linear b c -> Linear a b -> Linear a c Source Github #
Promonad Pointed Source Github #
Instance details Defined in Proarrow.Category.Instance.PointedHask Methods id :: forall (a :: POINTED). Ob a => Pointed a a Source Github # (.) :: forall (b :: POINTED) (c :: POINTED) (a :: POINTED). Pointed b c -> Pointed a b -> Pointed a c Source Github #
Promonad Zero Source Github #
Instance details Defined in Proarrow.Category.Instance.Zero Methods id :: forall (a :: VOID). Ob a => Zero a a Source Github # (.) :: forall (b :: VOID) (c :: VOID) (a :: VOID). Zero b c -> Zero a b -> Zero a c Source Github #
Promonad Dot Source Github #
Instance details Defined in Proarrow.Tools.Diagrams.Dot Methods id :: forall (a :: DOT). Ob a => Dot a a Source Github # (.) :: forall (b :: DOT) (c :: DOT) (a :: DOT). Dot b c -> Dot a b -> Dot a c Source Github #
Promonad Unit Source Github #
Instance details Defined in Proarrow.Category.Instance.Unit Methods id :: forall (a :: ()). Ob a => Unit a a Source Github # (.) :: forall (b :: ()) (c :: ()) (a :: ()). Unit b c -> Unit a b -> Unit a c Source Github #
Promonad SymRefl Source Github #
Instance details Defined in Proarrow.Tools.Diagrams.Dot Methods id :: forall (a :: Symbol). Ob a => SymRefl a a Source Github # (.) :: forall (b :: Symbol) (c :: Symbol) (a :: Symbol). SymRefl b c -> SymRefl a b -> SymRefl a c Source Github #
Monad m => Promonad (Kleisli m :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Arrow Methods id :: Ob a => Kleisli m a a Source Github # (.) :: Kleisli m b c -> Kleisli m a b -> Kleisli m a c Source Github #
Comonoid w => Promonad (ComonoidAsCat w :: Type -> Type -> Type) Source Github #
Instance details 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 #
Instance details Defined in Proarrow.Profunctor.Instance.Arrow Methods id :: Ob a => Arr arr a a Source Github # (.) :: Arr arr b c -> Arr arr a b -> Arr arr a c Source Github #
CategoryOf k => Promonad (Id :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Identity Methods id :: forall (a :: k). Ob a => Id a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). Id b c -> Id a b -> Id a c Source Github #
Promonad (->) Source Github #
Instance details Defined in Proarrow.Core Methods id :: Ob a => a -> a Source Github # (.) :: (b -> c) -> (a -> b) -> a -> c Source Github #
Profunctor p => Promonad (FreePromonad p :: k -> k -> Type) Source Github #
Instance details 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 #
Promonad p => Promonad (Fix p :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Fix Methods id :: forall (a :: k). Ob a => Fix p a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). Fix p b c -> Fix p a b -> Fix p a c Source Github #
CategoryOf k => Promonad (TerminalProfunctor :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.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 #
Instance details Defined in Proarrow.Promonad.Cont Methods id :: forall (a :: k). Ob a => Cont r a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). Cont r b c -> Cont r a b -> Cont r a c Source Github #
(Comonoid r, Monoidal k) => Promonad (Reader ('OP r) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Reader Methods id :: forall (a :: k). Ob a => Reader ('OP r) a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). Reader ('OP r) b c -> Reader ('OP r) a b -> Reader ('OP r) a c Source Github #
(Monoid w, Monoidal k) => Promonad (Writer w :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Writer Methods id :: forall (a :: k). Ob a => Writer w a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). Writer w b c -> Writer w a b -> Writer w a c Source Github #
Adjunction p => Promonad (Adj p :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Adj Methods id :: Ob a => Adj p a a Source Github # (.) :: Adj p b c -> Adj p a b -> Adj p a c Source Github #
Promonad (Costar ((,) Int)) Source Github #
Instance details Defined in Proarrow.Profunctor.Cofree Methods id :: Ob a => Costar ((,) Int) a a Source Github # (.) :: Costar ((,) Int) b c -> Costar ((,) Int) a b -> Costar ((,) Int) a c Source Github #
Monad m => Promonad (Star (Prelude m) :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Star Methods id :: Ob a => Star (Prelude m) a a Source Github # (.) :: Star (Prelude m) b c -> Star (Prelude m) a b -> Star (Prelude m) a c Source Github #
Promonad p => Promonad (FromProfunctor p :: k -> k -> Type) Source Github #
Instance details 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 #
(HasBinaryProducts k, Ob a) => Promonad (Corep (Product a) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Limit.BinaryProduct Methods id :: forall (a0 :: k). Ob a0 => Corep (Product a) a0 a0 Source Github # (.) :: forall (b :: k) (c :: k) (a0 :: k). Corep (Product a) b c -> Corep (Product a) a0 b -> Corep (Product a) a0 c Source Github #
(Monoid c, CategoryOf k) => Promonad (HaskValue c :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.HaskValue Methods id :: forall (a :: k). Ob a => HaskValue c a a Source Github # (.) :: forall (b :: k) (c0 :: k) (a :: k). HaskValue c b c0 -> HaskValue c a b -> HaskValue c a c0 Source Github #
Promonad p => Promonad (Wrapped p :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Wrapped Methods id :: forall (a :: k). Ob a => Wrapped p a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). Wrapped p b c -> Wrapped p a b -> Wrapped p a c Source Github #
(FunctorForRep f, Promonad (Corep f)) => Promonad (RepCostar (Rep f) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Representable Methods id :: forall (a :: k). Ob a => RepCostar (Rep f) a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). RepCostar (Rep f) b c -> RepCostar (Rep f) a b -> RepCostar (Rep f) a c Source Github #
(Comonoid r, Monoidal k, Strong (Tensor :: k -> (k, k) -> Type) p, Promonad p) => Promonad (ReaderT ('OP r) p :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Reader Methods id :: forall (a :: k). Ob a => ReaderT ('OP r) p a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). ReaderT ('OP r) p b c -> ReaderT ('OP r) p a b -> ReaderT ('OP r) p a c Source Github #
(Ob s, Monoidal k, Strong (Tensor :: k -> (k, k) -> Type) p, Promonad p) => Promonad (StateT s p :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.State Methods id :: forall (a :: k). Ob a => StateT s p a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). StateT s p b c -> StateT s p a b -> StateT s p a c Source Github #
(Monoid w, Strong (Tensor :: k -> (k, k) -> Type) p, Promonad p) => Promonad (WriterT w p :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Writer Methods id :: forall (a :: k). Ob a => WriterT w p a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). WriterT w p b c -> WriterT w p a b -> WriterT w p a c Source Github #
Proadjunction p q => Promonad (q :.: p :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Adjunction Methods id :: forall (a :: k). Ob a => (q :.: p) a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). (q :.: p) b c -> (q :.: p) a b -> (q :.: p) a c Source Github #
(p ~ j, Profunctor p) => Promonad (Ran ('OP j) p :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Ran Methods id :: forall (a :: k). Ob a => Ran ('OP j) p a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). Ran ('OP j) p b c -> Ran ('OP j) p a b -> Ran ('OP j) p a c Source Github #
(p ~ j, Profunctor p) => Promonad (Rift ('OP j) p :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Rift Methods id :: forall (a :: k). Ob a => Rift ('OP j) p a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). Rift ('OP j) p b c -> Rift ('OP j) p a b -> Rift ('OP j) p a c Source Github #
HasPushouts k => Promonad (Cospan :: COSPAN k -> COSPAN k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Cospan Methods id :: forall (a :: COSPAN k). Ob a => Cospan a a Source Github # (.) :: forall (b :: COSPAN k) (c :: COSPAN k) (a :: COSPAN k). Cospan b c -> Cospan a b -> Cospan a c Source Github #
Promonad (Codiscrete :: CODISCRETE k -> CODISCRETE k -> Type) Source Github #
Instance details 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 #
Instance details Defined in Proarrow.Category.Instance.Discrete Methods id :: forall (a :: DISCRETE k). Ob a => Discrete a a Source Github # (.) :: forall (b :: DISCRETE k) (c :: DISCRETE k) (a :: DISCRETE k). Discrete b c -> Discrete a b -> Discrete a c Source Github #
CategoryOf k => Promonad (Fam :: FAM k -> FAM k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Fam Methods id :: forall (a :: FAM k). Ob a => Fam a a Source Github # (.) :: forall (b :: FAM k) (c :: FAM k) (a :: FAM k). Fam b c -> Fam a b -> Fam a c Source Github #
Promonad (LTE :: FIN n -> FIN n -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Fin Methods id :: forall (a :: FIN n). Ob a => LTE a a Source Github # (.) :: forall (b :: FIN n) (c :: FIN n) (a :: FIN n). LTE b c -> LTE a b -> LTE a c Source Github #
TracedMonoidal k => Promonad (IntConstruction :: INT k -> INT k -> Type) Source Github #
Instance details 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 #
Instance details Defined in Proarrow.Category.Instance.Mat Methods id :: forall (a0 :: MatK a). Ob a0 => Mat a0 a0 Source Github # (.) :: forall (b :: MatK a) (c :: MatK a) (a0 :: MatK a). Mat b c -> Mat a0 b -> Mat a0 c Source Github #
HasPullbacks k => Promonad (Span :: SPAN k -> SPAN k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Span Methods id :: forall (a :: SPAN k). Ob a => Span a a Source Github # (.) :: forall (b :: SPAN k) (c :: SPAN k) (a :: SPAN k). Span b c -> Span a b -> Span a c Source Github #
CategoryOf k => Promonad (Endo :: ENDO k -> ENDO k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Endo Methods id :: forall (a :: ENDO k). Ob a => Endo a a Source Github # (.) :: forall (b :: ENDO k) (c :: ENDO k) (a :: ENDO k). Endo b c -> Endo a b -> Endo a c Source Github #
Monoidal k => Promonad (Strictified :: [k] -> [k] -> Type) Source Github #
Instance details 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 c => Promonad (Op c :: OPPOSITE j -> OPPOSITE j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Opposite Methods id :: forall (a :: OPPOSITE j). Ob a => Op c a a Source Github # (.) :: forall (b :: OPPOSITE j) (c0 :: OPPOSITE j) (a :: OPPOSITE j). Op c b c0 -> Op c a b -> Op c a c0 Source Github #
Promonad p => Promonad (Rev p :: REV j -> REV j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Rev Methods id :: forall (a :: REV j). Ob a => Rev p a a Source Github # (.) :: forall (b :: REV j) (c :: REV j) (a :: REV j). Rev p b c -> Rev p a b -> Rev p a c Source Github #
Promonad p => Promonad (Coprod p :: COPROD j -> COPROD j -> Type) Source Github #
Instance details Defined in Proarrow.Colimit.BinaryCoproduct Methods id :: forall (a :: COPROD j). Ob a => Coprod p a a Source Github # (.) :: forall (b :: COPROD j) (c :: COPROD j) (a :: COPROD j). Coprod p b c -> Coprod p a b -> Coprod p a c Source Github #
Promonad p => Promonad (Prod p :: PROD j -> PROD j -> Type) Source Github #
Instance details Defined in Proarrow.Limit.BinaryProduct Methods id :: forall (a :: PROD j). Ob a => Prod p a a Source Github # (.) :: forall (b :: PROD j) (c :: PROD j) (a :: PROD j). Prod p b c -> Prod p a b -> Prod p a c Source Github #
Promonad p => Promonad (List p :: LIST j -> LIST j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.List Methods id :: forall (a :: LIST j). Ob a => List p a a Source Github # (.) :: forall (b :: LIST j) (c :: LIST j) (a :: LIST j). List p b c -> List p a b -> List p a c Source Github #
BiCCC k => Promonad (Term :: FBC p -> FBC p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.FreeBiCCC Methods id :: forall (a :: FBC p). Ob a => Term a a Source Github # (.) :: forall (b :: FBC p) (c :: FBC p) (a :: FBC p). Term b c -> Term a b -> Term a c Source Github #
Promonad p => Promonad (Kleisli :: KLEISLI p -> KLEISLI p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Kleisli Methods id :: forall (a :: KLEISLI p). Ob a => Kleisli a a Source Github # (.) :: forall (b :: KLEISLI p) (c :: KLEISLI p) (a :: KLEISLI p). Kleisli b c -> Kleisli a b -> Kleisli a c Source Github #
Promonad (Nat' :: (j .-> k) -> (j .-> k) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods id :: forall (a :: j .-> k). Ob a => Nat' a a Source Github # (.) :: forall (b :: j .-> k) (c :: j .-> k) (a :: j .-> k). Nat' b c -> Nat' a b -> Nat' a c Source Github #
Promonad (Prof :: (j +-> k) -> (j +-> k) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Prof Methods id :: forall (a :: j +-> k). Ob a => Prof a a Source Github # (.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Prof b c -> Prof a b -> Prof a c Source Github #
Promonad (Nat :: (j -> Type) -> (j -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods id :: forall (a :: j -> Type). Ob a => Nat a a Source Github # (.) :: forall (b :: j -> Type) (c :: j -> Type) (a :: j -> Type). Nat b c -> Nat a b -> Nat a c Source Github #
Promonad (Nat :: (k1 -> k2 -> k3 -> k4 -> Type) -> (k1 -> k2 -> k3 -> k4 -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods id :: forall (a :: k1 -> k2 -> k3 -> k4 -> Type). Ob a => Nat a a Source Github # (.) :: forall (b :: k1 -> k2 -> k3 -> k4 -> Type) (c :: k1 -> k2 -> k3 -> k4 -> Type) (a :: k1 -> k2 -> k3 -> k4 -> Type). Nat b c -> Nat a b -> Nat a c Source Github #
Promonad (Nat :: (k1 -> k2 -> k3 -> Type) -> (k1 -> k2 -> k3 -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods id :: forall (a :: k1 -> k2 -> k3 -> Type). Ob a => Nat a a Source Github # (.) :: forall (b :: k1 -> k2 -> k3 -> Type) (c :: k1 -> k2 -> k3 -> Type) (a :: k1 -> k2 -> k3 -> Type). Nat b c -> Nat a b -> Nat a c Source Github #
Promonad p => Promonad (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Sub Methods id :: forall (a :: SUBCAT ob). Ob a => Sub p a a Source Github # (.) :: forall (b :: SUBCAT ob) (c :: SUBCAT ob) (a :: SUBCAT ob). Sub p b c -> Sub p a b -> Sub p a c Source Github #
Promonad (Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.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 #
ClosedUnder w => Promonad (Costar (Tambara w) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.PastroTambara Methods id :: forall (a :: j +-> k). Ob a => Costar (Tambara w) a a Source Github # (.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Costar (Tambara w) b c -> Costar (Tambara w) a b -> Costar (Tambara w) a c Source Github #
Profunctor p => Promonad (Costar ((:*:) p) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Costar Methods id :: forall (a :: j +-> k). Ob a => Costar ((::) p) a a Source Github # (.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Costar ((::) p) b c -> Costar ((::) p) a b -> Costar ((::) p) a c Source Github #
Promonad (Costar (Yoneda :: (j +-> k) -> k -> j -> Type) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.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 #
ClosedUnder w => Promonad (Star (Pastro w) :: (k -> j -> Type) -> (j +-> k) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.PastroTambara Methods id :: forall (a :: j +-> k). Ob a => Star (Pastro w) a a Source Github # (.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Star (Pastro w) b c -> Star (Pastro w) a b -> Star (Pastro w) 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 `p ~> ReaderT p` and `ReaderT (ReaderT p) ~> ReaderT p`.
Instance details Defined in Proarrow.Promonad.Reader Methods id :: forall (a :: k +-> k). Ob a => Star (ReaderT ('OP r)) a a Source Github # (.) :: forall (b :: k +-> k) (c :: k +-> k) (a :: k +-> k). Star (ReaderT ('OP r)) b c -> Star (ReaderT ('OP r)) a b -> Star (ReaderT ('OP r)) a c Source Github #
(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 `p ~> WriterT p` and `WriterT (WriterT p) ~> WriterT p`.
Instance details Defined in Proarrow.Promonad.Writer Methods id :: forall (a :: k +-> k). Ob a => Star (WriterT w) a a Source Github # (.) :: forall (b :: k +-> k) (c :: k +-> k) (a :: k +-> k). Star (WriterT w) b c -> Star (WriterT w) a b -> Star (WriterT w) a c Source Github #
Procomonad j => Promonad (Star (Ran ('OP j) :: (i +-> k) -> k -> i -> Type) :: (k -> i -> Type) -> (i +-> k) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.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 #
Instance details Defined in Proarrow.Profunctor.Instance.Star Methods id :: forall (a :: k -> j -> Type). Ob a => Star ((:+:) p) a a Source Github # (.) :: forall (b :: k -> j -> Type) (c :: k -> j -> Type) (a :: k -> j -> Type). Star ((:+:) p) b c -> Star ((:+:) p) a b -> Star ((:+:) p) a c Source Github #
Promonad (Star (Coyoneda :: (j +-> k) -> k -> j -> Type) :: (k -> j -> Type) -> (j +-> k) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.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 #
Instance details Defined in Proarrow.Profunctor.Instance.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 #
Instance details Defined in Proarrow.Profunctor.Instance.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 #
Instance details 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 #
Instance details 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 #
Instance details Defined in Proarrow.Category.Instance.Ap Methods id :: forall (a :: AP f k). Ob a => Ap p a a Source Github # (.) :: forall (b :: AP f k) (c :: AP f k) (a :: AP f k). Ap p b c -> Ap p a b -> Ap p a c Source Github #
Monoid m => Promonad (Mon :: MONOIDK m -> MONOIDK m -> Type) Source Github #
Instance details Defined in Proarrow.Monoid Methods id :: forall (a :: MONOIDK m). Ob a => Mon a a Source Github # (.) :: forall (b :: MONOIDK m) (c :: MONOIDK m) (a :: MONOIDK m). Mon b c -> Mon a b -> Mon a c Source Github #
(Promonad p, Promonad q) => Promonad (p :++: q :: COPRODUCT j1 j2 -> COPRODUCT j1 j2 -> Type) Source Github #	The coproduct of two promonads.
Instance details Defined in Proarrow.Category.Instance.Coproduct Methods id :: forall (a :: COPRODUCT j1 j2). Ob a => (p :++: q) a a Source Github # (.) :: forall (b :: COPRODUCT j1 j2) (c :: COPRODUCT j1 j2) (a :: COPRODUCT j1 j2). (p :++: q) b c -> (p :++: q) a b -> (p :++: q) a c Source Github #
(Promonad p, Promonad q) => Promonad (p :**: q :: (j1, j2) -> (j1, j2) -> Type) Source Github #	The product promonad of promonads `p` and `q`.
Instance details Defined in Proarrow.Category.Instance.Product Methods id :: forall (a :: (j1, j2)). Ob a => (p :: q) a a Source Github # (.) :: forall (b :: (j1, j2)) (c :: (j1, j2)) (a :: (j1, j2)). (p :: q) b c -> (p :: q) a b -> (p :: q) a c Source Github #
Profunctor p => Promonad (Collage :: COLLAGE p -> COLLAGE p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Collage Methods id :: forall (a :: COLLAGE p). Ob a => Collage a a Source Github # (.) :: forall (b :: COLLAGE p) (c :: COLLAGE p) (a :: COLLAGE p). Collage b c -> Collage a b -> Collage a c 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!
Instance details Defined in Proarrow.Category.Instance.Duploid Methods id :: forall (a :: DUPLOID adj). Ob a => Duploid a a Source Github # (.) :: forall (b :: DUPLOID adj) (c :: DUPLOID adj) (a :: DUPLOID adj). Duploid b c -> Duploid a b -> Duploid a c Source Github #
Promonad (Free :: FREE cs p -> FREE cs p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Free Methods id :: forall (a :: FREE cs p). Ob a => Free a a Source Github # (.) :: forall (b :: FREE cs p) (c :: FREE cs p) (a :: FREE cs p). Free b c -> Free a b -> Free a c Source Github #
ThinProfunctor p => Promonad (Graph :: GRAPH p -> GRAPH p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Graph Methods id :: forall (a :: GRAPH p). Ob a => Graph a a Source Github # (.) :: forall (b :: GRAPH p) (c :: GRAPH p) (a :: GRAPH p). Graph b c -> Graph a b -> Graph a c Source Github #
(CategoryOf j, CategoryOf k) => Promonad (Optic_ :: OPTIC j k c -> OPTIC j k c -> Type) Source Github #
Instance details Defined in Proarrow.Optic Methods id :: forall (a :: OPTIC j k c). Ob a => Optic_ a a Source Github # (.) :: forall (b :: OPTIC j k c) (c0 :: OPTIC j k c) (a :: OPTIC j k c). Optic_ b c0 -> Optic_ a b -> Optic_ a c0 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

type Obj (a :: k) = a ~> a Source Github #

Type of identity morphism for object a.

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 where ... Source Github #

A helper type family to unwrap a wrapped kind w x.

Equations

UN (w :: j -> k) (w x :: k) = x

type Is (w :: j -> k) (a :: k) = a ~ w (UN w a) Source Github #

Is w a checks that the kind a is a kind wrapped by w.

type WrappedOb (w :: j -> k) (a :: k) = (Is w a, Ob (UN w a)) Source Github #

WrappedOb w a asserts both that a is wrapped by w (Is w a) and that its unwrapped kind satisfies Ob.