| Safe Haskell | None |
|---|---|
| Language | GHC2024 |
Proarrow
Description
The main entry point of the library. One import gives the curated core vocabulary
(categories, profunctors, functors, promonads, objects, monoids, universal properties and
optics). Several Prelude names are redefined here, so import it with
import Prelude hiding (id, (.), Functor, fmap, Monad, return, Monoid, mempty, mappend, map) import Proarrow
There is much more under Proarrow.* than this module exports: concrete categories (the
Proarrow.Category.Instance.* modules), monoidal structure, (co)limits, adjunctions, Kan
extensions, enriched categories. Proarrow.Core documents the design of the core abstractions
in depth.
Synopsis
- type CAT k = k +-> k
- type (+->) j k = k -> j -> Type
- class Promonad ((~>) :: CAT k) => CategoryOf k where
- class Profunctor p => Promonad (p :: CAT k) where
- class (CategoryOf j, CategoryOf k) => Profunctor (p :: j +-> k) where
- type (:~>) (p :: k -> k1 -> Type) (q :: k -> k1 -> Type) = forall (a :: k) (b :: k1). p a b -> q a b
- (//) :: forall {k1} {k2} p (a :: k2) (b :: k1) r. Profunctor p => p a b -> ((Ob a, Ob b) => r) -> r
- dimapDefault :: forall {k} p (c :: k) (a :: k) (b :: k) (d :: k). Promonad p => p c a -> p b d -> p a b -> p c d
- 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
- pattern Objs :: forall {j} {k} p (a :: k) (b :: j). Profunctor p => (Ob a, Ob b) => p a b
- class (Ob a, CategoryOf k) => Ob' (a :: k)
- class CategoryOf k => ObId (a :: k) where
- class (CategoryOf k1, CategoryOf k2, forall (a :: k1). Ob a => Ob' (f a)) => Functor (f :: k1 -> k2) where
- type (.~>) (f :: k -> k1) (g :: k -> k1) = forall (a :: k). Ob a => f a ~> g a
- newtype Prelude (f :: Type -> Type) a = Prelude {
- unPrelude :: f a
- class (CategoryOf j, CategoryOf k) => FunctorForRep (f :: j +-> k) where
- class Profunctor p => Representable (p :: j +-> k) where
- data Rep (f :: j +-> k) (a :: k) (b :: j) where
- class Profunctor p => Corepresentable (p :: j +-> k) where
- data Corep (f :: j +-> k) (a :: j) (b :: k) where
- type Monad (m :: CAT j) = (Promonad m, Representable m)
- return :: forall {j} (m :: CAT j) (a :: j). (Monad m, Ob a) => a ~> (m % a)
- bind :: forall {j} (m :: CAT j) (b :: j) (a :: j). (Monad m, Ob b) => (a ~> (m % b)) -> (m % a) ~> (m % b)
- type Comonad (w :: CAT j) = (Promonad w, Corepresentable w)
- extract :: forall {k} (w :: CAT k) (a :: k). (Comonad w, Ob a) => (w %% a) ~> a
- extend :: forall {j} (w :: CAT j) (a :: j) (b :: j). (Comonad w, Ob a) => ((w %% a) ~> b) -> (w %% a) ~> (w %% b)
- class (Monoidal k, Ob m) => Monoid (m :: k) where
- class (Monoid m, SymMonoidal k) => CommutativeMonoid (m :: k)
- class (Monoidal k, Ob c) => Comonoid (c :: k) where
- data ComonoidOn (c :: k) = ComonoidOn {}
- class (Representable r, Ob a) => InitUniversal (a :: k) (r :: j +-> k) where
- type InitUnivTgt (r :: j +-> k) (a :: k) :: j
- initUnivArr :: r a (InitUnivTgt r a)
- initUnivProp :: forall (b :: j). r a b -> InitUnivTgt r a ~> b
- class (Corepresentable l, Ob b) => TermUniversal (b :: j) (l :: j +-> k) where
- type TermUnivSrc (l :: j +-> k) (b :: j) :: k
- termUnivArr :: l (TermUnivSrc l b) b
- termUnivProp :: forall (a :: k). l a b -> a ~> TermUnivSrc l b
- class (Representable p, Corepresentable p) => Adjunction (p :: j +-> k)
- leftAdjunct :: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j). (Adjunction p, Ob a) => ((p %% a) ~> b) -> a ~> (p % b)
- rightAdjunct :: forall {k1} {k2} (p :: k1 +-> k2) (a :: k2) (b :: k1). (Adjunction p, Ob b) => (a ~> (p % b)) -> (p %% a) ~> b
- module Proarrow.Optics
Categories and profunctors
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.
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.
Instances
| CategoryOf Nat Source Github # | The (augmented) simplex category is the category of finite ordinals and order preserving maps. | ||||||||
Defined in Proarrow.Category.Instance.Simplex Associated Types
| |||||||||
| CategoryOf Nat Source Github # | The category of qubits, to implement ZX calculus from quantum computing. | ||||||||
Defined in Proarrow.Category.Instance.ZX Associated Types
| |||||||||
| CategoryOf BOOL Source Github # | The category of 2 objects and one arrow between them, a.k.a. the walking arrow. | ||||||||
Defined in Proarrow.Category.Instance.Bool Associated Types
| |||||||||
| CategoryOf CONSTRAINT Source Github # | The category of type class constraints. An arrow from constraint a to constraint b means that a implies b, i.e. if a holds then b holds. | ||||||||
Defined in Proarrow.Category.Instance.Constraint Associated Types
| |||||||||
| CategoryOf COST Source Github # | Cost category. Categories enriched in the cost category are lawvere metric spaces. | ||||||||
Defined in Proarrow.Category.Instance.Cost Associated Types
| |||||||||
| CategoryOf FINHASK Source Github # | The category of finite Haskell types, with morphisms stored extensionally as finite lookup tables. | ||||||||
| CategoryOf FINREL Source Github # | The skeleton of the category of finite sets and relations: objects are natural numbers and
an arrow | ||||||||
Defined in Proarrow.Category.Instance.FinRel | |||||||||
| CategoryOf FINSET Source Github # | The skeleton of the category of finite sets: objects are natural numbers and an arrow
| ||||||||
Defined in Proarrow.Category.Instance.FinSet | |||||||||
| CategoryOf LINEAR Source Github # | Category of linear functions. | ||||||||
Defined in Proarrow.Category.Instance.Linear | |||||||||
| CategoryOf POINTED Source Github # | The category of types with an added point and point-preserving morphisms. | ||||||||
Defined in Proarrow.Category.Instance.PointedHask | |||||||||
| CategoryOf VOID Source Github # | The category with no objects, the initial category. | ||||||||
Defined in Proarrow.Category.Instance.Zero Associated Types
| |||||||||
| CategoryOf DOT Source Github # | The category string diagrams are built in: an object | ||||||||
Defined in Proarrow.Tools.Diagrams.Dot | |||||||||
| CategoryOf SVG Source Github # | The category string diagrams are drawn in: an object | ||||||||
Defined in Proarrow.Tools.Diagrams.Svg | |||||||||
| CategoryOf W Source Github # | The discrete category on wires, so that lists of wires are objects of | ||||||||
Defined in Proarrow.Tools.Diagrams.Svg Associated Types
| |||||||||
| CategoryOf () Source Github # | The category with one object, the terminal category. | ||||||||
Defined in Proarrow.Category.Instance.Unit Associated Types
| |||||||||
| CategoryOf Symbol Source Github # | The discrete category on type-level | ||||||||
Defined in Proarrow.Tools.Diagrams.Dot Associated Types
| |||||||||
| CategoryOf Type Source Github # | The category of Haskell types (a.k.a | ||||||||
Defined in Proarrow.Core Associated Types
| |||||||||
| HasPushouts k => CategoryOf (COSPAN k) Source Github # | The category of cospans in | ||||||||
Defined in Proarrow.Category.Instance.Cospan | |||||||||
| Indexed k => CategoryOf (CODISCRETE k) Source Github # | The codiscrete category has exactly one arrow between any two objects, the numbered inhabitants
of | ||||||||
Defined in Proarrow.Category.Instance.Discrete Associated Types
| |||||||||
| Indexed k => CategoryOf (DISCRETE k) Source Github # | The discrete category with only identity arrows on the numbered inhabitants of | ||||||||
Defined in Proarrow.Category.Instance.Discrete | |||||||||
| CategoryOf k => CategoryOf (FAM k) Source Github # | The Fam construction a.k.a. the free coproduct completion of | ||||||||
Defined in Proarrow.Category.Instance.Fam | |||||||||
| TracedMonoidal k => CategoryOf (INT k) Source Github # | The Int construction, a.k.a. the geometry of interaction, the free compact closed category on a traced monoidal category. | ||||||||
Defined in Proarrow.Category.Instance.IntConstruction Associated Types
| |||||||||
| Num a => CategoryOf (MatK a) Source Github # | The category of matrices with entries in a type | ||||||||
Defined in Proarrow.Category.Instance.Mat | |||||||||
| CategoryOf k => CategoryOf (OPPOSITE k) Source Github # | The opposite category of the category of | ||||||||
Defined in Proarrow.Category.Instance.Opposite | |||||||||
| 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. | ||||||||
Defined in Proarrow.Category.Instance.Ordinal | |||||||||
| HasPullbacks k => CategoryOf (SPAN k) Source Github # | The category of spans in | ||||||||
Defined in Proarrow.Category.Instance.Span | |||||||||
| CategoryOf k => CategoryOf (ENDO k) Source Github # | The category of endoprofunctors on | ||||||||
Defined in Proarrow.Category.Monoidal.EndoProf | |||||||||
| CategoryOf k => CategoryOf (REV k) Source Github # | The reverse of the category of | ||||||||
Defined in Proarrow.Category.Monoidal.Rev | |||||||||
| CategoryOf k => CategoryOf (COPROD k) Source Github # | The same category as the category of | ||||||||
Defined in Proarrow.Colimit.BinaryCoproduct | |||||||||
| CategoryOf k => CategoryOf (PROD k) Source Github # | The same category as the category of | ||||||||
Defined in Proarrow.Limit.BinaryProduct | |||||||||
| CategoryOf k => CategoryOf (LIST k) Source Github # | The category of lists of arrows. | ||||||||
Defined in Proarrow.Profunctor.Instance.List | |||||||||
| Monoidal k => CategoryOf [k] Source Github # | The strictified monoidal category, making the unitors and associators identities. | ||||||||
Defined in Proarrow.Category.Monoidal.Strictified Associated Types
| |||||||||
| (CategoryOf j, CategoryOf k) => CategoryOf (COPRODUCT j k) Source Github # | The coproduct of two categories. | ||||||||
Defined in Proarrow.Category.Instance.Coproduct | |||||||||
| Promonad p => CategoryOf (KLEISLI p) Source Github # | Every promonad makes a category. | ||||||||
Defined in Proarrow.Category.Instance.Kleisli | |||||||||
| Monoid m => CategoryOf (MONOID m) Source Github # | A monoid as a one object category. | ||||||||
Defined in Proarrow.Category.Instance.Monoid | |||||||||
| CategoryOf (j .-> k) Source Github # | The category of functors and natural transformations. | ||||||||
Defined in Proarrow.Category.Instance.Nat | |||||||||
| (CategoryOf k, Rewrite p) => CategoryOf (PATHS p) Source Github # | |||||||||
Defined in Proarrow.Category.Instance.Paths | |||||||||
| CategoryOf k => CategoryOf (SUBCAT ob) Source Github # | The subcategory with objects with instances of the given constraint | ||||||||
Defined in Proarrow.Category.Instance.Sub | |||||||||
| (InternalIn ik FINSET, SNatI (NumObs ik)) => CategoryOf (INTERNAL ik) Source Github # | |||||||||
Defined in Proarrow.Category.Internal | |||||||||
| CategoryOf (j +-> k) Source Github # | The category of profunctors and natural transformations between them. | ||||||||
Defined in Proarrow.Category.Instance.Prof | |||||||||
| (CategoryOf k1, CategoryOf k2) => CategoryOf (k1, k2) Source Github # | The product of two categories. | ||||||||
Defined in Proarrow.Category.Instance.Product | |||||||||
| CategoryOf (k1 -> k2 -> k3 -> k4 -> Type) Source Github # | The category of functors with target category k2 -> k3 -> k4 -> Type. | ||||||||
Defined in Proarrow.Category.Instance.Nat | |||||||||
| CategoryOf (k1 -> k2 -> k3 -> Type) Source Github # | The category of functors with target category | ||||||||
Defined in Proarrow.Category.Instance.Nat | |||||||||
| CategoryOf (k1 -> Type) Source Github # | The category of functors with target category Hask. | ||||||||
Defined in Proarrow.Category.Instance.Nat | |||||||||
| Profunctor p => CategoryOf (COLLAGE p) Source Github # | The collage of a profunctor. | ||||||||
Defined in Proarrow.Category.Instance.Collage | |||||||||
| Adjunction adj => CategoryOf (DUPLOID adj) Source Github # | The duploid of an adjunction, with polarized objects. Deliberately unlawful: composition is
polarity-biased and not associative (see the warning on the | ||||||||
Defined in Proarrow.Category.Instance.Duploid | |||||||||
| CategoryOf (FREE cs p) Source Github # | The category freely generated from the heteromorphisms of | ||||||||
Defined in Proarrow.Category.Instance.Free | |||||||||
| ThinProfunctor p => CategoryOf (GRAPH p) Source Github # | The graph of a thin profunctor. Doing this for any profunctor would need dependent types. | ||||||||
Defined in Proarrow.Category.Instance.Graph | |||||||||
| (CategoryOf j, CategoryOf k) => CategoryOf (OPTIC j k c) Source Github # | Optics form a category: an object | ||||||||
Defined in Proarrow.Optic | |||||||||
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:
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.
(.) :: forall (b :: k) (c :: k) (a :: k). p b c -> p a b -> p a c infixr 9 Source Github #
Composition (note the parameter order matches function composition).
Instances
| Promonad Simplex Source Github # | |
| Promonad ZX Source Github # | |
| Promonad Booleans Source Github # | |
| Promonad (:-) Source Github # | |
Defined in Proarrow.Category.Instance.Constraint Methods id :: forall (a :: CONSTRAINT). Ob a => a :- a Source Github # (.) :: forall (b :: CONSTRAINT) (c :: CONSTRAINT) (a :: CONSTRAINT). (b :- c) -> (a :- b) -> a :- c Source Github # | |
| Promonad GTE Source Github # | |
| Promonad FinHask Source Github # | |
| Promonad FinRel Source Github # | |
| Promonad FinSet Source Github # | |
| Promonad Linear Source Github # | |
| Promonad Pointed Source Github # | |
| Promonad Zero Source Github # | |
| Promonad Dot Source Github # | |
| Promonad Svg Source Github # | |
| Promonad WireId Source Github # | |
| Promonad Unit Source Github # | |
| Promonad SymRefl Source Github # | |
| Monad m => Promonad (Kleisli m :: Type -> Type -> Type) Source Github # | |
| Comonoid w => Promonad (ComonoidAsCat w :: Type -> Type -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods id :: Ob a => ComonoidAsCat w a a Source Github # (.) :: ComonoidAsCat w b c -> ComonoidAsCat w a b -> ComonoidAsCat w a c Source Github # | |
| Arrow arr => Promonad (Arr arr :: Type -> Type -> Type) Source Github # | |
| (VacuousOb k, Hom k ~ ((:~:) :: k -> k -> Type)) => Promonad ((:~:) :: k -> k -> Type) Source Github # | |
| CategoryOf k => Promonad (Id :: k -> k -> Type) Source Github # | |
| Promonad (->) Source Github # | |
| Profunctor p => Promonad (FreePromonad p :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Free Methods id :: forall (a :: k). Ob a => FreePromonad p a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). FreePromonad p b c -> FreePromonad p a b -> FreePromonad p a c Source Github # | |
| Promonad p => Promonad (Fix p :: k -> k -> Type) Source Github # | |
| CategoryOf k => Promonad (TerminalProfunctor :: k -> k -> Type) Source Github # | |
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 # | |
| (Comonoid r, Monoidal k) => Promonad (Reader ('OP r) :: k -> k -> Type) Source Github # | |
| (Monoid w, Monoidal k) => Promonad (Writer w :: k -> k -> Type) Source Github # | |
| Adjunction p => Promonad (Adj p :: Type -> Type -> Type) Source Github # | |
| Monad m => Promonad (Star (Prelude m) :: Type -> Type -> Type) Source Github # | |
| Promonad (Star []) Source Github # | The list monad without the |
| Promonad p => Promonad (FromProfunctor p :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Functor Methods id :: forall (a :: k). Ob a => FromProfunctor p a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). FromProfunctor p b c -> FromProfunctor p a b -> FromProfunctor p a c Source Github # | |
| (HasBinaryProducts k, Ob a) => Promonad (Corep (Product a) :: k -> k -> Type) Source Github # | |
| (Monoid c, CategoryOf k) => Promonad (HaskValue c :: k -> k -> Type) Source Github # | |
| Promonad p => Promonad (Wrapped p :: k -> k -> Type) Source Github # | |
| (FunctorForRep f, Promonad (Corep f)) => Promonad (RepCostar (Rep f) :: k -> k -> Type) Source Github # | |
| Promonad m => Promonad (AsRelative m :: k -> k -> Type) Source Github # | |
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 # | |
| (Ob s, Monoidal k, Strong (Tensor :: k -> (k, k) -> Type) p, Promonad p) => Promonad (StateT s p :: k -> k -> Type) Source Github # | |
| (Monoid w, Strong (Tensor :: k -> (k, k) -> Type) p, Promonad p) => Promonad (WriterT w p :: k -> k -> Type) Source Github # | |
| Proadjunction p q => Promonad (q :.: p :: k -> k -> Type) Source Github # | |
| (p ~ j, Profunctor p) => Promonad (Ran ('OP j) p :: k -> k -> Type) Source Github # | |
| (p ~ j, Profunctor p) => Promonad (Rift ('OP j) p :: k -> k -> Type) Source Github # | |
| HasPushouts k => Promonad (Cospan :: COSPAN k -> COSPAN k -> Type) Source Github # | |
| Indexed k => Promonad (Codiscrete :: CODISCRETE k -> CODISCRETE k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Discrete Methods id :: forall (a :: CODISCRETE k). Ob a => Codiscrete a a Source Github # (.) :: forall (b :: CODISCRETE k) (c :: CODISCRETE k) (a :: CODISCRETE k). Codiscrete b c -> Codiscrete a b -> Codiscrete a c Source Github # | |
| Indexed k => Promonad (Discrete :: DISCRETE k -> DISCRETE k -> Type) Source Github # | |
| CategoryOf k => Promonad (Fam :: FAM k -> FAM k -> Type) Source Github # | |
| TracedMonoidal k => Promonad (IntConstruction :: INT k -> INT k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.IntConstruction Methods id :: forall (a :: INT k). Ob a => IntConstruction a a Source Github # (.) :: forall (b :: INT k) (c :: INT k) (a :: INT k). IntConstruction b c -> IntConstruction a b -> IntConstruction a c Source Github # | |
| Num a => Promonad (Mat :: MatK a -> MatK a -> Type) Source Github # | |
| Promonad (LTE :: ORDINAL n -> ORDINAL n -> Type) Source Github # | |
| HasPullbacks k => Promonad (Span :: SPAN k -> SPAN k -> Type) Source Github # | |
| CategoryOf k => Promonad (Endo :: ENDO k -> ENDO k -> Type) Source Github # | |
| Monoidal k => Promonad (Strictified :: [k] -> [k] -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Strictified Methods id :: forall (a :: [k]). Ob a => Strictified a a Source Github # (.) :: forall (b :: [k]) (c :: [k]) (a :: [k]). Strictified b c -> Strictified a b -> Strictified a c Source Github # | |
| Promonad c => Promonad (Op c :: OPPOSITE j -> OPPOSITE j -> Type) Source Github # | |
| Promonad p => Promonad (Rev p :: REV j -> REV j -> Type) Source Github # | |
| Promonad p => Promonad (Coprod p :: COPROD j -> COPROD j -> Type) Source Github # | |
| Promonad p => Promonad (Prod p :: PROD j -> PROD j -> Type) Source Github # | |
| Promonad p => Promonad (List p :: LIST j -> LIST j -> Type) Source Github # | |
| Promonad p => Promonad (Kleisli :: KLEISLI p -> KLEISLI p -> Type) Source Github # | |
| Promonad (Nat' :: (j .-> k) -> (j .-> k) -> Type) Source Github # | |
| (CategoryOf k, Rewrite p) => Promonad (Paths :: PATHS p -> PATHS p -> Type) Source Github # | |
| (InternalIn ik FINSET, SNatI (NumObs ik)) => Promonad (Internal :: INTERNAL ik -> INTERNAL ik -> Type) Source Github # | |
| Promonad (Prof :: (j +-> k) -> (j +-> k) -> Type) Source Github # | |
| Promonad (Nat :: (j -> Type) -> (j -> Type) -> Type) Source Github # | |
| Promonad (Nat :: (k1 -> k2 -> k3 -> k4 -> Type) -> (k1 -> k2 -> k3 -> k4 -> Type) -> Type) Source Github # | |
| Promonad (Nat :: (k1 -> k2 -> k3 -> Type) -> (k1 -> k2 -> k3 -> Type) -> Type) Source Github # | |
| Promonad p => Promonad (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |
| Promonad (Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.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 # | |
| Profunctor p => Promonad (Costar ((:*:) p) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github # | |
| Promonad (Costar (Yoneda :: (j +-> k) -> k -> j -> Type) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.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 # | |
| (Comonoid r, Monoidal k) => Promonad (Star (ReaderT ('OP r)) :: (k +-> k) -> (k +-> k) -> Type) Source Github # | ReaderT is a monad on profunctors, i.e. we have |
| (Monoid w, Monoidal k) => Promonad (Star (WriterT w) :: (k +-> k) -> (k +-> k) -> Type) Source Github # | WriterT is a monad on profunctors, with |
| Procomonad j => Promonad (Star (Ran ('OP j) :: (i +-> k) -> k -> i -> Type) :: (k -> i -> Type) -> (i +-> k) -> Type) Source Github # | |
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 # | |
| Promonad (Star (Coyoneda :: (j +-> k) -> k -> j -> Type) :: (k -> j -> Type) -> (j +-> k) -> Type) Source Github # | |
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 # | |
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 # | |
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 # | |
Defined in Proarrow.Profunctor.Free Methods id :: forall (a :: k -> k -> Type). Ob a => Star (FreePromonad :: (k -> k -> Type) -> k -> k -> Type) a a Source Github # (.) :: forall (b :: k -> k -> Type) (c :: k -> k -> Type) (a :: k -> k -> Type). Star (FreePromonad :: (k -> k -> Type) -> k -> k -> Type) b c -> Star (FreePromonad :: (k -> k -> Type) -> k -> k -> Type) a b -> Star (FreePromonad :: (k -> k -> Type) -> k -> k -> Type) a c Source Github # | |
| Monoidal k => Promonad (Star (Ap :: (k -> Type) -> k -> Type) :: (k -> Type) -> (k -> Type) -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Free Methods id :: forall (a :: k -> Type). Ob a => Star (Ap :: (k -> Type) -> k -> Type) a a Source Github # (.) :: forall (b :: k -> Type) (c :: k -> Type) (a :: k -> Type). Star (Ap :: (k -> Type) -> k -> Type) b c -> Star (Ap :: (k -> Type) -> k -> Type) a b -> Star (Ap :: (k -> Type) -> k -> Type) a c Source Github # | |
| Monoid m => Promonad (Mon :: MONOID m -> MONOID m -> Type) Source Github # | |
| (Promonad p, Promonad q) => Promonad (p :++: q :: COPRODUCT j1 j2 -> COPRODUCT j1 j2 -> Type) Source Github # | The coproduct of two promonads. |
| (Promonad p, Promonad q) => Promonad (p :**: q :: (j1, j2) -> (j1, j2) -> Type) Source Github # | The product promonad of promonads |
| Profunctor p => Promonad (Collage :: COLLAGE p -> COLLAGE p -> Type) Source Github # | |
| Adjunction adj => Promonad (Duploid :: DUPLOID adj -> DUPLOID adj -> Type) Source Github # | ATTENTION: a duploid is not associative, so not really a promonad/category! |
| Promonad (Free :: FREE cs p -> FREE cs p -> Type) Source Github # | |
| ThinProfunctor p => Promonad (Graph :: GRAPH p -> GRAPH p -> Type) Source Github # | |
| (CategoryOf j, CategoryOf k) => Promonad (Optic_ :: OPTIC j k c -> OPTIC j k c -> Type) Source Github # | |
class (CategoryOf j, CategoryOf k) => Profunctor (p :: j +-> k) where Source Github #
The core profunctor abstraction. A profunctor is contravariant in its first argument and covariant in its second argument.
Laws:
Methods
dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> p a b -> p c d Source Github #
Map contravariantly over the first argument and covariantly over the second.
lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> p a b -> p c b Source Github #
Left mapping (contravariant mapping over first argument).
rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> p a b -> p a d Source Github #
Right mapping (covariant mapping over second argument).
(\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> p a b -> r infixl 1 Source Github #
Constraint elimination, extracts object constraints from a profunctor heteromorphism.
Instances
| Profunctor Simplex Source Github # | |
Defined in Proarrow.Category.Instance.Simplex Methods dimap :: forall (c :: Nat) (a :: Nat) (b :: Nat) (d :: Nat). (c ~> a) -> (b ~> d) -> Simplex a b -> Simplex c d Source Github # lmap :: forall (c :: Nat) (a :: Nat) (b :: Nat). (c ~> a) -> Simplex a b -> Simplex c b Source Github # rmap :: forall (b :: Nat) (d :: Nat) (a :: Nat). (b ~> d) -> Simplex a b -> Simplex a d Source Github # (\\) :: forall (a :: Nat) (b :: Nat) r. ((Ob a, Ob b) => r) -> Simplex a b -> r Source Github # | |
| Profunctor ZX Source Github # | |
Defined in Proarrow.Category.Instance.ZX Methods dimap :: forall (c :: Nat) (a :: Nat) (b :: Nat) (d :: Nat). (c ~> a) -> (b ~> d) -> ZX a b -> ZX c d Source Github # lmap :: forall (c :: Nat) (a :: Nat) (b :: Nat). (c ~> a) -> ZX a b -> ZX c b Source Github # rmap :: forall (b :: Nat) (d :: Nat) (a :: Nat). (b ~> d) -> ZX a b -> ZX a d Source Github # (\\) :: forall (a :: Nat) (b :: Nat) r. ((Ob a, Ob b) => r) -> ZX a b -> r Source Github # | |
| Profunctor Booleans Source Github # | |
Defined in Proarrow.Category.Instance.Bool Methods dimap :: forall (c :: BOOL) (a :: BOOL) (b :: BOOL) (d :: BOOL). (c ~> a) -> (b ~> d) -> Booleans a b -> Booleans c d Source Github # lmap :: forall (c :: BOOL) (a :: BOOL) (b :: BOOL). (c ~> a) -> Booleans a b -> Booleans c b Source Github # rmap :: forall (b :: BOOL) (d :: BOOL) (a :: BOOL). (b ~> d) -> Booleans a b -> Booleans a d Source Github # (\\) :: forall (a :: BOOL) (b :: BOOL) r. ((Ob a, Ob b) => r) -> Booleans a b -> r Source Github # | |
| Profunctor (:-) Source Github # | |
Defined in Proarrow.Category.Instance.Constraint Methods dimap :: forall (c :: CONSTRAINT) (a :: CONSTRAINT) (b :: CONSTRAINT) (d :: CONSTRAINT). (c ~> a) -> (b ~> d) -> (a :- b) -> c :- d Source Github # lmap :: forall (c :: CONSTRAINT) (a :: CONSTRAINT) (b :: CONSTRAINT). (c ~> a) -> (a :- b) -> c :- b Source Github # rmap :: forall (b :: CONSTRAINT) (d :: CONSTRAINT) (a :: CONSTRAINT). (b ~> d) -> (a :- b) -> a :- d Source Github # (\\) :: forall (a :: CONSTRAINT) (b :: CONSTRAINT) r. ((Ob a, Ob b) => r) -> (a :- b) -> r Source Github # | |
| Profunctor GTE Source Github # | |
Defined in Proarrow.Category.Instance.Cost Methods dimap :: forall (c :: COST) (a :: COST) (b :: COST) (d :: COST). (c ~> a) -> (b ~> d) -> GTE a b -> GTE c d Source Github # lmap :: forall (c :: COST) (a :: COST) (b :: COST). (c ~> a) -> GTE a b -> GTE c b Source Github # rmap :: forall (b :: COST) (d :: COST) (a :: COST). (b ~> d) -> GTE a b -> GTE a d Source Github # (\\) :: forall (a :: COST) (b :: COST) r. ((Ob a, Ob b) => r) -> GTE a b -> r Source Github # | |
| Profunctor FinHask Source Github # | |
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 # | |
Defined in Proarrow.Category.Instance.FinRel Methods dimap :: forall (c :: FINREL) (a :: FINREL) (b :: FINREL) (d :: FINREL). (c ~> a) -> (b ~> d) -> FinRel a b -> FinRel c d Source Github # lmap :: forall (c :: FINREL) (a :: FINREL) (b :: FINREL). (c ~> a) -> FinRel a b -> FinRel c b Source Github # rmap :: forall (b :: FINREL) (d :: FINREL) (a :: FINREL). (b ~> d) -> FinRel a b -> FinRel a d Source Github # (\\) :: forall (a :: FINREL) (b :: FINREL) r. ((Ob a, Ob b) => r) -> FinRel a b -> r Source Github # | |
| Profunctor FinSet Source Github # | |
Defined in Proarrow.Category.Instance.FinSet Methods dimap :: forall (c :: FINSET) (a :: FINSET) (b :: FINSET) (d :: FINSET). (c ~> a) -> (b ~> d) -> FinSet a b -> FinSet c d Source Github # lmap :: forall (c :: FINSET) (a :: FINSET) (b :: FINSET). (c ~> a) -> FinSet a b -> FinSet c b Source Github # rmap :: forall (b :: FINSET) (d :: FINSET) (a :: FINSET). (b ~> d) -> FinSet a b -> FinSet a d Source Github # (\\) :: forall (a :: FINSET) (b :: FINSET) r. ((Ob a, Ob b) => r) -> FinSet a b -> r Source Github # | |
| Profunctor Linear Source Github # | |
Defined in Proarrow.Category.Instance.Linear Methods dimap :: forall (c :: LINEAR) (a :: LINEAR) (b :: LINEAR) (d :: LINEAR). (c ~> a) -> (b ~> d) -> Linear a b -> Linear c d Source Github # lmap :: forall (c :: LINEAR) (a :: LINEAR) (b :: LINEAR). (c ~> a) -> Linear a b -> Linear c b Source Github # rmap :: forall (b :: LINEAR) (d :: LINEAR) (a :: LINEAR). (b ~> d) -> Linear a b -> Linear a d Source Github # (\\) :: forall (a :: LINEAR) (b :: LINEAR) r. ((Ob a, Ob b) => r) -> Linear a b -> r Source Github # | |
| Profunctor Pointed Source Github # | |
Defined in Proarrow.Category.Instance.PointedHask Methods dimap :: forall (c :: POINTED) (a :: POINTED) (b :: POINTED) (d :: POINTED). (c ~> a) -> (b ~> d) -> Pointed a b -> Pointed c d Source Github # lmap :: forall (c :: POINTED) (a :: POINTED) (b :: POINTED). (c ~> a) -> Pointed a b -> Pointed c b Source Github # rmap :: forall (b :: POINTED) (d :: POINTED) (a :: POINTED). (b ~> d) -> Pointed a b -> Pointed a d Source Github # (\\) :: forall (a :: POINTED) (b :: POINTED) r. ((Ob a, Ob b) => r) -> Pointed a b -> r Source Github # | |
| Profunctor Zero Source Github # | |
Defined in Proarrow.Category.Instance.Zero Methods dimap :: forall (c :: VOID) (a :: VOID) (b :: VOID) (d :: VOID). (c ~> a) -> (b ~> d) -> Zero a b -> Zero c d Source Github # lmap :: forall (c :: VOID) (a :: VOID) (b :: VOID). (c ~> a) -> Zero a b -> Zero c b Source Github # rmap :: forall (b :: VOID) (d :: VOID) (a :: VOID). (b ~> d) -> Zero a b -> Zero a d Source Github # (\\) :: forall (a :: VOID) (b :: VOID) r. ((Ob a, Ob b) => r) -> Zero a b -> r Source Github # | |
| Profunctor Dot Source Github # | |
Defined in Proarrow.Tools.Diagrams.Dot Methods dimap :: forall (c :: DOT) (a :: DOT) (b :: DOT) (d :: DOT). (c ~> a) -> (b ~> d) -> Dot a b -> Dot c d Source Github # lmap :: forall (c :: DOT) (a :: DOT) (b :: DOT). (c ~> a) -> Dot a b -> Dot c b Source Github # rmap :: forall (b :: DOT) (d :: DOT) (a :: DOT). (b ~> d) -> Dot a b -> Dot a d Source Github # (\\) :: forall (a :: DOT) (b :: DOT) r. ((Ob a, Ob b) => r) -> Dot a b -> r Source Github # | |
| Profunctor Svg Source Github # | |
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 # | |
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 # | |
Defined in Proarrow.Category.Instance.Unit Methods dimap :: forall (c :: ()) (a :: ()) (b :: ()) (d :: ()). (c ~> a) -> (b ~> d) -> Unit a b -> Unit c d Source Github # lmap :: forall (c :: ()) (a :: ()) (b :: ()). (c ~> a) -> Unit a b -> Unit c b Source Github # rmap :: forall (b :: ()) (d :: ()) (a :: ()). (b ~> d) -> Unit a b -> Unit a d Source Github # (\\) :: forall (a :: ()) (b :: ()) r. ((Ob a, Ob b) => r) -> Unit a b -> r Source Github # | |
| Profunctor SymRefl Source Github # | |
Defined in Proarrow.Tools.Diagrams.Dot Methods dimap :: forall (c :: Symbol) (a :: Symbol) (b :: Symbol) (d :: Symbol). (c ~> a) -> (b ~> d) -> SymRefl a b -> SymRefl c d Source Github # lmap :: forall (c :: Symbol) (a :: Symbol) (b :: Symbol). (c ~> a) -> SymRefl a b -> SymRefl c b Source Github # rmap :: forall (b :: Symbol) (d :: Symbol) (a :: Symbol). (b ~> d) -> SymRefl a b -> SymRefl a d Source Github # (\\) :: forall (a :: Symbol) (b :: Symbol) r. ((Ob a, Ob b) => r) -> SymRefl a b -> r Source Github # | |
| Profunctor (NonTrivialProfunctor ft :: BOOL -> BOOL -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Bool Methods dimap :: forall (c :: BOOL) (a :: BOOL) (b :: BOOL) (d :: BOOL). (c ~> a) -> (b ~> d) -> NonTrivialProfunctor ft a b -> NonTrivialProfunctor ft c d Source Github # lmap :: forall (c :: BOOL) (a :: BOOL) (b :: BOOL). (c ~> a) -> NonTrivialProfunctor ft a b -> NonTrivialProfunctor ft c b Source Github # rmap :: forall (b :: BOOL) (d :: BOOL) (a :: BOOL). (b ~> d) -> NonTrivialProfunctor ft a b -> NonTrivialProfunctor ft a d Source Github # (\\) :: forall (a :: BOOL) (b :: BOOL) r. ((Ob a, Ob b) => r) -> NonTrivialProfunctor ft a b -> r Source Github # | |
| Functor m => Profunctor (Kleisli m :: Type -> Type -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Instance.Arrow | |
| Functor w => Profunctor (ComonoidAsCat w :: Type -> Type -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods dimap :: (c ~> a) -> (b ~> d) -> ComonoidAsCat w a b -> ComonoidAsCat w c d Source Github # lmap :: (c ~> a) -> ComonoidAsCat w a b -> ComonoidAsCat w c b Source Github # rmap :: (b ~> d) -> ComonoidAsCat w a b -> ComonoidAsCat w a d Source Github # (\\) :: ((Ob a, Ob b) => r) -> ComonoidAsCat w a b -> r Source Github # | |
| Arrow arr => Profunctor (Arr arr :: Type -> Type -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Instance.Arrow | |
| (VacuousOb k, Hom k ~ ((:~:) :: k -> k -> Type)) => Profunctor ((:~:) :: k -> k -> Type) Source Github # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
| Profunctor p => Profunctor (FreePromonad p :: j -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Free Methods dimap :: forall (c :: j) (a :: j) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> FreePromonad p a b -> FreePromonad p c d Source Github # lmap :: forall (c :: j) (a :: j) (b :: j). (c ~> a) -> FreePromonad p a b -> FreePromonad p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: j). (b ~> d) -> FreePromonad p a b -> FreePromonad p a d Source Github # (\\) :: forall (a :: j) (b :: j) r. ((Ob a, Ob b) => r) -> FreePromonad p a b -> r Source Github # | |
| Profunctor p => Profunctor (Fix p :: j -> j -> Type) Source Github # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
Defined in Proarrow.Promonad.Cont Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Cont r a b -> Cont r c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Cont r a b -> Cont r c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Cont r a b -> Cont r a d Source Github # (\\) :: forall (a :: k) (b :: k) r0. ((Ob a, Ob b) => r0) -> Cont r a b -> r0 Source Github # | |
| (Ob r, Monoidal k) => Profunctor (Reader ('OP r) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Promonad.Reader Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Reader ('OP r) a b -> Reader ('OP r) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Reader ('OP r) a b -> Reader ('OP r) c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Reader ('OP r) a b -> Reader ('OP r) a d Source Github # (\\) :: forall (a :: k) (b :: k) r0. ((Ob a, Ob b) => r0) -> Reader ('OP r) a b -> r0 Source Github # | |
| (Ob w, Monoidal k) => Profunctor (Writer w :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Promonad.Writer Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Writer w a b -> Writer w c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Writer w a b -> Writer w c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Writer w a b -> Writer w a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> Writer w a b -> r Source Github # | |
| (CategoryOf k, Profunctor dx) => Profunctor (AsPresheaf dx :: k -> () -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Fam Methods dimap :: forall (c :: k) (a :: k) (b :: ()) (d :: ()). (c ~> a) -> (b ~> d) -> AsPresheaf dx a b -> AsPresheaf dx c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: ()). (c ~> a) -> AsPresheaf dx a b -> AsPresheaf dx c b Source Github # rmap :: forall (b :: ()) (d :: ()) (a :: k). (b ~> d) -> AsPresheaf dx a b -> AsPresheaf dx a d Source Github # (\\) :: forall (a :: k) (b :: ()) r. ((Ob a, Ob b) => r) -> AsPresheaf dx a b -> r Source Github # | |
| Profunctor p => Profunctor (Walk n p :: j -> j -> Type) Source Github # | |
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 |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
Defined in Proarrow.Profunctor.Representable Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> CorepStar p a b -> CorepStar p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> CorepStar p a b -> CorepStar p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> CorepStar p a b -> CorepStar p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> CorepStar p a b -> r Source Github # | |
| FunctorForRep f => Profunctor (Rep f :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Representable Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Rep f a b -> Rep f c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Rep f a b -> Rep f c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Rep f a b -> Rep f a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Rep f a b -> r Source Github # | |
| Representable p => Profunctor (RepCostar p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Representable Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> RepCostar p a b -> RepCostar p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> RepCostar p a b -> RepCostar p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> RepCostar p a b -> RepCostar p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> RepCostar p a b -> r Source Github # | |
| Profunctor m => Profunctor (AsRelative m :: k -> j -> Type) Source Github # | |
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 # | |
Defined in Proarrow.Universal Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> AsLeftAdjoint l a b -> AsLeftAdjoint l c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> AsLeftAdjoint l a b -> AsLeftAdjoint l c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> AsLeftAdjoint l a b -> AsLeftAdjoint l a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> AsLeftAdjoint l a b -> r Source Github # | |
| Profunctor r => Profunctor (AsRightAdjoint r :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Universal Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> AsRightAdjoint r a b -> AsRightAdjoint r c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> AsRightAdjoint r a b -> AsRightAdjoint r c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> AsRightAdjoint r a b -> AsRightAdjoint r a d Source Github # (\\) :: forall (a :: k) (b :: j) r0. ((Ob a, Ob b) => r0) -> AsRightAdjoint r a b -> r0 Source Github # | |
| Profunctor p => Profunctor (FromAdjunction p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Universal Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> FromAdjunction p a b -> FromAdjunction p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> FromAdjunction p a b -> FromAdjunction p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> FromAdjunction p a b -> FromAdjunction p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> FromAdjunction p a b -> r Source Github # | |
| Profunctor j2 => Profunctor (AnyColimit j2 :: k -> j1 -> Type) Source Github # | |
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 # | |
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 # | |
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 # | |
Defined in Proarrow.Promonad.Reader Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> ReaderT ('OP r) p a b -> ReaderT ('OP r) p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> ReaderT ('OP r) p a b -> ReaderT ('OP r) p c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> ReaderT ('OP r) p a b -> ReaderT ('OP r) p a d Source Github # (\\) :: forall (a :: k) (b :: k) r0. ((Ob a, Ob b) => r0) -> ReaderT ('OP r) p a b -> r0 Source Github # | |
| (Profunctor p, Monoidal k, Ob s) => Profunctor (StateT s p :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Promonad.State Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> StateT s p a b -> StateT s p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> StateT s p a b -> StateT s p c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> StateT s p a b -> StateT s p a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> StateT s p a b -> r Source Github # | |
| (Profunctor p, Monoidal k, Ob w) => Profunctor (WriterT w p :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Promonad.Writer Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> WriterT w p a b -> WriterT w p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> WriterT w p a b -> WriterT w p c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> WriterT w p a b -> WriterT w p a d Source Github # (\\) :: forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> WriterT w p a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (Plus t p :: k -> j -> Type) Source Github # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # |
|
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
Defined in Proarrow.Category.Promonoidal Methods dimap :: forall (c :: k) (a :: k) (b :: LIST k) (d :: LIST k). (c ~> a) -> (b ~> d) -> Tensor a b -> Tensor c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: LIST k). (c ~> a) -> Tensor a b -> Tensor c b Source Github # rmap :: forall (b :: LIST k) (d :: LIST k) (a :: k). (b ~> d) -> Tensor a b -> Tensor a d Source Github # (\\) :: forall (a :: k) (b :: LIST k) r. ((Ob a, Ob b) => r) -> Tensor a b -> r Source Github # | |
| Profunctor p => Profunctor (CoprodDom p :: k -> COPROD j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Instance.Star Methods dimap :: forall (c :: k) (a :: k) (b :: COPROD j) (d :: COPROD j). (c ~> a) -> (b ~> d) -> CoprodDom p a b -> CoprodDom p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: COPROD j). (c ~> a) -> CoprodDom p a b -> CoprodDom p c b Source Github # rmap :: forall (b :: COPROD j) (d :: COPROD j) (a :: k). (b ~> d) -> CoprodDom p a b -> CoprodDom p a d Source Github # (\\) :: forall (a :: k) (b :: COPROD j) r. ((Ob a, Ob b) => r) -> CoprodDom p a b -> r Source Github # | |
| HasPushouts k => Profunctor (Cospan :: COSPAN k -> COSPAN k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Cospan Methods dimap :: forall (c :: COSPAN k) (a :: COSPAN k) (b :: COSPAN k) (d :: COSPAN k). (c ~> a) -> (b ~> d) -> Cospan a b -> Cospan c d Source Github # lmap :: forall (c :: COSPAN k) (a :: COSPAN k) (b :: COSPAN k). (c ~> a) -> Cospan a b -> Cospan c b Source Github # rmap :: forall (b :: COSPAN k) (d :: COSPAN k) (a :: COSPAN k). (b ~> d) -> Cospan a b -> Cospan a d Source Github # (\\) :: forall (a :: COSPAN k) (b :: COSPAN k) r. ((Ob a, Ob b) => r) -> Cospan a b -> r Source Github # | |
| Indexed k => Profunctor (Codiscrete :: CODISCRETE k -> CODISCRETE k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Discrete Methods dimap :: forall (c :: CODISCRETE k) (a :: CODISCRETE k) (b :: CODISCRETE k) (d :: CODISCRETE k). (c ~> a) -> (b ~> d) -> Codiscrete a b -> Codiscrete c d Source Github # lmap :: forall (c :: CODISCRETE k) (a :: CODISCRETE k) (b :: CODISCRETE k). (c ~> a) -> Codiscrete a b -> Codiscrete c b Source Github # rmap :: forall (b :: CODISCRETE k) (d :: CODISCRETE k) (a :: CODISCRETE k). (b ~> d) -> Codiscrete a b -> Codiscrete a d Source Github # (\\) :: forall (a :: CODISCRETE k) (b :: CODISCRETE k) r. ((Ob a, Ob b) => r) -> Codiscrete a b -> r Source Github # | |
| Indexed k => Profunctor (Discrete :: DISCRETE k -> DISCRETE k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Discrete Methods dimap :: forall (c :: DISCRETE k) (a :: DISCRETE k) (b :: DISCRETE k) (d :: DISCRETE k). (c ~> a) -> (b ~> d) -> Discrete a b -> Discrete c d Source Github # lmap :: forall (c :: DISCRETE k) (a :: DISCRETE k) (b :: DISCRETE k). (c ~> a) -> Discrete a b -> Discrete c b Source Github # rmap :: forall (b :: DISCRETE k) (d :: DISCRETE k) (a :: DISCRETE k). (b ~> d) -> Discrete a b -> Discrete a d Source Github # (\\) :: forall (a :: DISCRETE k) (b :: DISCRETE k) r. ((Ob a, Ob b) => r) -> Discrete a b -> r Source Github # | |
| CategoryOf k => Profunctor (Fam :: FAM k -> FAM k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Fam Methods dimap :: forall (c :: FAM k) (a :: FAM k) (b :: FAM k) (d :: FAM k). (c ~> a) -> (b ~> d) -> Fam a b -> Fam c d Source Github # lmap :: forall (c :: FAM k) (a :: FAM k) (b :: FAM k). (c ~> a) -> Fam a b -> Fam c b Source Github # rmap :: forall (b :: FAM k) (d :: FAM k) (a :: FAM k). (b ~> d) -> Fam a b -> Fam a d Source Github # (\\) :: forall (a :: FAM k) (b :: FAM k) r. ((Ob a, Ob b) => r) -> Fam a b -> r Source Github # | |
| TracedMonoidal k => Profunctor (IntConstruction :: INT k -> INT k -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.IntConstruction Methods dimap :: forall (c :: INT k) (a :: INT k) (b :: INT k) (d :: INT k). (c ~> a) -> (b ~> d) -> IntConstruction a b -> IntConstruction c d Source Github # lmap :: forall (c :: INT k) (a :: INT k) (b :: INT k). (c ~> a) -> IntConstruction a b -> IntConstruction c b Source Github # rmap :: forall (b :: INT k) (d :: INT k) (a :: INT k). (b ~> d) -> IntConstruction a b -> IntConstruction a d Source Github # (\\) :: forall (a :: INT k) (b :: INT k) r. ((Ob a, Ob b) => r) -> IntConstruction a b -> r Source Github # | |
| Num a => Profunctor (Mat :: MatK a -> MatK a -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Mat Methods dimap :: forall (c :: MatK a) (a0 :: MatK a) (b :: MatK a) (d :: MatK a). (c ~> a0) -> (b ~> d) -> Mat a0 b -> Mat c d Source Github # lmap :: forall (c :: MatK a) (a0 :: MatK a) (b :: MatK a). (c ~> a0) -> Mat a0 b -> Mat c b Source Github # rmap :: forall (b :: MatK a) (d :: MatK a) (a0 :: MatK a). (b ~> d) -> Mat a0 b -> Mat a0 d Source Github # (\\) :: forall (a0 :: MatK a) (b :: MatK a) r. ((Ob a0, Ob b) => r) -> Mat a0 b -> r Source Github # | |
| Profunctor (LTE :: ORDINAL n -> ORDINAL n -> Type) Source Github # | |
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 # | |
Defined in Proarrow.Category.Instance.Span Methods dimap :: forall (c :: SPAN k) (a :: SPAN k) (b :: SPAN k) (d :: SPAN k). (c ~> a) -> (b ~> d) -> Span a b -> Span c d Source Github # lmap :: forall (c :: SPAN k) (a :: SPAN k) (b :: SPAN k). (c ~> a) -> Span a b -> Span c b Source Github # rmap :: forall (b :: SPAN k) (d :: SPAN k) (a :: SPAN k). (b ~> d) -> Span a b -> Span a d Source Github # (\\) :: forall (a :: SPAN k) (b :: SPAN k) r. ((Ob a, Ob b) => r) -> Span a b -> r Source Github # | |
| CategoryOf k => Profunctor (Endo :: ENDO k -> ENDO k -> Type) Source Github # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
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 # | |
Defined in Proarrow.Category.Promonoidal Methods dimap :: forall (c :: LIST k) (a :: LIST k) (b :: LIST j) (d :: LIST j). (c ~> a) -> (b ~> d) -> PList ps a b -> PList ps c d Source Github # lmap :: forall (c :: LIST k) (a :: LIST k) (b :: LIST j). (c ~> a) -> PList ps a b -> PList ps c b Source Github # rmap :: forall (b :: LIST j) (d :: LIST j) (a :: LIST k). (b ~> d) -> PList ps a b -> PList ps a d Source Github # (\\) :: forall (a :: LIST k) (b :: LIST j) r. ((Ob a, Ob b) => r) -> PList ps a b -> r Source Github # | |
| Profunctor p => Profunctor (List p :: LIST k -> LIST j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.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 # | |
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 # | |
| Promonad p => Profunctor (Kleisli :: KLEISLI p -> KLEISLI p -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Kleisli Methods dimap :: forall (c :: KLEISLI p) (a :: KLEISLI p) (b :: KLEISLI p) (d :: KLEISLI p). (c ~> a) -> (b ~> d) -> Kleisli a b -> Kleisli c d Source Github # lmap :: forall (c :: KLEISLI p) (a :: KLEISLI p) (b :: KLEISLI p). (c ~> a) -> Kleisli a b -> Kleisli c b Source Github # rmap :: forall (b :: KLEISLI p) (d :: KLEISLI p) (a :: KLEISLI p). (b ~> d) -> Kleisli a b -> Kleisli a d Source Github # (\\) :: forall (a :: KLEISLI p) (b :: KLEISLI p) r. ((Ob a, Ob b) => r) -> Kleisli a b -> r Source Github # | |
| Profunctor (Nat' :: (j .-> k) -> (j .-> k) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods dimap :: forall (c :: j .-> k) (a :: j .-> k) (b :: j .-> k) (d :: j .-> k). (c ~> a) -> (b ~> d) -> Nat' a b -> Nat' c d Source Github # lmap :: forall (c :: j .-> k) (a :: j .-> k) (b :: j .-> k). (c ~> a) -> Nat' a b -> Nat' c b Source Github # rmap :: forall (b :: j .-> k) (d :: j .-> k) (a :: j .-> k). (b ~> d) -> Nat' a b -> Nat' a d Source Github # (\\) :: forall (a :: j .-> k) (b :: j .-> k) r. ((Ob a, Ob b) => r) -> Nat' a b -> r Source Github # | |
| (CategoryOf k, Rewrite p) => Profunctor (Paths :: PATHS p -> PATHS p -> Type) Source Github # | |
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 # | |
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 # | |
Defined in Proarrow.Category.Instance.Prof Methods dimap :: forall (c :: j +-> k) (a :: j +-> k) (b :: j +-> k) (d :: j +-> k). (c ~> a) -> (b ~> d) -> Prof a b -> Prof c d Source Github # lmap :: forall (c :: j +-> k) (a :: j +-> k) (b :: j +-> k). (c ~> a) -> Prof a b -> Prof c b Source Github # rmap :: forall (b :: j +-> k) (d :: j +-> k) (a :: j +-> k). (b ~> d) -> Prof a b -> Prof a d Source Github # (\\) :: forall (a :: j +-> k) (b :: j +-> k) r. ((Ob a, Ob b) => r) -> Prof a b -> r Source Github # | |
| Profunctor (Nat :: (k1 -> k2 -> k3 -> k4 -> Type) -> (k1 -> k2 -> k3 -> k4 -> Type) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods dimap :: forall (c :: k1 -> k2 -> k3 -> k4 -> Type) (a :: k1 -> k2 -> k3 -> k4 -> Type) (b :: k1 -> k2 -> k3 -> k4 -> Type) (d :: k1 -> k2 -> k3 -> k4 -> Type). (c ~> a) -> (b ~> d) -> Nat a b -> Nat c d Source Github # lmap :: forall (c :: k1 -> k2 -> k3 -> k4 -> Type) (a :: k1 -> k2 -> k3 -> k4 -> Type) (b :: k1 -> k2 -> k3 -> k4 -> Type). (c ~> a) -> Nat a b -> Nat c b Source Github # rmap :: forall (b :: k1 -> k2 -> k3 -> k4 -> Type) (d :: k1 -> k2 -> k3 -> k4 -> Type) (a :: k1 -> k2 -> k3 -> k4 -> Type). (b ~> d) -> Nat a b -> Nat a d Source Github # (\\) :: forall (a :: k1 -> k2 -> k3 -> k4 -> Type) (b :: k1 -> k2 -> k3 -> k4 -> Type) r. ((Ob a, Ob b) => r) -> Nat a b -> r Source Github # | |
| Profunctor (Nat :: (k1 -> k2 -> k3 -> Type) -> (k1 -> k2 -> k3 -> Type) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods dimap :: forall (c :: k1 -> k2 -> k3 -> Type) (a :: k1 -> k2 -> k3 -> Type) (b :: k1 -> k2 -> k3 -> Type) (d :: k1 -> k2 -> k3 -> Type). (c ~> a) -> (b ~> d) -> Nat a b -> Nat c d Source Github # lmap :: forall (c :: k1 -> k2 -> k3 -> Type) (a :: k1 -> k2 -> k3 -> Type) (b :: k1 -> k2 -> k3 -> Type). (c ~> a) -> Nat a b -> Nat c b Source Github # rmap :: forall (b :: k1 -> k2 -> k3 -> Type) (d :: k1 -> k2 -> k3 -> Type) (a :: k1 -> k2 -> k3 -> Type). (b ~> d) -> Nat a b -> Nat a d Source Github # (\\) :: forall (a :: k1 -> k2 -> k3 -> Type) (b :: k1 -> k2 -> k3 -> Type) r. ((Ob a, Ob b) => r) -> Nat a b -> r Source Github # | |
| Profunctor (Nat :: (k1 -> Type) -> (k1 -> Type) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods dimap :: forall (c :: k1 -> Type) (a :: k1 -> Type) (b :: k1 -> Type) (d :: k1 -> Type). (c ~> a) -> (b ~> d) -> Nat a b -> Nat c d Source Github # lmap :: forall (c :: k1 -> Type) (a :: k1 -> Type) (b :: k1 -> Type). (c ~> a) -> Nat a b -> Nat c b Source Github # rmap :: forall (b :: k1 -> Type) (d :: k1 -> Type) (a :: k1 -> Type). (b ~> d) -> Nat a b -> Nat a d Source Github # (\\) :: forall (a :: k1 -> Type) (b :: k1 -> Type) r. ((Ob a, Ob b) => r) -> Nat a b -> r Source Github # | |
| Profunctor p => Profunctor (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Sub Methods dimap :: forall (c :: SUBCAT ob) (a :: SUBCAT ob) (b :: SUBCAT ob) (d :: SUBCAT ob). (c ~> a) -> (b ~> d) -> Sub p a b -> Sub p c d Source Github # lmap :: forall (c :: SUBCAT ob) (a :: SUBCAT ob) (b :: SUBCAT ob). (c ~> a) -> Sub p a b -> Sub p c b Source Github # rmap :: forall (b :: SUBCAT ob) (d :: SUBCAT ob) (a :: SUBCAT ob). (b ~> d) -> Sub p a b -> Sub p a d Source Github # (\\) :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) r. ((Ob a, Ob b) => r) -> Sub p a b -> r Source Github # | |
| Monoid m => Profunctor (Mon :: MONOID m -> MONOID m -> Type) Source Github # | |
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 # | |
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 # | |
Defined in Proarrow.Category.Instance.Coproduct Methods dimap :: forall (c :: COPRODUCT k1 k2) (a :: COPRODUCT k1 k2) (b :: COPRODUCT j1 j2) (d :: COPRODUCT j1 j2). (c ~> a) -> (b ~> d) -> (p :++: q) a b -> (p :++: q) c d Source Github # lmap :: forall (c :: COPRODUCT k1 k2) (a :: COPRODUCT k1 k2) (b :: COPRODUCT j1 j2). (c ~> a) -> (p :++: q) a b -> (p :++: q) c b Source Github # rmap :: forall (b :: COPRODUCT j1 j2) (d :: COPRODUCT j1 j2) (a :: COPRODUCT k1 k2). (b ~> d) -> (p :++: q) a b -> (p :++: q) a d Source Github # (\\) :: forall (a :: COPRODUCT k1 k2) (b :: COPRODUCT j1 j2) r. ((Ob a, Ob b) => r) -> (p :++: q) a b -> r Source Github # | |
| (Profunctor p, Profunctor q) => Profunctor (p :**: q :: (k1, k2) -> (j1, j2) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Product Methods dimap :: forall (c :: (k1, k2)) (a :: (k1, k2)) (b :: (j1, j2)) (d :: (j1, j2)). (c ~> a) -> (b ~> d) -> (p :**: q) a b -> (p :**: q) c d Source Github # lmap :: forall (c :: (k1, k2)) (a :: (k1, k2)) (b :: (j1, j2)). (c ~> a) -> (p :**: q) a b -> (p :**: q) c b Source Github # rmap :: forall (b :: (j1, j2)) (d :: (j1, j2)) (a :: (k1, k2)). (b ~> d) -> (p :**: q) a b -> (p :**: q) a d Source Github # (\\) :: forall (a :: (k1, k2)) (b :: (j1, j2)) r. ((Ob a, Ob b) => r) -> (p :**: q) a b -> r Source Github # | |
| Profunctor p => Profunctor (Collage :: COLLAGE p -> COLLAGE p -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Collage Methods dimap :: forall (c :: COLLAGE p) (a :: COLLAGE p) (b :: COLLAGE p) (d :: COLLAGE p). (c ~> a) -> (b ~> d) -> Collage a b -> Collage c d Source Github # lmap :: forall (c :: COLLAGE p) (a :: COLLAGE p) (b :: COLLAGE p). (c ~> a) -> Collage a b -> Collage c b Source Github # rmap :: forall (b :: COLLAGE p) (d :: COLLAGE p) (a :: COLLAGE p). (b ~> d) -> Collage a b -> Collage a d Source Github # (\\) :: forall (a :: COLLAGE p) (b :: COLLAGE p) r. ((Ob a, Ob b) => r) -> Collage a b -> r Source Github # | |
| Adjunction adj => Profunctor (Duploid :: DUPLOID adj -> DUPLOID adj -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Duploid Methods dimap :: forall (c :: DUPLOID adj) (a :: DUPLOID adj) (b :: DUPLOID adj) (d :: DUPLOID adj). (c ~> a) -> (b ~> d) -> Duploid a b -> Duploid c d Source Github # lmap :: forall (c :: DUPLOID adj) (a :: DUPLOID adj) (b :: DUPLOID adj). (c ~> a) -> Duploid a b -> Duploid c b Source Github # rmap :: forall (b :: DUPLOID adj) (d :: DUPLOID adj) (a :: DUPLOID adj). (b ~> d) -> Duploid a b -> Duploid a d Source Github # (\\) :: forall (a :: DUPLOID adj) (b :: DUPLOID adj) r. ((Ob a, Ob b) => r) -> Duploid a b -> r Source Github # | |
| Profunctor (Free :: FREE cs p -> FREE cs p -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Free Methods dimap :: forall (c :: FREE cs p) (a :: FREE cs p) (b :: FREE cs p) (d :: FREE cs p). (c ~> a) -> (b ~> d) -> Free a b -> Free c d Source Github # lmap :: forall (c :: FREE cs p) (a :: FREE cs p) (b :: FREE cs p). (c ~> a) -> Free a b -> Free c b Source Github # rmap :: forall (b :: FREE cs p) (d :: FREE cs p) (a :: FREE cs p). (b ~> d) -> Free a b -> Free a d Source Github # (\\) :: forall (a :: FREE cs p) (b :: FREE cs p) r. ((Ob a, Ob b) => r) -> Free a b -> r Source Github # | |
| ThinProfunctor p => Profunctor (Graph :: GRAPH p -> GRAPH p -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Graph Methods dimap :: forall (c :: GRAPH p) (a :: GRAPH p) (b :: GRAPH p) (d :: GRAPH p). (c ~> a) -> (b ~> d) -> Graph a b -> Graph c d Source Github # lmap :: forall (c :: GRAPH p) (a :: GRAPH p) (b :: GRAPH p). (c ~> a) -> Graph a b -> Graph c b Source Github # rmap :: forall (b :: GRAPH p) (d :: GRAPH p) (a :: GRAPH p). (b ~> d) -> Graph a b -> Graph a d Source Github # (\\) :: forall (a :: GRAPH p) (b :: GRAPH p) r. ((Ob a, Ob b) => r) -> Graph a b -> r Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (Optic_ :: OPTIC j k c -> OPTIC j k c -> Type) Source Github # | |
Defined in Proarrow.Optic Methods dimap :: forall (c0 :: OPTIC j k c) (a :: OPTIC j k c) (b :: OPTIC j k c) (d :: OPTIC j k c). (c0 ~> a) -> (b ~> d) -> Optic_ a b -> Optic_ c0 d Source Github # lmap :: forall (c0 :: OPTIC j k c) (a :: OPTIC j k c) (b :: OPTIC j k c). (c0 ~> a) -> Optic_ a b -> Optic_ c0 b Source Github # rmap :: forall (b :: OPTIC j k c) (d :: OPTIC j k c) (a :: OPTIC j k c). (b ~> d) -> Optic_ a b -> Optic_ a d Source Github # (\\) :: forall (a :: OPTIC j k c) (b :: OPTIC j k c) r. ((Ob a, Ob b) => r) -> Optic_ a b -> r Source Github # | |
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.
(//) :: 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 (\\).
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.
Objects
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.
pattern Objs :: forall {j} {k} p (a :: k) (b :: j). Profunctor p => (Ob a, Ob b) => p a b Source Github #
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
| (Ob a, CategoryOf k) => Ob' (a :: k) Source Github # | |
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
Functors
class (CategoryOf k1, CategoryOf k2, forall (a :: k1). Ob a => Ob' (f a)) => Functor (f :: k1 -> k2) where Source Github #
Functors between kind-indexed categories: map sends arrows of the source category to
arrows of the target category. Only functors landing in a kind of shape ... -> Type can be
written as type constructors like this; the rest are encoded as representable profunctors
instead (FunctorForRep, Proarrow.Profunctor.Representable).
Instances
type (.~>) (f :: k -> k1) (g :: k -> k1) = forall (a :: k). Ob a => f a ~> g a infixr 0 Source Github #
Natural transformations between functors: an arrow f a for every object ~> g aa.
newtype Prelude (f :: Type -> Type) a Source Github #
Makes a base-style Functor (kind Type -> Type) a Functor, to use with deriving via
(see the instances below). A direct instance Functor (f :: Type -> Type) would overlap with
the Functor instances at every other kind k -> Type, hence the wrapper.
Instances
class (CategoryOf j, CategoryOf k) => FunctorForRep (f :: j +-> k) where Source Github #
A perfectly valid functor definition, but hard to use.
So we only use it to easily make (co)representable profunctors with Rep and Corep.
Instances
class Profunctor p => Representable (p :: j +-> k) where Source Github #
A profunctor is representable if p ? a as a presheaf is representable in a functorial way over a.
Methods
index :: forall (a :: k) (b :: j). p a b -> a ~> (p % b) Source Github #
tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (p % b)) -> p a b Source Github #
repMap :: forall (a :: j) (b :: j). (a ~> b) -> (p % a) ~> (p % b) Source Github #
repUniv :: forall (a :: j). Ob a => p (p % a) a Source Github #
Instances
| Representable Booleans Source Github # | |||||
Defined in Proarrow.Profunctor.Representable Associated Types
Methods index :: forall (a :: BOOL) (b :: BOOL). Booleans a b -> a ~> (Booleans % b) Source Github # tabulate :: forall (b :: BOOL) (a :: BOOL). Ob b => (a ~> (Booleans % b)) -> Booleans a b Source Github # repMap :: forall (a :: BOOL) (b :: BOOL). (a ~> b) -> (Booleans % a) ~> (Booleans % b) Source Github # repUniv :: forall (a :: BOOL). Ob a => Booleans (Booleans % a) a Source Github # | |||||
| Functor m => Representable (Kleisli m :: Type -> Type -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Arrow | |||||
| ArrowApply arr => Representable (Arr arr :: Type -> Type -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Arrow | |||||
| CategoryOf k => Representable (Id :: k -> k -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Representable Methods index :: forall (a :: k) (b :: k). Id a b -> a ~> ((Id :: k -> k -> Type) % b) Source Github # tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> ((Id :: k -> k -> Type) % b)) -> Id a b Source Github # repMap :: forall (a :: k) (b :: k). (a ~> b) -> ((Id :: k -> k -> Type) % a) ~> ((Id :: k -> k -> Type) % b) Source Github # repUniv :: forall (a :: k). Ob a => Id ((Id :: k -> k -> Type) % a) a Source Github # | |||||
| Representable (Cont r :: Type -> Type -> Type) Source Github # | At | ||||
| Representable (->) Source Github # | |||||
Defined in Proarrow.Profunctor.Representable Associated Types
| |||||
| (HasTerminalObject k, CategoryOf j) => Representable (TerminalProfunctor :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Limit.Terminal Methods index :: forall (a :: k) (b :: j). TerminalProfunctor a b -> a ~> ((TerminalProfunctor :: k -> j -> Type) % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> ((TerminalProfunctor :: k -> j -> Type) % b)) -> TerminalProfunctor a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> ((TerminalProfunctor :: k -> j -> Type) % a) ~> ((TerminalProfunctor :: k -> j -> Type) % b) Source Github # repUniv :: forall (a :: j). Ob a => TerminalProfunctor ((TerminalProfunctor :: k -> j -> Type) % a) a Source Github # | |||||
| (Monoidal k, SNatI n) => Representable (Pow n :: k -> k -> Type) Source Github # | |||||
Defined in Proarrow.Optic.PowerGrate Methods index :: forall (a :: k) (b :: k). Pow n a b -> a ~> ((Pow n :: k -> k -> Type) % b) Source Github # tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> ((Pow n :: k -> k -> Type) % b)) -> Pow n a b Source Github # repMap :: forall (a :: k) (b :: k). (a ~> b) -> ((Pow n :: k -> k -> Type) % a) ~> ((Pow n :: k -> k -> Type) % b) Source Github # repUniv :: forall (a :: k). Ob a => Pow n ((Pow n :: k -> k -> Type) % a) a Source Github # | |||||
| (Ob r, SymMonoidal k, Closed k) => Representable (Reader ('OP r) :: k -> k -> Type) Source Github # | The reader monad given the Promonad instance. | ||||
Defined in Proarrow.Promonad.Reader Methods index :: forall (a :: k) (b :: k). Reader ('OP r) a b -> a ~> (Reader ('OP r) % b) Source Github # tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> (Reader ('OP r) % b)) -> Reader ('OP r) a b Source Github # repMap :: forall (a :: k) (b :: k). (a ~> b) -> (Reader ('OP r) % a) ~> (Reader ('OP r) % b) Source Github # repUniv :: forall (a :: k). Ob a => Reader ('OP r) (Reader ('OP r) % a) a Source Github # | |||||
| (Ob w, Monoidal k) => Representable (Writer w :: k -> k -> Type) Source Github # | The writer monad given the Promonad instance. | ||||
Defined in Proarrow.Promonad.Writer Methods index :: forall (a :: k) (b :: k). Writer w a b -> a ~> (Writer w % b) Source Github # tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> (Writer w % b)) -> Writer w a b Source Github # repMap :: forall (a :: k) (b :: k). (a ~> b) -> (Writer w % a) ~> (Writer w % b) Source Github # repUniv :: forall (a :: k). Ob a => Writer w (Writer w % a) a Source Github # | |||||
| Representable (Costar ((,) a) :: Type -> Type -> Type) Source Github # | The right adjoint of | ||||
Defined in Proarrow.Adjunction Methods index :: Costar ((,) a) a0 b -> a0 ~> (Costar ((,) a) % b) Source Github # tabulate :: Ob b => (a0 ~> (Costar ((,) a) % b)) -> Costar ((,) a) a0 b Source Github # repMap :: (a0 ~> b) -> (Costar ((,) a) % a0) ~> (Costar ((,) a) % b) Source Github # repUniv :: Ob a0 => Costar ((,) a) (Costar ((,) a) % a0) a0 Source Github # | |||||
| Representable p => Representable (Adj p :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Adj Methods index :: forall (a :: k) (b :: j). Adj p a b -> a ~> (Adj p % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (Adj p % b)) -> Adj p a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> (Adj p % a) ~> (Adj p % b) Source Github # repUniv :: forall (a :: j). Ob a => Adj p (Adj p % a) a Source Github # | |||||
| Functor f => Representable (Star f :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Star Methods index :: forall (a :: k) (b :: j). Star f a b -> a ~> (Star f % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (Star f % b)) -> Star f a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> (Star f % a) ~> (Star f % b) Source Github # repUniv :: forall (a :: j). Ob a => Star f (Star f % a) a Source Github # | |||||
| Representable p => Representable (Wrapped p :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Wrapped Methods index :: forall (a :: k) (b :: j). Wrapped p a b -> a ~> (Wrapped p % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (Wrapped p % b)) -> Wrapped p a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> (Wrapped p % a) ~> (Wrapped p % b) Source Github # repUniv :: forall (a :: j). Ob a => Wrapped p (Wrapped p % a) a Source Github # | |||||
| Corepresentable p => Representable (CorepStar p :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Representable Methods index :: forall (a :: k) (b :: j). CorepStar p a b -> a ~> (CorepStar p % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (CorepStar p % b)) -> CorepStar p a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> (CorepStar p % a) ~> (CorepStar p % b) Source Github # repUniv :: forall (a :: j). Ob a => CorepStar p (CorepStar p % a) a Source Github # | |||||
| FunctorForRep f => Representable (Rep f :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Representable Methods index :: forall (a :: k) (b :: j). Rep f a b -> a ~> (Rep f % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (Rep f % b)) -> Rep f a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> (Rep f % a) ~> (Rep f % b) Source Github # repUniv :: forall (a :: j). Ob a => Rep f (Rep f % a) a Source Github # | |||||
| Representable m => Representable (AsRelative m :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Promonad Methods index :: forall (a :: k) (b :: j). AsRelative m a b -> a ~> (AsRelative m % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (AsRelative m % b)) -> AsRelative m a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> (AsRelative m % a) ~> (AsRelative m % b) Source Github # repUniv :: forall (a :: j). Ob a => AsRelative m (AsRelative m % a) a Source Github # | |||||
| (forall (b :: j). Ob b => TermUniversal b l, Corepresentable l) => Representable (AsLeftAdjoint l :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Universal Methods index :: forall (a :: k) (b :: j). AsLeftAdjoint l a b -> a ~> (AsLeftAdjoint l % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (AsLeftAdjoint l % b)) -> AsLeftAdjoint l a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> (AsLeftAdjoint l % a) ~> (AsLeftAdjoint l % b) Source Github # repUniv :: forall (a :: j). Ob a => AsLeftAdjoint l (AsLeftAdjoint l % a) a Source Github # | |||||
| Representable r => Representable (AsRightAdjoint r :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Universal Methods index :: forall (a :: k) (b :: j). AsRightAdjoint r a b -> a ~> (AsRightAdjoint r % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (AsRightAdjoint r % b)) -> AsRightAdjoint r a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> (AsRightAdjoint r % a) ~> (AsRightAdjoint r % b) Source Github # repUniv :: forall (a :: j). Ob a => AsRightAdjoint r (AsRightAdjoint r % a) a Source Github # | |||||
| Representable p => Representable (FromAdjunction p :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Universal Methods index :: forall (a :: k) (b :: j). FromAdjunction p a b -> a ~> (FromAdjunction p % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (FromAdjunction p % b)) -> FromAdjunction p a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> (FromAdjunction p % a) ~> (FromAdjunction p % b) Source Github # repUniv :: forall (a :: j). Ob a => FromAdjunction p (FromAdjunction p % a) a Source Github # | |||||
| (Powered v k, Ob n) => Representable (GenArrow ('OP n) :: k -> k -> Type) Source Github # | |||||
Defined in Proarrow.Limit.Power Methods index :: forall (a :: k) (b :: k). GenArrow ('OP n) a b -> a ~> ((GenArrow ('OP n) :: k -> k -> Type) % b) Source Github # tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> ((GenArrow ('OP n) :: k -> k -> Type) % b)) -> GenArrow ('OP n) a b Source Github # repMap :: forall (a :: k) (b :: k). (a ~> b) -> ((GenArrow ('OP n) :: k -> k -> Type) % a) ~> ((GenArrow ('OP n) :: k -> k -> Type) % b) Source Github # repUniv :: forall (a :: k). Ob a => GenArrow ('OP n) ((GenArrow ('OP n) :: k -> k -> Type) % a) a Source Github # | |||||
| (Representable p, Ob r, SymMonoidal k, Closed k) => Representable (ReaderT ('OP r) p :: k -> k -> Type) Source Github # | |||||
Defined in Proarrow.Promonad.Reader Methods index :: forall (a :: k) (b :: k). ReaderT ('OP r) p a b -> a ~> (ReaderT ('OP r) p % b) Source Github # tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> (ReaderT ('OP r) p % b)) -> ReaderT ('OP r) p a b Source Github # repMap :: forall (a :: k) (b :: k). (a ~> b) -> (ReaderT ('OP r) p % a) ~> (ReaderT ('OP r) p % b) Source Github # repUniv :: forall (a :: k). Ob a => ReaderT ('OP r) p (ReaderT ('OP r) p % a) a Source Github # | |||||
| (Representable p, Ob s, SymMonoidal k, Closed k) => Representable (StateT s p :: k -> k -> Type) Source Github # | |||||
Defined in Proarrow.Promonad.State Methods index :: forall (a :: k) (b :: k). StateT s p a b -> a ~> (StateT s p % b) Source Github # tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> (StateT s p % b)) -> StateT s p a b Source Github # repMap :: forall (a :: k) (b :: k). (a ~> b) -> (StateT s p % a) ~> (StateT s p % b) Source Github # repUniv :: forall (a :: k). Ob a => StateT s p (StateT s p % a) a Source Github # | |||||
| (Representable p, Ob w, Monoidal k) => Representable (WriterT w p :: k -> k -> Type) Source Github # | |||||
Defined in Proarrow.Promonad.Writer Methods index :: forall (a :: k) (b :: k). WriterT w p a b -> a ~> (WriterT w p % b) Source Github # tabulate :: forall (b :: k) (a :: k). Ob b => (a ~> (WriterT w p % b)) -> WriterT w p a b Source Github # repMap :: forall (a :: k) (b :: k). (a ~> b) -> (WriterT w p % a) ~> (WriterT w p % b) Source Github # repUniv :: forall (a :: k). Ob a => WriterT w p (WriterT w p % a) a Source Github # | |||||
| (HasBinaryProducts k, Representable p, Representable q) => Representable (p :*: q :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Limit.BinaryProduct Methods index :: forall (a :: k) (b :: j). (p :*: q) a b -> a ~> ((p :*: q) % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> ((p :*: q) % b)) -> (p :*: q) a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> ((p :*: q) % a) ~> ((p :*: q) % b) Source Github # repUniv :: forall (a :: j). Ob a => (p :*: q) ((p :*: q) % a) a Source Github # | |||||
| (HasLimits j2 k, Representable d) => Representable (Ran ('OP j2) d :: k -> j1 -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Ran Methods index :: forall (a :: k) (b :: j1). Ran ('OP j2) d a b -> a ~> (Ran ('OP j2) d % b) Source Github # tabulate :: forall (b :: j1) (a :: k). Ob b => (a ~> (Ran ('OP j2) d % b)) -> Ran ('OP j2) d a b Source Github # repMap :: forall (a :: j1) (b :: j1). (a ~> b) -> (Ran ('OP j2) d % a) ~> (Ran ('OP j2) d % b) Source Github # repUniv :: forall (a :: j1). Ob a => Ran ('OP j2) d (Ran ('OP j2) d % a) a Source Github # | |||||
| (Representable p, Representable q) => Representable (p :.: q :: k -> j2 -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Representable Methods index :: forall (a :: k) (b :: j2). (p :.: q) a b -> a ~> ((p :.: q) % b) Source Github # tabulate :: forall (b :: j2) (a :: k). Ob b => (a ~> ((p :.: q) % b)) -> (p :.: q) a b Source Github # repMap :: forall (a :: j2) (b :: j2). (a ~> b) -> ((p :.: q) % a) ~> ((p :.: q) % b) Source Github # repUniv :: forall (a :: j2). Ob a => (p :.: q) ((p :.: q) % a) a Source Github # | |||||
| HasCofree ob => Representable (Corep (Forget ob) :: SUBCAT ob -> k -> Type) Source Github # | By creating the right adjoint to the forgetful functor, we obtain the forgetful-cofree adjunction. | ||||
Defined in Proarrow.Profunctor.Cofree Methods index :: forall (a :: SUBCAT ob) (b :: k). Corep (Forget ob) a b -> a ~> (Corep (Forget ob) % b) Source Github # tabulate :: forall (b :: k) (a :: SUBCAT ob). Ob b => (a ~> (Corep (Forget ob) % b)) -> Corep (Forget ob) a b Source Github # repMap :: forall (a :: k) (b :: k). (a ~> b) -> (Corep (Forget ob) % a) ~> (Corep (Forget ob) % b) Source Github # repUniv :: forall (a :: k). Ob a => Corep (Forget ob) (Corep (Forget ob) % a) a Source Github # | |||||
| Monoidal k => Representable (Tensor :: k -> LIST k -> Type) Source Github # | |||||
Defined in Proarrow.Category.Promonoidal Methods index :: forall (a :: k) (b :: LIST k). Tensor a b -> a ~> ((Tensor :: k -> LIST k -> Type) % b) Source Github # tabulate :: forall (b :: LIST k) (a :: k). Ob b => (a ~> ((Tensor :: k -> LIST k -> Type) % b)) -> Tensor a b Source Github # repMap :: forall (a :: LIST k) (b :: LIST k). (a ~> b) -> ((Tensor :: k -> LIST k -> Type) % a) ~> ((Tensor :: k -> LIST k -> Type) % b) Source Github # repUniv :: forall (a :: LIST k). Ob a => Tensor ((Tensor :: k -> LIST k -> Type) % a) a Source Github # | |||||
| Corepresentable p => Representable (Op p :: OPPOSITE j -> OPPOSITE k -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Representable Methods index :: forall (a :: OPPOSITE j) (b :: OPPOSITE k). Op p a b -> a ~> (Op p % b) Source Github # tabulate :: forall (b :: OPPOSITE k) (a :: OPPOSITE j). Ob b => (a ~> (Op p % b)) -> Op p a b Source Github # repMap :: forall (a :: OPPOSITE k) (b :: OPPOSITE k). (a ~> b) -> (Op p % a) ~> (Op p % b) Source Github # repUniv :: forall (a :: OPPOSITE k). Ob a => Op p (Op p % a) a Source Github # | |||||
| Representable p => Representable (Coprod p :: COPROD k -> COPROD j -> Type) Source Github # | |||||
Defined in Proarrow.Colimit.BinaryCoproduct Methods index :: forall (a :: COPROD k) (b :: COPROD j). Coprod p a b -> a ~> (Coprod p % b) Source Github # tabulate :: forall (b :: COPROD j) (a :: COPROD k). Ob b => (a ~> (Coprod p % b)) -> Coprod p a b Source Github # repMap :: forall (a :: COPROD j) (b :: COPROD j). (a ~> b) -> (Coprod p % a) ~> (Coprod p % b) Source Github # repUniv :: forall (a :: COPROD j). Ob a => Coprod p (Coprod p % a) a Source Github # | |||||
| Representable p => Representable (Prod p :: PROD k -> PROD j -> Type) Source Github # | |||||
Defined in Proarrow.Limit.BinaryProduct Methods index :: forall (a :: PROD k) (b :: PROD j). Prod p a b -> a ~> (Prod p % b) Source Github # tabulate :: forall (b :: PROD j) (a :: PROD k). Ob b => (a ~> (Prod p % b)) -> Prod p a b Source Github # repMap :: forall (a :: PROD j) (b :: PROD j). (a ~> b) -> (Prod p % a) ~> (Prod p % b) Source Github # repUniv :: forall (a :: PROD j). Ob a => Prod p (Prod p % a) a Source Github # | |||||
| Representable p => Representable (List p :: LIST k -> LIST j -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.List Methods index :: forall (a :: LIST k) (b :: LIST j). List p a b -> a ~> (List p % b) Source Github # tabulate :: forall (b :: LIST j) (a :: LIST k). Ob b => (a ~> (List p % b)) -> List p a b Source Github # repMap :: forall (a :: LIST j) (b :: LIST j). (a ~> b) -> (List p % a) ~> (List p % b) Source Github # repUniv :: forall (a :: LIST j). Ob a => List p (List p % a) a Source Github # | |||||
| HasBinaryProducts k => Representable (Corep (Diag :: k +-> (k, k)) :: k -> (k, k) -> Type) Source Github # | The right adjoint to the diagonal functor. | ||||
Defined in Proarrow.Limit.BinaryProduct Methods index :: forall (a :: k) (b :: (k, k)). Corep (Diag :: k +-> (k, k)) a b -> a ~> (Corep (Diag :: k +-> (k, k)) % b) Source Github # tabulate :: forall (b :: (k, k)) (a :: k). Ob b => (a ~> (Corep (Diag :: k +-> (k, k)) % b)) -> Corep (Diag :: k +-> (k, k)) a b Source Github # repMap :: forall (a :: (k, k)) (b :: (k, k)). (a ~> b) -> (Corep (Diag :: k +-> (k, k)) % a) ~> (Corep (Diag :: k +-> (k, k)) % b) Source Github # repUniv :: forall (a :: (k, k)). Ob a => Corep (Diag :: k +-> (k, k)) (Corep (Diag :: k +-> (k, k)) % a) a Source Github # | |||||
| (Representable p, forall (a :: k). ob a => ob (p % a)) => Representable (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |||||
Defined in Proarrow.Category.Instance.Sub Methods index :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). Sub p a b -> a ~> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % b) Source Github # tabulate :: forall (b :: SUBCAT ob) (a :: SUBCAT ob). Ob b => (a ~> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % b)) -> Sub p a b Source Github # repMap :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (a ~> b) -> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % a) ~> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % b) Source Github # repUniv :: forall (a :: SUBCAT ob). Ob a => Sub p ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % a) a Source Github # | |||||
| HasLimits j k => Representable (LimitAdj j :: COREPK b k -> REPK a k -> Type) Source Github # |
| ||||
Defined in Proarrow.Adjunction Methods index :: forall (a0 :: COREPK b k) (b0 :: REPK a k). LimitAdj j a0 b0 -> a0 ~> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % b0) Source Github # tabulate :: forall (b0 :: REPK a k) (a0 :: COREPK b k). Ob b0 => (a0 ~> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % b0)) -> LimitAdj j a0 b0 Source Github # repMap :: forall (a0 :: REPK a k) (b0 :: REPK a k). (a0 ~> b0) -> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % a0) ~> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % b0) Source Github # repUniv :: forall (a0 :: REPK a k). Ob a0 => LimitAdj j ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % a0) a0 Source Github # | |||||
| (Representable p, Representable q) => Representable (p :++: q :: COPRODUCT k1 k2 -> COPRODUCT j1 j2 -> Type) Source Github # | |||||
Defined in Proarrow.Category.Instance.Coproduct Methods index :: forall (a :: COPRODUCT k1 k2) (b :: COPRODUCT j1 j2). (p :++: q) a b -> a ~> ((p :++: q) % b) Source Github # tabulate :: forall (b :: COPRODUCT j1 j2) (a :: COPRODUCT k1 k2). Ob b => (a ~> ((p :++: q) % b)) -> (p :++: q) a b Source Github # repMap :: forall (a :: COPRODUCT j1 j2) (b :: COPRODUCT j1 j2). (a ~> b) -> ((p :++: q) % a) ~> ((p :++: q) % b) Source Github # repUniv :: forall (a :: COPRODUCT j1 j2). Ob a => (p :++: q) ((p :++: q) % a) a Source Github # | |||||
| (Representable p, Representable q) => Representable (p :**: q :: (k1, k2) -> (j1, j2) -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Representable Methods index :: forall (a :: (k1, k2)) (b :: (j1, j2)). (p :**: q) a b -> a ~> ((p :**: q) % b) Source Github # tabulate :: forall (b :: (j1, j2)) (a :: (k1, k2)). Ob b => (a ~> ((p :**: q) % b)) -> (p :**: q) a b Source Github # repMap :: forall (a :: (j1, j2)) (b :: (j1, j2)). (a ~> b) -> ((p :**: q) % a) ~> ((p :**: q) % b) Source Github # repUniv :: forall (a :: (j1, j2)). Ob a => (p :**: q) ((p :**: q) % a) a Source Github # | |||||
data Rep (f :: j +-> k) (a :: k) (b :: j) where Source Github #
The representable profunctor of a functor-for-representation f (FunctorForRep): a value
Rep f a ba . This is the profunctor encoding of
functors used throughout the library.~> f @ b
Constructors
| Rep | |
Instances
| (ThinProfunctor p, FunctorForRep g, Thin j) => ComposeThin 'ByRight (p :: j +-> k) (Rep g :: j -> i -> Type) Source Github # | A represented right leg forces the middle object up to |
Defined in Proarrow.Category.Enriched.Thin.Composition | |
| (DecidableProfunctor p, FunctorForRep g, Thin j) => DecideComp 'ByRight (p :: j +-> k) (Rep g :: j -> i -> Type) Source Github # | |
Defined in Proarrow.Category.Enriched.Thin.Composition | |
| (MonoidalAction act, Ob x) => ActFl (act :: (m, j) +-> j) (Rep (ActionAt act x) :: j -> j -> Type) (Corep (ActionAt act x) :: j -> j -> Type) Source Github # | |
| Monoidal k => MonoidalAction (Tensor :: k -> (k, k) -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Action Methods unitor :: forall (x :: k). Ob x => Act (Tensor :: k -> (k, k) -> Type) (Unit :: k) x ~> x Source Github # unitorInv :: forall (x :: k). Ob x => x ~> Act (Tensor :: k -> (k, k) -> Type) (Unit :: k) x Source Github # multiplicator :: forall (a :: k) (b :: k) (x :: k). (Ob a, Ob b, Ob x) => Act (Tensor :: k -> (k, k) -> Type) (a ** b) x ~> Act (Tensor :: k -> (k, k) -> Type) a (Act (Tensor :: k -> (k, k) -> Type) b x) Source Github # multiplicatorInv :: forall (a :: k) (b :: k) (x :: k). (Ob a, Ob b, Ob x) => Act (Tensor :: k -> (k, k) -> Type) a (Act (Tensor :: k -> (k, k) -> Type) b x) ~> Act (Tensor :: k -> (k, k) -> Type) (a ** b) x Source Github # | |
| Costrong (Tensor :: DOT -> (DOT, DOT) -> Type) Dot Source Github # | |
| Costrong (Tensor :: SVG -> (SVG, SVG) -> Type) Svg Source Github # | The traced wires loop round the side of the diagram they are nearest to. |
| MonadFix m => Costrong (Tensor :: Type -> (Type, Type) -> Type) (Kleisli m :: Type -> Type -> Type) Source Github # | |
| ArrowLoop arr => Costrong (Tensor :: Type -> (Type, Type) -> Type) (Arr arr :: Type -> Type -> Type) Source Github # | |
| Monad m => Strong (Tensor :: Type -> (Type, Type) -> Type) (Kleisli m :: Type -> Type -> Type) Source Github # | |
| Arrow arr => Strong (Tensor :: Type -> (Type, Type) -> Type) (Arr arr :: Type -> Type -> Type) Source Github # | |
| Costrong (Tensor :: Type -> (Type, Type) -> Type) (->) Source Github # | |
| Strong (Tensor :: Type -> (Type, Type) -> Type) (Cont r :: Type -> Type -> Type) Source Github # | |
| (CopyDiscard k, SNatI n) => Strong (Tensor :: k -> (k, k) -> Type) (Pow n :: k -> k -> Type) Source Github # | |
| (Ob r, SymMonoidal k) => Strong (Tensor :: k -> (k, k) -> Type) (Reader ('OP r) :: k -> k -> Type) Source Github # | |
| (Ob w, SymMonoidal k) => Strong (Tensor :: k -> (k, k) -> Type) (Writer w :: k -> k -> Type) Source Github # | |
| Functor f => Strong (Tensor :: Type -> (Type, Type) -> Type) (Star f :: Type -> Type -> Type) Source Github # | |
| (SymMonoidal k, Ob m) => Strong (Tensor :: k -> (k, k) -> Type) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
| (Closed k, SymMonoidal k, Ob m) => Strong (Tensor :: k -> (k, k) -> Type) (Rep (Exp m) :: k -> k -> Type) Source Github # | |
| (CopyDiscard k, Ob r) => Strong (Tensor :: k -> (k, k) -> Type) (Rep (Constant r) :: k -> k -> Type) Source Github # | The constant functor ignores the acting object: discard it. Only copying/discarding is needed, so this works in biproduct categories as well as cartesian ones. |
| (Strong (Tensor :: k -> (k, k) -> Type) p, Ob r, SymMonoidal k) => Strong (Tensor :: k -> (k, k) -> Type) (ReaderT ('OP r) p :: k -> k -> Type) Source Github # | |
| (Strong (Tensor :: k -> (k, k) -> Type) p, Ob s, SymMonoidal k) => Strong (Tensor :: k -> (k, k) -> Type) (StateT s p :: k -> k -> Type) Source Github # | |
| (Strong (Tensor :: k -> (k, k) -> Type) p, Ob w, SymMonoidal k) => Strong (Tensor :: k -> (k, k) -> Type) (WriterT w p :: k -> k -> Type) Source Github # | |
| (Monoidal k, Ob a, Ob b, Flavor w, forall (m :: k). Ob m => w (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m))) => Costrong (Tensor :: k -> (k, k) -> Type) (ExOptic w a b :: k -> k -> Type) Source Github # | The generic carrier absorbs the residual of a |
| (Monoidal k, Ob a, Ob b, Flavor w, forall (x :: k). Ob x => w (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) x)) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) x))) => Strong (Tensor :: k -> (k, k) -> Type) (ExOptic w a b :: k -> k -> Type) Source Github # | |
| (FunctorForRep f, DecidableProfunctor (Hom k)) => DecidableProfunctor (Rep f :: k -> j -> Type) Source Github # | |
| (FunctorForRep f, Thin k) => ThinProfunctor (Rep f :: k -> j -> Type) Source Github # | |
| MonoidalProfunctor (Rep Fun) Source Github # | |
| MonoidalProfunctor (Rep Forget) Source Github # | Forget is a lax monoidal functor |
| (SymMonoidal k, Monoid m) => MonoidalProfunctor (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | Tensoring with a monoid, |
Defined in Proarrow.Monoid Methods one :: Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) (Unit :: k) (Unit :: k) Source Github # (**) :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) x1 x2 -> Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) y1 y2 -> Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) (x1 ** y1) (x2 ** y2) Source Github # | |
| (Closed k, SymMonoidal k, Comonoid m) => MonoidalProfunctor (Rep (Exp m) :: k -> k -> Type) Source Github # | The exponential by a comonoid, |
| (Monoidal k, Monoid r) => MonoidalProfunctor (Rep (Constant r) :: k -> k -> Type) Source Github # | |
| CategoryOf k => MonoidalAction (Rep (NoAction :: ((), k) +-> k) :: k -> ((), k) -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Action Methods unitor :: forall (x :: k). Ob x => Act (Rep (NoAction :: ((), k) +-> k)) (Unit :: ()) x ~> x Source Github # unitorInv :: forall (x :: k). Ob x => x ~> Act (Rep (NoAction :: ((), k) +-> k)) (Unit :: ()) x Source Github # multiplicator :: forall (a :: ()) (b :: ()) (x :: k). (Ob a, Ob b, Ob x) => Act (Rep (NoAction :: ((), k) +-> k)) (a ** b) x ~> Act (Rep (NoAction :: ((), k) +-> k)) a (Act (Rep (NoAction :: ((), k) +-> k)) b x) Source Github # multiplicatorInv :: forall (a :: ()) (b :: ()) (x :: k). (Ob a, Ob b, Ob x) => Act (Rep (NoAction :: ((), k) +-> k)) a (Act (Rep (NoAction :: ((), k) +-> k)) b x) ~> Act (Rep (NoAction :: ((), k) +-> k)) (a ** b) x Source Github # | |
| FunctorForRep f => Profunctor (Rep f :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Representable Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Rep f a b -> Rep f c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Rep f a b -> Rep f c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Rep f a b -> Rep f a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Rep f a b -> r Source Github # | |
| Corepresentable (Rep Forget) Source Github # | By creating the left adjoint to the forgetful functor, we obtain the free-forgetful adjunction between Hask and LINEAR |
Defined in Proarrow.Category.Instance.Linear Methods coindex :: forall a (b :: LINEAR). Rep Forget a b -> (Rep Forget %% a) ~> b Source Github # cotabulate :: forall a (b :: LINEAR). Ob a => ((Rep Forget %% a) ~> b) -> Rep Forget a b Source Github # corepMap :: (a ~> b) -> (Rep Forget %% a) ~> (Rep Forget %% b) Source Github # corepUniv :: Ob a => Rep Forget a (Rep Forget %% a) Source Github # | |
| FunctorForRep f => Representable (Rep f :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Representable Methods index :: forall (a :: k) (b :: j). Rep f a b -> a ~> (Rep f % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> (Rep f % b)) -> Rep f a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> (Rep f % a) ~> (Rep f % b) Source Github # repUniv :: forall (a :: j). Ob a => Rep f (Rep f % a) a Source Github # | |
| ProLaws (Costrong (Tensor :: j -> (j, j) -> Type) :: (j +-> j) -> Constraint) Source Github # | The laws of costrength for the tensor acting on its own category: |
| ProLaws (Strong (Tensor :: j -> (j, j) -> Type) :: (j +-> j) -> Constraint) Source Github # | The laws of strength for the tensor acting on its own category: acting by the |
| FunctorForRep f => HasColimits (Rep f :: i -> a -> Type) k Source Github # | |
| FunctorForRep f => Proadjunction (Rep f :: k -> j -> Type) (Corep f :: j -> k -> Type) Source Github # | |
| (OplaxMonoidalRep m, Algebra m x, Comonoid x) => AlgLensFl (m :: k +-> k) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) x) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) x) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Action | |
| (OplaxMonoidalRep l, Algebra l x, Monoid x, Comonoid x, SymMonoidal k, HasCoproducts k) => ClassifyFl (l :: k +-> k) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) x) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) x) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Action | |
| (HasCoproducts k, Ob t) => AffineFoldFl (Corep (Coproduct t) :: k -> k -> Type) (Rep (Coproduct t) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.AffineFold Methods previewP :: forall (s :: k) (a :: k). Bicartesian k => Corep (Coproduct t) s a -> s ~> (a || (TerminalObject :: k)) Source Github # | |
| Comonoid m => AffineFoldFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | The tensor-action witness pair |
Defined in Proarrow.Optic.MonoidalLens | |
| (CopyDiscard k, HasCoproducts k, Ob t) => AffineFoldFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.AffineFold Methods previewP :: forall (s :: k) (a :: k). Bicartesian k => Rep (Coproduct t) s a -> s ~> (a || (TerminalObject :: k)) Source Github # | |
| (HasBinaryProducts k, Ob s) => AffineFoldFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.AffineFold Methods previewP :: forall (s0 :: k) (a :: k). Bicartesian k => Rep (Product s) s0 a -> s0 ~> (a || (TerminalObject :: k)) Source Github # | |
| (FoldFl p1 q1, FoldFl p2 q2, Monoidal k) => FoldFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github # | |
| (FoldFl p1 q1, FoldFl p2 q2, HasBinaryCoproducts k) => FoldFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github # | |
| (HasCoproducts k, Ob t) => FoldFl (Corep (Coproduct t) :: k -> k -> Type) (Rep (Coproduct t) :: k -> k -> Type) Source Github # | |
| Comonoid m => FoldFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | The tensor-action witness pair |
| (CopyDiscard k, HasCoproducts k, Ob t) => FoldFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
| (HasBinaryProducts k, Ob s) => FoldFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
| (HasCoproducts k, Ob t) => GetterFl (Corep (Coproduct t) :: k -> k -> Type) (Rep (Coproduct t) :: k -> k -> Type) Source Github # | |
| Comonoid m => GetterFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
| (HasBinaryProducts k, Ob s) => GetterFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
| HasBinaryCoproducts k => Corepresentable (Rep (Diag :: k +-> (k, k)) :: (k, k) -> k -> Type) Source Github # | The left adjoint to the diagonal functor. |
Defined in Proarrow.Colimit.BinaryCoproduct Methods coindex :: forall (a :: (k, k)) (b :: k). Rep (Diag :: k +-> (k, k)) a b -> (Rep (Diag :: k +-> (k, k)) %% a) ~> b Source Github # cotabulate :: forall (a :: (k, k)) (b :: k). Ob a => ((Rep (Diag :: k +-> (k, k)) %% a) ~> b) -> Rep (Diag :: k +-> (k, k)) a b Source Github # corepMap :: forall (a :: (k, k)) (b :: (k, k)). (a ~> b) -> (Rep (Diag :: k +-> (k, k)) %% a) ~> (Rep (Diag :: k +-> (k, k)) %% b) Source Github # corepUniv :: forall (a :: (k, k)). Ob a => Rep (Diag :: k +-> (k, k)) a (Rep (Diag :: k +-> (k, k)) %% a) Source Github # | |
| (FunctorForRep f, Promonad (Corep f)) => Promonad (RepCostar (Rep f) :: k -> k -> Type) Source Github # | |
| Comonoid m => AffineTravFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | In a cartesian category the tensor is the product, so the comonoidal residual can be
projected out and put back: |
Defined in Proarrow.Optic.MonoidalLens Methods affineMatch :: forall (s :: k) (a :: k) (b :: k) (t :: k). Bicartesian k => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> s ~> (t || a) Source Github # affineSet :: forall (s :: k) (a :: k) (b :: k) (t :: k). Bicartesian k => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> (s && b) ~> t Source Github # | |
| (CopyDiscard k, HasCoproducts k, Ob t) => AffineTravFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.AffineTraversal Methods affineMatch :: forall (s :: k) (a :: k) (b :: k) (t0 :: k). Bicartesian k => Rep (Coproduct t) s a -> Corep (Coproduct t) b t0 -> s ~> (t0 || a) Source Github # affineSet :: forall (s :: k) (a :: k) (b :: k) (t0 :: k). Bicartesian k => Rep (Coproduct t) s a -> Corep (Coproduct t) b t0 -> (s && b) ~> t0 Source Github # | |
| (HasBinaryProducts k, Ob s) => AffineTravFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.AffineTraversal Methods affineMatch :: forall (s0 :: k) (a :: k) (b :: k) (t :: k). Bicartesian k => Rep (Product s) s0 a -> Corep (Product s) b t -> s0 ~> (t || a) Source Github # affineSet :: forall (s0 :: k) (a :: k) (b :: k) (t :: k). Bicartesian k => Rep (Product s) s0 a -> Corep (Product s) b t -> (s0 && b) ~> t Source Github # | |
| Comonoid m => GlassFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
| (Closed k, Ob d) => GlassFl (Rep (Exp d) :: k -> k -> Type) (Corep (Exp d) :: k -> k -> Type) Source Github # | The exponential pair, a grate witness: the source is ignored, and the consumer is fed the
selector |
| (HasBinaryProducts k, Ob c) => GlassFl (Rep (Product c) :: k -> k -> Type) (Corep (Product c) :: k -> k -> Type) Source Github # | The product pair, a lens witness: the selector is the lens's own |
| (Closed k, SymMonoidal k, HasCoproducts k, Comonoid m) => GrateFl (Rep (Exp m) :: k -> k -> Type) (Corep (Exp m) :: k -> k -> Type) Source Github # | |
| (SymMonoidal k, HasCoproducts k, Monoid m) => CotravFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | The tensor-action pair for a monoid residual: |
| (Closed k, SymMonoidal k, HasCoproducts k, Comonoid m) => CotravFl (Rep (Exp m) :: k -> k -> Type) (Corep (Exp m) :: k -> k -> Type) Source Github # | The exponential pair for a comonoid exponent: |
Defined in Proarrow.Optic.Kaleidoscope | |
| (SymMonoidal k, HasCoproducts k, Monoid m) => KaleidoFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
| (Closed k, SymMonoidal k, HasCoproducts k, Comonoid m) => KaleidoFl (Rep (Exp m) :: k -> k -> Type) (Corep (Exp m) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Kaleidoscope | |
| (HasBinaryProducts k, Ob s) => LensFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
| Comonoid m => MonLensFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.MonoidalLens Methods withMonLensP :: forall (s :: k) (a :: k) (b :: k) (t :: k) r. SymMonoidal k => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> (forall (m0 :: k). Ob m0 => ComonoidOn m0 -> (s ~> (m0 ** a)) -> ((m0 ** b) ~> t) -> r) -> r Source Github # | |
| (CopyDiscard k, HasCoproducts k, Ob t) => PrismFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
| (SetterFl p1 q1, SetterFl p2 q2, Monoidal k) => SetterFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github # | |
| (SetterFl p1 q1, SetterFl p2 q2, HasBinaryCoproducts k) => SetterFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| (TracedMonoidal k, Ob m) => SetterFl (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | The tracer witness: the tensor-action pair read the other way round, |
| (Monoidal k, Ob a) => SetterFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) a) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) a) :: k -> k -> Type) Source Github # | The tensor-action witness pair |
| (Closed k, Ob m) => SetterFl (Rep (Exp m) :: k -> k -> Type) (Corep (Exp m) :: k -> k -> Type) Source Github # | The grate witness is a setter witness: map under the exponential. The |
| (HasCoproducts k, Ob t) => SetterFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
| (HasBinaryProducts k, Ob s) => SetterFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
| (TracedMonoidal k, Ob m) => TracerFl (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Tracer | |
| (MonTravFl p1 q1, MonTravFl p2 q2, Monoidal k) => MonTravFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| (MonTravFl p1 q1, MonTravFl p2 q2, HasBinaryCoproducts k) => MonTravFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal Methods monTravP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). StrongDistributiveProfunctor r => BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> r a b -> r s t Source Github # | |
| Comonoid m => MonTravFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
| (CopyDiscard k, HasCoproducts k, Ob t) => MonTravFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| (TravFl p1 q1, TravFl p2 q2, Monoidal k) => TravFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| (TravFl p1 q1, TravFl p2 q2, HasBinaryCoproducts k) => TravFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal Methods travP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). (StrongDistributiveProfunctor r, Strong (ProdAction :: k -> (PROD k, k) -> Type) r) => BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> r a b -> r s t Source Github # | |
| Comonoid m => TravFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| (CopyDiscard k, HasCoproducts k, Ob t) => TravFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| (HasBinaryProducts k, Ob s) => TravFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| CategoryOf k => MonoidalAction (RepAction :: k -> (RepSub k, k) -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.EndoProf Methods unitor :: forall (x :: k). Ob x => Act (RepAction :: k -> (RepSub k, k) -> Type) (Unit :: RepSub k) x ~> x Source Github # unitorInv :: forall (x :: k). Ob x => x ~> Act (RepAction :: k -> (RepSub k, k) -> Type) (Unit :: RepSub k) x Source Github # multiplicator :: forall (a :: RepSub k) (b :: RepSub k) (x :: k). (Ob a, Ob b, Ob x) => Act (RepAction :: k -> (RepSub k, k) -> Type) (a ** b) x ~> Act (RepAction :: k -> (RepSub k, k) -> Type) a (Act (RepAction :: k -> (RepSub k, k) -> Type) b x) Source Github # multiplicatorInv :: forall (a :: RepSub k) (b :: RepSub k) (x :: k). (Ob a, Ob b, Ob x) => Act (RepAction :: k -> (RepSub k, k) -> Type) a (Act (RepAction :: k -> (RepSub k, k) -> Type) b x) ~> Act (RepAction :: k -> (RepSub k, k) -> Type) (a ** b) x Source Github # | |
| CategoryOf k => MonoidalAction (TravAction :: k -> (TravSub k, k) -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.EndoProf Methods unitor :: forall (x :: k). Ob x => Act (TravAction :: k -> (TravSub k, k) -> Type) (Unit :: TravSub k) x ~> x Source Github # unitorInv :: forall (x :: k). Ob x => x ~> Act (TravAction :: k -> (TravSub k, k) -> Type) (Unit :: TravSub k) x Source Github # multiplicator :: forall (a :: TravSub k) (b :: TravSub k) (x :: k). (Ob a, Ob b, Ob x) => Act (TravAction :: k -> (TravSub k, k) -> Type) (a ** b) x ~> Act (TravAction :: k -> (TravSub k, k) -> Type) a (Act (TravAction :: k -> (TravSub k, k) -> Type) b x) Source Github # multiplicatorInv :: forall (a :: TravSub k) (b :: TravSub k) (x :: k). (Ob a, Ob b, Ob x) => Act (TravAction :: k -> (TravSub k, k) -> Type) a (Act (TravAction :: k -> (TravSub k, k) -> Type) b x) ~> Act (TravAction :: k -> (TravSub k, k) -> Type) (a ** b) x Source Github # | |
| HasCoproducts k => MonoidalAction (CoprodAction :: k -> (COPROD k, k) -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Action Methods unitor :: forall (x :: k). Ob x => Act (CoprodAction :: k -> (COPROD k, k) -> Type) (Unit :: COPROD k) x ~> x Source Github # unitorInv :: forall (x :: k). Ob x => x ~> Act (CoprodAction :: k -> (COPROD k, k) -> Type) (Unit :: COPROD k) x Source Github # multiplicator :: forall (a :: COPROD k) (b :: COPROD k) (x :: k). (Ob a, Ob b, Ob x) => Act (CoprodAction :: k -> (COPROD k, k) -> Type) (a ** b) x ~> Act (CoprodAction :: k -> (COPROD k, k) -> Type) a (Act (CoprodAction :: k -> (COPROD k, k) -> Type) b x) Source Github # multiplicatorInv :: forall (a :: COPROD k) (b :: COPROD k) (x :: k). (Ob a, Ob b, Ob x) => Act (CoprodAction :: k -> (COPROD k, k) -> Type) a (Act (CoprodAction :: k -> (COPROD k, k) -> Type) b x) ~> Act (CoprodAction :: k -> (COPROD k, k) -> Type) (a ** b) x Source Github # | |
| HasProducts k => MonoidalAction (ProdAction :: k -> (PROD k, k) -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Action Methods unitor :: forall (x :: k). Ob x => Act (ProdAction :: k -> (PROD k, k) -> Type) (Unit :: PROD k) x ~> x Source Github # unitorInv :: forall (x :: k). Ob x => x ~> Act (ProdAction :: k -> (PROD k, k) -> Type) (Unit :: PROD k) x Source Github # multiplicator :: forall (a :: PROD k) (b :: PROD k) (x :: k). (Ob a, Ob b, Ob x) => Act (ProdAction :: k -> (PROD k, k) -> Type) (a ** b) x ~> Act (ProdAction :: k -> (PROD k, k) -> Type) a (Act (ProdAction :: k -> (PROD k, k) -> Type) b x) Source Github # multiplicatorInv :: forall (a :: PROD k) (b :: PROD k) (x :: k). (Ob a, Ob b, Ob x) => Act (ProdAction :: k -> (PROD k, k) -> Type) a (Act (ProdAction :: k -> (PROD k, k) -> Type) b x) ~> Act (ProdAction :: k -> (PROD k, k) -> Type) (a ** b) x Source Github # | |
| Costrong (CoprodAction :: LINEAR -> (COPROD LINEAR, LINEAR) -> Type) Linear Source Github # | |
Defined in Proarrow.Category.Instance.Linear | |
| Cartesian k => Costrong (ProdAction :: k -> (PROD k, k) -> Type) (Fold :: k -> k -> Type) Source Github # | |
| MonadPlus m => Strong (CoprodAction :: Type -> (COPROD Type, Type) -> Type) (Kleisli m :: Type -> Type -> Type) Source Github # | |
| BiCCC k => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (Fold :: k -> k -> Type) Source Github # | |
| (CopyDiscard k, HasCoproducts k, SNatI n) => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (Pow n :: k -> k -> Type) Source Github # | |
| Applicative f => Strong (CoprodAction :: Type -> (COPROD Type, Type) -> Type) (Star f :: Type -> Type -> Type) Source Github # | |
| (Monoidal k, HasCoproducts k, Monoid m) => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Monoid | |
| (Closed k, HasCoproducts k, Comonoid m) => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (Rep (Exp m) :: k -> k -> Type) Source Github # | |
| (CopyDiscard k, HasCoproducts k, Monoid r) => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (Rep (Constant r) :: k -> k -> Type) Source Github # | The constant functor absorbs a coproduct action: the injected summand is discarded onto the monoid's unit, so this needs only copying/discarding on the tensor side and coproducts. |
| Functor f => Strong (ProdAction :: Type -> (PROD Type, Type) -> Type) (Star (Prelude f) :: Type -> Type -> Type) Source Github # | |
| (HasCoproducts k, Ob a, Ob b, Flavor w, forall (t :: k). Ob t => w (Rep (Coproduct t)) (Corep (Coproduct t))) => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (ExOptic w a b :: k -> k -> Type) Source Github # | |
| (HasProducts k, Ob a, Ob b, Flavor w, forall (s :: k). Ob s => w (Rep (Product s)) (Corep (Product s))) => Strong (ProdAction :: k -> (PROD k, k) -> Type) (ExOptic w a b :: k -> k -> Type) Source Github # | |
| Num a => MonoidalProfunctor (Rep (App :: MatK a +-> Type) :: Type -> MatK a -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Mat | |
| (Closed k, SymMonoidal k, Ob r) => Corepresentable (Rep (Not r) :: k -> OPPOSITE k -> Type) Source Github # | The Op-Op adjunction, giving rise to the continuation monad. |
Defined in Proarrow.Category.Monoidal.Closed Methods coindex :: forall (a :: k) (b :: OPPOSITE k). Rep (Not r) a b -> (Rep (Not r) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: OPPOSITE k). Ob a => ((Rep (Not r) %% a) ~> b) -> Rep (Not r) a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Rep (Not r) %% a) ~> (Rep (Not r) %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Rep (Not r) a (Rep (Not r) %% a) Source Github # | |
| RealFloat a => MonoidalProfunctor (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) :: MatK (Complex a) -> MatK (Complex a) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Mat Methods one :: Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) (Unit :: MatK (Complex a)) (Unit :: MatK (Complex a)) Source Github # (**) :: forall (x1 :: MatK (Complex a)) (x2 :: MatK (Complex a)) (y1 :: MatK (Complex a)) (y2 :: MatK (Complex a)). Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) x1 x2 -> Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) y1 y2 -> Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) (x1 ** y1) (x2 ** y2) Source Github # | |
| MonoidalProfunctor (Coprod (Rep Fun)) Source Github # | |
Defined in Proarrow.Category.Instance.FinRel Methods one :: Coprod (Rep Fun) (Unit :: COPROD FINREL) (Unit :: COPROD FINSET) Source Github # (**) :: forall (x1 :: COPROD FINREL) (x2 :: COPROD FINSET) (y1 :: COPROD FINREL) (y2 :: COPROD FINSET). Coprod (Rep Fun) x1 x2 -> Coprod (Rep Fun) y1 y2 -> Coprod (Rep Fun) (x1 ** y1) (x2 ** y2) Source Github # | |
| (Monoidal k, HasCoproducts k, Ob m) => MonoidalProfunctor (Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) :: COPROD k -> COPROD k -> Type) Source Github # | |
Defined in Proarrow.Monoid Methods one :: Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # (**) :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) x1 x2 -> Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) y1 y2 -> Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) (x1 ** y1) (x2 ** y2) Source Github # | |
| (Closed k, HasCoproducts k, Ob m) => MonoidalProfunctor (Coprod (Rep (Exp m)) :: COPROD k -> COPROD k -> Type) Source Github # | |
Defined in Proarrow.Monoid | |
| (HasCoproducts k, Ob r) => MonoidalProfunctor (Coprod (Rep (Constant r)) :: COPROD k -> COPROD k -> Type) Source Github # | |
Defined in Proarrow.Monoid Methods one :: Coprod (Rep (Constant r)) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # (**) :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod (Rep (Constant r)) x1 x2 -> Coprod (Rep (Constant r)) y1 y2 -> Coprod (Rep (Constant r)) (x1 ** y1) (x2 ** y2) Source Github # | |
| MonoidalAction t => MonoidalAction (Rep (OpAction t) :: OPPOSITE k -> (OPPOSITE m, OPPOSITE k) -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Action Methods unitor :: forall (x :: OPPOSITE k). Ob x => Act (Rep (OpAction t)) (Unit :: OPPOSITE m) x ~> x Source Github # unitorInv :: forall (x :: OPPOSITE k). Ob x => x ~> Act (Rep (OpAction t)) (Unit :: OPPOSITE m) x Source Github # multiplicator :: forall (a :: OPPOSITE m) (b :: OPPOSITE m) (x :: OPPOSITE k). (Ob a, Ob b, Ob x) => Act (Rep (OpAction t)) (a ** b) x ~> Act (Rep (OpAction t)) a (Act (Rep (OpAction t)) b x) Source Github # multiplicatorInv :: forall (a :: OPPOSITE m) (b :: OPPOSITE m) (x :: OPPOSITE k). (Ob a, Ob b, Ob x) => Act (Rep (OpAction t)) a (Act (Rep (OpAction t)) b x) ~> Act (Rep (OpAction t)) (a ** b) x Source Github # | |
| RealFloat a => Corepresentable (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) :: MatK (Complex a) -> MatK (Complex a) -> Type) Source Github # | Conjugation is a self-adjoint functor |
Defined in Proarrow.Category.Instance.Mat Methods coindex :: forall (a0 :: MatK (Complex a)) (b :: MatK (Complex a)). Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) a0 b -> (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% a0) ~> b Source Github # cotabulate :: forall (a0 :: MatK (Complex a)) (b :: MatK (Complex a)). Ob a0 => ((Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% a0) ~> b) -> Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) a0 b Source Github # corepMap :: forall (a0 :: MatK (Complex a)) (b :: MatK (Complex a)). (a0 ~> b) -> (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% a0) ~> (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% b) Source Github # corepUniv :: forall (a0 :: MatK (Complex a)). Ob a0 => Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) a0 (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% a0) Source Github # | |
| (CategoryOf j, CategoryOf k) => Strong (ProdAction :: (j +-> k) -> (PROD (j +-> k), j +-> k) -> Type) (Prof :: (j +-> k) -> (j +-> k) -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Strength | |
| (CategoryOf h, CategoryOf x) => MonoidalAction (Rep Precomp :: (x +-> h) -> (REV (ENDO x), x +-> h) -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.EndoProf Methods unitor :: forall (x0 :: x +-> h). Ob x0 => Act (Rep Precomp) (Unit :: REV (ENDO x)) x0 ~> x0 Source Github # unitorInv :: forall (x0 :: x +-> h). Ob x0 => x0 ~> Act (Rep Precomp) (Unit :: REV (ENDO x)) x0 Source Github # multiplicator :: forall (a :: REV (ENDO x)) (b :: REV (ENDO x)) (x0 :: x +-> h). (Ob a, Ob b, Ob x0) => Act (Rep Precomp) (a ** b) x0 ~> Act (Rep Precomp) a (Act (Rep Precomp) b x0) Source Github # multiplicatorInv :: forall (a :: REV (ENDO x)) (b :: REV (ENDO x)) (x0 :: x +-> h). (Ob a, Ob b, Ob x0) => Act (Rep Precomp) a (Act (Rep Precomp) b x0) ~> Act (Rep Precomp) (a ** b) x0 Source Github # | |
| RealFloat a => Involution (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) :: MatK (Complex a) -> MatK (Complex a) -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Mat Methods involuted :: forall (a0 :: MatK (Complex a)) (a' :: MatK (Complex a)). (Ob a0, Ob a') => PIso a0 a' (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) % (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) % a0)) (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) % (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) % a')) Source Github # | |
| MonoidalAction ApplyAction Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods unitor :: Ob x => Act ApplyAction (Unit :: Type -> Type) x ~> x Source Github # unitorInv :: Ob x => x ~> Act ApplyAction (Unit :: Type -> Type) x Source Github # multiplicator :: forall (a :: Type -> Type) (b :: Type -> Type) x. (Ob a, Ob b, Ob x) => Act ApplyAction (a ** b) x ~> Act ApplyAction a (Act ApplyAction b x) Source Github # multiplicatorInv :: forall (a :: Type -> Type) (b :: Type -> Type) x. (Ob a, Ob b, Ob x) => Act ApplyAction a (Act ApplyAction b x) ~> Act ApplyAction (a ** b) x Source Github # | |
| HasFree ob => Corepresentable (Rep (Forget ob) :: k -> SUBCAT ob -> Type) Source Github # | By creating the left adjoint to the forgetful functor, we obtain the free-forgetful adjunction. |
Defined in Proarrow.Profunctor.Free Methods coindex :: forall (a :: k) (b :: SUBCAT ob). Rep (Forget ob) a b -> (Rep (Forget ob) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: SUBCAT ob). Ob a => ((Rep (Forget ob) %% a) ~> b) -> Rep (Forget ob) a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Rep (Forget ob) %% a) ~> (Rep (Forget ob) %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Rep (Forget ob) a (Rep (Forget ob) %% a) Source Github # | |
| (Monoidal k2, Monoidal (SUBCAT ob), MonoidalAction t) => MonoidalAction (SubAction ob t :: k1 -> (SUBCAT ob, k1) -> Type) Source Github # | |
Defined in Proarrow.Category.Monoidal.Action Methods unitor :: forall (x :: k1). Ob x => Act (SubAction ob t) (Unit :: SUBCAT ob) x ~> x Source Github # unitorInv :: forall (x :: k1). Ob x => x ~> Act (SubAction ob t) (Unit :: SUBCAT ob) x Source Github # multiplicator :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (x :: k1). (Ob a, Ob b, Ob x) => Act (SubAction ob t) (a ** b) x ~> Act (SubAction ob t) a (Act (SubAction ob t) b x) Source Github # multiplicatorInv :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (x :: k1). (Ob a, Ob b, Ob x) => Act (SubAction ob t) a (Act (SubAction ob t) b x) ~> Act (SubAction ob t) (a ** b) x Source Github # | |
| Applicative f => Strong (SubAction Traversable ApplyAction) (Star (Prelude f) :: Type -> Type -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Instance.Star Methods act :: forall (a :: SUBCAT Traversable) x y. Ob a => Star (Prelude f) x y -> Star (Prelude f) (Act (SubAction Traversable ApplyAction) a x) (Act (SubAction Traversable ApplyAction) a y) Source Github # | |
| type HasArrowComp 'ByRight (p :: j +-> k) (Rep g :: j -> i -> Type) (a :: k) (c :: i) Source Github # | |
Defined in Proarrow.Category.Enriched.Thin.Composition | |
| type HoldsComp 'ByRight (p :: j +-> k) (Rep g :: j -> i -> Type) (a :: k) (c :: i) Source Github # | |
| type Colimit (Rep f :: i -> a -> Type) (d :: k +-> i) Source Github # | |
| type (Rep Forget) %% (a :: Type) Source Github # | |
| type (Rep f :: k -> j -> Type) % (a :: j) Source Github # | |
Defined in Proarrow.Profunctor.Representable | |
| type HasArrow (Rep f :: k -> j -> Type) (a :: k) (b :: j) Source Github # | |
| type Holds (Rep f :: k -> j -> Type) (a :: k) (b :: j) Source Github # | |
| type (Rep (Not r) :: k -> OPPOSITE k -> Type) %% (a :: k) Source Github # | |
| type (Rep (Forget ob) :: k -> SUBCAT ob -> Type) %% (a :: k) Source Github # | |
| type (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) :: MatK (Complex a) -> MatK (Complex a) -> Type) %% (n :: MatK (Complex a)) Source Github # | |
| type (Rep (Diag :: k +-> (k, k)) :: (k, k) -> k -> Type) %% ('(a, b) :: (k, k)) Source Github # | |
class Profunctor p => Corepresentable (p :: j +-> k) where Source Github #
A profunctor is corepresentable if p a ? as a copresheaf is representable in a functorial way over a.
Minimal complete definition
coindex, (cotabulate, corepMap | corepUniv)
Methods
coindex :: forall (a :: k) (b :: j). p a b -> (p %% a) ~> b Source Github #
cotabulate :: forall (a :: k) (b :: j). Ob a => ((p %% a) ~> b) -> p a b Source Github #
corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (p %% a) ~> (p %% b) Source Github #
corepUniv :: forall (a :: k). Ob a => p a (p %% a) Source Github #
Instances
| Corepresentable Booleans Source Github # | |||||
Defined in Proarrow.Profunctor.Corepresentable Associated Types
Methods coindex :: forall (a :: BOOL) (b :: BOOL). Booleans a b -> (Booleans %% a) ~> b Source Github # cotabulate :: forall (a :: BOOL) (b :: BOOL). Ob a => ((Booleans %% a) ~> b) -> Booleans a b Source Github # corepMap :: forall (a :: BOOL) (b :: BOOL). (a ~> b) -> (Booleans %% a) ~> (Booleans %% b) Source Github # corepUniv :: forall (a :: BOOL). Ob a => Booleans a (Booleans %% a) Source Github # | |||||
| Corepresentable (Fold :: Type -> Type -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Fold Methods coindex :: Fold a b -> ((Fold :: Type -> Type -> Type) %% a) ~> b Source Github # cotabulate :: Ob a => (((Fold :: Type -> Type -> Type) %% a) ~> b) -> Fold a b Source Github # corepMap :: (a ~> b) -> ((Fold :: Type -> Type -> Type) %% a) ~> ((Fold :: Type -> Type -> Type) %% b) Source Github # corepUniv :: Ob a => Fold a ((Fold :: Type -> Type -> Type) %% a) Source Github # | |||||
| CategoryOf k => Corepresentable (Id :: k -> k -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Corepresentable Methods coindex :: forall (a :: k) (b :: k). Id a b -> ((Id :: k -> k -> Type) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: k). Ob a => (((Id :: k -> k -> Type) %% a) ~> b) -> Id a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> ((Id :: k -> k -> Type) %% a) ~> ((Id :: k -> k -> Type) %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Id a ((Id :: k -> k -> Type) %% a) Source Github # | |||||
| Corepresentable (->) Source Github # | |||||
Defined in Proarrow.Profunctor.Corepresentable Associated Types
| |||||
| (HasInitialObject j, CategoryOf k) => Corepresentable (TerminalProfunctor :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Colimit.Initial Methods coindex :: forall (a :: k) (b :: j). TerminalProfunctor a b -> ((TerminalProfunctor :: k -> j -> Type) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => (((TerminalProfunctor :: k -> j -> Type) %% a) ~> b) -> TerminalProfunctor a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> ((TerminalProfunctor :: k -> j -> Type) %% a) ~> ((TerminalProfunctor :: k -> j -> Type) %% b) Source Github # corepUniv :: forall (a :: k). Ob a => TerminalProfunctor a ((TerminalProfunctor :: k -> j -> Type) %% a) Source Github # | |||||
| (Ob r, Monoidal k) => Corepresentable (Reader ('OP r) :: k -> k -> Type) Source Github # | The coreader comonad given the Promonad instance.
Together with the | ||||
Defined in Proarrow.Promonad.Reader Methods coindex :: forall (a :: k) (b :: k). Reader ('OP r) a b -> (Reader ('OP r) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: k). Ob a => ((Reader ('OP r) %% a) ~> b) -> Reader ('OP r) a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Reader ('OP r) %% a) ~> (Reader ('OP r) %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Reader ('OP r) a (Reader ('OP r) %% a) Source Github # | |||||
| (Ob w, CompactClosed k) => Corepresentable (Writer w :: k -> k -> Type) Source Github # | The cowriter comonad given the Promonad instance. | ||||
Defined in Proarrow.Promonad.Writer Methods coindex :: forall (a :: k) (b :: k). Writer w a b -> (Writer w %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: k). Ob a => ((Writer w %% a) ~> b) -> Writer w a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Writer w %% a) ~> (Writer w %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Writer w a (Writer w %% a) Source Github # | |||||
| Corepresentable (Rep Forget) Source Github # | By creating the left adjoint to the forgetful functor, we obtain the free-forgetful adjunction between Hask and LINEAR | ||||
Defined in Proarrow.Category.Instance.Linear Methods coindex :: forall a (b :: LINEAR). Rep Forget a b -> (Rep Forget %% a) ~> b Source Github # cotabulate :: forall a (b :: LINEAR). Ob a => ((Rep Forget %% a) ~> b) -> Rep Forget a b Source Github # corepMap :: (a ~> b) -> (Rep Forget %% a) ~> (Rep Forget %% b) Source Github # corepUniv :: Ob a => Rep Forget a (Rep Forget %% a) Source Github # | |||||
| Corepresentable (Star ((->) a) :: Type -> Type -> Type) Source Github # | The left adjoint of | ||||
Defined in Proarrow.Adjunction Methods coindex :: Star ((->) a) a0 b -> (Star ((->) a) %% a0) ~> b Source Github # cotabulate :: Ob a0 => ((Star ((->) a) %% a0) ~> b) -> Star ((->) a) a0 b Source Github # corepMap :: (a0 ~> b) -> (Star ((->) a) %% a0) ~> (Star ((->) a) %% b) Source Github # corepUniv :: Ob a0 => Star ((->) a) a0 (Star ((->) a) %% a0) Source Github # | |||||
| (Relation p, Representable p) => Corepresentable (Converse p :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Category.Instance.Rel Methods coindex :: forall (a :: k) (b :: j). Converse p a b -> (Converse p %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((Converse p %% a) ~> b) -> Converse p a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Converse p %% a) ~> (Converse p %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Converse p a (Converse p %% a) Source Github # | |||||
| FunctorForRep f => Corepresentable (Corep f :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Corepresentable Methods coindex :: forall (a :: k) (b :: j). Corep f a b -> (Corep f %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((Corep f %% a) ~> b) -> Corep f a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Corep f %% a) ~> (Corep f %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Corep f a (Corep f %% a) Source Github # | |||||
| Corepresentable p => Corepresentable (Adj p :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Adj Methods coindex :: forall (a :: k) (b :: j). Adj p a b -> (Adj p %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((Adj p %% a) ~> b) -> Adj p a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Adj p %% a) ~> (Adj p %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Adj p a (Adj p %% a) Source Github # | |||||
| Functor f => Corepresentable (Costar f :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Costar Methods coindex :: forall (a :: k) (b :: j). Costar f a b -> (Costar f %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((Costar f %% a) ~> b) -> Costar f a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Costar f %% a) ~> (Costar f %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Costar f a (Costar f %% a) Source Github # | |||||
| Corepresentable p => Corepresentable (Wrapped p :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Wrapped Methods coindex :: forall (a :: k) (b :: j). Wrapped p a b -> (Wrapped p %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((Wrapped p %% a) ~> b) -> Wrapped p a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Wrapped p %% a) ~> (Wrapped p %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Wrapped p a (Wrapped p %% a) Source Github # | |||||
| Representable p => Corepresentable (RepCostar p :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Representable Methods coindex :: forall (a :: k) (b :: j). RepCostar p a b -> (RepCostar p %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((RepCostar p %% a) ~> b) -> RepCostar p a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (RepCostar p %% a) ~> (RepCostar p %% b) Source Github # corepUniv :: forall (a :: k). Ob a => RepCostar p a (RepCostar p %% a) Source Github # | |||||
| Corepresentable m => Corepresentable (AsRelative m :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Promonad Methods coindex :: forall (a :: k) (b :: j). AsRelative m a b -> (AsRelative m %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((AsRelative m %% a) ~> b) -> AsRelative m a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (AsRelative m %% a) ~> (AsRelative m %% b) Source Github # corepUniv :: forall (a :: k). Ob a => AsRelative m a (AsRelative m %% a) Source Github # | |||||
| Corepresentable l => Corepresentable (AsLeftAdjoint l :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Universal Methods coindex :: forall (a :: k) (b :: j). AsLeftAdjoint l a b -> (AsLeftAdjoint l %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((AsLeftAdjoint l %% a) ~> b) -> AsLeftAdjoint l a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (AsLeftAdjoint l %% a) ~> (AsLeftAdjoint l %% b) Source Github # corepUniv :: forall (a :: k). Ob a => AsLeftAdjoint l a (AsLeftAdjoint l %% a) Source Github # | |||||
| (forall (a :: k). Ob a => InitUniversal a r, Representable r) => Corepresentable (AsRightAdjoint r :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Universal Methods coindex :: forall (a :: k) (b :: j). AsRightAdjoint r a b -> (AsRightAdjoint r %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((AsRightAdjoint r %% a) ~> b) -> AsRightAdjoint r a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (AsRightAdjoint r %% a) ~> (AsRightAdjoint r %% b) Source Github # corepUniv :: forall (a :: k). Ob a => AsRightAdjoint r a (AsRightAdjoint r %% a) Source Github # | |||||
| Corepresentable p => Corepresentable (FromAdjunction p :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Universal Methods coindex :: forall (a :: k) (b :: j). FromAdjunction p a b -> (FromAdjunction p %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((FromAdjunction p %% a) ~> b) -> FromAdjunction p a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (FromAdjunction p %% a) ~> (FromAdjunction p %% b) Source Github # corepUniv :: forall (a :: k). Ob a => FromAdjunction p a (FromAdjunction p %% a) Source Github # | |||||
| (Copowered v k, Ob n) => Corepresentable (GenArrow ('OP n) :: k -> k -> Type) Source Github # | |||||
Defined in Proarrow.Colimit.Copower Methods coindex :: forall (a :: k) (b :: k). GenArrow ('OP n) a b -> ((GenArrow ('OP n) :: k -> k -> Type) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: k). Ob a => (((GenArrow ('OP n) :: k -> k -> Type) %% a) ~> b) -> GenArrow ('OP n) a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> ((GenArrow ('OP n) :: k -> k -> Type) %% a) ~> ((GenArrow ('OP n) :: k -> k -> Type) %% b) Source Github # corepUniv :: forall (a :: k). Ob a => GenArrow ('OP n) a ((GenArrow ('OP n) :: k -> k -> Type) %% a) Source Github # | |||||
| (Corepresentable p, Ob r, Monoidal k) => Corepresentable (ReaderT ('OP r) p :: k -> k -> Type) Source Github # | |||||
Defined in Proarrow.Promonad.Reader Methods coindex :: forall (a :: k) (b :: k). ReaderT ('OP r) p a b -> (ReaderT ('OP r) p %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: k). Ob a => ((ReaderT ('OP r) p %% a) ~> b) -> ReaderT ('OP r) p a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (ReaderT ('OP r) p %% a) ~> (ReaderT ('OP r) p %% b) Source Github # corepUniv :: forall (a :: k). Ob a => ReaderT ('OP r) p a (ReaderT ('OP r) p %% a) Source Github # | |||||
| (Corepresentable p, Ob s, Monoidal k, CompactClosed k) => Corepresentable (StateT s p :: k -> k -> Type) Source Github # | |||||
Defined in Proarrow.Promonad.State Methods coindex :: forall (a :: k) (b :: k). StateT s p a b -> (StateT s p %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: k). Ob a => ((StateT s p %% a) ~> b) -> StateT s p a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (StateT s p %% a) ~> (StateT s p %% b) Source Github # corepUniv :: forall (a :: k). Ob a => StateT s p a (StateT s p %% a) Source Github # | |||||
| (Corepresentable p, Ob w, CompactClosed k) => Corepresentable (WriterT w p :: k -> k -> Type) Source Github # | |||||
Defined in Proarrow.Promonad.Writer Methods coindex :: forall (a :: k) (b :: k). WriterT w p a b -> (WriterT w p %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: k). Ob a => ((WriterT w p %% a) ~> b) -> WriterT w p a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (WriterT w p %% a) ~> (WriterT w p %% b) Source Github # corepUniv :: forall (a :: k). Ob a => WriterT w p a (WriterT w p %% a) Source Github # | |||||
| (HasBinaryCoproducts j, Corepresentable p, Corepresentable q) => Corepresentable (p :*: q :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Colimit.BinaryCoproduct Methods coindex :: forall (a :: k) (b :: j). (p :*: q) a b -> ((p :*: q) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => (((p :*: q) %% a) ~> b) -> (p :*: q) a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> ((p :*: q) %% a) ~> ((p :*: q) %% b) Source Github # corepUniv :: forall (a :: k). Ob a => (p :*: q) a ((p :*: q) %% a) Source Github # | |||||
| (Corepresentable p, Corepresentable q) => Corepresentable (p :.: q :: k -> j2 -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Corepresentable Methods coindex :: forall (a :: k) (b :: j2). (p :.: q) a b -> ((p :.: q) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j2). Ob a => (((p :.: q) %% a) ~> b) -> (p :.: q) a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> ((p :.: q) %% a) ~> ((p :.: q) %% b) Source Github # corepUniv :: forall (a :: k). Ob a => (p :.: q) a ((p :.: q) %% a) Source Github # | |||||
| (HasColimits j k2, Corepresentable d) => Corepresentable (Rift ('OP j) d :: k1 -> k2 -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Rift Methods coindex :: forall (a :: k1) (b :: k2). Rift ('OP j) d a b -> (Rift ('OP j) d %% a) ~> b Source Github # cotabulate :: forall (a :: k1) (b :: k2). Ob a => ((Rift ('OP j) d %% a) ~> b) -> Rift ('OP j) d a b Source Github # corepMap :: forall (a :: k1) (b :: k1). (a ~> b) -> (Rift ('OP j) d %% a) ~> (Rift ('OP j) d %% b) Source Github # corepUniv :: forall (a :: k1). Ob a => Rift ('OP j) d a (Rift ('OP j) d %% a) Source Github # | |||||
| HasBinaryCoproducts k => Corepresentable (Rep (Diag :: k +-> (k, k)) :: (k, k) -> k -> Type) Source Github # | The left adjoint to the diagonal functor. | ||||
Defined in Proarrow.Colimit.BinaryCoproduct Methods coindex :: forall (a :: (k, k)) (b :: k). Rep (Diag :: k +-> (k, k)) a b -> (Rep (Diag :: k +-> (k, k)) %% a) ~> b Source Github # cotabulate :: forall (a :: (k, k)) (b :: k). Ob a => ((Rep (Diag :: k +-> (k, k)) %% a) ~> b) -> Rep (Diag :: k +-> (k, k)) a b Source Github # corepMap :: forall (a :: (k, k)) (b :: (k, k)). (a ~> b) -> (Rep (Diag :: k +-> (k, k)) %% a) ~> (Rep (Diag :: k +-> (k, k)) %% b) Source Github # corepUniv :: forall (a :: (k, k)). Ob a => Rep (Diag :: k +-> (k, k)) a (Rep (Diag :: k +-> (k, k)) %% a) Source Github # | |||||
| (Closed k, SymMonoidal k, Ob r) => Corepresentable (Rep (Not r) :: k -> OPPOSITE k -> Type) Source Github # | The Op-Op adjunction, giving rise to the continuation monad. | ||||
Defined in Proarrow.Category.Monoidal.Closed Methods coindex :: forall (a :: k) (b :: OPPOSITE k). Rep (Not r) a b -> (Rep (Not r) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: OPPOSITE k). Ob a => ((Rep (Not r) %% a) ~> b) -> Rep (Not r) a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Rep (Not r) %% a) ~> (Rep (Not r) %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Rep (Not r) a (Rep (Not r) %% a) Source Github # | |||||
| RealFloat a => Corepresentable (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) :: MatK (Complex a) -> MatK (Complex a) -> Type) Source Github # | Conjugation is a self-adjoint functor | ||||
Defined in Proarrow.Category.Instance.Mat Methods coindex :: forall (a0 :: MatK (Complex a)) (b :: MatK (Complex a)). Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) a0 b -> (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% a0) ~> b Source Github # cotabulate :: forall (a0 :: MatK (Complex a)) (b :: MatK (Complex a)). Ob a0 => ((Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% a0) ~> b) -> Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) a0 b Source Github # corepMap :: forall (a0 :: MatK (Complex a)) (b :: MatK (Complex a)). (a0 ~> b) -> (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% a0) ~> (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% b) Source Github # corepUniv :: forall (a0 :: MatK (Complex a)). Ob a0 => Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) a0 (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) %% a0) Source Github # | |||||
| Representable p => Corepresentable (Op p :: OPPOSITE j -> OPPOSITE k -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Representable Methods coindex :: forall (a :: OPPOSITE j) (b :: OPPOSITE k). Op p a b -> (Op p %% a) ~> b Source Github # cotabulate :: forall (a :: OPPOSITE j) (b :: OPPOSITE k). Ob a => ((Op p %% a) ~> b) -> Op p a b Source Github # corepMap :: forall (a :: OPPOSITE j) (b :: OPPOSITE j). (a ~> b) -> (Op p %% a) ~> (Op p %% b) Source Github # corepUniv :: forall (a :: OPPOSITE j). Ob a => Op p a (Op p %% a) Source Github # | |||||
| HasFree ob => Corepresentable (Rep (Forget ob) :: k -> SUBCAT ob -> Type) Source Github # | By creating the left adjoint to the forgetful functor, we obtain the free-forgetful adjunction. | ||||
Defined in Proarrow.Profunctor.Free Methods coindex :: forall (a :: k) (b :: SUBCAT ob). Rep (Forget ob) a b -> (Rep (Forget ob) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: SUBCAT ob). Ob a => ((Rep (Forget ob) %% a) ~> b) -> Rep (Forget ob) a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Rep (Forget ob) %% a) ~> (Rep (Forget ob) %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Rep (Forget ob) a (Rep (Forget ob) %% a) Source Github # | |||||
| Profunctor j2 => Corepresentable (Star (Ran ('OP j2) :: (i +-> k) -> k -> j1 -> Type) :: (k -> j1 -> Type) -> (i +-> k) -> Type) Source Github # | The right Kan extension is the right adjoint of the precomposition functor. | ||||
Defined in Proarrow.Profunctor.Instance.Ran Methods coindex :: forall (a :: k -> j1 -> Type) (b :: i +-> k). Star (Ran ('OP j2) :: (i +-> k) -> k -> j1 -> Type) a b -> (Star (Ran ('OP j2) :: (i +-> k) -> k -> j1 -> Type) %% a) ~> b Source Github # cotabulate :: forall (a :: k -> j1 -> Type) (b :: i +-> k). Ob a => ((Star (Ran ('OP j2) :: (i +-> k) -> k -> j1 -> Type) %% a) ~> b) -> Star (Ran ('OP j2) :: (i +-> k) -> k -> j1 -> Type) a b Source Github # corepMap :: forall (a :: k -> j1 -> Type) (b :: k -> j1 -> Type). (a ~> b) -> (Star (Ran ('OP j2) :: (i +-> k) -> k -> j1 -> Type) %% a) ~> (Star (Ran ('OP j2) :: (i +-> k) -> k -> j1 -> Type) %% b) Source Github # corepUniv :: forall (a :: k -> j1 -> Type). Ob a => Star (Ran ('OP j2) :: (i +-> k) -> k -> j1 -> Type) a (Star (Ran ('OP j2) :: (i +-> k) -> k -> j1 -> Type) %% a) Source Github # | |||||
| Corepresentable (Star (Tambara w) :: (k -> j -> Type) -> (j +-> k) -> Type) Source Github # |
| ||||
Defined in Proarrow.Profunctor.Instance.PastroTambara Methods coindex :: forall (a :: j +-> k) (b :: j +-> k). Star (Tambara w) a b -> (Star (Tambara w) %% a) ~> b Source Github # cotabulate :: forall (a :: j +-> k) (b :: j +-> k). Ob a => ((Star (Tambara w) %% a) ~> b) -> Star (Tambara w) a b Source Github # corepMap :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> (Star (Tambara w) %% a) ~> (Star (Tambara w) %% b) Source Github # corepUniv :: forall (a :: j +-> k). Ob a => Star (Tambara w) a (Star (Tambara w) %% a) Source Github # | |||||
| Profunctor j2 => Corepresentable (Star (Rift ('OP j2) :: (j1 +-> i) -> k -> j1 -> Type) :: (k -> j1 -> Type) -> (j1 +-> i) -> Type) Source Github # | The right Kan lift is the right adjoint of the postcomposition functor. | ||||
Defined in Proarrow.Profunctor.Instance.Rift Methods coindex :: forall (a :: k -> j1 -> Type) (b :: j1 +-> i). Star (Rift ('OP j2) :: (j1 +-> i) -> k -> j1 -> Type) a b -> (Star (Rift ('OP j2) :: (j1 +-> i) -> k -> j1 -> Type) %% a) ~> b Source Github # cotabulate :: forall (a :: k -> j1 -> Type) (b :: j1 +-> i). Ob a => ((Star (Rift ('OP j2) :: (j1 +-> i) -> k -> j1 -> Type) %% a) ~> b) -> Star (Rift ('OP j2) :: (j1 +-> i) -> k -> j1 -> Type) a b Source Github # corepMap :: forall (a :: k -> j1 -> Type) (b :: k -> j1 -> Type). (a ~> b) -> (Star (Rift ('OP j2) :: (j1 +-> i) -> k -> j1 -> Type) %% a) ~> (Star (Rift ('OP j2) :: (j1 +-> i) -> k -> j1 -> Type) %% b) Source Github # corepUniv :: forall (a :: k -> j1 -> Type). Ob a => Star (Rift ('OP j2) :: (j1 +-> i) -> k -> j1 -> Type) a (Star (Rift ('OP j2) :: (j1 +-> i) -> k -> j1 -> Type) %% a) Source Github # | |||||
| HasColimits j k => Corepresentable (LimitAdj j :: COREPK b k -> REPK a k -> Type) Source Github # | |||||
Defined in Proarrow.Adjunction Methods coindex :: forall (a0 :: COREPK b k) (b0 :: REPK a k). LimitAdj j a0 b0 -> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) %% a0) ~> b0 Source Github # cotabulate :: forall (a0 :: COREPK b k) (b0 :: REPK a k). Ob a0 => (((LimitAdj j :: COREPK b k -> REPK a k -> Type) %% a0) ~> b0) -> LimitAdj j a0 b0 Source Github # corepMap :: forall (a0 :: COREPK b k) (b0 :: COREPK b k). (a0 ~> b0) -> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) %% a0) ~> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) %% b0) Source Github # corepUniv :: forall (a0 :: COREPK b k). Ob a0 => LimitAdj j a0 ((LimitAdj j :: COREPK b k -> REPK a k -> Type) %% a0) Source Github # | |||||
| (Corepresentable p, Corepresentable q) => Corepresentable (p :++: q :: COPRODUCT k1 k2 -> COPRODUCT j1 j2 -> Type) Source Github # | |||||
Defined in Proarrow.Category.Instance.Coproduct Methods coindex :: forall (a :: COPRODUCT k1 k2) (b :: COPRODUCT j1 j2). (p :++: q) a b -> ((p :++: q) %% a) ~> b Source Github # cotabulate :: forall (a :: COPRODUCT k1 k2) (b :: COPRODUCT j1 j2). Ob a => (((p :++: q) %% a) ~> b) -> (p :++: q) a b Source Github # corepMap :: forall (a :: COPRODUCT k1 k2) (b :: COPRODUCT k1 k2). (a ~> b) -> ((p :++: q) %% a) ~> ((p :++: q) %% b) Source Github # corepUniv :: forall (a :: COPRODUCT k1 k2). Ob a => (p :++: q) a ((p :++: q) %% a) Source Github # | |||||
data Corep (f :: j +-> k) (a :: j) (b :: k) where Source Github #
Constructors
| Corep | |
Instances
| (FunctorForRep f, Thin j, ThinProfunctor q) => ComposeThin 'ByLeft (Corep f :: k -> j -> Type) (q :: i +-> j) Source Github # | |
Defined in Proarrow.Category.Enriched.Thin.Composition | |
| (FunctorForRep f, Thin j, DecidableProfunctor q) => DecideComp 'ByLeft (Corep f :: k -> j -> Type) (q :: i +-> j) Source Github # | |
Defined in Proarrow.Category.Enriched.Thin.Composition | |
| (MonoidalAction act, Ob x) => ActFl (act :: (m, j) +-> j) (Rep (ActionAt act x) :: j -> j -> Type) (Corep (ActionAt act x) :: j -> j -> Type) Source Github # | |
| (FunctorForRep f, LocallyFinite j) => Finitary (Corep f :: k -> j -> Type) Source Github # | A corepresentable over finite hom-sets is finitary, numbered as the hom-set |
Defined in Proarrow.Category.Enriched.Finitary Methods size :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural Source Github # toIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => Corep f a b -> Natural Source Github # fromIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural -> Corep f a b Source Github # elements :: forall (a :: k) (b :: j). (Ob a, Ob b) => [Corep f a b] Source Github # | |
| (FunctorForRep f, DecidableProfunctor (Hom j)) => DecidableProfunctor (Corep f :: k -> j -> Type) Source Github # | |
| (FunctorForRep f, Thin j) => ThinProfunctor (Corep f :: k -> j -> Type) Source Github # |
|
| MonoidalProfunctor (Corep Forget) Source Github # | Forget is also a colax monoidal functor |
| (Monoidal k, Comonoid r) => MonoidalProfunctor (Corep (Constant r) :: k -> k -> Type) Source Github # | |
| FunctorForRep f => Profunctor (Corep f :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Corepresentable Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Corep f a b -> Corep f c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Corep f a b -> Corep f c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Corep f a b -> Corep f a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Corep f a b -> r Source Github # | |
| FunctorForRep f => Corepresentable (Corep f :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Profunctor.Corepresentable Methods coindex :: forall (a :: k) (b :: j). Corep f a b -> (Corep f %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((Corep f %% a) ~> b) -> Corep f a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Corep f %% a) ~> (Corep f %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Corep f a (Corep f %% a) Source Github # | |
| FunctorForRep f => HasLimits (Corep f :: a -> i -> Type) k Source Github # | |
| FunctorForRep f => Proadjunction (Rep f :: k -> j -> Type) (Corep f :: j -> k -> Type) Source Github # | |
| (OplaxMonoidalRep m, Algebra m x, Comonoid x) => AlgLensFl (m :: k +-> k) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) x) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) x) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Action | |
| (OplaxMonoidalRep l, Algebra l x, Monoid x, Comonoid x, SymMonoidal k, HasCoproducts k) => ClassifyFl (l :: k +-> k) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) x) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) x) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Action | |
| (HasCoproducts k, Ob t) => AffineFoldFl (Corep (Coproduct t) :: k -> k -> Type) (Rep (Coproduct t) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.AffineFold Methods previewP :: forall (s :: k) (a :: k). Bicartesian k => Corep (Coproduct t) s a -> s ~> (a || (TerminalObject :: k)) Source Github # | |
| Comonoid m => AffineFoldFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | The tensor-action witness pair |
Defined in Proarrow.Optic.MonoidalLens | |
| (CopyDiscard k, HasCoproducts k, Ob t) => AffineFoldFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.AffineFold Methods previewP :: forall (s :: k) (a :: k). Bicartesian k => Rep (Coproduct t) s a -> s ~> (a || (TerminalObject :: k)) Source Github # | |
| (HasBinaryProducts k, Ob s) => AffineFoldFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.AffineFold Methods previewP :: forall (s0 :: k) (a :: k). Bicartesian k => Rep (Product s) s0 a -> s0 ~> (a || (TerminalObject :: k)) Source Github # | |
| (FoldFl p1 q1, FoldFl p2 q2, Monoidal k) => FoldFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github # | |
| (FoldFl p1 q1, FoldFl p2 q2, HasBinaryCoproducts k) => FoldFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github # | |
| (HasCoproducts k, Ob t) => FoldFl (Corep (Coproduct t) :: k -> k -> Type) (Rep (Coproduct t) :: k -> k -> Type) Source Github # | |
| Comonoid m => FoldFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | The tensor-action witness pair |
| (CopyDiscard k, HasCoproducts k, Ob t) => FoldFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
| (HasBinaryProducts k, Ob s) => FoldFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
| (HasCoproducts k, Ob t) => GetterFl (Corep (Coproduct t) :: k -> k -> Type) (Rep (Coproduct t) :: k -> k -> Type) Source Github # | |
| Comonoid m => GetterFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
| (HasBinaryProducts k, Ob s) => GetterFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
| HasCofree ob => Representable (Corep (Forget ob) :: SUBCAT ob -> k -> Type) Source Github # | By creating the right adjoint to the forgetful functor, we obtain the forgetful-cofree adjunction. |
Defined in Proarrow.Profunctor.Cofree Methods index :: forall (a :: SUBCAT ob) (b :: k). Corep (Forget ob) a b -> a ~> (Corep (Forget ob) % b) Source Github # tabulate :: forall (b :: k) (a :: SUBCAT ob). Ob b => (a ~> (Corep (Forget ob) % b)) -> Corep (Forget ob) a b Source Github # repMap :: forall (a :: k) (b :: k). (a ~> b) -> (Corep (Forget ob) % a) ~> (Corep (Forget ob) % b) Source Github # repUniv :: forall (a :: k). Ob a => Corep (Forget ob) (Corep (Forget ob) % a) a Source Github # | |
| (HasBinaryProducts k, Ob a) => Promonad (Corep (Product a) :: k -> k -> Type) Source Github # | |
| Comonoid m => AffineTravFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | In a cartesian category the tensor is the product, so the comonoidal residual can be
projected out and put back: |
Defined in Proarrow.Optic.MonoidalLens Methods affineMatch :: forall (s :: k) (a :: k) (b :: k) (t :: k). Bicartesian k => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> s ~> (t || a) Source Github # affineSet :: forall (s :: k) (a :: k) (b :: k) (t :: k). Bicartesian k => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> (s && b) ~> t Source Github # | |
| (CopyDiscard k, HasCoproducts k, Ob t) => AffineTravFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.AffineTraversal Methods affineMatch :: forall (s :: k) (a :: k) (b :: k) (t0 :: k). Bicartesian k => Rep (Coproduct t) s a -> Corep (Coproduct t) b t0 -> s ~> (t0 || a) Source Github # affineSet :: forall (s :: k) (a :: k) (b :: k) (t0 :: k). Bicartesian k => Rep (Coproduct t) s a -> Corep (Coproduct t) b t0 -> (s && b) ~> t0 Source Github # | |
| (HasBinaryProducts k, Ob s) => AffineTravFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.AffineTraversal Methods affineMatch :: forall (s0 :: k) (a :: k) (b :: k) (t :: k). Bicartesian k => Rep (Product s) s0 a -> Corep (Product s) b t -> s0 ~> (t || a) Source Github # affineSet :: forall (s0 :: k) (a :: k) (b :: k) (t :: k). Bicartesian k => Rep (Product s) s0 a -> Corep (Product s) b t -> (s0 && b) ~> t Source Github # | |
| Comonoid m => GlassFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
| (Closed k, Ob d) => GlassFl (Rep (Exp d) :: k -> k -> Type) (Corep (Exp d) :: k -> k -> Type) Source Github # | The exponential pair, a grate witness: the source is ignored, and the consumer is fed the
selector |
| (HasBinaryProducts k, Ob c) => GlassFl (Rep (Product c) :: k -> k -> Type) (Corep (Product c) :: k -> k -> Type) Source Github # | The product pair, a lens witness: the selector is the lens's own |
| (Closed k, SymMonoidal k, HasCoproducts k, Comonoid m) => GrateFl (Rep (Exp m) :: k -> k -> Type) (Corep (Exp m) :: k -> k -> Type) Source Github # | |
| (SymMonoidal k, HasCoproducts k, Monoid m) => CotravFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | The tensor-action pair for a monoid residual: |
| (Closed k, SymMonoidal k, HasCoproducts k, Comonoid m) => CotravFl (Rep (Exp m) :: k -> k -> Type) (Corep (Exp m) :: k -> k -> Type) Source Github # | The exponential pair for a comonoid exponent: |
Defined in Proarrow.Optic.Kaleidoscope | |
| (SymMonoidal k, HasCoproducts k, Monoid m) => KaleidoFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
| (Closed k, SymMonoidal k, HasCoproducts k, Comonoid m) => KaleidoFl (Rep (Exp m) :: k -> k -> Type) (Corep (Exp m) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Kaleidoscope | |
| (HasBinaryProducts k, Ob s) => LensFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
| Comonoid m => MonLensFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.MonoidalLens Methods withMonLensP :: forall (s :: k) (a :: k) (b :: k) (t :: k) r. SymMonoidal k => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> (forall (m0 :: k). Ob m0 => ComonoidOn m0 -> (s ~> (m0 ** a)) -> ((m0 ** b) ~> t) -> r) -> r Source Github # | |
| (CopyDiscard k, HasCoproducts k, Ob t) => PrismFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
| (SetterFl p1 q1, SetterFl p2 q2, Monoidal k) => SetterFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github # | |
| (SetterFl p1 q1, SetterFl p2 q2, HasBinaryCoproducts k) => SetterFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| (TracedMonoidal k, Ob m) => SetterFl (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | The tracer witness: the tensor-action pair read the other way round, |
| (Monoidal k, Ob a) => SetterFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) a) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) a) :: k -> k -> Type) Source Github # | The tensor-action witness pair |
| (Closed k, Ob m) => SetterFl (Rep (Exp m) :: k -> k -> Type) (Corep (Exp m) :: k -> k -> Type) Source Github # | The grate witness is a setter witness: map under the exponential. The |
| (HasCoproducts k, Ob t) => SetterFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
| (HasBinaryProducts k, Ob s) => SetterFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
| (TracedMonoidal k, Ob m) => TracerFl (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Tracer | |
| (MonTravFl p1 q1, MonTravFl p2 q2, Monoidal k) => MonTravFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| (MonTravFl p1 q1, MonTravFl p2 q2, HasBinaryCoproducts k) => MonTravFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal Methods monTravP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). StrongDistributiveProfunctor r => BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> r a b -> r s t Source Github # | |
| Comonoid m => MonTravFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
| (CopyDiscard k, HasCoproducts k, Ob t) => MonTravFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| (TravFl p1 q1, TravFl p2 q2, Monoidal k) => TravFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| (TravFl p1 q1, TravFl p2 q2, HasBinaryCoproducts k) => TravFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal Methods travP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). (StrongDistributiveProfunctor r, Strong (ProdAction :: k -> (PROD k, k) -> Type) r) => BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> r a b -> r s t Source Github # | |
| Comonoid m => TravFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| (CopyDiscard k, HasCoproducts k, Ob t) => TravFl (Rep (Coproduct t) :: k -> k -> Type) (Corep (Coproduct t) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| (HasBinaryProducts k, Ob s) => TravFl (Rep (Product s) :: k -> k -> Type) (Corep (Product s) :: k -> k -> Type) Source Github # | |
Defined in Proarrow.Optic.Traversal | |
| HasBinaryProducts k => Representable (Corep (Diag :: k +-> (k, k)) :: k -> (k, k) -> Type) Source Github # | The right adjoint to the diagonal functor. |
Defined in Proarrow.Limit.BinaryProduct Methods index :: forall (a :: k) (b :: (k, k)). Corep (Diag :: k +-> (k, k)) a b -> a ~> (Corep (Diag :: k +-> (k, k)) % b) Source Github # tabulate :: forall (b :: (k, k)) (a :: k). Ob b => (a ~> (Corep (Diag :: k +-> (k, k)) % b)) -> Corep (Diag :: k +-> (k, k)) a b Source Github # repMap :: forall (a :: (k, k)) (b :: (k, k)). (a ~> b) -> (Corep (Diag :: k +-> (k, k)) % a) ~> (Corep (Diag :: k +-> (k, k)) % b) Source Github # repUniv :: forall (a :: (k, k)). Ob a => Corep (Diag :: k +-> (k, k)) (Corep (Diag :: k +-> (k, k)) % a) a Source Github # | |
| type HasArrowComp 'ByLeft (Corep f :: k -> j -> Type) (q :: i +-> j) (a :: k) (c :: i) Source Github # | |
Defined in Proarrow.Category.Enriched.Thin.Composition | |
| type HoldsComp 'ByLeft (Corep f :: k -> j -> Type) (q :: i +-> j) (a :: k) (c :: i) Source Github # | |
| type Limit (Corep f :: a -> i -> Type) (d :: i +-> k) Source Github # | |
| type (Corep f :: k -> j -> Type) %% (a :: k) Source Github # | |
Defined in Proarrow.Profunctor.Corepresentable | |
| type HasArrow (Corep f :: k -> j -> Type) (a :: k) (b :: j) Source Github # | |
| type Holds (Corep f :: k -> j -> Type) (a :: k) (b :: j) Source Github # | |
| type (Corep (Forget ob) :: SUBCAT ob -> k -> Type) % (a :: k) Source Github # | |
| type (Corep (Diag :: k +-> (k, k)) :: k -> (k, k) -> Type) % ('(a, b) :: (k, k)) Source Github # | |
Promonads as effects
return :: forall {j} (m :: CAT j) (a :: j). (Monad m, Ob a) => a ~> (m % a) Source Github #
The unit of the monad m.
bind :: forall {j} (m :: CAT j) (b :: j) (a :: j). (Monad m, Ob b) => (a ~> (m % b)) -> (m % a) ~> (m % b) Source Github #
Kleisli extension: run a Kleisli arrow under m.
extract :: forall {k} (w :: CAT k) (a :: k). (Comonad w, Ob a) => (w %% a) ~> a Source Github #
The counit of the comonad w.
extend :: forall {j} (w :: CAT j) (a :: j) (b :: j). (Comonad w, Ob a) => ((w %% a) ~> b) -> (w %% a) ~> (w %% b) Source Github #
CoKleisli extension: run a coKleisli arrow under w.
Monoids and comonoids
class (Monoidal k, Ob m) => Monoid (m :: k) where Source Github #
A monoid object in a monoidal category: a unit and an (associative, unital) multiplication
for the object m. At k = Type (with tensor (,)) this is the ordinary Monoid.
Instances
| Monoid 'Z Source Github # | |
| KnownNat n => Monoid (n :: Nat) Source Github # | |
| Monoid 'TRU Source Github # | |
| Monoid m => Monoid (m :: Type) Source Github # | |
| Monoid ('S 'Z) Source Github # | |
| Monoid ('CNSTRNT ()) Source Github # | |
| Monoid ('FH ()) Source Github # | |
| SNatI a => Monoid ('FR a :: FINREL) Source Github # |
|
| Monoid ('FS Nat1) Source Github # | |
| Monoid ('P Void) Source Github # | |
| Monoid ('P ()) Source Github # | Conjunction with False = Nothing, True = Just () |
| Monoid ('P [a] :: POINTED) Source Github # | |
| Ob as => Monoid ('D as :: DOT) Source Github # | |
| Ob as => Monoid ('S as :: SVG) Source Github # | The unit point takes the unit wire in, and the discard point gives it out. |
| (HasPushouts k, HasCoproducts k, Ob a) => Monoid ('CS a :: COSPAN k) Source Github # | |
| (Num a, IsNat n) => Monoid ('M n :: MatK a) Source Github # | Monoids are associative, unital algebras. |
| Comonoid c => Monoid ('OP c :: OPPOSITE k) Source Github # | |
| (HasPullbacks k, HasProducts k, Ob a) => Monoid ('SP a :: SPAN k) Source Github # | |
| Monoid a => Monoid ('R a :: REV k) Source Github # | |
| (HasCoproducts k, Ob a) => Monoid ('COPR a :: COPROD k) Source Github # | |
| (Profunctor p, MonoidalProfunctor p) => Monoid (p :: j +-> k) Source Github # | |
| (Elems '[Supplies Monoid, Monoidal] cs, Ob a) => Monoid (a :: FREE cs p) Source Github # | |
class (Monoid m, SymMonoidal k) => CommutativeMonoid (m :: k) Source Github #
Instances
| KnownNat a => CommutativeMonoid (a :: Nat) Source Github # | |
Defined in Proarrow.Category.Instance.ZX | |
| CommutativeMonoid 'TRU Source Github # | |
Defined in Proarrow.Monoid | |
| CommutativeMonoid () Source Github # | |
Defined in Proarrow.Monoid | |
| SNatI a => CommutativeMonoid ('FR a :: FINREL) Source Github # | |
Defined in Proarrow.Category.Instance.FinRel | |
| Ob as => CommutativeMonoid ('D as :: DOT) Source Github # | |
Defined in Proarrow.Tools.Diagrams.Dot | |
| Ob as => CommutativeMonoid ('S as :: SVG) Source Github # | |
Defined in Proarrow.Tools.Diagrams.Svg | |
| (HasZeroObject k, HasBiproducts k, Ob a, Ob b) => CommutativeMonoid (Id a b :: Type) Source Github # | |
Defined in Proarrow.Monoid | |
| (HasPushouts k, HasCoproducts k, Ob a) => CommutativeMonoid ('CS a :: COSPAN k) Source Github # | |
Defined in Proarrow.Category.Instance.Cospan | |
| (Num a, IsNat n) => CommutativeMonoid ('M n :: MatK a) Source Github # | |
Defined in Proarrow.Category.Instance.Mat | |
| CocommutativeComonoid c => CommutativeMonoid ('OP c :: OPPOSITE k) Source Github # | |
Defined in Proarrow.Monoid | |
| (HasPullbacks k, HasProducts k, Ob a) => CommutativeMonoid ('SP a :: SPAN k) Source Github # | |
Defined in Proarrow.Category.Instance.Span | |
| (Monoid a, SymMonoidal (FREE cs p)) => CommutativeMonoid (a :: FREE cs p) Source Github # | The free supply is commutative only up to interpretation ( |
Defined in Proarrow.Monoid | |
class (Monoidal k, Ob c) => Comonoid (c :: k) where Source Github #
Instances
| KnownNat n => Comonoid (n :: Nat) Source Github # | |
| Ob a => Comonoid (a :: BOOL) Source Github # | |
| Comonoid '() Source Github # | |
| Comonoid (a :: Type) Source Github # | |
| Comonoid ('CNSTRNT a :: CONSTRAINT) Source Github # | |
| Ob ('FH a) => Comonoid ('FH a :: FINHASK) Source Github # | |
| SNatI a => Comonoid ('FR a :: FINREL) Source Github # |
|
| SNatI a => Comonoid ('FS a :: FINSET) Source Github # |
|
| Comonoid ('L (Ur a) :: LINEAR) Source Github # | |
| Comonoid ('L Bool) Source Github # |
|
| Comonoid ('P x :: POINTED) Source Github # | |
| Ob as => Comonoid ('D as :: DOT) Source Github # | |
| Ob as => Comonoid ('S as :: SVG) Source Github # | |
| (MonoidalOrdinal n, Ob a) => Comonoid (a :: ORDINAL n) Source Github # | Every object is a comonoid by the diagonal and the map to the top. So the chain is
|
| (CopyDiscard k, Ob as) => Comonoid (as :: [k]) Source Github # | |
| (HasPushouts k, HasCoproducts k, Ob a) => Comonoid ('CS a :: COSPAN k) Source Github # | |
| (Num a, IsNat n) => Comonoid ('M n :: MatK a) Source Github # | |
| Monoid c => Comonoid ('OP c :: OPPOSITE k) Source Github # | |
| (HasPullbacks k, HasProducts k, Ob a) => Comonoid ('SP a :: SPAN k) Source Github # | |
| Comonoid a => Comonoid ('R a :: REV k) Source Github # | |
| (HasProducts k, Ob a) => Comonoid ('PR a :: PROD k) Source Github # | In a category with products every object is a comonoid via the diagonal and the terminal
map. With this comonoid structure |
| (Promonad p, MonoidalProfunctor p, CopyDiscard k, Ob a) => Comonoid (a :: KLEISLI p) Source Github # | |
| (SubMonoidal ob, CopyDiscard k, Ob a) => Comonoid (a :: SUBCAT ob) Source Github # | |
| (SymMonoidal j, CopyDiscard k, Supplies CommutativeMonoid j, Profunctor p) => Comonoid (p :: j +-> k) Source Github # | |
| (CopyDiscard j, CopyDiscard k, Ob a) => Comonoid (a :: (j, k)) Source Github # | The comonoid supply of a product category, a subcategory and a strictified category are
inherited componentwise: each object's comonoid is the ambient |
| CategoryOf k => Comonoid (CatAsComonoid k :: Type -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Nat Methods counit :: CatAsComonoid k ~> (Unit :: Type -> Type) Source Github # comult :: CatAsComonoid k ~> (CatAsComonoid k ** CatAsComonoid k) Source Github # | |
| CommutativeMonoid m => Comonoid ('M :: MONOID m) Source Github # | |
| (Elems '[Supplies Comonoid, Monoidal] cs, Ob a) => Comonoid (a :: FREE cs p) Source Github # | |
data ComonoidOn (c :: k) Source Github #
A comonoid structure on c carried as a value. Unit and ( are type families and so
cannot head a **)Comonoid instance, yet the unit is a comonoid and, in a symmetric monoidal
category, so is a tensor of comonoids. unitComonoid and tensorComonoid say so at the value
level, so that withMonLens can hand back the comonoid of a
composite residual (cf. withAlgP, which passes algebras the same way).
Universal properties and adjunctions
class (Representable r, Ob a) => InitUniversal (a :: k) (r :: j +-> k) where Source Github #
The initial universal property of a functor r (as a representable profunctor) and an object a.
Associated Types
type InitUnivTgt (r :: j +-> k) (a :: k) :: j Source Github #
The target of the universal arrow out of a.
Methods
initUnivArr :: r a (InitUnivTgt r a) Source Github #
initUnivProp :: forall (b :: j). r a b -> InitUnivTgt r a ~> b Source Github #
Instances
| InitUniversal a r => InitUniversal (a :: k) (AsRightAdjoint r :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Universal Associated Types
Methods initUnivArr :: AsRightAdjoint r a (InitUnivTgt (AsRightAdjoint r) a) Source Github # initUnivProp :: forall (b :: j). AsRightAdjoint r a b -> InitUnivTgt (AsRightAdjoint r) a ~> b Source Github # | |||||
| (Adjunction p, Ob a) => InitUniversal (a :: k) (FromAdjunction p :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Universal Associated Types
Methods initUnivArr :: FromAdjunction p a (InitUnivTgt (FromAdjunction p) a) Source Github # initUnivProp :: forall (b :: j). FromAdjunction p a b -> InitUnivTgt (FromAdjunction p) a ~> b Source Github # | |||||
| TermUniversal b l => InitUniversal ('OP b :: OPPOSITE j) (Op l :: OPPOSITE j -> OPPOSITE k -> Type) Source Github # | |||||
Defined in Proarrow.Universal Associated Types
Methods initUnivArr :: Op l ('OP b) (InitUnivTgt (Op l) ('OP b)) Source Github # initUnivProp :: forall (b0 :: OPPOSITE k). Op l ('OP b) b0 -> InitUnivTgt (Op l) ('OP b) ~> b0 Source Github # | |||||
class (Corepresentable l, Ob b) => TermUniversal (b :: j) (l :: j +-> k) where Source Github #
The terminal universal property of a functor l (as a corepresentable profunctor) and an object b.
Associated Types
type TermUnivSrc (l :: j +-> k) (b :: j) :: k Source Github #
The source of the universal arrow into b.
Methods
termUnivArr :: l (TermUnivSrc l b) b Source Github #
termUnivProp :: forall (a :: k). l a b -> a ~> TermUnivSrc l b Source Github #
Instances
| (Adjunction p, Ob b) => TermUniversal (b :: j) (FromAdjunction p :: k -> j -> Type) Source Github # | |||||
Defined in Proarrow.Universal Associated Types
Methods termUnivArr :: FromAdjunction p (TermUnivSrc (FromAdjunction p) b) b Source Github # termUnivProp :: forall (a :: k). FromAdjunction p a b -> a ~> TermUnivSrc (FromAdjunction p) b Source Github # | |||||
| TermUniversal b l => TermUniversal (b :: k1) (AsLeftAdjoint l :: k2 -> k1 -> Type) Source Github # | |||||
Defined in Proarrow.Universal Associated Types
Methods termUnivArr :: AsLeftAdjoint l (TermUnivSrc (AsLeftAdjoint l) b) b Source Github # termUnivProp :: forall (a :: k2). AsLeftAdjoint l a b -> a ~> TermUnivSrc (AsLeftAdjoint l) b Source Github # | |||||
| InitUniversal a r => TermUniversal ('OP a :: OPPOSITE k) (Op r :: OPPOSITE j -> OPPOSITE k -> Type) Source Github # | |||||
Defined in Proarrow.Universal Associated Types
Methods termUnivArr :: Op r (TermUnivSrc (Op r) ('OP a)) ('OP a) Source Github # termUnivProp :: forall (a0 :: OPPOSITE j). Op r a0 ('OP a) -> a0 ~> TermUnivSrc (Op r) ('OP a) Source Github # | |||||
class (Representable p, Corepresentable p) => Adjunction (p :: j +-> k) Source Github #
Adjunctions as heteromorphisms.
Instances
| (Representable p, Corepresentable p) => Adjunction (p :: j +-> k) Source Github # | |
Defined in Proarrow.Adjunction | |
leftAdjunct :: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j). (Adjunction p, Ob a) => ((p %% a) ~> b) -> a ~> (p % b) Source Github #
One direction of the adjunction isomorphism: transpose an arrow out of the left adjoint,
p , to an arrow into the right adjoint, %% a ~> ba .~> p % b
rightAdjunct :: forall {k1} {k2} (p :: k1 +-> k2) (a :: k2) (b :: k1). (Adjunction p, Ob b) => (a ~> (p % b)) -> (p %% a) ~> b Source Github #
The other direction of the adjunction isomorphism, inverse to leftAdjunct.
Optics
The full optics vocabulary. See Proarrow.Optics for the guided tour: the subtyping lattice, and how to build, eliminate and compose each optic flavor.
module Proarrow.Optics