Safe Haskell	None
Language	GHC2024

Proarrow.Core

Contents

Type Infrastructure
- Basic Type Definitions
Category Infrastructure
- CategoryOf Class
Profunctors
Promonads
- Promonad Class
- Promonad Utilities
Object Identities
Universal Constraint
Lifted Type Classes
Constraint Continuations
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 defines the design, and is 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
class (c1 p, c2 p) => ((c1 :: OB k) :&&: (c2 :: OB k)) (p :: k)
type Kind = Type
class Promonad ((~>) :: CAT k) => CategoryOf k where
- type (~>) :: CAT k
- type Ob (a :: k)
type Hom k = (~>) :: CAT k
class (Ob a, CategoryOf k) => Ob' (a :: k)
class CategoryOf k => ObId (a :: k) where
- objId :: a ~> a
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 :: CAT 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
class Any (a :: k)
class (CategoryOf k, forall (a :: k). Ob' a) => VacuousOb k
class (forall (x :: k) (y :: k1). Eq (p x y)) => Eq2 (p :: k -> k1 -> Type)
class (forall (x :: k) (y :: k1). Show (p x y)) => Show2 (p :: k -> k1 -> Type)
($) :: ((c => r) -> r) -> (c => r) -> r
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. 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.

class (c1 p, c2 p) => ((c1 :: OB k) :&&: (c2 :: OB k)) (p :: k) Source Github #

The conjunction of two constraints on a common argument, as one constraint.

Instances

Instances details

(c1 p, c2 p) => ((c1 :: k -> Constraint) :&&: (c2 :: k -> Constraint)) (p :: k) Source Github #
Instance details Defined in Proarrow.Core

type Kind = Type Source Github #

Alias for Type for clarity in kind signatures.

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. Defaults to ObId, which suits a category with more than one object. A category where every type of the kind is an object, with no evidence needed, says type Ob a = Any a instead.

type Ob (a :: k) = ObId 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 PREPARED Source Github #

Instance details

Defined in Proarrow.Category.Instance.Circuit

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Circuit type (~>) = Prepared
type Ob (a :: PREPARED)
Instance details Defined in Proarrow.Category.Instance.Circuit type Ob (a :: PREPARED) = (Is 'Ready a, KnownWires (UN 'Ready a))

CategoryOf Wires Source Github #

Instance details

Defined in Proarrow.Category.Instance.Circuit

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Circuit type (~>) = Circuit
type Ob (a :: Wires)
Instance details Defined in Proarrow.Category.Instance.Circuit type Ob (a :: Wires) = KnownWires a

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 DIFF Source Github #

Differentiable maps between products of real vector spaces.

Instance details

Defined in Proarrow.Category.Instance.Diff

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Diff type (~>) = Diff
type Ob (a :: DIFF)
Instance details Defined in Proarrow.Category.Instance.Diff type Ob (a :: DIFF) = (Is 'DF a, KnownListOf KnownNat (UN 'DF 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 SIMULATOR Source Github #

Instance details

Defined in Proarrow.Category.Instance.Simulator

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Simulator type (~>) = Simulator
type Ob (a :: SIMULATOR)
Instance details Defined in Proarrow.Category.Instance.Simulator type Ob (a :: SIMULATOR) = Is 'Sim 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 SVG Source Github #

The category string diagrams are drawn in: an object S ws is the list of wires along a boundary.

Instance details

Defined in Proarrow.Tools.Diagrams.Svg

Associated Types

type (~>)
Instance details Defined in Proarrow.Tools.Diagrams.Svg type (~>) = Svg
type Ob (a :: SVG)
Instance details Defined in Proarrow.Tools.Diagrams.Svg type Ob (a :: SVG) = (Is 'S a, IsList (UN 'S a))

CategoryOf W Source Github #

The discrete category on wires, so that lists of wires are objects of Strictified.

Instance details

Defined in Proarrow.Tools.Diagrams.Svg

Associated Types

type (~>)
Instance details Defined in Proarrow.Tools.Diagrams.Svg type (~>) = WireId
type Ob (w :: W)
Instance details Defined in Proarrow.Tools.Diagrams.Svg type Ob (w :: W) = KnownWire w

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

Indexed k => CategoryOf (CODISCRETE k) Source Github #

The codiscrete category has exactly one arrow between any two objects, the numbered inhabitants of k. The numbering makes it enumerable, so its closure can be computed.

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

Indexed k => CategoryOf (DISCRETE k) Source Github #

The discrete category with only identity arrows on the numbered inhabitants of k.

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

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)

CategoryOf (ORDINAL 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.Ordinal

Associated Types

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

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

Scalar e => CategoryOf (TNET e) Source Github #

Tensor networks with entries e, between lists of dimensions.

Instance details

Defined in Proarrow.Category.Instance.TensorNetwork

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.TensorNetwork type (~>) = TensorNetwork :: TNET e -> TNET e -> 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.EndoProf

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Monoidal.EndoProf 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

(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)

CategoryOf k => CategoryOf (CPS r) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Cps

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Cps type (~>) = Cps :: CPS r -> CPS r -> Type

(HasPushouts k, Alternative f) => CategoryOf (DECCOSPAN f) Source Github #

The category of decorated cospans in k: an arrow DC a ~> DC b is a pair of arrows a ~> x and b ~> x into a common object, with a decoration of x.

Instance details

Defined in Proarrow.Category.Instance.DecoratedCospan

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.DecoratedCospan type (~>) = DecCospan :: DECCOSPAN f -> DECCOSPAN f -> 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

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

A monoid as a one object category.

Instance details

Defined in Proarrow.Category.Instance.Monoid

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Monoid type (~>) = Mon :: MONOID m -> MONOID m -> 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, Rewrite p) => CategoryOf (PATHS p) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Paths

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Paths type (~>) = Paths :: PATHS p -> PATHS p -> 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

(InternalIn ik FINSET, SNatI (NumObs ik)) => CategoryOf (INTERNAL ik) Source Github #

Instance details

Defined in Proarrow.Category.Internal

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Internal type (~>) = Internal :: INTERNAL ik -> INTERNAL ik -> 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

(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. 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. An object is a shape (IsFreeOb).

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.

class (Ob a, CategoryOf k) => Ob' (a :: k) Source Github #

Ob as a proper class, for the positions where the type family Ob itself cannot appear, such as the head of a quantified constraint.

Instances

Instances details

(Ob a, CategoryOf k) => Ob' (a :: k) Source Github #
Instance details Defined in Proarrow.Core

class CategoryOf k => ObId (a :: k) where Source Github #

Objecthood that carries the object's own identity arrow, and the default for Ob.

A category with more than one object needs this. id must produce the identity at whichever object it is asked for, so it has to dispatch on the object, and one instance per object does that dispatch. Since Ob defaults to ObId and id defaults to objId, such a category defines neither. It just gives an ObId instance per object:

type data STATE = Draft | Live

type Move :: CAT STATE
data Move a b where
  KeepDraft :: Move Draft Draft
  Publish :: Move Draft Live
  KeepLive :: Move Live Live

instance ObId Draft where objId = KeepDraft
instance ObId Live where objId = KeepLive

instance CategoryOf STATE where
  type (~>) = Move

Methods

objId :: a ~> a Source Github #

The identity arrow at a.

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 Prepared Source Github #
Instance details Defined in Proarrow.Category.Instance.Circuit Methods dimap :: forall (c :: PREPARED) (a :: PREPARED) (b :: PREPARED) (d :: PREPARED). (c ~> a) -> (b ~> d) -> Prepared a b -> Prepared c d Source Github # lmap :: forall (c :: PREPARED) (a :: PREPARED) (b :: PREPARED). (c ~> a) -> Prepared a b -> Prepared c b Source Github # rmap :: forall (b :: PREPARED) (d :: PREPARED) (a :: PREPARED). (b ~> d) -> Prepared a b -> Prepared a d Source Github # (\\) :: forall (a :: PREPARED) (b :: PREPARED) r. ((Ob a, Ob b) => r) -> Prepared a b -> r Source Github #
Profunctor Circuit Source Github #
Instance details Defined in Proarrow.Category.Instance.Circuit Methods dimap :: forall (c :: Wires) (a :: Wires) (b :: Wires) (d :: Wires). (c ~> a) -> (b ~> d) -> Circuit a b -> Circuit c d Source Github # lmap :: forall (c :: Wires) (a :: Wires) (b :: Wires). (c ~> a) -> Circuit a b -> Circuit c b Source Github # rmap :: forall (b :: Wires) (d :: Wires) (a :: Wires). (b ~> d) -> Circuit a b -> Circuit a d Source Github # (\\) :: forall (a :: Wires) (b :: Wires) r. ((Ob a, Ob b) => r) -> Circuit 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 Diff Source Github #
Instance details Defined in Proarrow.Category.Instance.Diff Methods dimap :: forall (c :: DIFF) (a :: DIFF) (b :: DIFF) (d :: DIFF). (c ~> a) -> (b ~> d) -> Diff a b -> Diff c d Source Github # lmap :: forall (c :: DIFF) (a :: DIFF) (b :: DIFF). (c ~> a) -> Diff a b -> Diff c b Source Github # rmap :: forall (b :: DIFF) (d :: DIFF) (a :: DIFF). (b ~> d) -> Diff a b -> Diff a d Source Github # (\\) :: forall (a :: DIFF) (b :: DIFF) r. ((Ob a, Ob b) => r) -> Diff 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 Simulator Source Github #
Instance details Defined in Proarrow.Category.Instance.Simulator Methods dimap :: forall (c :: SIMULATOR) (a :: SIMULATOR) (b :: SIMULATOR) (d :: SIMULATOR). (c ~> a) -> (b ~> d) -> Simulator a b -> Simulator c d Source Github # lmap :: forall (c :: SIMULATOR) (a :: SIMULATOR) (b :: SIMULATOR). (c ~> a) -> Simulator a b -> Simulator c b Source Github # rmap :: forall (b :: SIMULATOR) (d :: SIMULATOR) (a :: SIMULATOR). (b ~> d) -> Simulator a b -> Simulator a d Source Github # (\\) :: forall (a :: SIMULATOR) (b :: SIMULATOR) r. ((Ob a, Ob b) => r) -> Simulator 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 Svg Source Github #
Instance details Defined in Proarrow.Tools.Diagrams.Svg Methods dimap :: forall (c :: SVG) (a :: SVG) (b :: SVG) (d :: SVG). (c ~> a) -> (b ~> d) -> Svg a b -> Svg c d Source Github # lmap :: forall (c :: SVG) (a :: SVG) (b :: SVG). (c ~> a) -> Svg a b -> Svg c b Source Github # rmap :: forall (b :: SVG) (d :: SVG) (a :: SVG). (b ~> d) -> Svg a b -> Svg a d Source Github # (\\) :: forall (a :: SVG) (b :: SVG) r. ((Ob a, Ob b) => r) -> Svg a b -> r Source Github #
Profunctor WireId Source Github #
Instance details Defined in Proarrow.Tools.Diagrams.Svg Methods dimap :: forall (c :: W) (a :: W) (b :: W) (d :: W). (c ~> a) -> (b ~> d) -> WireId a b -> WireId c d Source Github # lmap :: forall (c :: W) (a :: W) (b :: W). (c ~> a) -> WireId a b -> WireId c b Source Github # rmap :: forall (b :: W) (d :: W) (a :: W). (b ~> d) -> WireId a b -> WireId a d Source Github # (\\) :: forall (a :: W) (b :: W) r. ((Ob a, Ob b) => r) -> WireId 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 #
(VacuousOb k, Hom k ~ ((:~:) :: k -> k -> Type)) => Profunctor ((:~:) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Core Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> (a :~: b) -> c :~: d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> (a :~: b) -> c :~: b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> (a :~: b) -> a :~: d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> (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 (Sieve :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Sieve Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Sieve a b -> Sieve c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Sieve a b -> Sieve c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Sieve a b -> Sieve a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Sieve 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 #
(Monoidal k, SNatI n) => Profunctor (CoPow n :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.PowerGrate 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, SNatI n) => Profunctor (Pow n :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.PowerGrate 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 #
CategoryOf k => Profunctor (Cont r :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Cont Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Cont r a b -> Cont r c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Cont r a b -> Cont r c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Cont r a b -> Cont r a d Source Github # (\\) :: forall (a :: k) (b :: k) r0. ((Ob a, Ob b) => r0) -> Cont r a b -> r0 Source Github #
(Ob r, Monoidal k) => Profunctor (Reader ('OP r) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Reader Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Reader ('OP r) a b -> Reader ('OP r) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Reader ('OP r) a b -> Reader ('OP r) c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Reader ('OP r) a b -> Reader ('OP r) a d Source Github # (\\) :: forall (a :: k) (b :: k) r0. ((Ob a, Ob b) => r0) -> Reader ('OP r) a b -> r0 Source Github #
(Ob w, Monoidal k) => Profunctor (Writer w :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Writer Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Writer w a b -> Writer w c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Writer w a b -> Writer w c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Writer w a b -> Writer w a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> Writer w a b -> r Source Github #
(CategoryOf k, Profunctor dx) => Profunctor (AsPresheaf dx :: k -> () -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Fam Methods dimap :: forall (c :: k) (a :: k) (b :: ()) (d :: ()). (c ~> a) -> (b ~> d) -> AsPresheaf dx a b -> AsPresheaf dx c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: ()). (c ~> a) -> AsPresheaf dx a b -> AsPresheaf dx c b Source Github # rmap :: forall (b :: ()) (d :: ()) (a :: k). (b ~> d) -> AsPresheaf dx a b -> AsPresheaf dx a d Source Github # (\\) :: forall (a :: k) (b :: ()) r. ((Ob a, Ob b) => r) -> AsPresheaf dx a b -> r Source Github #
Profunctor p => Profunctor (Walk n p :: j -> j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin.Composition Methods dimap :: forall (c :: j) (a :: j) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Walk n p a b -> Walk n p c d Source Github # lmap :: forall (c :: j) (a :: j) (b :: j). (c ~> a) -> Walk n p a b -> Walk n p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: j). (b ~> d) -> Walk n p a b -> Walk n p a d Source Github # (\\) :: forall (a :: j) (b :: j) r. ((Ob a, Ob b) => r) -> Walk n p a b -> r Source Github #
(CategoryOf j, CategoryOf k) => Profunctor (ClosedSieve t :: k -> j -> Type) Source Github #	Closure commutes with `dimap` (the Lawvere–Tierney axiom that `lawvereTierney` packages as an arrow on `Omega`), so a restriction of a closed sieve is closed.
Instance details Defined in Proarrow.Category.Enriched.Finitary.Sheaf Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> ClosedSieve t a b -> ClosedSieve t c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> ClosedSieve t a b -> ClosedSieve t c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> ClosedSieve t a b -> ClosedSieve t a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> ClosedSieve t 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 #
Profunctor r => Profunctor (CotravAs r :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> CotravAs r a b -> CotravAs r c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> CotravAs r a b -> CotravAs r c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> CotravAs r a b -> CotravAs r a d Source Github # (\\) :: forall (a :: k) (b :: j) r0. ((Ob a, Ob b) => r0) -> CotravAs r a b -> r0 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 m => Profunctor (AsRelative m :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Promonad Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> AsRelative m a b -> AsRelative m c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> AsRelative m a b -> AsRelative m c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> AsRelative m a b -> AsRelative m a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> AsRelative m 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 #
(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 #
(CategoryOf j, CategoryOf k) => Profunctor (Plus t p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Finitary.Sheaf Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Plus t p a b -> Plus t p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Plus t p a b -> Plus t p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Plus t p a b -> Plus t p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Plus t 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 p => Profunctor (Reindex r p fs :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Finitary.Topos Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Reindex r p fs a b -> Reindex r p fs c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Reindex r p fs a b -> Reindex r p fs c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Reindex r p fs a b -> Reindex r p fs a d Source Github # (\\) :: forall (a :: k) (b :: j) r0. ((Ob a, Ob b) => r0) -> Reindex r p fs a b -> r0 Source Github #
(FiniteCat j, FiniteCat k, KnownTables j k lm rm) => Profunctor (Tabulated t lm rm :: k -> j -> Type) Source Github #	`lmap` reads the arrow's row in the `lm` cell at the value's index; `rmap` then reads the `rm` cell at the new source object.
Instance details Defined in Proarrow.Category.Enriched.Finitary.Topos Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Tabulated t lm rm a b -> Tabulated t lm rm c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Tabulated t lm rm a b -> Tabulated t lm rm c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Tabulated t lm rm a b -> Tabulated t lm rm a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Tabulated t lm rm a b -> 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 #
(Profunctor w, CategoryOf j) => Profunctor (RiftWeight w a b :: k2 -> j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Finitary.Topos Methods dimap :: forall (c :: k2) (a0 :: k2) (b0 :: j) (d :: j). (c ~> a0) -> (b0 ~> d) -> RiftWeight w a b a0 b0 -> RiftWeight w a b c d Source Github # lmap :: forall (c :: k2) (a0 :: k2) (b0 :: j). (c ~> a0) -> RiftWeight w a b a0 b0 -> RiftWeight w a b c b0 Source Github # rmap :: forall (b0 :: j) (d :: j) (a0 :: k2). (b0 ~> d) -> RiftWeight w a b a0 b0 -> RiftWeight w a b a0 d Source Github # (\\) :: forall (a0 :: k2) (b0 :: j) r. ((Ob a0, Ob b0) => r) -> RiftWeight w a b a0 b0 -> 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 #
Indexed k => 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 #
Indexed k => 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 #
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 #
Profunctor (LTE :: ORDINAL n -> ORDINAL n -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Ordinal Methods dimap :: forall (c :: ORDINAL n) (a :: ORDINAL n) (b :: ORDINAL n) (d :: ORDINAL n). (c ~> a) -> (b ~> d) -> LTE a b -> LTE c d Source Github # lmap :: forall (c :: ORDINAL n) (a :: ORDINAL n) (b :: ORDINAL n). (c ~> a) -> LTE a b -> LTE c b Source Github # rmap :: forall (b :: ORDINAL n) (d :: ORDINAL n) (a :: ORDINAL n). (b ~> d) -> LTE a b -> LTE a d Source Github # (\\) :: forall (a :: ORDINAL n) (b :: ORDINAL n) r. ((Ob a, Ob b) => r) -> LTE a 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 #
Scalar e => Profunctor (TensorNetwork :: TNET e -> TNET e -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.TensorNetwork Methods dimap :: forall (c :: TNET e) (a :: TNET e) (b :: TNET e) (d :: TNET e). (c ~> a) -> (b ~> d) -> TensorNetwork a b -> TensorNetwork c d Source Github # lmap :: forall (c :: TNET e) (a :: TNET e) (b :: TNET e). (c ~> a) -> TensorNetwork a b -> TensorNetwork c b Source Github # rmap :: forall (b :: TNET e) (d :: TNET e) (a :: TNET e). (b ~> d) -> TensorNetwork a b -> TensorNetwork a d Source Github # (\\) :: forall (a :: TNET e) (b :: TNET e) r. ((Ob a, Ob b) => r) -> TensorNetwork a b -> r Source Github #
CategoryOf k => Profunctor (Endo :: ENDO k -> ENDO k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.EndoProf 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 #
Indexed k => Profunctor (Edges es :: DISCRETE k -> DISCRETE k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Edges Methods dimap :: forall (c :: DISCRETE k) (a :: DISCRETE k) (b :: DISCRETE k) (d :: DISCRETE k). (c ~> a) -> (b ~> d) -> Edges es a b -> Edges es c d Source Github # lmap :: forall (c :: DISCRETE k) (a :: DISCRETE k) (b :: DISCRETE k). (c ~> a) -> Edges es a b -> Edges es c b Source Github # rmap :: forall (b :: DISCRETE k) (d :: DISCRETE k) (a :: DISCRETE k). (b ~> d) -> Edges es a b -> Edges es a d Source Github # (\\) :: forall (a :: DISCRETE k) (b :: DISCRETE k) r. ((Ob a, Ob b) => r) -> Edges es 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 #
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 #
CategoryOf k => Profunctor (Cps :: CPS r -> CPS r -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Cps Methods dimap :: forall (c :: CPS r) (a :: CPS r) (b :: CPS r) (d :: CPS r). (c ~> a) -> (b ~> d) -> Cps a b -> Cps c d Source Github # lmap :: forall (c :: CPS r) (a :: CPS r) (b :: CPS r). (c ~> a) -> Cps a b -> Cps c b Source Github # rmap :: forall (b :: CPS r) (d :: CPS r) (a :: CPS r). (b ~> d) -> Cps a b -> Cps a d Source Github # (\\) :: forall (a :: CPS r) (b :: CPS r) r0. ((Ob a, Ob b) => r0) -> Cps a b -> r0 Source Github #
(HasPushouts k, Alternative f) => Profunctor (DecCospan :: DECCOSPAN f -> DECCOSPAN f -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.DecoratedCospan Methods dimap :: forall (c :: DECCOSPAN f) (a :: DECCOSPAN f) (b :: DECCOSPAN f) (d :: DECCOSPAN f). (c ~> a) -> (b ~> d) -> DecCospan a b -> DecCospan c d Source Github # lmap :: forall (c :: DECCOSPAN f) (a :: DECCOSPAN f) (b :: DECCOSPAN f). (c ~> a) -> DecCospan a b -> DecCospan c b Source Github # rmap :: forall (b :: DECCOSPAN f) (d :: DECCOSPAN f) (a :: DECCOSPAN f). (b ~> d) -> DecCospan a b -> DecCospan a d Source Github # (\\) :: forall (a :: DECCOSPAN f) (b :: DECCOSPAN f) r. ((Ob a, Ob b) => r) -> DecCospan 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 #
(CategoryOf k, Rewrite p) => Profunctor (Paths :: PATHS p -> PATHS p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Paths Methods dimap :: forall (c :: PATHS p) (a :: PATHS p) (b :: PATHS p) (d :: PATHS p). (c ~> a) -> (b ~> d) -> Paths a b -> Paths c d Source Github # lmap :: forall (c :: PATHS p) (a :: PATHS p) (b :: PATHS p). (c ~> a) -> Paths a b -> Paths c b Source Github # rmap :: forall (b :: PATHS p) (d :: PATHS p) (a :: PATHS p). (b ~> d) -> Paths a b -> Paths a d Source Github # (\\) :: forall (a :: PATHS p) (b :: PATHS p) r. ((Ob a, Ob b) => r) -> Paths a b -> r Source Github #
(InternalIn ik FINSET, SNatI (NumObs ik)) => Profunctor (Internal :: INTERNAL ik -> INTERNAL ik -> Type) Source Github #
Instance details Defined in Proarrow.Category.Internal Methods dimap :: forall (c :: INTERNAL ik) (a :: INTERNAL ik) (b :: INTERNAL ik) (d :: INTERNAL ik). (c ~> a) -> (b ~> d) -> Internal a b -> Internal c d Source Github # lmap :: forall (c :: INTERNAL ik) (a :: INTERNAL ik) (b :: INTERNAL ik). (c ~> a) -> Internal a b -> Internal c b Source Github # rmap :: forall (b :: INTERNAL ik) (d :: INTERNAL ik) (a :: INTERNAL ik). (b ~> d) -> Internal a b -> Internal a d Source Github # (\\) :: forall (a :: INTERNAL ik) (b :: INTERNAL ik) r. ((Ob a, Ob b) => r) -> Internal 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 #
Monoid m => Profunctor (Mon :: MONOID m -> MONOID m -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Monoid Methods dimap :: forall (c :: MONOID m) (a :: MONOID m) (b :: MONOID m) (d :: MONOID m). (c ~> a) -> (b ~> d) -> Mon a b -> Mon c d Source Github # lmap :: forall (c :: MONOID m) (a :: MONOID m) (b :: MONOID m). (c ~> a) -> Mon a b -> Mon c b Source Github # rmap :: forall (b :: MONOID m) (d :: MONOID m) (a :: MONOID m). (b ~> d) -> Mon a b -> Mon a d Source Github # (\\) :: forall (a :: MONOID m) (b :: MONOID m) r. ((Ob a, Ob b) => r) -> Mon 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 #
(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 :: CAT 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)

Minimal complete definition

(.)

Methods

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

Identity morphisms.

Defaults to objId for a category's own hom-profunctor, so a category that leaves Ob at its ObId default gets id for free.

default id :: forall (a :: k). (ObId a, p ~ ((~>) :: CAT k)) => p a a Source Github #

(.) :: 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 Prepared Source Github #
Instance details Defined in Proarrow.Category.Instance.Circuit Methods id :: forall (a :: PREPARED). Ob a => Prepared a a Source Github # (.) :: forall (b :: PREPARED) (c :: PREPARED) (a :: PREPARED). Prepared b c -> Prepared a b -> Prepared a c Source Github #
Promonad Circuit Source Github #
Instance details Defined in Proarrow.Category.Instance.Circuit Methods id :: forall (a :: Wires). Ob a => Circuit a a Source Github # (.) :: forall (b :: Wires) (c :: Wires) (a :: Wires). Circuit b c -> Circuit a b -> Circuit 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 Diff Source Github #
Instance details Defined in Proarrow.Category.Instance.Diff Methods id :: forall (a :: DIFF). Ob a => Diff a a Source Github # (.) :: forall (b :: DIFF) (c :: DIFF) (a :: DIFF). Diff b c -> Diff a b -> Diff 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 Simulator Source Github #
Instance details Defined in Proarrow.Category.Instance.Simulator Methods id :: forall (a :: SIMULATOR). Ob a => Simulator a a Source Github # (.) :: forall (b :: SIMULATOR) (c :: SIMULATOR) (a :: SIMULATOR). Simulator b c -> Simulator a b -> Simulator 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 Svg Source Github #
Instance details Defined in Proarrow.Tools.Diagrams.Svg Methods id :: forall (a :: SVG). Ob a => Svg a a Source Github # (.) :: forall (b :: SVG) (c :: SVG) (a :: SVG). Svg b c -> Svg a b -> Svg a c Source Github #
Promonad WireId Source Github #
Instance details Defined in Proarrow.Tools.Diagrams.Svg Methods id :: forall (a :: W). Ob a => WireId a a Source Github # (.) :: forall (b :: W) (c :: W) (a :: W). WireId b c -> WireId a b -> WireId 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 #
(VacuousOb k, Hom k ~ ((:~:) :: k -> k -> Type)) => Promonad ((:~:) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Core Methods id :: forall (a :: k). Ob a => a :~: a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). (b :~: c) -> (a :~: b) -> 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 #
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 (Star []) Source Github #	The list monad without the `Prelude` wrapper, so that a Kleisli arrow of `[]` reads as the plain `a -> [b]`.
Instance details Defined in Proarrow.Profunctor.Instance.Star Methods id :: Ob a => Star [] a a Source Github # (.) :: Star [] b c -> Star [] a b -> Star [] 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 #
Promonad m => Promonad (AsRelative m :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad Methods id :: forall (a :: k). Ob a => AsRelative m a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). AsRelative m b c -> AsRelative m a b -> AsRelative m 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 #
Indexed k => 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 #
Indexed k => 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 #
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 #
Promonad (LTE :: ORDINAL n -> ORDINAL n -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Ordinal Methods id :: forall (a :: ORDINAL n). Ob a => LTE a a Source Github # (.) :: forall (b :: ORDINAL n) (c :: ORDINAL n) (a :: ORDINAL n). LTE b c -> LTE a b -> LTE a 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 #
Scalar e => Promonad (TensorNetwork :: TNET e -> TNET e -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.TensorNetwork Methods id :: forall (a :: TNET e). Ob a => TensorNetwork a a Source Github # (.) :: forall (b :: TNET e) (c :: TNET e) (a :: TNET e). TensorNetwork b c -> TensorNetwork a b -> TensorNetwork a c Source Github #
CategoryOf k => Promonad (Endo :: ENDO k -> ENDO k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.EndoProf 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 #
CategoryOf k => Promonad (Cps :: CPS r -> CPS r -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Cps Methods id :: forall (a :: CPS r). Ob a => Cps a a Source Github # (.) :: forall (b :: CPS r) (c :: CPS r) (a :: CPS r). Cps b c -> Cps a b -> Cps a c Source Github #
(HasPushouts k, Alternative f) => Promonad (DecCospan :: DECCOSPAN f -> DECCOSPAN f -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.DecoratedCospan Methods id :: forall (a :: DECCOSPAN f). Ob a => DecCospan a a Source Github # (.) :: forall (b :: DECCOSPAN f) (c :: DECCOSPAN f) (a :: DECCOSPAN f). DecCospan b c -> DecCospan a b -> DecCospan 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 #
(CategoryOf k, Rewrite p) => Promonad (Paths :: PATHS p -> PATHS p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Paths Methods id :: forall (a :: PATHS p). Ob a => Paths a a Source Github # (.) :: forall (b :: PATHS p) (c :: PATHS p) (a :: PATHS p). Paths b c -> Paths a b -> Paths a c Source Github #
(InternalIn ik FINSET, SNatI (NumObs ik)) => Promonad (Internal :: INTERNAL ik -> INTERNAL ik -> Type) Source Github #
Instance details Defined in Proarrow.Category.Internal Methods id :: forall (a :: INTERNAL ik). Ob a => Internal a a Source Github # (.) :: forall (b :: INTERNAL ik) (c :: INTERNAL ik) (a :: INTERNAL ik). Internal b c -> Internal a b -> Internal 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 #
Flavor 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 #
Flavor 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, with `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 #
Monoid m => Promonad (Mon :: MONOID m -> MONOID m -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Monoid Methods id :: forall (a :: MONOID m). Ob a => Mon a a Source Github # (.) :: forall (b :: MONOID m) (c :: MONOID m) (a :: MONOID 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.

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

class (CategoryOf k, forall (a :: k). Ob' a) => VacuousOb k Source Github #

A category without constraints on its objects.

Instances

Instances details

(CategoryOf k, forall (a :: k). Ob' a) => VacuousOb k Source Github #
Instance details Defined in Proarrow.Core

Lifted Type Classes

class (forall (x :: k) (y :: k1). Eq (p x y)) => Eq2 (p :: k -> k1 -> Type) Source Github #

A profunctor (or something of that kind) whose elements can be compared.

Instances

Instances details

(forall (x :: k1) (y :: k2). Eq (p x y)) => Eq2 (p :: k1 -> k2 -> Type) Source Github #
Instance details Defined in Proarrow.Core

class (forall (x :: k) (y :: k1). Show (p x y)) => Show2 (p :: k -> k1 -> Type) Source Github #

A profunctor (or something of that kind) whose elements can be shown.

Instances

Instances details

(forall (x :: k1) (y :: k2). Show (p x y)) => Show2 (p :: k1 -> k2 -> Type) Source Github #
Instance details Defined in Proarrow.Core

Constraint Continuations

($) :: ((c => r) -> r) -> (c => r) -> r infixr 0 Source Github #

Application of a constraint continuation such as withOb2 to its body, as in withOb2 @_ @a @b $ body. Unlike Prelude's $ it only applies functions of this shape.

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.