Safe Haskell	None
Language	GHC2024

Proarrow.Category.Monoidal

Documentation

class (Monoidal j, Monoidal k, Profunctor p) => MonoidalProfunctor (p :: j +-> k) where Source Github #

Methods

par0 :: p (Unit :: k) (Unit :: j) Source Github #

par :: forall (x1 :: k) (x2 :: j) (y1 :: k) (y2 :: j). p x1 x2 -> p y1 y2 -> p (x1 ** y1) (x2 ** y2) Source Github #

Instances

Instances details

MonoidalProfunctor Simplex Source Github #
Instance details Defined in Proarrow.Category.Instance.Simplex Methods par0 :: Simplex (Unit :: Nat) (Unit :: Nat) Source Github # par :: forall (x1 :: Nat) (x2 :: Nat) (y1 :: Nat) (y2 :: Nat). Simplex x1 x2 -> Simplex y1 y2 -> Simplex (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor ZX Source Github #
Instance details Defined in Proarrow.Category.Instance.ZX Methods par0 :: ZX (Unit :: Nat) (Unit :: Nat) Source Github # par :: forall (x1 :: Nat) (x2 :: Nat) (y1 :: Nat) (y2 :: Nat). ZX x1 x2 -> ZX y1 y2 -> ZX (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor Booleans Source Github #
Instance details Defined in Proarrow.Category.Instance.Bool Methods par0 :: Booleans (Unit :: BOOL) (Unit :: BOOL) Source Github # par :: forall (x1 :: BOOL) (x2 :: BOOL) (y1 :: BOOL) (y2 :: BOOL). Booleans x1 x2 -> Booleans y1 y2 -> Booleans (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor Cat Source Github #
Instance details Defined in Proarrow.Category.Instance.Cat Methods par0 :: Cat (Unit :: KIND) (Unit :: KIND) Source Github # par :: forall (x1 :: KIND) (x2 :: KIND) (y1 :: KIND) (y2 :: KIND). Cat x1 x2 -> Cat y1 y2 -> Cat (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor (:-) Source Github #
Instance details Defined in Proarrow.Category.Instance.Constraint Methods par0 :: (Unit :: CONSTRAINT) :- (Unit :: CONSTRAINT) Source Github # par :: forall (x1 :: CONSTRAINT) (x2 :: CONSTRAINT) (y1 :: CONSTRAINT) (y2 :: CONSTRAINT). (x1 :- x2) -> (y1 :- y2) -> (x1 y1) :- (x2 y2) Source Github #
MonoidalProfunctor GTE Source Github #
Instance details Defined in Proarrow.Category.Instance.Cost Methods par0 :: GTE (Unit :: COST) (Unit :: COST) Source Github # par :: forall (x1 :: COST) (x2 :: COST) (y1 :: COST) (y2 :: COST). GTE x1 x2 -> GTE y1 y2 -> GTE (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor FinRel Source Github #
Instance details Defined in Proarrow.Category.Instance.FinRel Methods par0 :: FinRel (Unit :: FINREL) (Unit :: FINREL) Source Github # par :: forall (x1 :: FINREL) (x2 :: FINREL) (y1 :: FINREL) (y2 :: FINREL). FinRel x1 x2 -> FinRel y1 y2 -> FinRel (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor FinSet Source Github #
Instance details Defined in Proarrow.Category.Instance.FinSet Methods par0 :: FinSet (Unit :: FINSET) (Unit :: FINSET) Source Github # par :: forall (x1 :: FINSET) (x2 :: FINSET) (y1 :: FINSET) (y2 :: FINSET). FinSet x1 x2 -> FinSet y1 y2 -> FinSet (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor Linear Source Github #
Instance details Defined in Proarrow.Category.Instance.Linear Methods par0 :: Linear (Unit :: LINEAR) (Unit :: LINEAR) Source Github # par :: forall (x1 :: LINEAR) (x2 :: LINEAR) (y1 :: LINEAR) (y2 :: LINEAR). Linear x1 x2 -> Linear y1 y2 -> Linear (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor Pointed Source Github #
Instance details Defined in Proarrow.Category.Instance.PointedHask Methods par0 :: Pointed (Unit :: POINTED) (Unit :: POINTED) Source Github # par :: forall (x1 :: POINTED) (x2 :: POINTED) (y1 :: POINTED) (y2 :: POINTED). Pointed x1 x2 -> Pointed y1 y2 -> Pointed (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor Dot Source Github #
Instance details Defined in Proarrow.Tools.Diagrams.Dot Methods par0 :: Dot (Unit :: DOT) (Unit :: DOT) Source Github # par :: forall (x1 :: DOT) (x2 :: DOT) (y1 :: DOT) (y2 :: DOT). Dot x1 x2 -> Dot y1 y2 -> Dot (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor Unit Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods par0 :: Unit (Unit :: ()) (Unit :: ()) Source Github # par :: forall (x1 :: ()) (x2 :: ()) (y1 :: ()) (y2 :: ()). Unit x1 x2 -> Unit y1 y2 -> Unit (x1 y1) (x2 y2) Source Github #
Monad m => MonoidalProfunctor (Kleisli m :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Arrow Methods par0 :: Kleisli m (Unit :: Type) (Unit :: Type) Source Github # par :: Kleisli m x1 x2 -> Kleisli m y1 y2 -> Kleisli m (x1 y1) (x2 y2) Source Github #
Arrow arr => MonoidalProfunctor (Arr arr :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Arrow Methods par0 :: Arr arr (Unit :: Type) (Unit :: Type) Source Github # par :: Arr arr x1 x2 -> Arr arr y1 y2 -> Arr arr (x1 y1) (x2 y2) Source Github #
SymMonoidal k => MonoidalProfunctor (Fold :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Fold Methods par0 :: Fold (Unit :: k) (Unit :: k) Source Github # par :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). Fold x1 x2 -> Fold y1 y2 -> Fold (x1 y1) (x2 y2) Source Github #
Monoidal k => MonoidalProfunctor (Id :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Identity Methods par0 :: Id (Unit :: k) (Unit :: k) Source Github # par :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). Id x1 x2 -> Id y1 y2 -> Id (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor (Cont r :: Type -> Type -> Type) Source Github #	Only premonoidal not monoidal?
Instance details Defined in Proarrow.Promonad.Cont Methods par0 :: Cont r (Unit :: Type) (Unit :: Type) Source Github # par :: Cont r x1 x2 -> Cont r y1 y2 -> Cont r (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor (->) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods par0 :: (Unit :: Type) -> (Unit :: Type) Source Github # par :: (x1 -> x2) -> (y1 -> y2) -> (x1 y1) -> (x2 y2) Source Github #
MonoidalProfunctor p => MonoidalProfunctor (Fix p :: j -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Fix Methods par0 :: Fix p (Unit :: j) (Unit :: j) Source Github # par :: forall (x1 :: j) (x2 :: j) (y1 :: j) (y2 :: j). Fix p x1 x2 -> Fix p y1 y2 -> Fix p (x1 y1) (x2 y2) Source Github #
(Monoidal j, Monoidal k) => MonoidalProfunctor (TerminalProfunctor :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Terminal Methods par0 :: TerminalProfunctor (Unit :: k) (Unit :: j) Source Github # par :: forall (x1 :: k) (x2 :: j) (y1 :: k) (y2 :: j). TerminalProfunctor x1 x2 -> TerminalProfunctor y1 y2 -> TerminalProfunctor (x1 y1) (x2 y2) Source Github #
(Comonoid r, SelfAction k, SymMonoidal k) => MonoidalProfunctor (Reader ('OP r) :: k -> k -> Type) Source Github #	Note: This is only premonoidal, not monoidal, unless the comonoid is cocommutative.
Instance details Defined in Proarrow.Promonad.Reader Methods par0 :: Reader ('OP r) (Unit :: k) (Unit :: k) Source Github # par :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). Reader ('OP r) x1 x2 -> Reader ('OP r) y1 y2 -> Reader ('OP r) (x1 y1) (x2 y2) Source Github #
(SymMonoidal k, Ob s) => MonoidalProfunctor (State s :: k -> k -> Type) Source Github #	Note: This is only premonoidal, not monoidal.
Instance details Defined in Proarrow.Promonad.State Methods par0 :: State s (Unit :: k) (Unit :: k) Source Github # par :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). State s x1 x2 -> State s y1 y2 -> State s (x1 y1) (x2 y2) Source Github #
(Monoid w, SymMonoidal k) => MonoidalProfunctor (Writer w :: k -> k -> Type) Source Github #	Note: This is only premonoidal, not monoidal, unless the monoid is commutative.
Instance details Defined in Proarrow.Promonad.Writer Methods par0 :: Writer w (Unit :: k) (Unit :: k) Source Github # par :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). Writer w x1 x2 -> Writer w y1 y2 -> Writer w (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor (Rep Fun) Source Github #
Instance details Defined in Proarrow.Category.Instance.FinRel Methods par0 :: Rep Fun (Unit :: FINREL) (Unit :: FINSET) Source Github # par :: forall (x1 :: FINREL) (x2 :: FINSET) (y1 :: FINREL) (y2 :: FINSET). Rep Fun x1 x2 -> Rep Fun y1 y2 -> Rep Fun (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor (Rep Forget) Source Github #	Forget is a lax monoidal functor
Instance details Defined in Proarrow.Category.Instance.Linear Methods par0 :: Rep Forget (Unit :: Type) (Unit :: LINEAR) Source Github # par :: forall x1 (x2 :: LINEAR) y1 (y2 :: LINEAR). Rep Forget x1 x2 -> Rep Forget y1 y2 -> Rep Forget (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor (Corep Forget) Source Github #	Forget is also a colax monoidal functor
Instance details Defined in Proarrow.Category.Instance.Linear Methods par0 :: Corep Forget (Unit :: LINEAR) (Unit :: Type) Source Github # par :: forall (x1 :: LINEAR) x2 (y1 :: LINEAR) y2. Corep Forget x1 x2 -> Corep Forget y1 y2 -> Corep Forget (x1 y1) (x2 y2) Source Github #
(Cartesian j, Cartesian k, Adjunction p) => MonoidalProfunctor (Adj p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Adjunction Methods par0 :: Adj p (Unit :: k) (Unit :: j) Source Github # par :: forall (x1 :: k) (x2 :: j) (y1 :: k) (y2 :: j). Adj p x1 x2 -> Adj p y1 y2 -> Adj p (x1 y1) (x2 y2) Source Github #
(Monoid c, Monoidal j, Monoidal k) => MonoidalProfunctor (HaskValue c :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.HaskValue Methods par0 :: HaskValue c (Unit :: k) (Unit :: j) Source Github # par :: forall (x1 :: k) (x2 :: j) (y1 :: k) (y2 :: j). HaskValue c x1 x2 -> HaskValue c y1 y2 -> HaskValue c (x1 y1) (x2 y2) Source Github #
(Applicative f, Monoidal j, Monoidal k) => MonoidalProfunctor (Star f :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Star Methods par0 :: Star f (Unit :: k) (Unit :: j) Source Github # par :: forall (x1 :: k) (x2 :: j) (y1 :: k) (y2 :: j). Star f x1 x2 -> Star f y1 y2 -> Star f (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor p => MonoidalProfunctor (Wrapped p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Wrapped Methods par0 :: Wrapped p (Unit :: k) (Unit :: j) Source Github # par :: forall (x1 :: k) (x2 :: j) (y1 :: k) (y2 :: j). Wrapped p x1 x2 -> Wrapped p y1 y2 -> Wrapped p (x1 y1) (x2 y2) Source Github #
(Cartesian j, Cartesian k, Functor f) => MonoidalProfunctor (Costar f :: j -> k -> Type) Source Github #	Every functor between cartesian categories is a colax monoidal functor.
Instance details Defined in Proarrow.Profunctor.Costar Methods par0 :: Costar f (Unit :: j) (Unit :: k) Source Github # par :: forall (x1 :: j) (x2 :: k) (y1 :: j) (y2 :: k). Costar f x1 x2 -> Costar f y1 y2 -> Costar f (x1 y1) (x2 y2) Source Github #
(Monoidal k, Comonoid r) => MonoidalProfunctor (Corep (Constant r) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Monoid Methods par0 :: Corep (Constant r) (Unit :: k) (Unit :: k) Source Github # par :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). Corep (Constant r) x1 x2 -> Corep (Constant r) y1 y2 -> Corep (Constant r) (x1 y1) (x2 y2) Source Github #
(Monoidal k, Monoid r) => MonoidalProfunctor (Rep (Constant r) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Monoid Methods par0 :: Rep (Constant r) (Unit :: k) (Unit :: k) Source Github # par :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). Rep (Constant r) x1 x2 -> Rep (Constant r) y1 y2 -> Rep (Constant r) (x1 y1) (x2 y2) Source Github #
(SymMonoidal j, SymMonoidal k, MonoidalProfunctor p, MonoidalProfunctor q) => MonoidalProfunctor (Day p q :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Day Methods par0 :: Day p q (Unit :: k) (Unit :: j) Source Github # par :: forall (x1 :: k) (x2 :: j) (y1 :: k) (y2 :: j). Day p q x1 x2 -> Day p q y1 y2 -> Day p q (x1 y1) (x2 y2) Source Github #
(MonoidalProfunctor p, MonoidalProfunctor q) => MonoidalProfunctor (p :*: q :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Product Methods par0 :: (p :: q) (Unit :: k) (Unit :: j) Source Github # par :: forall (x1 :: k) (x2 :: j) (y1 :: k) (y2 :: j). (p :: q) x1 x2 -> (p :: q) y1 y2 -> (p :: q) (x1 y1) (x2 y2) Source Github #
(MonoidalProfunctor p, MonoidalProfunctor q) => MonoidalProfunctor (p :.: q :: k -> j2 -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Composition Methods par0 :: (p :.: q) (Unit :: k) (Unit :: j2) Source Github # par :: forall (x1 :: k) (x2 :: j2) (y1 :: k) (y2 :: j2). (p :.: q) x1 x2 -> (p :.: q) y1 y2 -> (p :.: q) (x1 y1) (x2 y2) Source Github #
Monoidal k => MonoidalProfunctor (Tensor :: k -> LIST k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Promonoidal Methods par0 :: Tensor (Unit :: k) (Unit :: LIST k) Source Github # par :: forall (x1 :: k) (x2 :: LIST k) (y1 :: k) (y2 :: LIST k). Tensor x1 x2 -> Tensor y1 y2 -> Tensor (x1 y1) (x2 y2) Source Github #
Num a => MonoidalProfunctor (Rep (App :: MatK a +-> Type) :: Type -> MatK a -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Mat Methods par0 :: Rep (App :: MatK a +-> Type) (Unit :: Type) (Unit :: MatK a) Source Github # par :: forall x1 (x2 :: MatK a) y1 (y2 :: MatK a). Rep (App :: MatK a +-> Type) x1 x2 -> Rep (App :: MatK a +-> Type) y1 y2 -> Rep (App :: MatK a +-> Type) (x1 y1) (x2 y2) Source Github #
(Alternative f, Monoidal k, Distributive j) => MonoidalProfunctor (CoprodDom (Star f) :: k -> COPROD j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Star Methods par0 :: CoprodDom (Star f) (Unit :: k) (Unit :: COPROD j) Source Github # par :: forall (x1 :: k) (x2 :: COPROD j) (y1 :: k) (y2 :: COPROD j). CoprodDom (Star f) x1 x2 -> CoprodDom (Star f) y1 y2 -> CoprodDom (Star f) (x1 y1) (x2 y2) Source Github #
HasPushouts k => MonoidalProfunctor (Cospan :: COSPAN k -> COSPAN k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Cospan Methods par0 :: Cospan (Unit :: COSPAN k) (Unit :: COSPAN k) Source Github # par :: forall (x1 :: COSPAN k) (x2 :: COSPAN k) (y1 :: COSPAN k) (y2 :: COSPAN k). Cospan x1 x2 -> Cospan y1 y2 -> Cospan (x1 y1) (x2 y2) Source Github #
TracedMonoidal k => MonoidalProfunctor (IntConstruction :: INT k -> INT k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.IntConstruction Methods par0 :: IntConstruction (Unit :: INT k) (Unit :: INT k) Source Github # par :: forall (x1 :: INT k) (x2 :: INT k) (y1 :: INT k) (y2 :: INT k). IntConstruction x1 x2 -> IntConstruction y1 y2 -> IntConstruction (x1 y1) (x2 y2) Source Github #
Num a => MonoidalProfunctor (Mat :: MatK a -> MatK a -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Mat Methods par0 :: Mat (Unit :: MatK a) (Unit :: MatK a) Source Github # par :: forall (x1 :: MatK a) (x2 :: MatK a) (y1 :: MatK a) (y2 :: MatK a). Mat x1 x2 -> Mat y1 y2 -> Mat (x1 y1) (x2 y2) Source Github #
HasPullbacks k => MonoidalProfunctor (Span :: SPAN k -> SPAN k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Span Methods par0 :: Span (Unit :: SPAN k) (Unit :: SPAN k) Source Github # par :: forall (x1 :: SPAN k) (x2 :: SPAN k) (y1 :: SPAN k) (y2 :: SPAN k). Span x1 x2 -> Span y1 y2 -> Span (x1 y1) (x2 y2) Source Github #
HasCoproducts k => MonoidalProfunctor (Cocone :: LIST k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Object.Pushout Methods par0 :: Cocone (Unit :: LIST k) (Unit :: COPROD k) Source Github # par :: forall (x1 :: LIST k) (x2 :: COPROD k) (y1 :: LIST k) (y2 :: COPROD k). Cocone x1 x2 -> Cocone y1 y2 -> Cocone (x1 y1) (x2 y2) Source Github #
HasProducts k => MonoidalProfunctor (Cone :: PROD k -> LIST k -> Type) Source Github #
Instance details Defined in Proarrow.Object.Pullback Methods par0 :: Cone (Unit :: PROD k) (Unit :: LIST k) Source Github # par :: forall (x1 :: PROD k) (x2 :: LIST k) (y1 :: PROD k) (y2 :: LIST k). Cone x1 x2 -> Cone y1 y2 -> Cone (x1 y1) (x2 y2) Source Github #
Monoidal k => MonoidalProfunctor (Strictified :: [k] -> [k] -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Strictified Methods par0 :: Strictified (Unit :: [k]) (Unit :: [k]) Source Github # par :: forall (x1 :: [k]) (x2 :: [k]) (y1 :: [k]) (y2 :: [k]). Strictified x1 x2 -> Strictified y1 y2 -> Strictified (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor p => MonoidalProfunctor (Rev p :: REV k -> REV j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Rev Methods par0 :: Rev p (Unit :: REV k) (Unit :: REV j) Source Github # par :: forall (x1 :: REV k) (x2 :: REV j) (y1 :: REV k) (y2 :: REV j). Rev p x1 x2 -> Rev p y1 y2 -> Rev p (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor p => MonoidalProfunctor (Op p :: OPPOSITE j -> OPPOSITE k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods par0 :: Op p (Unit :: OPPOSITE j) (Unit :: OPPOSITE k) Source Github # par :: forall (x1 :: OPPOSITE j) (x2 :: OPPOSITE k) (y1 :: OPPOSITE j) (y2 :: OPPOSITE k). Op p x1 x2 -> Op p y1 y2 -> Op p (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor (Coprod (Rep Fun)) Source Github #
Instance details Defined in Proarrow.Category.Instance.FinRel Methods par0 :: Coprod (Rep Fun) (Unit :: COPROD FINREL) (Unit :: COPROD FINSET) Source Github # par :: 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 #
MonoidalProfunctor (Coprod Linear) Source Github #
Instance details Defined in Proarrow.Category.Instance.Linear Methods par0 :: Coprod Linear (Unit :: COPROD LINEAR) (Unit :: COPROD LINEAR) Source Github # par :: forall (x1 :: COPROD LINEAR) (x2 :: COPROD LINEAR) (y1 :: COPROD LINEAR) (y2 :: COPROD LINEAR). Coprod Linear x1 x2 -> Coprod Linear y1 y2 -> Coprod Linear (x1 y1) (x2 y2) Source Github #
MonadPlus m => MonoidalProfunctor (Coprod (Kleisli m) :: COPROD Type -> COPROD Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Arrow Methods par0 :: Coprod (Kleisli m) (Unit :: COPROD Type) (Unit :: COPROD Type) Source Github # par :: forall (x1 :: COPROD Type) (x2 :: COPROD Type) (y1 :: COPROD Type) (y2 :: COPROD Type). Coprod (Kleisli m) x1 x2 -> Coprod (Kleisli m) y1 y2 -> Coprod (Kleisli m) (x1 y1) (x2 y2) Source Github #
ArrowChoice arr => MonoidalProfunctor (Coprod (Arr arr) :: COPROD Type -> COPROD Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Arrow Methods par0 :: Coprod (Arr arr) (Unit :: COPROD Type) (Unit :: COPROD Type) Source Github # par :: forall (x1 :: COPROD Type) (x2 :: COPROD Type) (y1 :: COPROD Type) (y2 :: COPROD Type). Coprod (Arr arr) x1 x2 -> Coprod (Arr arr) y1 y2 -> Coprod (Arr arr) (x1 y1) (x2 y2) Source Github #
(Cocartesian j, Cocartesian k, Adjunction p) => MonoidalProfunctor (Coprod (Adj p) :: COPROD k -> COPROD j -> Type) Source Github #
Instance details Defined in Proarrow.Adjunction Methods par0 :: Coprod (Adj p) (Unit :: COPROD k) (Unit :: COPROD j) Source Github # par :: forall (x1 :: COPROD k) (x2 :: COPROD j) (y1 :: COPROD k) (y2 :: COPROD j). Coprod (Adj p) x1 x2 -> Coprod (Adj p) y1 y2 -> Coprod (Adj p) (x1 y1) (x2 y2) Source Github #
(Functor f, HasCoproducts j, HasCoproducts k) => MonoidalProfunctor (Coprod (Star f) :: COPROD k -> COPROD j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Star Methods par0 :: Coprod (Star f) (Unit :: COPROD k) (Unit :: COPROD j) Source Github # par :: forall (x1 :: COPROD k) (x2 :: COPROD j) (y1 :: COPROD k) (y2 :: COPROD j). Coprod (Star f) x1 x2 -> Coprod (Star f) y1 y2 -> Coprod (Star f) (x1 y1) (x2 y2) Source Github #
(HasCoproducts j, HasCoproducts k) => MonoidalProfunctor (Coprod (TerminalProfunctor :: k -> j -> Type) :: COPROD k -> COPROD j -> Type) Source Github #
Instance details Defined in Proarrow.Object.BinaryCoproduct Methods par0 :: Coprod (TerminalProfunctor :: k -> j -> Type) (Unit :: COPROD k) (Unit :: COPROD j) Source Github # par :: forall (x1 :: COPROD k) (x2 :: COPROD j) (y1 :: COPROD k) (y2 :: COPROD j). Coprod (TerminalProfunctor :: k -> j -> Type) x1 x2 -> Coprod (TerminalProfunctor :: k -> j -> Type) y1 y2 -> Coprod (TerminalProfunctor :: k -> j -> Type) (x1 y1) (x2 y2) Source Github #
(Profunctor f, Profunctor g, MonoidalProfunctor (Coprod f), MonoidalProfunctor (Coprod g)) => MonoidalProfunctor (Coprod (f :.: g) :: COPROD k -> COPROD j2 -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Composition Methods par0 :: Coprod (f :.: g) (Unit :: COPROD k) (Unit :: COPROD j2) Source Github # par :: forall (x1 :: COPROD k) (x2 :: COPROD j2) (y1 :: COPROD k) (y2 :: COPROD j2). Coprod (f :.: g) x1 x2 -> Coprod (f :.: g) y1 y2 -> Coprod (f :.: g) (x1 y1) (x2 y2) Source Github #
HasCoproducts k => MonoidalProfunctor (Coprod (Id :: k -> k -> Type) :: COPROD k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Object.BinaryCoproduct Methods par0 :: Coprod (Id :: k -> k -> Type) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # par :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod (Id :: k -> k -> Type) x1 x2 -> Coprod (Id :: k -> k -> Type) y1 y2 -> Coprod (Id :: k -> k -> Type) (x1 y1) (x2 y2) Source Github #
(HasCoproducts k, Ob r) => MonoidalProfunctor (Coprod (Rep (Constant r)) :: COPROD k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Monoid Methods par0 :: Coprod (Rep (Constant r)) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # par :: 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 #
HasCoproducts k => MonoidalProfunctor (Coprod (Cont r) :: COPROD k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Cont Methods par0 :: Coprod (Cont r) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # par :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod (Cont r) x1 x2 -> Coprod (Cont r) y1 y2 -> Coprod (Cont r) (x1 y1) (x2 y2) Source Github #
(HasProducts k, cat ~ Hom k) => MonoidalProfunctor (Prod cat :: PROD k -> PROD k -> Type) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods par0 :: Prod cat (Unit :: PROD k) (Unit :: PROD k) Source Github # par :: forall (x1 :: PROD k) (x2 :: PROD k) (y1 :: PROD k) (y2 :: PROD k). Prod cat x1 x2 -> Prod cat y1 y2 -> Prod cat (x1 y1) (x2 y2) Source Github #
Profunctor p => MonoidalProfunctor (List p :: LIST k -> LIST j -> Type) Source Github #	The free monoidal profunctor on a profunctor.
Instance details Defined in Proarrow.Profunctor.List Methods par0 :: List p (Unit :: LIST k) (Unit :: LIST j) Source Github # par :: forall (x1 :: LIST k) (x2 :: LIST j) (y1 :: LIST k) (y2 :: LIST j). List p x1 x2 -> List p y1 y2 -> List p (x1 y1) (x2 y2) Source Github #
(Promonad p, MonoidalProfunctor p) => MonoidalProfunctor (Kleisli :: KLEISLI p -> KLEISLI p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Kleisli Methods par0 :: Kleisli (Unit :: KLEISLI p) (Unit :: KLEISLI p) Source Github # par :: forall (x1 :: KLEISLI p) (x2 :: KLEISLI p) (y1 :: KLEISLI p) (y2 :: KLEISLI p). Kleisli x1 x2 -> Kleisli y1 y2 -> Kleisli (x1 y1) (x2 y2) Source Github #
(Monoidal j, Monoidal k) => MonoidalProfunctor (Prof :: (j +-> k) -> (j +-> k) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Day Methods par0 :: Prof (Unit :: j +-> k) (Unit :: j +-> k) Source Github # par :: forall (x1 :: j +-> k) (x2 :: j +-> k) (y1 :: j +-> k) (y2 :: j +-> k). Prof x1 x2 -> Prof y1 y2 -> Prof (x1 y1) (x2 y2) Source Github #
MonoidalProfunctor (Nat :: (Type -> Type) -> (Type -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods par0 :: Nat (Unit :: Type -> Type) (Unit :: Type -> Type) Source Github # par :: forall (x1 :: Type -> Type) (x2 :: Type -> Type) (y1 :: Type -> Type) (y2 :: Type -> Type). Nat x1 x2 -> Nat y1 y2 -> Nat (x1 y1) (x2 y2) Source Github #
(MonoidalProfunctor p, SubMonoidal ob) => MonoidalProfunctor (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Sub Methods par0 :: Sub p (Unit :: SUBCAT ob) (Unit :: SUBCAT ob) Source Github # par :: forall (x1 :: SUBCAT ob) (x2 :: SUBCAT ob) (y1 :: SUBCAT ob) (y2 :: SUBCAT ob). Sub p x1 x2 -> Sub p y1 y2 -> Sub p (x1 y1) (x2 y2) Source Github #
(Applicative f, MonoidalProfunctor p) => MonoidalProfunctor (Ap p :: AP f k -> AP f j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Ap Methods par0 :: Ap p (Unit :: AP f k) (Unit :: AP f j) Source Github # par :: forall (x1 :: AP f k) (x2 :: AP f j) (y1 :: AP f k) (y2 :: AP f j). Ap p x1 x2 -> Ap p y1 y2 -> Ap p (x1 y1) (x2 y2) Source Github #
CommutativeMonoid m => MonoidalProfunctor (Mon :: MONOIDK m -> MONOIDK m -> Type) Source Github #
Instance details Defined in Proarrow.Monoid Methods par0 :: Mon (Unit :: MONOIDK m) (Unit :: MONOIDK m) Source Github # par :: forall (x1 :: MONOIDK m) (x2 :: MONOIDK m) (y1 :: MONOIDK m) (y2 :: MONOIDK m). Mon x1 x2 -> Mon y1 y2 -> Mon (x1 y1) (x2 y2) Source Github #
(MonoidalProfunctor p, MonoidalProfunctor q) => MonoidalProfunctor (p :**: q :: (k1, k2) -> (j1, j2) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods par0 :: (p :: q) (Unit :: (k1, k2)) (Unit :: (j1, j2)) Source Github # par :: forall (x1 :: (k1, k2)) (x2 :: (j1, j2)) (y1 :: (k1, k2)) (y2 :: (j1, j2)). (p :: q) x1 x2 -> (p :: q) y1 y2 -> (p :: q) (x1 y1) (x2 y2) Source Github #
(Adjunction adj, StrongMonoidalRep adj) => MonoidalProfunctor (Duploid :: DUPLOID adj -> DUPLOID adj -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Duploid Methods par0 :: Duploid (Unit :: DUPLOID adj) (Unit :: DUPLOID adj) Source Github # par :: forall (x1 :: DUPLOID adj) (x2 :: DUPLOID adj) (y1 :: DUPLOID adj) (y2 :: DUPLOID adj). Duploid x1 x2 -> Duploid y1 y2 -> Duploid (x1 y1) (x2 y2) Source Github #
(Ok cs p, Elem Monoidal cs) => MonoidalProfunctor (Free :: FREE cs p -> FREE cs p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Free Methods par0 :: Free (Unit :: FREE cs p) (Unit :: FREE cs p) Source Github # par :: forall (x1 :: FREE cs p) (x2 :: FREE cs p) (y1 :: FREE cs p) (y2 :: FREE cs p). Free x1 x2 -> Free y1 y2 -> Free (x1 y1) (x2 y2) Source Github #
(Bicategory kk, Ob0 kk k, Ob (I :: kk k k)) => MonoidalProfunctor (Endo :: ENDO kk k -> ENDO kk k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Endo Methods par0 :: Endo (Unit :: ENDO kk k) (Unit :: ENDO kk k) Source Github # par :: forall (x1 :: ENDO kk k) (x2 :: ENDO kk k) (y1 :: ENDO kk k) (y2 :: ENDO kk k). Endo x1 x2 -> Endo y1 y2 -> Endo (x1 y1) (x2 y2) Source Github #

par0Rep :: forall {j} {k} (p :: j +-> k). (Representable p, MonoidalProfunctor p) => (Unit :: k) ~> (p % (Unit :: j)) Source Github #

parRep :: forall {k1} {k2} (p :: k1 +-> k2) (x :: k1) (y :: k1). (Representable p, MonoidalProfunctor p, Ob x, Ob y) => ((p % x) ** (p % y)) ~> (p % (x ** y)) Source Github #

unpar0Corep :: forall {k1} {k2} (p :: k1 +-> k2). (Corepresentable p, MonoidalProfunctor p) => (p %% (Unit :: k2)) ~> (Unit :: k1) Source Github #

unparCorep :: forall {j} {k} (p :: j +-> k) (x :: k) (y :: k). (Corepresentable p, MonoidalProfunctor p, Ob x, Ob y) => (p %% (x ** y)) ~> ((p %% x) ** (p %% y)) Source Github #

type StrongMonoidalRep (p :: k +-> j) = (Representable p, MonoidalProfunctor p, MonoidalProfunctor (RepCostar p)) Source Github #

unpar0Rep :: forall {j} {k} (p :: j +-> k). StrongMonoidalRep p => (p % (Unit :: j)) ~> (Unit :: k) Source Github #

unparRep :: forall {j} {k} (p :: j +-> k) (x :: j) (y :: j). (StrongMonoidalRep p, Ob x, Ob y) => (p % (x ** y)) ~> ((p % x) ** (p % y)) Source Github #

type StrongMonoidalCorep (p :: k +-> j) = (Corepresentable p, MonoidalProfunctor p, MonoidalProfunctor (CorepStar p)) Source Github #

par0Corep :: forall {k1} {k2} (p :: k1 +-> k2). StrongMonoidalCorep p => (Unit :: k1) ~> (p %% (Unit :: k2)) Source Github #

parCorep :: forall {j} {k} (p :: j +-> k) (x :: k) (y :: k). (StrongMonoidalCorep p, Ob x, Ob y) => ((p %% x) ** (p %% y)) ~> (p %% (x ** y)) Source Github #

class (CategoryOf k, MonoidalProfunctor ((~>) :: CAT k), Ob (Unit :: k)) => Monoidal k where Source Github #

Minimal complete definition

withOb2, leftUnitor, rightUnitor, rightUnitorInv

Associated Types

type Unit :: k Source Github #

type (a :: k) ** (b :: k) :: k Source Github #

Methods

withOb2 :: forall (a :: k) (b :: k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: k). Ob a => ((Unit :: k) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: k). Ob a => a ~> ((Unit :: k) ** a) Source Github #

rightUnitor :: forall (a :: k). Ob a => (a ** (Unit :: k)) ~> a Source Github #

rightUnitorInv :: forall (a :: k). Ob a => a ~> (a ** (Unit :: k)) Source Github #

associator :: forall (a :: k) (b :: k) (c :: k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: k) (b :: k) (c :: k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Instances

Instances details

Monoidal Nat Source Github #

Addition as monoidal tensor.

Instance details

Defined in Proarrow.Category.Instance.Simplex

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Simplex type Unit = 'Z
type (a :: Nat) ** (b :: Nat)
Instance details Defined in Proarrow.Category.Instance.Simplex type (a :: Nat) ** (b :: Nat) = a + b

Methods

withOb2 :: forall (a :: Nat) (b :: Nat) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: Nat). Ob a => ((Unit :: Nat) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: Nat). Ob a => a ~> ((Unit :: Nat) ** a) Source Github #

rightUnitor :: forall (a :: Nat). Ob a => (a ** (Unit :: Nat)) ~> a Source Github #

rightUnitorInv :: forall (a :: Nat). Ob a => a ~> (a ** (Unit :: Nat)) Source Github #

associator :: forall (a :: Nat) (b :: Nat) (c :: Nat). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: Nat) (b :: Nat) (c :: Nat). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal Nat Source Github #

Addition of the number of qubits as monoidal tensor. This is the Kronecker product of the matrices.

Instance details

Defined in Proarrow.Category.Instance.ZX

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.ZX type Unit = 0
type (p :: Natural) ** (q :: Natural)
Instance details Defined in Proarrow.Category.Instance.ZX type (p :: Natural) ** (q :: Natural) = p + q

Methods

withOb2 :: forall (a :: Nat) (b :: Nat) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: Nat). Ob a => ((Unit :: Nat) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: Nat). Ob a => a ~> ((Unit :: Nat) ** a) Source Github #

rightUnitor :: forall (a :: Nat). Ob a => (a ** (Unit :: Nat)) ~> a Source Github #

rightUnitorInv :: forall (a :: Nat). Ob a => a ~> (a ** (Unit :: Nat)) Source Github #

associator :: forall (a :: Nat) (b :: Nat) (c :: Nat). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: Nat) (b :: Nat) (c :: Nat). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal BOOL Source Github #

Products as monoidal structure.

Instance details

Defined in Proarrow.Category.Instance.Bool

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Bool type Unit = TerminalObject :: BOOL
type (a :: BOOL) ** (b :: BOOL)
Instance details Defined in Proarrow.Category.Instance.Bool type (a :: BOOL) ** (b :: BOOL) = a && b

Methods

withOb2 :: forall (a :: BOOL) (b :: BOOL) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: BOOL). Ob a => ((Unit :: BOOL) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: BOOL). Ob a => a ~> ((Unit :: BOOL) ** a) Source Github #

rightUnitor :: forall (a :: BOOL). Ob a => (a ** (Unit :: BOOL)) ~> a Source Github #

rightUnitorInv :: forall (a :: BOOL). Ob a => a ~> (a ** (Unit :: BOOL)) Source Github #

associator :: forall (a :: BOOL) (b :: BOOL) (c :: BOOL). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: BOOL) (b :: BOOL) (c :: BOOL). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal KIND Source Github #

Products as monoidal structure.

Instance details

Defined in Proarrow.Category.Instance.Cat

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Cat type Unit = 'K ()
type (l :: KIND) ** (r :: KIND)
Instance details Defined in Proarrow.Category.Instance.Cat type (l :: KIND) ** (r :: KIND) = 'K (UN 'K l, UN 'K r)

Methods

withOb2 :: forall (a :: KIND) (b :: KIND) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: KIND). Ob a => ((Unit :: KIND) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: KIND). Ob a => a ~> ((Unit :: KIND) ** a) Source Github #

rightUnitor :: forall (a :: KIND). Ob a => (a ** (Unit :: KIND)) ~> a Source Github #

rightUnitorInv :: forall (a :: KIND). Ob a => a ~> (a ** (Unit :: KIND)) Source Github #

associator :: forall (a :: KIND) (b :: KIND) (c :: KIND). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: KIND) (b :: KIND) (c :: KIND). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal CONSTRAINT Source Github #

Products as monoidal structure.

Instance details

Defined in Proarrow.Category.Instance.Constraint

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Constraint type Unit = TerminalObject :: CONSTRAINT
type (a :: CONSTRAINT) ** (b :: CONSTRAINT)
Instance details Defined in Proarrow.Category.Instance.Constraint type (a :: CONSTRAINT) ** (b :: CONSTRAINT) = a && b

Methods

withOb2 :: forall (a :: CONSTRAINT) (b :: CONSTRAINT) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: CONSTRAINT). Ob a => ((Unit :: CONSTRAINT) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: CONSTRAINT). Ob a => a ~> ((Unit :: CONSTRAINT) ** a) Source Github #

rightUnitor :: forall (a :: CONSTRAINT). Ob a => (a ** (Unit :: CONSTRAINT)) ~> a Source Github #

rightUnitorInv :: forall (a :: CONSTRAINT). Ob a => a ~> (a ** (Unit :: CONSTRAINT)) Source Github #

associator :: forall (a :: CONSTRAINT) (b :: CONSTRAINT) (c :: CONSTRAINT). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: CONSTRAINT) (b :: CONSTRAINT) (c :: CONSTRAINT). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal COST Source Github #

Instance details

Defined in Proarrow.Category.Instance.Cost

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Cost type Unit = 'C 0
type ('C a :: COST) ** ('C b :: COST)
Instance details Defined in Proarrow.Category.Instance.Cost type ('C a :: COST) ** ('C b :: COST) = 'C (a + b)
type 'INF ** (b :: COST)
Instance details Defined in Proarrow.Category.Instance.Cost type 'INF ** (b :: COST) = 'INF
type (a :: COST) ** 'INF
Instance details Defined in Proarrow.Category.Instance.Cost type (a :: COST) ** 'INF = 'INF

Methods

withOb2 :: forall (a :: COST) (b :: COST) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: COST). Ob a => ((Unit :: COST) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: COST). Ob a => a ~> ((Unit :: COST) ** a) Source Github #

rightUnitor :: forall (a :: COST). Ob a => (a ** (Unit :: COST)) ~> a Source Github #

rightUnitorInv :: forall (a :: COST). Ob a => a ~> (a ** (Unit :: COST)) Source Github #

associator :: forall (a :: COST) (b :: COST) (c :: COST). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: COST) (b :: COST) (c :: COST). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal FINREL Source Github #

Instance details

Defined in Proarrow.Category.Instance.FinRel

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.FinRel type Unit = 'FR Nat1
type ('FR a :: FINREL) ** ('FR b :: FINREL)
Instance details Defined in Proarrow.Category.Instance.FinRel type ('FR a :: FINREL) ** ('FR b :: FINREL) = 'FR (Mult a b)

Methods

withOb2 :: forall (a :: FINREL) (b :: FINREL) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: FINREL). Ob a => ((Unit :: FINREL) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: FINREL). Ob a => a ~> ((Unit :: FINREL) ** a) Source Github #

rightUnitor :: forall (a :: FINREL). Ob a => (a ** (Unit :: FINREL)) ~> a Source Github #

rightUnitorInv :: forall (a :: FINREL). Ob a => a ~> (a ** (Unit :: FINREL)) Source Github #

associator :: forall (a :: FINREL) (b :: FINREL) (c :: FINREL). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: FINREL) (b :: FINREL) (c :: FINREL). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal FINSET Source Github #

Instance details

Defined in Proarrow.Category.Instance.FinSet

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.FinSet type Unit = 'FS Nat1
type (a :: FINSET) ** (b :: FINSET)
Instance details Defined in Proarrow.Category.Instance.FinSet type (a :: FINSET) ** (b :: FINSET) = a && b

Methods

withOb2 :: forall (a :: FINSET) (b :: FINSET) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: FINSET). Ob a => ((Unit :: FINSET) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: FINSET). Ob a => a ~> ((Unit :: FINSET) ** a) Source Github #

rightUnitor :: forall (a :: FINSET). Ob a => (a ** (Unit :: FINSET)) ~> a Source Github #

rightUnitorInv :: forall (a :: FINSET). Ob a => a ~> (a ** (Unit :: FINSET)) Source Github #

associator :: forall (a :: FINSET) (b :: FINSET) (c :: FINSET). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: FINSET) (b :: FINSET) (c :: FINSET). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal LINEAR Source Github #

Tuples as monoidal tensor. Note that tuples are not the binary product in LINEAR.

Instance details

Defined in Proarrow.Category.Instance.Linear

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Linear type Unit = 'L ()
type ('L a :: LINEAR) ** ('L b :: LINEAR)
Instance details Defined in Proarrow.Category.Instance.Linear type ('L a :: LINEAR) ** ('L b :: LINEAR) = 'L (a, b)

Methods

withOb2 :: forall (a :: LINEAR) (b :: LINEAR) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: LINEAR). Ob a => ((Unit :: LINEAR) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: LINEAR). Ob a => a ~> ((Unit :: LINEAR) ** a) Source Github #

rightUnitor :: forall (a :: LINEAR). Ob a => (a ** (Unit :: LINEAR)) ~> a Source Github #

rightUnitorInv :: forall (a :: LINEAR). Ob a => a ~> (a ** (Unit :: LINEAR)) Source Github #

associator :: forall (a :: LINEAR) (b :: LINEAR) (c :: LINEAR). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: LINEAR) (b :: LINEAR) (c :: LINEAR). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal POINTED Source Github #

The smash product of pointed sets. Monoids relative to the smash product are absorption monoids.

Instance details

Defined in Proarrow.Category.Instance.PointedHask

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.PointedHask type Unit = 'P ()
type ('P a :: POINTED) ** ('P b :: POINTED)
Instance details Defined in Proarrow.Category.Instance.PointedHask type ('P a :: POINTED) ** ('P b :: POINTED) = 'P (a, b)

Methods

withOb2 :: forall (a :: POINTED) (b :: POINTED) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: POINTED). Ob a => ((Unit :: POINTED) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: POINTED). Ob a => a ~> ((Unit :: POINTED) ** a) Source Github #

rightUnitor :: forall (a :: POINTED). Ob a => (a ** (Unit :: POINTED)) ~> a Source Github #

rightUnitorInv :: forall (a :: POINTED). Ob a => a ~> (a ** (Unit :: POINTED)) Source Github #

associator :: forall (a :: POINTED) (b :: POINTED) (c :: POINTED). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: POINTED) (b :: POINTED) (c :: POINTED). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal DOT Source Github #

Instance details

Defined in Proarrow.Tools.Diagrams.Dot

Associated Types

type Unit
Instance details Defined in Proarrow.Tools.Diagrams.Dot type Unit = 'D ('[] :: [Symbol])
type (ls :: DOT) ** (rs :: DOT)
Instance details Defined in Proarrow.Tools.Diagrams.Dot type (ls :: DOT) ** (rs :: DOT) = 'D (UN 'D ls ++ UN 'D rs)

Methods

withOb2 :: forall (a :: DOT) (b :: DOT) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: DOT). Ob a => ((Unit :: DOT) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: DOT). Ob a => a ~> ((Unit :: DOT) ** a) Source Github #

rightUnitor :: forall (a :: DOT). Ob a => (a ** (Unit :: DOT)) ~> a Source Github #

rightUnitorInv :: forall (a :: DOT). Ob a => a ~> (a ** (Unit :: DOT)) Source Github #

associator :: forall (a :: DOT) (b :: DOT) (c :: DOT). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: DOT) (b :: DOT) (c :: DOT). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal () Source Github #

Instance details

Defined in Proarrow.Category.Monoidal

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Monoidal type Unit = '()
type '() ** '()
Instance details Defined in Proarrow.Category.Monoidal type '() ** '() = '()

Methods

withOb2 :: forall (a :: ()) (b :: ()) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: ()). Ob a => ((Unit :: ()) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: ()). Ob a => a ~> ((Unit :: ()) ** a) Source Github #

rightUnitor :: forall (a :: ()). Ob a => (a ** (Unit :: ())) ~> a Source Github #

rightUnitorInv :: forall (a :: ()). Ob a => a ~> (a ** (Unit :: ())) Source Github #

associator :: forall (a :: ()) (b :: ()) (c :: ()). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: ()) (b :: ()) (c :: ()). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal Type Source Github #

Products as monoidal structure.

Instance details

Defined in Proarrow.Object.BinaryProduct

Associated Types

type Unit
Instance details Defined in Proarrow.Object.BinaryProduct type Unit = TerminalObject :: Type
type (a :: Type) ** (b :: Type)
Instance details Defined in Proarrow.Object.BinaryProduct type (a :: Type) ** (b :: Type) = a && b

Methods

withOb2 :: (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: Ob a => ((Unit :: Type) ** a) ~> a Source Github #

leftUnitorInv :: Ob a => a ~> ((Unit :: Type) ** a) Source Github #

rightUnitor :: Ob a => (a ** (Unit :: Type)) ~> a Source Github #

rightUnitorInv :: Ob a => a ~> (a ** (Unit :: Type)) Source Github #

associator :: (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

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

Instance details

Defined in Proarrow.Category.Instance.Cospan

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Cospan type Unit = 'CS (InitialObject :: k)

Methods

withOb2 :: forall (a :: COSPAN k) (b :: COSPAN k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: COSPAN k). Ob a => ((Unit :: COSPAN k) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: COSPAN k). Ob a => a ~> ((Unit :: COSPAN k) ** a) Source Github #

rightUnitor :: forall (a :: COSPAN k). Ob a => (a ** (Unit :: COSPAN k)) ~> a Source Github #

rightUnitorInv :: forall (a :: COSPAN k). Ob a => a ~> (a ** (Unit :: COSPAN k)) Source Github #

associator :: forall (a :: COSPAN k) (b :: COSPAN k) (c :: COSPAN k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: COSPAN k) (b :: COSPAN k) (c :: COSPAN k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

TracedMonoidal k => Monoidal (INT k) Source Github #

The monoidal tensor is pointwise, tensoring of the plus and minus parts.

Instance details

Defined in Proarrow.Category.Instance.IntConstruction

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.IntConstruction type Unit = 'I (Unit :: k) (Unit :: k)

Methods

withOb2 :: forall (a :: INT k) (b :: INT k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: INT k). Ob a => ((Unit :: INT k) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: INT k). Ob a => a ~> ((Unit :: INT k) ** a) Source Github #

rightUnitor :: forall (a :: INT k). Ob a => (a ** (Unit :: INT k)) ~> a Source Github #

rightUnitorInv :: forall (a :: INT k). Ob a => a ~> (a ** (Unit :: INT k)) Source Github #

associator :: forall (a :: INT k) (b :: INT k) (c :: INT k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: INT k) (b :: INT k) (c :: INT k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

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

Products of the dimensions of the matrices as the tensor. This is the Kronecker product of matrices.

Instance details

Defined in Proarrow.Category.Instance.Mat

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Mat type Unit = 'M ('S 'Z) :: MatK a

Methods

withOb2 :: forall (a0 :: MatK a) (b :: MatK a) r. (Ob a0, Ob b) => (Ob (a0 ** b) => r) -> r Source Github #

leftUnitor :: forall (a0 :: MatK a). Ob a0 => ((Unit :: MatK a) ** a0) ~> a0 Source Github #

leftUnitorInv :: forall (a0 :: MatK a). Ob a0 => a0 ~> ((Unit :: MatK a) ** a0) Source Github #

rightUnitor :: forall (a0 :: MatK a). Ob a0 => (a0 ** (Unit :: MatK a)) ~> a0 Source Github #

rightUnitorInv :: forall (a0 :: MatK a). Ob a0 => a0 ~> (a0 ** (Unit :: MatK a)) Source Github #

associator :: forall (a0 :: MatK a) (b :: MatK a) (c :: MatK a). (Ob a0, Ob b, Ob c) => ((a0 ** b) ** c) ~> (a0 ** (b ** c)) Source Github #

associatorInv :: forall (a0 :: MatK a) (b :: MatK a) (c :: MatK a). (Ob a0, Ob b, Ob c) => (a0 ** (b ** c)) ~> ((a0 ** b) ** c) Source Github #

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

Instance details

Defined in Proarrow.Category.Instance.Span

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Span type Unit = 'SP (TerminalObject :: k)

Methods

withOb2 :: forall (a :: SPAN k) (b :: SPAN k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: SPAN k). Ob a => ((Unit :: SPAN k) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: SPAN k). Ob a => a ~> ((Unit :: SPAN k) ** a) Source Github #

rightUnitor :: forall (a :: SPAN k). Ob a => (a ** (Unit :: SPAN k)) ~> a Source Github #

rightUnitorInv :: forall (a :: SPAN k). Ob a => a ~> (a ** (Unit :: SPAN k)) Source Github #

associator :: forall (a :: SPAN k) (b :: SPAN k) (c :: SPAN k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: SPAN k) (b :: SPAN k) (c :: SPAN k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

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

The flipped tensor.

Instance details

Defined in Proarrow.Category.Monoidal.Rev

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Monoidal.Rev type Unit = 'R (Unit :: k)

Methods

withOb2 :: forall (a :: REV k) (b :: REV k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: REV k). Ob a => ((Unit :: REV k) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: REV k). Ob a => a ~> ((Unit :: REV k) ** a) Source Github #

rightUnitor :: forall (a :: REV k). Ob a => (a ** (Unit :: REV k)) ~> a Source Github #

rightUnitorInv :: forall (a :: REV k). Ob a => a ~> (a ** (Unit :: REV k)) Source Github #

associator :: forall (a :: REV k) (b :: REV k) (c :: REV k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: REV k) (b :: REV k) (c :: REV k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

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

The opposite of a monoidal category is also monoidal, with the same tensor product.

Instance details

Defined in Proarrow.Category.Monoidal

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Monoidal type Unit = 'OP (Unit :: k)

Methods

withOb2 :: forall (a :: OPPOSITE k) (b :: OPPOSITE k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: OPPOSITE k). Ob a => ((Unit :: OPPOSITE k) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: OPPOSITE k). Ob a => a ~> ((Unit :: OPPOSITE k) ** a) Source Github #

rightUnitor :: forall (a :: OPPOSITE k). Ob a => (a ** (Unit :: OPPOSITE k)) ~> a Source Github #

rightUnitorInv :: forall (a :: OPPOSITE k). Ob a => a ~> (a ** (Unit :: OPPOSITE k)) Source Github #

associator :: forall (a :: OPPOSITE k) (b :: OPPOSITE k) (c :: OPPOSITE k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: OPPOSITE k) (b :: OPPOSITE k) (c :: OPPOSITE k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

HasCoproducts k => Monoidal (COPROD k) Source Github #

Coproducts as monoidal tensor.

Instance details

Defined in Proarrow.Object.BinaryCoproduct

Associated Types

type Unit
Instance details Defined in Proarrow.Object.BinaryCoproduct type Unit = 'COPR (InitialObject :: k)

Methods

withOb2 :: forall (a :: COPROD k) (b :: COPROD k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: COPROD k). Ob a => ((Unit :: COPROD k) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: COPROD k). Ob a => a ~> ((Unit :: COPROD k) ** a) Source Github #

rightUnitor :: forall (a :: COPROD k). Ob a => (a ** (Unit :: COPROD k)) ~> a Source Github #

rightUnitorInv :: forall (a :: COPROD k). Ob a => a ~> (a ** (Unit :: COPROD k)) Source Github #

associator :: forall (a :: COPROD k) (b :: COPROD k) (c :: COPROD k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: COPROD k) (b :: COPROD k) (c :: COPROD k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

HasProducts k => Monoidal (PROD k) Source Github #

Products as monoidal structure.

Instance details

Defined in Proarrow.Object.BinaryProduct

Associated Types

type Unit
Instance details Defined in Proarrow.Object.BinaryProduct type Unit = TerminalObject :: PROD k

Methods

withOb2 :: forall (a :: PROD k) (b :: PROD k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: PROD k). Ob a => ((Unit :: PROD k) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: PROD k). Ob a => a ~> ((Unit :: PROD k) ** a) Source Github #

rightUnitor :: forall (a :: PROD k). Ob a => (a ** (Unit :: PROD k)) ~> a Source Github #

rightUnitorInv :: forall (a :: PROD k). Ob a => a ~> (a ** (Unit :: PROD k)) Source Github #

associator :: forall (a :: PROD k) (b :: PROD k) (c :: PROD k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: PROD k) (b :: PROD k) (c :: PROD k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

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

The free monoidal category on a category.

Instance details

Defined in Proarrow.Profunctor.List

Associated Types

type Unit
Instance details Defined in Proarrow.Profunctor.List type Unit = 'L ('[] :: [k])

Methods

withOb2 :: forall (a :: LIST k) (b :: LIST k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: LIST k). Ob a => ((Unit :: LIST k) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: LIST k). Ob a => a ~> ((Unit :: LIST k) ** a) Source Github #

rightUnitor :: forall (a :: LIST k). Ob a => (a ** (Unit :: LIST k)) ~> a Source Github #

rightUnitorInv :: forall (a :: LIST k). Ob a => a ~> (a ** (Unit :: LIST k)) Source Github #

associator :: forall (a :: LIST k) (b :: LIST k) (c :: LIST k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: LIST k) (b :: LIST k) (c :: LIST k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal k => Monoidal [k] Source Github #

List concattenation as monoidal tensor.

Instance details

Defined in Proarrow.Category.Monoidal.Strictified

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Monoidal.Strictified type Unit = '[] :: [k]

Methods

withOb2 :: forall (a :: [k]) (b :: [k]) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: [k]). Ob a => ((Unit :: [k]) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: [k]). Ob a => a ~> ((Unit :: [k]) ** a) Source Github #

rightUnitor :: forall (a :: [k]). Ob a => (a ** (Unit :: [k])) ~> a Source Github #

rightUnitorInv :: forall (a :: [k]). Ob a => a ~> (a ** (Unit :: [k])) Source Github #

associator :: forall (a :: [k]) (b :: [k]) (c :: [k]). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: [k]) (b :: [k]) (c :: [k]). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

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

Instance details

Defined in Proarrow.Category.Instance.Ap

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Ap type Unit = 'A (Unit :: k) :: AP f k

Methods

withOb2 :: forall (a :: AP f k) (b :: AP f k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: AP f k). Ob a => ((Unit :: AP f k) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: AP f k). Ob a => a ~> ((Unit :: AP f k) ** a) Source Github #

rightUnitor :: forall (a :: AP f k). Ob a => (a ** (Unit :: AP f k)) ~> a Source Github #

rightUnitorInv :: forall (a :: AP f k). Ob a => a ~> (a ** (Unit :: AP f k)) Source Github #

associator :: forall (a :: AP f k) (b :: AP f k) (c :: AP f k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: AP f k) (b :: AP f k) (c :: AP f k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

(Promonad p, MonoidalProfunctor p) => Monoidal (KLEISLI p) Source Github #

If the promonad is a monoidal profunctor, then its Kleisli category is a monoidal category.

Instance details

Defined in Proarrow.Category.Instance.Kleisli

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Kleisli type Unit = 'KL (Unit :: k) :: KLEISLI p

Methods

withOb2 :: forall (a :: KLEISLI p) (b :: KLEISLI p) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: KLEISLI p). Ob a => ((Unit :: KLEISLI p) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: KLEISLI p). Ob a => a ~> ((Unit :: KLEISLI p) ** a) Source Github #

rightUnitor :: forall (a :: KLEISLI p). Ob a => (a ** (Unit :: KLEISLI p)) ~> a Source Github #

rightUnitorInv :: forall (a :: KLEISLI p). Ob a => a ~> (a ** (Unit :: KLEISLI p)) Source Github #

associator :: forall (a :: KLEISLI p) (b :: KLEISLI p) (c :: KLEISLI p). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: KLEISLI p) (b :: KLEISLI p) (c :: KLEISLI p). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

SubMonoidal ob => Monoidal (SUBCAT ob) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Sub

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Sub type Unit = 'SUB (Unit :: k) :: SUBCAT ob

Methods

withOb2 :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: SUBCAT ob). Ob a => ((Unit :: SUBCAT ob) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: SUBCAT ob). Ob a => a ~> ((Unit :: SUBCAT ob) ** a) Source Github #

rightUnitor :: forall (a :: SUBCAT ob). Ob a => (a ** (Unit :: SUBCAT ob)) ~> a Source Github #

rightUnitorInv :: forall (a :: SUBCAT ob). Ob a => a ~> (a ** (Unit :: SUBCAT ob)) Source Github #

associator :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (c :: SUBCAT ob). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (c :: SUBCAT ob). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

(Monoidal j, Monoidal k) => Monoidal (j +-> k) Source Github #

Instance details

Defined in Proarrow.Profunctor.Day

Associated Types

type Unit
Instance details Defined in Proarrow.Profunctor.Day type Unit = DayUnit :: k -> j -> Type

Methods

withOb2 :: forall (a :: j +-> k) (b :: j +-> k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: j +-> k). Ob a => ((Unit :: j +-> k) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: j +-> k). Ob a => a ~> ((Unit :: j +-> k) ** a) Source Github #

rightUnitor :: forall (a :: j +-> k). Ob a => (a ** (Unit :: j +-> k)) ~> a Source Github #

rightUnitorInv :: forall (a :: j +-> k). Ob a => a ~> (a ** (Unit :: j +-> k)) Source Github #

associator :: forall (a :: j +-> k) (b :: j +-> k) (c :: j +-> k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: j +-> k) (b :: j +-> k) (c :: j +-> k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

CommutativeMonoid m => Monoidal (MONOIDK m) Source Github #

Instance details

Defined in Proarrow.Monoid

Associated Types

type Unit
Instance details Defined in Proarrow.Monoid type Unit = 'M :: MONOIDK m

Methods

withOb2 :: forall (a :: MONOIDK m) (b :: MONOIDK m) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: MONOIDK m). Ob a => ((Unit :: MONOIDK m) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: MONOIDK m). Ob a => a ~> ((Unit :: MONOIDK m) ** a) Source Github #

rightUnitor :: forall (a :: MONOIDK m). Ob a => (a ** (Unit :: MONOIDK m)) ~> a Source Github #

rightUnitorInv :: forall (a :: MONOIDK m). Ob a => a ~> (a ** (Unit :: MONOIDK m)) Source Github #

associator :: forall (a :: MONOIDK m) (b :: MONOIDK m) (c :: MONOIDK m). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: MONOIDK m) (b :: MONOIDK m) (c :: MONOIDK m). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

(Monoidal j, Monoidal k) => Monoidal (j, k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Monoidal type Unit = '(Unit :: j, Unit :: k)

Methods

withOb2 :: forall (a :: (j, k)) (b :: (j, k)) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: (j, k)). Ob a => ((Unit :: (j, k)) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: (j, k)). Ob a => a ~> ((Unit :: (j, k)) ** a) Source Github #

rightUnitor :: forall (a :: (j, k)). Ob a => (a ** (Unit :: (j, k))) ~> a Source Github #

rightUnitorInv :: forall (a :: (j, k)). Ob a => a ~> (a ** (Unit :: (j, k))) Source Github #

associator :: forall (a :: (j, k)) (b :: (j, k)) (c :: (j, k)). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: (j, k)) (b :: (j, k)) (c :: (j, k)). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

Monoidal (Type -> Type) Source Github #

Composition as monoidal tensor.

Instance details

Defined in Proarrow.Category.Instance.Nat

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Nat type Unit = Identity
type (f :: Type -> Type) ** (g :: Type -> Type)
Instance details Defined in Proarrow.Category.Instance.Nat type (f :: Type -> Type) ** (g :: Type -> Type) = Compose f g

Methods

withOb2 :: forall (a :: Type -> Type) (b :: Type -> Type) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: Type -> Type). Ob a => ((Unit :: Type -> Type) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: Type -> Type). Ob a => a ~> ((Unit :: Type -> Type) ** a) Source Github #

rightUnitor :: forall (a :: Type -> Type). Ob a => (a ** (Unit :: Type -> Type)) ~> a Source Github #

rightUnitorInv :: forall (a :: Type -> Type). Ob a => a ~> (a ** (Unit :: Type -> Type)) Source Github #

associator :: forall (a :: Type -> Type) (b :: Type -> Type) (c :: Type -> Type). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: Type -> Type) (b :: Type -> Type) (c :: Type -> Type). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

(Adjunction adj, StrongMonoidalRep adj) => Monoidal (DUPLOID adj) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Duploid

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Duploid type Unit = 'P (Unit :: p) :: DUPLOID adj

Methods

withOb2 :: forall (a :: DUPLOID adj) (b :: DUPLOID adj) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: DUPLOID adj). Ob a => ((Unit :: DUPLOID adj) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: DUPLOID adj). Ob a => a ~> ((Unit :: DUPLOID adj) ** a) Source Github #

rightUnitor :: forall (a :: DUPLOID adj). Ob a => (a ** (Unit :: DUPLOID adj)) ~> a Source Github #

rightUnitorInv :: forall (a :: DUPLOID adj). Ob a => a ~> (a ** (Unit :: DUPLOID adj)) Source Github #

associator :: forall (a :: DUPLOID adj) (b :: DUPLOID adj) (c :: DUPLOID adj). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: DUPLOID adj) (b :: DUPLOID adj) (c :: DUPLOID adj). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

(Ok cs p, Elem Monoidal cs) => Monoidal (FREE cs p) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Free

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Free type Unit = UnitF :: FREE cs p

Methods

withOb2 :: forall (a :: FREE cs p) (b :: FREE cs p) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: FREE cs p). Ob a => ((Unit :: FREE cs p) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: FREE cs p). Ob a => a ~> ((Unit :: FREE cs p) ** a) Source Github #

rightUnitor :: forall (a :: FREE cs p). Ob a => (a ** (Unit :: FREE cs p)) ~> a Source Github #

rightUnitorInv :: forall (a :: FREE cs p). Ob a => a ~> (a ** (Unit :: FREE cs p)) Source Github #

associator :: forall (a :: FREE cs p) (b :: FREE cs p) (c :: FREE cs p). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: FREE cs p) (b :: FREE cs p) (c :: FREE cs p). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

(Bicategory kk, Ob0 kk k, Ob (I :: kk k k)) => Monoidal (ENDO kk k) Source Github #

The monoidal subcategory of a bicategory for a single object.

Instance details

Defined in Proarrow.Category.Monoidal.Endo

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Monoidal.Endo type Unit = 'E (I :: kk k k)

Methods

withOb2 :: forall (a :: ENDO kk k) (b :: ENDO kk k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: ENDO kk k). Ob a => ((Unit :: ENDO kk k) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: ENDO kk k). Ob a => a ~> ((Unit :: ENDO kk k) ** a) Source Github #

rightUnitor :: forall (a :: ENDO kk k). Ob a => (a ** (Unit :: ENDO kk k)) ~> a Source Github #

rightUnitorInv :: forall (a :: ENDO kk k). Ob a => a ~> (a ** (Unit :: ENDO kk k)) Source Github #

associator :: forall (a :: ENDO kk k) (b :: ENDO kk k) (c :: ENDO kk k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: ENDO kk k) (b :: ENDO kk k) (c :: ENDO kk k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

leftUnitorIso :: forall k (a :: k) (a' :: k). (Monoidal k, Ob a, Ob a') => Iso ((Unit :: k) ** a) ((Unit :: k) ** a') a a' Source Github #

rightUnitorIso :: forall k (a :: k) (a' :: k). (Monoidal k, Ob a, Ob a') => Iso (a ** (Unit :: k)) (a' ** (Unit :: k)) a a' Source Github #

associatorIso :: forall k (a :: k) (b :: k) (c :: k) (a' :: k) (b' :: k) (c' :: k). (Monoidal k, Ob a, Ob b, Ob c, Ob a', Ob b', Ob c') => Iso ((a ** b) ** c) ((a' ** b') ** c') (a ** (b ** c)) (a' ** (b' ** c')) Source Github #

(||) :: forall k (a :: k) (b :: k) (c :: k) (d :: k). Monoidal k => (a ~> b) -> (c ~> d) -> (a ** c) ~> (b ** d) infixl 8 Source Github #

(==) :: forall k (a :: k) (b :: k) (c :: k). CategoryOf k => (a ~> b) -> (b ~> c) -> a ~> c infixl 7 Source Github #

obj2 :: forall {k} (a :: k) (b :: k). (Monoidal k, Ob a, Ob b) => Obj (a ** b) Source Github #

leftUnitor' :: forall k (a :: k) (b :: k). Monoidal k => (a ~> b) -> ((Unit :: k) ** a) ~> b Source Github #

leftUnitorInv' :: forall k (a :: k) (b :: k). Monoidal k => (a ~> b) -> a ~> ((Unit :: k) ** b) Source Github #

rightUnitor' :: forall k (a :: k) (b :: k). Monoidal k => (a ~> b) -> (a ** (Unit :: k)) ~> b Source Github #

rightUnitorInv' :: forall k (a :: k) (b :: k). Monoidal k => (a ~> b) -> a ~> (b ** (Unit :: k)) Source Github #

associator' :: forall {k} (a :: k) (b :: k) (c :: k). Monoidal k => Obj a -> Obj b -> Obj c -> ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv' :: forall {k} (a :: k) (b :: k) (c :: k). Monoidal k => Obj a -> Obj b -> Obj c -> (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

leftUnitorWith :: forall {k} (a :: k) (b :: k). (Monoidal k, Ob a) => (b ~> (Unit :: k)) -> (b ** a) ~> a Source Github #

leftUnitorInvWith :: forall {k} (a :: k) (b :: k). (Monoidal k, Ob a) => ((Unit :: k) ~> b) -> a ~> (b ** a) Source Github #

rightUnitorWith :: forall {k} (a :: k) (b :: k). (Monoidal k, Ob a) => (b ~> (Unit :: k)) -> (a ** b) ~> a Source Github #

rightUnitorInvWith :: forall {k} (a :: k) (b :: k). (Monoidal k, Ob a) => ((Unit :: k) ~> b) -> a ~> (a ** b) Source Github #

unitObj :: Monoidal k => Obj (Unit :: k) Source Github #

first :: forall {k} (c :: k) (a :: k) (b :: k). (Monoidal k, Ob c) => (a ~> b) -> (a ** c) ~> (b ** c) Source Github #

second :: forall {k} (c :: k) (a :: k) (b :: k). (Monoidal k, Ob c) => (a ~> b) -> (c ** a) ~> (c ** b) Source Github #

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

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

type Scalar k = (Unit :: k) ~> (Unit :: k) Source Github #

class Monoidal k => SymMonoidal k where Source Github #

Methods

swap :: forall (a :: k) (b :: k). (Ob a, Ob b) => (a ** b) ~> (b ** a) Source Github #

Instances

Instances details

SymMonoidal Nat Source Github #
Instance details Defined in Proarrow.Category.Instance.ZX Methods swap :: forall (a :: Nat) (b :: Nat). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal BOOL Source Github #
Instance details Defined in Proarrow.Category.Instance.Bool Methods swap :: forall (a :: BOOL) (b :: BOOL). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal KIND Source Github #
Instance details Defined in Proarrow.Category.Instance.Cat Methods swap :: forall (a :: KIND) (b :: KIND). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal CONSTRAINT Source Github #
Instance details Defined in Proarrow.Category.Instance.Constraint Methods swap :: forall (a :: CONSTRAINT) (b :: CONSTRAINT). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal COST Source Github #
Instance details Defined in Proarrow.Category.Instance.Cost Methods swap :: forall (a :: COST) (b :: COST). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal FINREL Source Github #
Instance details Defined in Proarrow.Category.Instance.FinRel Methods swap :: forall (a :: FINREL) (b :: FINREL). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal FINSET Source Github #
Instance details Defined in Proarrow.Category.Instance.FinSet Methods swap :: forall (a :: FINSET) (b :: FINSET). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal LINEAR Source Github #
Instance details Defined in Proarrow.Category.Instance.Linear Methods swap :: forall (a :: LINEAR) (b :: LINEAR). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal POINTED Source Github #
Instance details Defined in Proarrow.Category.Instance.PointedHask Methods swap :: forall (a :: POINTED) (b :: POINTED). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal DOT Source Github #
Instance details Defined in Proarrow.Tools.Diagrams.Dot Methods swap :: forall (a :: DOT) (b :: DOT). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal () Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods swap :: forall (a :: ()) (b :: ()). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal Type Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods swap :: (Ob a, Ob b) => (a b) ~> (b a) Source Github #
HasPushouts k => SymMonoidal (COSPAN k) Source Github #
Instance details Defined in Proarrow.Category.Instance.Cospan Methods swap :: forall (a :: COSPAN k) (b :: COSPAN k). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
TracedMonoidal k => SymMonoidal (INT k) Source Github #
Instance details Defined in Proarrow.Category.Instance.IntConstruction Methods swap :: forall (a :: INT k) (b :: INT k). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
Num a => SymMonoidal (MatK a) Source Github #
Instance details Defined in Proarrow.Category.Instance.Mat Methods swap :: forall (a0 :: MatK a) (b :: MatK a). (Ob a0, Ob b) => (a0 b) ~> (b a0) Source Github #
HasPullbacks k => SymMonoidal (SPAN k) Source Github #
Instance details Defined in Proarrow.Category.Instance.Span Methods swap :: forall (a :: SPAN k) (b :: SPAN k). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal k => SymMonoidal (REV k) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Rev Methods swap :: forall (a :: REV k) (b :: REV k). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal k => SymMonoidal (OPPOSITE k) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods swap :: forall (a :: OPPOSITE k) (b :: OPPOSITE k). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
HasCoproducts k => SymMonoidal (COPROD k) Source Github #
Instance details Defined in Proarrow.Object.BinaryCoproduct Methods swap :: forall (a :: COPROD k) (b :: COPROD k). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
HasProducts k => SymMonoidal (PROD k) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods swap :: forall (a :: PROD k) (b :: PROD k). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
SymMonoidal k => SymMonoidal [k] Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Strictified Methods swap :: forall (a :: [k]) (b :: [k]). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
(Applicative f, SymMonoidal k) => SymMonoidal (AP f k) Source Github #
Instance details Defined in Proarrow.Category.Instance.Ap Methods swap :: forall (a :: AP f k) (b :: AP f k). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
(Promonad p, MonoidalProfunctor p, SymMonoidal k) => SymMonoidal (KLEISLI p) Source Github #
Instance details Defined in Proarrow.Category.Instance.Kleisli Methods swap :: forall (a :: KLEISLI p) (b :: KLEISLI p). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
(SymMonoidal k, SubMonoidal ob) => SymMonoidal (SUBCAT ob) Source Github #
Instance details Defined in Proarrow.Category.Instance.Sub Methods swap :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
(SymMonoidal j, SymMonoidal k) => SymMonoidal (j +-> k) Source Github #
Instance details Defined in Proarrow.Profunctor.Day Methods swap :: forall (a :: j +-> k) (b :: j +-> k). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
CommutativeMonoid m => SymMonoidal (MONOIDK m) Source Github #
Instance details Defined in Proarrow.Monoid Methods swap :: forall (a :: MONOIDK m) (b :: MONOIDK m). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
(SymMonoidal j, SymMonoidal k) => SymMonoidal (j, k) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods swap :: forall (a :: (j, k)) (b :: (j, k)). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
StrongSymMonAdj adj => SymMonoidal (DUPLOID adj) Source Github #
Instance details Defined in Proarrow.Category.Instance.Duploid Methods swap :: forall (a :: DUPLOID adj) (b :: DUPLOID adj). (Ob a, Ob b) => (a b) ~> (b a) Source Github #
(Ok cs p, Elem SymMonoidal cs, Elem Monoidal cs) => SymMonoidal (FREE cs p) Source Github #
Instance details Defined in Proarrow.Category.Instance.Free Methods swap :: forall (a :: FREE cs p) (b :: FREE cs p). (Ob a, Ob b) => (a b) ~> (b a) Source Github #

swap' :: forall {k} (a :: k) (a' :: k) (b :: k) (b' :: k). SymMonoidal k => (a ~> a') -> (b ~> b') -> (a ** b) ~> (b' ** a') Source Github #

swapInner' :: forall k (a :: k) (a' :: k) (b :: k) (b' :: k) (c :: k) (c' :: k) (d :: k) (d' :: k). SymMonoidal k => (a ~> a') -> (b ~> b') -> (c ~> c') -> (d ~> d') -> ((a ** b) ** (c ** d)) ~> ((a' ** c') ** (b' ** d')) Source Github #

swapInner :: forall {k} (a :: k) (b :: k) (c :: k) (d :: k). (SymMonoidal k, Ob a, Ob b, Ob c, Ob d) => ((a ** b) ** (c ** d)) ~> ((a ** c) ** (b ** d)) Source Github #

swapFst :: forall {k} (a :: k) (b :: k) (c :: k) (d :: k). (SymMonoidal k, Ob a, Ob b, Ob c, Ob d) => ((a ** b) ** (c ** d)) ~> ((c ** b) ** (a ** d)) Source Github #

swapSnd :: forall {k} (a :: k) (b :: k) (c :: k) (d :: k). (SymMonoidal k, Ob a, Ob b, Ob c, Ob d) => ((a ** b) ** (c ** d)) ~> ((a ** d) ** (c ** b)) Source Github #

swapOuter :: forall {k} (a :: k) (b :: k) (c :: k) (d :: k). (SymMonoidal k, Ob a, Ob b, Ob c, Ob d) => ((a ** b) ** (c ** d)) ~> ((d ** b) ** (c ** a)) Source Github #

data UnitRep (a :: k) (b :: ()) Source Github #

Instances

Instances details

Monoidal k => FunctorForRep (UnitRep :: k -> () -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods fmap :: forall (a :: ()) (b :: ()). (a ~> b) -> ((UnitRep :: k -> () -> Type) @ a) ~> ((UnitRep :: k -> () -> Type) @ b) Source Github #
type (UnitRep :: k -> () -> Type) @ '() Source Github #
Instance details Defined in Proarrow.Category.Monoidal type (UnitRep :: k -> () -> Type) @ '() = Unit :: k

data MultRep (a :: k) (b :: (k, k)) Source Github #

Instances

Instances details

Monoidal k => FunctorForRep (MultRep :: k -> (k, k) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods fmap :: forall (a :: (k, k)) (b :: (k, k)). (a ~> b) -> ((MultRep :: k -> (k, k) -> Type) @ a) ~> ((MultRep :: k -> (k, k) -> Type) @ b) Source Github #
type (MultRep :: k -> (k, k) -> Type) @ ('(a, b) :: (k, k)) Source Github #
Instance details Defined in Proarrow.Category.Monoidal type (MultRep :: k -> (k, k) -> Type) @ ('(a, b) :: (k, k)) = a ** b