Safe Haskell	None
Language	GHC2024

Proarrow.Category.Monoidal

Synopsis

class (Monoidal j, Monoidal k, Profunctor p) => MonoidalProfunctor (p :: j +-> k) where
- one :: p (Unit :: k) (Unit :: j)
- (**) :: forall (x1 :: k) (x2 :: j) (y1 :: k) (y2 :: j). p x1 x2 -> p y1 y2 -> p (x1 ** y1) (x2 ** y2)
par0Rep :: forall {j} {k} (p :: j +-> k). (Representable p, MonoidalProfunctor p) => (Unit :: k) ~> (p % (Unit :: j))
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))
unpar0Corep :: forall {k1} {k2} (p :: k1 +-> k2). (Corepresentable p, MonoidalProfunctor p) => (p %% (Unit :: k2)) ~> (Unit :: k1)
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))
type StrongMonoidalRep (p :: k +-> j) = (Representable p, MonoidalProfunctor p, MonoidalProfunctor (RepCostar p))
unpar0Rep :: forall {j} {k} (p :: j +-> k). StrongMonoidalRep p => (p % (Unit :: j)) ~> (Unit :: k)
unparRep :: forall {j} {k} (p :: j +-> k) (x :: j) (y :: j). (StrongMonoidalRep p, Ob x, Ob y) => (p % (x ** y)) ~> ((p % x) ** (p % y))
type StrongMonoidalCorep (p :: k +-> j) = (Corepresentable p, MonoidalProfunctor p, MonoidalProfunctor (CorepStar p))
par0Corep :: forall {k1} {k2} (p :: k1 +-> k2). StrongMonoidalCorep p => (Unit :: k1) ~> (p %% (Unit :: k2))
parCorep :: forall {j} {k} (p :: j +-> k) (x :: k) (y :: k). (StrongMonoidalCorep p, Ob x, Ob y) => ((p %% x) ** (p %% y)) ~> (p %% (x ** y))
class (CategoryOf k, MonoidalProfunctor ((~>) :: CAT k), Ob (Unit :: k)) => Monoidal k where
- type Unit :: k
- type (a :: k) ** (b :: k) :: k
- withOb2 :: forall (a :: k) (b :: k) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r
- leftUnitor :: forall (a :: k). Ob a => ((Unit :: k) ** a) ~> a
- leftUnitorInv :: forall (a :: k). Ob a => a ~> ((Unit :: k) ** a)
- rightUnitor :: forall (a :: k). Ob a => (a ** (Unit :: k)) ~> a
- rightUnitorInv :: forall (a :: k). Ob a => a ~> (a ** (Unit :: k))
- associator :: forall (a :: k) (b :: k) (c :: k). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c))
- associatorInv :: forall (a :: k) (b :: k) (c :: k). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c)
leftUnitorIso :: forall k (a :: k) (a' :: k). (Monoidal k, Ob a, Ob a') => Iso ((Unit :: k) ** a) ((Unit :: k) ** a') a a'
rightUnitorIso :: forall k (a :: k) (a' :: k). (Monoidal k, Ob a, Ob a') => Iso (a ** (Unit :: k)) (a' ** (Unit :: k)) a a'
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'))
class ((a ** b) ** c) ~ (a ** (b ** c)) => StrictlyAssoc (a :: k) (b :: k) (c :: k)
class ((a ** (Unit :: k)) ~ a, ((Unit :: k) ** a) ~ a, forall (b :: k) (c :: k). (Ob b, Ob c) => StrictlyAssoc a b c) => Strictly (a :: k) where
- associatorDefault :: forall (b :: k) (c :: k). (Monoidal k, Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c))
(==) :: forall k (a :: k) (b :: k) (c :: k). CategoryOf k => (a ~> b) -> (b ~> c) -> a ~> c
obj2 :: forall {k} (a :: k) (b :: k). (Monoidal k, Ob a, Ob b) => Obj (a ** b)
leftUnitor' :: forall k (a :: k) (b :: k). Monoidal k => (a ~> b) -> ((Unit :: k) ** a) ~> b
leftUnitorInv' :: forall k (a :: k) (b :: k). Monoidal k => (a ~> b) -> a ~> ((Unit :: k) ** b)
rightUnitor' :: forall k (a :: k) (b :: k). Monoidal k => (a ~> b) -> (a ** (Unit :: k)) ~> b
rightUnitorInv' :: forall k (a :: k) (b :: k). Monoidal k => (a ~> b) -> a ~> (b ** (Unit :: k))
associator' :: forall {k} (a :: k) (b :: k) (c :: k). Monoidal k => Obj a -> Obj b -> Obj c -> ((a ** b) ** c) ~> (a ** (b ** c))
associatorInv' :: forall {k} (a :: k) (b :: k) (c :: k). Monoidal k => Obj a -> Obj b -> Obj c -> (a ** (b ** c)) ~> ((a ** b) ** c)
leftUnitorWith :: forall {k} (a :: k) (b :: k). (Monoidal k, Ob a) => (b ~> (Unit :: k)) -> (b ** a) ~> a
leftUnitorInvWith :: forall {k} (a :: k) (b :: k). (Monoidal k, Ob a) => ((Unit :: k) ~> b) -> a ~> (b ** a)
rightUnitorWith :: forall {k} (a :: k) (b :: k). (Monoidal k, Ob a) => (b ~> (Unit :: k)) -> (a ** b) ~> a
rightUnitorInvWith :: forall {k} (a :: k) (b :: k). (Monoidal k, Ob a) => ((Unit :: k) ~> b) -> a ~> (a ** b)
unitObj :: Monoidal k => Obj (Unit :: k)
first :: forall {k} (c :: k) (a :: k) (b :: k). (Monoidal k, Ob c) => (a ~> b) -> (a ** c) ~> (b ** c)
second :: forall {k} (c :: k) (a :: k) (b :: k). (Monoidal k, Ob c) => (a ~> b) -> (c ** a) ~> (c ** b)
type State (a :: k) = (Unit :: k) ~> a
type Costate (a :: k) = a ~> (Unit :: k)
type Scalar k = (Unit :: k) ~> (Unit :: k)
class Monoidal k => SymMonoidal k where
- swap :: forall (a :: k) (b :: k). (Ob a, Ob b) => (a ** b) ~> (b ** a)
swap' :: forall {k} (a :: k) (a' :: k) (b :: k) (b' :: k). SymMonoidal k => (a ~> a') -> (b ~> b') -> (a ** b) ~> (b' ** a')
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'))
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))
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))
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))
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))
data UnitRep (a :: k) (b :: ())
data MultRep (a :: k) (b :: (k, k))
type Tensor = Rep (MultRep :: k -> (k, k) -> Type)
data family UnitF :: k
data family (a :: k) **! (b :: k) :: k

Documentation

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

Methods

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

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

Instances

Instances details

MonoidalProfunctor Simplex Source Github #
Instance details Defined in Proarrow.Category.Instance.Simplex Methods one :: Simplex (Unit :: Nat) (Unit :: Nat) Source Github # () :: 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 one :: ZX (Unit :: Nat) (Unit :: Nat) Source Github # () :: 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 one :: Booleans (Unit :: BOOL) (Unit :: BOOL) Source Github # () :: forall (x1 :: BOOL) (x2 :: BOOL) (y1 :: BOOL) (y2 :: BOOL). Booleans x1 x2 -> Booleans y1 y2 -> Booleans (x1 y1) (x2 ** y2) Source Github #
MonoidalProfunctor (:-) Source Github #
Instance details Defined in Proarrow.Category.Instance.Constraint Methods one :: (Unit :: CONSTRAINT) :- (Unit :: CONSTRAINT) Source Github # () :: 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 one :: GTE (Unit :: COST) (Unit :: COST) Source Github # () :: forall (x1 :: COST) (x2 :: COST) (y1 :: COST) (y2 :: COST). GTE x1 x2 -> GTE y1 y2 -> GTE (x1 y1) (x2 ** y2) Source Github #
MonoidalProfunctor FinHask Source Github #
Instance details Defined in Proarrow.Category.Instance.FinHask Methods one :: FinHask (Unit :: FINHASK) (Unit :: FINHASK) Source Github # () :: forall (x1 :: FINHASK) (x2 :: FINHASK) (y1 :: FINHASK) (y2 :: FINHASK). FinHask x1 x2 -> FinHask y1 y2 -> FinHask (x1 y1) (x2 ** y2) Source Github #
MonoidalProfunctor FinRel Source Github #
Instance details Defined in Proarrow.Category.Instance.FinRel Methods one :: FinRel (Unit :: FINREL) (Unit :: FINREL) Source Github # () :: 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 one :: FinSet (Unit :: FINSET) (Unit :: FINSET) Source Github # () :: 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 one :: Linear (Unit :: LINEAR) (Unit :: LINEAR) Source Github # () :: 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 one :: Pointed (Unit :: POINTED) (Unit :: POINTED) Source Github # () :: 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 one :: Dot (Unit :: DOT) (Unit :: DOT) Source Github # () :: 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 one :: Unit (Unit :: ()) (Unit :: ()) Source Github # () :: 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.Instance.Arrow Methods one :: Kleisli m (Unit :: Type) (Unit :: Type) Source Github # () :: 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.Instance.Arrow Methods one :: Arr arr (Unit :: Type) (Unit :: Type) Source Github # () :: 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.Instance.Fold Methods one :: Fold (Unit :: k) (Unit :: k) Source Github # () :: 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.Instance.Identity Methods one :: Id (Unit :: k) (Unit :: k) Source Github # () :: 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 one :: Cont r (Unit :: Type) (Unit :: Type) Source Github # () :: Cont r x1 x2 -> Cont r y1 y2 -> Cont r (x1 y1) (x2 ** y2) Source Github #
MonoidalProfunctor (->) Source Github #
Instance details Defined in Proarrow.Limit.BinaryProduct Methods one :: (Unit :: Type) -> (Unit :: Type) Source Github # () :: (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.Instance.Fix Methods one :: Fix p (Unit :: j) (Unit :: j) Source Github # () :: 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.Instance.Terminal Methods one :: TerminalProfunctor (Unit :: k) (Unit :: j) Source Github # () :: forall (x1 :: k) (x2 :: j) (y1 :: k) (y2 :: j). TerminalProfunctor x1 x2 -> TerminalProfunctor y1 y2 -> TerminalProfunctor (x1 y1) (x2 ** y2) Source Github #
(Comonoid r, 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 one :: Reader ('OP r) (Unit :: k) (Unit :: k) Source Github # () :: 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 one :: State s (Unit :: k) (Unit :: k) Source Github # () :: 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 one :: Writer w (Unit :: k) (Unit :: k) Source Github # () :: 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 one :: Rep Fun (Unit :: FINREL) (Unit :: FINSET) Source Github # () :: 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 one :: Rep Forget (Unit :: Type) (Unit :: LINEAR) Source Github # () :: 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 one :: Corep Forget (Unit :: LINEAR) (Unit :: Type) Source Github # () :: 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, Corepresentable p) => MonoidalProfunctor (Adj p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Adjunction Methods one :: Adj p (Unit :: k) (Unit :: j) Source Github # () :: 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.Instance.HaskValue Methods one :: HaskValue c (Unit :: k) (Unit :: j) Source Github # () :: 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.Instance.Star Methods one :: Star f (Unit :: k) (Unit :: j) Source Github # () :: 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.Instance.Wrapped Methods one :: Wrapped p (Unit :: k) (Unit :: j) Source Github # () :: 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.Instance.Costar Methods one :: Costar f (Unit :: j) (Unit :: k) Source Github # () :: 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 one :: Corep (Constant r) (Unit :: k) (Unit :: k) Source Github # () :: 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 one :: Rep (Constant r) (Unit :: k) (Unit :: k) Source Github # () :: 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 #
(MonoidalProfunctor p, Comonoid r, SymMonoidal k) => MonoidalProfunctor (ReaderT ('OP r) p :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Reader Methods one :: ReaderT ('OP r) p (Unit :: k) (Unit :: k) Source Github # () :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). ReaderT ('OP r) p x1 x2 -> ReaderT ('OP r) p y1 y2 -> ReaderT ('OP r) p (x1 y1) (x2 ** y2) Source Github #
(MonoidalProfunctor p, Monoid w, SymMonoidal k) => MonoidalProfunctor (WriterT w p :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Writer Methods one :: WriterT w p (Unit :: k) (Unit :: k) Source Github # () :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). WriterT w p x1 x2 -> WriterT w p y1 y2 -> WriterT w p (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.Instance.Day Methods one :: Day p q (Unit :: k) (Unit :: j) Source Github # () :: 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.Instance.Product Methods one :: (p :: q) (Unit :: k) (Unit :: j) Source Github # () :: 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.Instance.Composition Methods one :: (p :.: q) (Unit :: k) (Unit :: j2) Source Github # () :: 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 one :: Tensor (Unit :: k) (Unit :: LIST k) Source Github # () :: 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 one :: Rep (App :: MatK a +-> Type) (Unit :: Type) (Unit :: MatK a) Source Github # () :: 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.Instance.Star Methods one :: CoprodDom (Star f) (Unit :: k) (Unit :: COPROD j) Source Github # () :: 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, HasCoproducts k) => MonoidalProfunctor (Cospan :: COSPAN k -> COSPAN k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Cospan Methods one :: Cospan (Unit :: COSPAN k) (Unit :: COSPAN k) Source Github # () :: 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 one :: IntConstruction (Unit :: INT k) (Unit :: INT k) Source Github # () :: 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 one :: Mat (Unit :: MatK a) (Unit :: MatK a) Source Github # () :: 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, HasProducts k) => MonoidalProfunctor (Span :: SPAN k -> SPAN k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Span Methods one :: Span (Unit :: SPAN k) (Unit :: SPAN k) Source Github # () :: 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 #
CategoryOf k => MonoidalProfunctor (Endo :: ENDO k -> ENDO k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Endo Methods one :: Endo (Unit :: ENDO k) (Unit :: ENDO k) Source Github # () :: forall (x1 :: ENDO k) (x2 :: ENDO k) (y1 :: ENDO k) (y2 :: ENDO k). Endo x1 x2 -> Endo y1 y2 -> Endo (x1 y1) (x2 ** y2) Source Github #
HasCoproducts k => MonoidalProfunctor (Cocone :: LIST k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Cocone Methods one :: Cocone (Unit :: LIST k) (Unit :: COPROD k) Source Github # () :: 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.Profunctor.Instance.Cone Methods one :: Cone (Unit :: PROD k) (Unit :: LIST k) Source Github # () :: 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 one :: Strictified (Unit :: [k]) (Unit :: [k]) Source Github # () :: forall (x1 :: [k]) (x2 :: [k]) (y1 :: [k]) (y2 :: [k]). Strictified x1 x2 -> Strictified y1 y2 -> Strictified (x1 y1) (x2 ** y2) Source Github #
RealFloat a => MonoidalProfunctor (Rep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) :: MatK (Complex a) -> MatK (Complex a) -> Type) Source Github #
Instance details 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 p => MonoidalProfunctor (Op p :: OPPOSITE j -> OPPOSITE k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods one :: Op p (Unit :: OPPOSITE j) (Unit :: OPPOSITE k) Source Github # () :: 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 p => MonoidalProfunctor (Rev p :: REV k -> REV j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Rev Methods one :: Rev p (Unit :: REV k) (Unit :: REV j) Source Github # () :: 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 (Coprod (Rep Fun)) Source Github #
Instance details 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 #
MonoidalProfunctor (Coprod Linear) Source Github #
Instance details Defined in Proarrow.Category.Instance.Linear Methods one :: Coprod Linear (Unit :: COPROD LINEAR) (Unit :: COPROD LINEAR) Source Github # () :: 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.Instance.Arrow Methods one :: Coprod (Kleisli m) (Unit :: COPROD Type) (Unit :: COPROD Type) Source Github # () :: 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.Instance.Arrow Methods one :: Coprod (Arr arr) (Unit :: COPROD Type) (Unit :: COPROD Type) Source Github # () :: 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 #
(HasCoproducts j, HasCoproducts k, Representable p) => MonoidalProfunctor (Coprod (Adj p) :: COPROD k -> COPROD j -> Type) Source Github #
Instance details Defined in Proarrow.Adjunction Methods one :: Coprod (Adj p) (Unit :: COPROD k) (Unit :: COPROD j) Source Github # () :: 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.Instance.Star Methods one :: Coprod (Star f) (Unit :: COPROD k) (Unit :: COPROD j) Source Github # () :: 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.Colimit.BinaryCoproduct Methods one :: Coprod (TerminalProfunctor :: k -> j -> Type) (Unit :: COPROD k) (Unit :: COPROD j) Source Github # () :: 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.Instance.Composition Methods one :: Coprod (f :.: g) (Unit :: COPROD k) (Unit :: COPROD j2) Source Github # () :: 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, Ob r) => MonoidalProfunctor (Coprod (Rep (Constant r)) :: COPROD k -> COPROD k -> Type) Source Github #
Instance details 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 #
HasCoproducts k => MonoidalProfunctor (Coprod (Cont r) :: COPROD k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Cont Methods one :: Coprod (Cont r) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # () :: 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 #
(HasCoproducts k, cat ~ Hom k) => MonoidalProfunctor (Coprod cat :: COPROD k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Colimit.BinaryCoproduct Methods one :: Coprod cat (Unit :: COPROD k) (Unit :: COPROD k) Source Github # () :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod cat x1 x2 -> Coprod cat y1 y2 -> Coprod cat (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.Limit.BinaryProduct Methods one :: Prod cat (Unit :: PROD k) (Unit :: PROD k) Source Github # () :: 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.Instance.List Methods one :: List p (Unit :: LIST k) (Unit :: LIST j) Source Github # () :: 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 #
BiCCC k => MonoidalProfunctor (Term :: FBC p -> FBC p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.FreeBiCCC Methods one :: Term (Unit :: FBC p) (Unit :: FBC p) Source Github # () :: forall (x1 :: FBC p) (x2 :: FBC p) (y1 :: FBC p) (y2 :: FBC p). Term x1 x2 -> Term y1 y2 -> Term (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 one :: Kleisli (Unit :: KLEISLI p) (Unit :: KLEISLI p) Source Github # () :: 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.Instance.Day Methods one :: Prof (Unit :: j +-> k) (Unit :: j +-> k) Source Github # () :: 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 one :: Nat (Unit :: Type -> Type) (Unit :: Type -> Type) Source Github # () :: 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 one :: Sub p (Unit :: SUBCAT ob) (Unit :: SUBCAT ob) Source Github # () :: 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 one :: Ap p (Unit :: AP f k) (Unit :: AP f j) Source Github # () :: 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 one :: Mon (Unit :: MONOIDK m) (Unit :: MONOIDK m) Source Github # () :: 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 one :: (p :: q) (Unit :: (k1, k2)) (Unit :: (j1, j2)) Source Github # () :: 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, StrongMonoidalCorep adj) => MonoidalProfunctor (Duploid :: DUPLOID adj -> DUPLOID adj -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Duploid Methods one :: Duploid (Unit :: DUPLOID adj) (Unit :: DUPLOID adj) Source Github # () :: 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 #
(Monoidal (FREE cs p), Elem Monoidal cs) => MonoidalProfunctor (Free :: FREE cs p -> FREE cs p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods one :: Free (Unit :: FREE cs p) (Unit :: FREE cs p) Source Github # () :: 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 #

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 #

Associated Types

type Unit :: k Source Github #

type (a :: k) ** (b :: k) :: k infixl 8 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 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 FINHASK Source Github #

Instance details

Defined in Proarrow.Category.Instance.FinHask

Associated Types

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

Methods

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

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

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

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

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

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

associatorInv :: forall (a :: FINHASK) (b :: FINHASK) (c :: FINHASK). (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.Limit.BinaryProduct

Associated Types

type Unit
Instance details Defined in Proarrow.Limit.BinaryProduct type Unit = TerminalObject :: Type
type (a :: Type) ** (b :: Type)
Instance details Defined in Proarrow.Limit.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, HasCoproducts 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 #

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 #

(HasPullbacks k, HasProducts 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 #

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

Instance details

Defined in Proarrow.Category.Monoidal.Endo

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Monoidal.Endo type Unit = 'E (Id :: k -> k -> Type)

Methods

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

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

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

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

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

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

associatorInv :: forall (a :: ENDO k) (b :: ENDO k) (c :: ENDO 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 #

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

Coproducts as monoidal tensor.

Instance details

Defined in Proarrow.Colimit.BinaryCoproduct

Associated Types

type Unit
Instance details Defined in Proarrow.Colimit.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.Limit.BinaryProduct

Associated Types

type Unit
Instance details Defined in Proarrow.Limit.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.Instance.List

Associated Types

type Unit
Instance details Defined in Proarrow.Profunctor.Instance.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 #

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

Instance details

Defined in Proarrow.Category.Instance.FreeBiCCC

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.FreeBiCCC type Unit = TerminalObject :: FBC p

Methods

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

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

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

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

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

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

associatorInv :: forall (a :: FBC p) (b :: FBC p) (c :: FBC p). (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.Instance.Day

Associated Types

type Unit
Instance details Defined in Proarrow.Profunctor.Instance.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, StrongMonoidalCorep 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 #

(CategoryOf (FREE cs p), MonoidalProfunctor ((~>) :: CAT (FREE cs p)), Elem Monoidal cs) => Monoidal (FREE cs p) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Monoidal 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 #

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 #

class ((a ** b) ** c) ~ (a ** (b ** c)) => StrictlyAssoc (a :: k) (b :: k) (c :: k) Source Github #

Instances

Instances details

((a b) c) ~ (a (b c)) => StrictlyAssoc (a :: k) (b :: k) (c :: k) Source Github #
Instance details Defined in Proarrow.Category.Monoidal

class ((a ** (Unit :: k)) ~ a, ((Unit :: k) ** a) ~ a, forall (b :: k) (c :: k). (Ob b, Ob c) => StrictlyAssoc a b c) => Strictly (a :: k) where Source Github #

If your monoidal category is a strict monoidal category, add Strictly to your Ob constraint. This will let GHC know that the unitors and associators are strict, so you won't have to provide proof of that. You can use associatorDefault as implementation for both associator and associatorInv:

leftUnitor = id
leftUnitorInv = id
rightUnitor = id
rightUnitorInv = id
associator @a @b @c = associatorDefault @a @b @c
associatorInv @a @b @c = associatorDefault @a @b @c

Methods

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

Instances

Instances details

((a (Unit :: k)) ~ a, ((Unit :: k) a) ~ a, forall (b :: k) (c :: k). (Ob b, Ob c) => StrictlyAssoc a b c) => Strictly (a :: k) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods associatorDefault :: forall (b :: k) (c :: k). (Monoidal k, Ob a, Ob b, Ob c) => ((a b) c) ~> (a (b c)) 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 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 FINHASK Source Github #
Instance details Defined in Proarrow.Category.Instance.FinHask Methods swap :: forall (a :: FINHASK) (b :: FINHASK). (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.Limit.BinaryProduct Methods swap :: (Ob a, Ob b) => (a b) ~> (b a) Source Github #
(HasPushouts k, HasCoproducts 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 #
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 #
(HasPullbacks k, HasProducts 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 #
HasCoproducts k => SymMonoidal (COPROD k) Source Github #
Instance details Defined in Proarrow.Colimit.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.Limit.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 #
BiCCC k => SymMonoidal (FBC p) Source Github #
Instance details Defined in Proarrow.Category.Instance.FreeBiCCC Methods swap :: forall (a :: FBC p) (b :: FBC p). (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.Instance.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 #
(Monoidal (FREE cs p), Elem SymMonoidal cs, Elem Monoidal cs) => SymMonoidal (FREE cs p) Source Github #
Instance details Defined in Proarrow.Category.Monoidal 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 => MonoidalAction (Tensor :: k -> (k, k) -> Type) Source Github #
Instance details 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 #
Instance details Defined in Proarrow.Tools.Diagrams.Dot Methods coact :: forall (a :: DOT) (x :: DOT) (y :: DOT). (Ob a, Ob x, Ob y) => Dot (Act (Tensor :: DOT -> (DOT, DOT) -> Type) a x) (Act (Tensor :: DOT -> (DOT, DOT) -> Type) a y) -> Dot x y Source Github #
MonadFix m => Costrong (Tensor :: Type -> (Type, Type) -> Type) (Kleisli m :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Arrow Methods coact :: (Ob a, Ob x, Ob y) => Kleisli m (Act (Tensor :: Type -> (Type, Type) -> Type) a x) (Act (Tensor :: Type -> (Type, Type) -> Type) a y) -> Kleisli m x y Source Github #
ArrowLoop arr => Costrong (Tensor :: Type -> (Type, Type) -> Type) (Arr arr :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Arrow Methods coact :: (Ob a, Ob x, Ob y) => Arr arr (Act (Tensor :: Type -> (Type, Type) -> Type) a x) (Act (Tensor :: Type -> (Type, Type) -> Type) a y) -> Arr arr x y Source Github #
Monad m => Strong (Tensor :: Type -> (Type, Type) -> Type) (Kleisli m :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Arrow Methods act :: Ob a => Kleisli m x y -> Kleisli m (Act (Tensor :: Type -> (Type, Type) -> Type) a x) (Act (Tensor :: Type -> (Type, Type) -> Type) a y) Source Github #
Arrow arr => Strong (Tensor :: Type -> (Type, Type) -> Type) (Arr arr :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Arrow Methods act :: Ob a => Arr arr x y -> Arr arr (Act (Tensor :: Type -> (Type, Type) -> Type) a x) (Act (Tensor :: Type -> (Type, Type) -> Type) a y) Source Github #
Costrong (Tensor :: Type -> (Type, Type) -> Type) (->) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Strength Methods coact :: (Ob a, Ob x, Ob y) => (Act (Tensor :: Type -> (Type, Type) -> Type) a x -> Act (Tensor :: Type -> (Type, Type) -> Type) a y) -> x -> y Source Github #
Strong (Tensor :: Type -> (Type, Type) -> Type) (Replacing a b :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: Ob a0 => Replacing a b x y -> Replacing a b (Act (Tensor :: Type -> (Type, Type) -> Type) a0 x) (Act (Tensor :: Type -> (Type, Type) -> Type) a0 y) Source Github #
Strong (Tensor :: Type -> (Type, Type) -> Type) (Cont r :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Cont Methods act :: Ob a => Cont r x y -> Cont r (Act (Tensor :: Type -> (Type, Type) -> Type) a x) (Act (Tensor :: Type -> (Type, Type) -> Type) a y) Source Github #
(Ob r, SymMonoidal k) => Strong (Tensor :: k -> (k, k) -> Type) (Reader ('OP r) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Reader Methods act :: forall (a :: k) (x :: k) (y :: k). Ob a => Reader ('OP r) x y -> Reader ('OP r) (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> Type) a y) Source Github #
(Ob w, SymMonoidal k) => Strong (Tensor :: k -> (k, k) -> Type) (Writer w :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Writer Methods act :: forall (a :: k) (x :: k) (y :: k). Ob a => Writer w x y -> Writer w (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> Type) a y) Source Github #
(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 #
Instance details Defined in Proarrow.Promonad.Reader Methods act :: forall (a :: k) (x :: k) (y :: k). Ob a => ReaderT ('OP r) p x y -> ReaderT ('OP r) p (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> Type) a y) 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 #
Instance details Defined in Proarrow.Promonad.State Methods act :: forall (a :: k) (x :: k) (y :: k). Ob a => StateT s p x y -> StateT s p (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> Type) a y) 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 #
Instance details Defined in Proarrow.Promonad.Writer Methods act :: forall (a :: k) (x :: k) (y :: k). Ob a => WriterT w p x y -> WriterT w p (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> Type) a y) Source Github #
Monad m => Strong (Tensor :: KlCat m -> (KlCat m, KlCat m) -> Type) (Updating a b :: KlCat m -> KlCat m -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: forall (a0 :: KlCat m) (x :: KlCat m) (y :: KlCat m). Ob a0 => Updating a b x y -> Updating a b (Act (Tensor :: KlCat m -> (KlCat m, KlCat m) -> Type) a0 x) (Act (Tensor :: KlCat m -> (KlCat m, KlCat m) -> Type) a0 y) Source Github #
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 #
Monad m => Strong (AlgAction m :: Type -> (SUBCAT (Algebra m), Type) -> Type) (Classifying m a b :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: forall (a0 :: SUBCAT (Algebra m)) x y. Ob a0 => Classifying m a b x y -> Classifying m a b (Act (AlgAction m) a0 x) (Act (AlgAction m) a0 y) 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

type Tensor = Rep (MultRep :: k -> (k, k) -> Type) Source Github #

data family UnitF :: k Source Github #

Instances

Instances details

Elem Monoidal cs => IsFreeOb (UnitF :: FREE cs p) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods withLowerOb :: forall {k} (f :: j +-> k) r. (Representable f, All cs k) => (Ob (Lower f (UnitF :: FREE cs p)) => r) -> r Source Github #
type Lower (f :: j +-> k) (UnitF :: FREE cs p) Source Github #
Instance details Defined in Proarrow.Category.Monoidal type Lower (f :: j +-> k) (UnitF :: FREE cs p) = Unit :: k

data family (a :: k) **! (b :: k) :: k Source Github #

Instances

Instances details

(Ob a, Ob b, Elem Monoidal cs) => IsFreeOb (a **! b :: FREE cs p) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods withLowerOb :: forall {k} (f :: j +-> k) r. (Representable f, All cs k) => (Ob (Lower f (a **! b)) => r) -> r Source Github #
type Lower (f :: j +-> k) (a **! b :: FREE cs p) Source Github #
Instance details Defined in Proarrow.Category.Monoidal type Lower (f :: j +-> k) (a ! b :: FREE cs p) = Lower f a Lower f b