Safe Haskell	None
Language	GHC2024

Proarrow.Category.Monoidal

Description

Monoidal categories, as kinds with a tensor: Monoidal provides Unit, the tensor (**), and the unitor and associator isomorphisms; SymMonoidal adds the symmetry swap. A MonoidalProfunctor is a lax monoidal profunctor with one and a value-level (**), and a category is Monoidal if and only if its hom-profunctor is.

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)
type LaxMonoidal (p :: j +-> k) = (MonoidalProfunctor p, Representable p)
par0Rep :: forall {j} {k} (p :: j +-> k). LaxMonoidal p => (Unit :: k) ~> (p % (Unit :: j))
parRep :: forall {k1} {k2} (p :: k1 +-> k2) (x :: k1) (y :: k1). (LaxMonoidal p, Ob x, Ob y) => ((p % x) ** (p % y)) ~> (p % (x ** y))
type OplaxMonoidal (p :: j +-> k) = (MonoidalProfunctor p, Corepresentable p)
unpar0Corep :: forall {k1} {k2} (p :: k1 +-> k2). OplaxMonoidal p => (p %% (Unit :: k2)) ~> (Unit :: k1)
unparCorep :: forall {j} {k} (p :: j +-> k) (x :: k) (y :: k). (OplaxMonoidal p, Ob x, Ob y) => (p %% (x ** y)) ~> ((p %% x) ** (p %% y))
type OplaxMonoidalRep (p :: k +-> j) = (Representable p, OplaxMonoidal (RepCostar p))
unpar0Rep :: forall {j} {k} (p :: j +-> k). OplaxMonoidalRep p => (p % (Unit :: j)) ~> (Unit :: k)
unparRep :: forall {j} {k} (p :: j +-> k) (x :: j) (y :: j). (OplaxMonoidalRep p, Ob x, Ob y) => (p % (x ** y)) ~> ((p % x) ** (p % y))
type LaxMonoidalCorep (p :: k +-> j) = (Corepresentable p, LaxMonoidal (CorepStar p))
par0Corep :: forall {k1} {k2} (p :: k1 +-> k2). LaxMonoidalCorep p => (Unit :: k1) ~> (p %% (Unit :: k2))
parCorep :: forall {j} {k} (p :: j +-> k) (x :: k) (y :: k). (LaxMonoidalCorep p, Ob x, Ob y) => ((p %% x) ** (p %% y)) ~> (p %% (x ** y))
type StrongMonoidalRep (p :: k +-> j) = (LaxMonoidal p, OplaxMonoidalRep p)
type StrongMonoidalCorep (p :: k +-> j) = (OplaxMonoidal p, LaxMonoidalCorep p)
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') => PIso ((Unit :: k) ** a) ((Unit :: k) ** a') a a'
rightUnitorIso :: forall k (a :: k) (a' :: k). (Monoidal k, Ob a, Ob a') => PIso (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') => PIso ((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)
type family NFold (n :: Nat) (x :: k) :: k where ...
type family NFoldS (n :: Nat) (x :: k) :: [k] where ...
withObNFold :: forall {k} (n :: Nat) (a :: k) r. (SNatI n, Ob a, Monoidal k) => (Ob (NFold n a) => r) -> r
class ((a ** (Unit :: k)) ~ a, ((Unit :: k) ** a) ~ a, forall (b :: k) (c :: k). 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
type SymMonoidalStructures = '[Monoidal, SymMonoidal]

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.Limit.BinaryProduct 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 Svg Source Github #
Instance details Defined in Proarrow.Tools.Diagrams.Svg Methods one :: Svg (Unit :: SVG) (Unit :: SVG) Source Github # () :: forall (x1 :: SVG) (x2 :: SVG) (y1 :: SVG) (y2 :: SVG). Svg x1 x2 -> Svg y1 y2 -> Svg (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.Category.Monoidal 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 #
(SymMonoidal k, SNatI n) => MonoidalProfunctor (Pow n :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.PowerGrate Methods one :: Pow n (Unit :: k) (Unit :: k) Source Github # () :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). Pow n x1 x2 -> Pow n y1 y2 -> Pow n (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 #	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 #	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.Profunctor.Instance.Adj 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 #
(Corepresentable p, Cocartesian j, Cocartesian k) => MonoidalProfunctor (CorepStar p :: j -> k -> Type) Source Github #	Every functor between cocartesian categories is lax monoidal, `f a \|\| f b ~> f (a \|\| b)` by the injections and `InitialObject ~> f InitialObject` by initiality. On the `CorepStar` of its corepresentable profunctor this is `LaxMonoidal`.
Instance details Defined in Proarrow.Colimit.BinaryCoproduct Methods one :: CorepStar p (Unit :: j) (Unit :: k) Source Github # () :: forall (x1 :: j) (x2 :: k) (y1 :: j) (y2 :: k). CorepStar p x1 x2 -> CorepStar p y1 y2 -> CorepStar p (x1 y1) (x2 ** y2) Source Github #
(Representable p, Cartesian j, Cartesian k) => MonoidalProfunctor (RepCostar p :: j -> k -> Type) Source Github #	Every functor between cartesian categories is oplax monoidal, `f (a && b) ~> f a && f b` by the projections and `f Unit ~> Unit` by terminality. On the `RepCostar` of its representable profunctor this is `OplaxMonoidal`.
Instance details Defined in Proarrow.Category.Monoidal.Cartesian Methods one :: RepCostar p (Unit :: j) (Unit :: k) Source Github # () :: forall (x1 :: j) (x2 :: k) (y1 :: j) (y2 :: k). RepCostar p x1 x2 -> RepCostar p y1 y2 -> RepCostar p (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 #
(SymMonoidal k, Monoid m) => MonoidalProfunctor (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #	Tensoring with a monoid, `m ** -`, is an applicative functor: the monoid's unit is `pure` and its multiplication is ``. Rendered on the representable profunctor `Rep (ActionAt Tensor m)` (legs `a ~> m * b`) this is a `StrongDistributiveProfunctor`, the Writer applicative of the literature. (The `Constant` instances above are the degenerate case `b = Unit`.)
Instance details Defined in Proarrow.Monoid Methods one :: Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) (Unit :: k) (Unit :: k) Source Github # () :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) x1 x2 -> Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) y1 y2 -> Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) (x1 y1) (x2 ** y2) Source Github #
(Closed k, SymMonoidal k, Comonoid m) => MonoidalProfunctor (Rep (Exp m) :: k -> k -> Type) Source Github #	The exponential by a comonoid, `m ~~> -`, is an applicative functor (the reader applicative): `pure` discards the argument with the counit and `*` duplicates it with the comultiplication. Rendered on `Rep (Exp m)` (legs `a ~> (m ~~> b)`) this is a `StrongDistributiveProfunctor`, so a `Grate` is a `Kaleidoscope`.
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods one :: Rep (Exp m) (Unit :: k) (Unit :: k) Source Github # () :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). Rep (Exp m) x1 x2 -> Rep (Exp m) y1 y2 -> Rep (Exp m) (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.Category.Monoidal 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, Ob a, Ob b, w (UnitW :: k -> k -> Type) (CoUnitW :: k -> k -> Type), forall (p1 :: k -> k -> Type) (p2 :: k -> k -> Type) (q1 :: k -> k -> Type) (q2 :: k -> k -> Type). (w p1 q1, w p2 q2, Profunctor p1, Profunctor p2, Profunctor q1, Profunctor q2) => w (Beside p1 p2) (CoBeside q1 q2)) => MonoidalProfunctor (ExOptic w a b :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalTraversal Methods one :: ExOptic w a b (Unit :: k) (Unit :: k) Source Github # () :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). ExOptic w a b x1 x2 -> ExOptic w a b y1 y2 -> ExOptic w a b (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 #
MonoidalOrdinal n => MonoidalProfunctor (LTE :: ORDINAL n -> ORDINAL n -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Ordinal Methods one :: LTE (Unit :: ORDINAL n) (Unit :: ORDINAL n) Source Github # () :: forall (x1 :: ORDINAL n) (x2 :: ORDINAL n) (y1 :: ORDINAL n) (y2 :: ORDINAL n). LTE x1 x2 -> LTE y1 y2 -> LTE (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.EndoProf 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.Profunctor.Instance.Adj 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.Colimit.BinaryCoproduct 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 a, Ob b, w (ZeroW :: k -> k -> Type) (CoZeroW :: k -> k -> Type), forall (p1 :: k -> k -> Type) (p2 :: k -> k -> Type) (q1 :: k -> k -> Type) (q2 :: k -> k -> Type). (w p1 q1, w p2 q2, Profunctor p1, Profunctor p2, Profunctor q1, Profunctor q2) => w (BesideSum p1 p2) (CoBesideSum q1 q2)) => MonoidalProfunctor (Coprod (ExOptic w a b) :: COPROD k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalTraversal Methods one :: Coprod (ExOptic w a b) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # () :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod (ExOptic w a b) x1 x2 -> Coprod (ExOptic w a b) y1 y2 -> Coprod (ExOptic w a b) (x1 y1) (x2 ** y2) Source Github #
(SymMonoidal k, HasCoproducts k, SNatI n) => MonoidalProfunctor (Coprod (Pow n :: k -> k -> Type) :: COPROD k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.PowerGrate Methods one :: Coprod (Pow n :: k -> k -> Type) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # () :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod (Pow n :: k -> k -> Type) x1 x2 -> Coprod (Pow n :: k -> k -> Type) y1 y2 -> Coprod (Pow n :: k -> k -> Type) (x1 y1) (x2 ** y2) Source Github #
HasCoproducts k => MonoidalProfunctor (Coprod (Id :: k -> k -> Type) :: COPROD k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Colimit.BinaryCoproduct Methods one :: Coprod (Id :: k -> k -> Type) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # () :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod (Id :: k -> k -> Type) x1 x2 -> Coprod (Id :: k -> k -> Type) y1 y2 -> Coprod (Id :: k -> k -> Type) (x1 y1) (x2 ** y2) Source Github #
(Monoidal k, HasCoproducts k, Ob m) => MonoidalProfunctor (Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) :: COPROD k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Monoid Methods one :: Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # () :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) x1 x2 -> Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) y1 y2 -> Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) (x1 y1) (x2 ** y2) Source Github #
(Closed k, HasCoproducts k, Ob m) => MonoidalProfunctor (Coprod (Rep (Exp m)) :: COPROD k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods one :: Coprod (Rep (Exp m)) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # () :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod (Rep (Exp m)) x1 x2 -> Coprod (Rep (Exp m)) y1 y2 -> Coprod (Rep (Exp m)) (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 #
(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 #
CommutativeMonoid m => MonoidalProfunctor (Mon :: MONOID m -> MONOID m -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Monoid Methods one :: Mon (Unit :: MONOID m) (Unit :: MONOID m) Source Github # () :: forall (x1 :: MONOID m) (x2 :: MONOID m) (y1 :: MONOID m) (y2 :: MONOID 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 #
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 #

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

A representable profunctor that is a MonoidalProfunctor: its functor p % is lax monoidal, splitting as par0Rep and parRep.

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

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

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

A corepresentable profunctor that is a MonoidalProfunctor: its functor p %% is oplax monoidal, splitting as unpar0Corep and unparCorep.

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

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

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

A representable profunctor whose functor p % is oplax monoidal. Stating the oplax structure of a representable functor means naming that same functor in its other variance, as RepCostar does. So the postfix here says which presentation p is in, not which structure it carries. Weaker than StrongMonoidalRep, which additionally asks p itself to be LaxMonoidal.

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

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

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

A corepresentable profunctor whose functor p %% is lax monoidal, dually through CorepStar.

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

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

type StrongMonoidalRep (p :: k +-> j) = (LaxMonoidal p, OplaxMonoidalRep p) Source Github #

A representable profunctor whose functor is strong monoidal: lax as it stands, and oplax in its other variance.

type StrongMonoidalCorep (p :: k +-> j) = (OplaxMonoidal p, LaxMonoidalCorep p) Source Github #

A corepresentable profunctor whose functor is strong monoidal, dually.

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

A monoidal category: a tensor ** with a Unit, associative and unital up to the coherent isomorphisms below. The tensor's action on arrows is the MonoidalProfunctor method ** at (~>), which the superclass supplies.

Laws:

The three isomorphisms must be mutually inverse:

leftUnitor . leftUnitorInv = id and leftUnitorInv . leftUnitor = id
rightUnitor . rightUnitorInv = id and rightUnitorInv . rightUnitor = id
associator . associatorInv = id and associatorInv . associator = id

and natural in every argument:

```
leftUnitor . (id ** f) = f . leftUnitor
```

rightUnitor . (f ** id) = f . rightUnitor

associator . ((f ** g) ** h) = (f ** (g ** h)) . associator

subject to the two coherence conditions:

Triangle: (id ** leftUnitor) . associator = rightUnitor ** id
Pentagon: (id ** associator) . associator . (associator ** id) = associator . associator

Checked by testMonoidal.

Minimal complete definition

withOb2, associator, associatorInv

Associated Types

type Unit :: k Source Github #

The tensor unit.

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

The tensor product of two objects.

Methods

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

Recovers Ob (a ** b) from the objecthood of the factors.

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

Cancels a Unit on the left.

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

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

Introduces a Unit on the left; inverse to leftUnitor.

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

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

Cancels a Unit on the right.

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

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

Introduces a Unit on the right; inverse to rightUnitor.

default rightUnitorInv :: forall (a :: k). (Ob a, (a ** (Unit :: k)) ~ 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 #

Reassociates the tensor to the right.

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

Reassociates the tensor to the left; inverse to associator.

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.Limit.BinaryProduct

Associated Types

type Unit
Instance details Defined in Proarrow.Limit.BinaryProduct type Unit = TerminalObject :: BOOL
type (a :: BOOL) ** (b :: BOOL)
Instance details Defined in Proarrow.Limit.BinaryProduct 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. 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 SVG Source Github #

The unit is the unit wire, and the unitors absorb or create it.

Instance details

Defined in Proarrow.Tools.Diagrams.Svg

Associated Types

type Unit
Instance details Defined in Proarrow.Tools.Diagrams.Svg type Unit = 'S '['I]
type (ls :: SVG) ** (rs :: SVG)
Instance details Defined in Proarrow.Tools.Diagrams.Svg type (ls :: SVG) ** (rs :: SVG) = 'S (UN 'S ls ++ UN 'S rs)

Methods

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

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

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

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

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

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

associatorInv :: forall (a :: SVG) (b :: SVG) (c :: SVG). (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 (_1 :: ()) ** (_2 :: ())
Instance details Defined in Proarrow.Category.Monoidal type (_1 :: ()) ** (_2 :: ()) = '()

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 #

MonoidalOrdinal n => Monoidal (ORDINAL n) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Ordinal

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Ordinal type Unit = TerminalObject :: ORDINAL n

Methods

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

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

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

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

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

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

associatorInv :: forall (a :: ORDINAL n) (b :: ORDINAL n) (c :: ORDINAL n). (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.EndoProf

Associated Types

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

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

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

Instance details

Defined in Proarrow.Category.Instance.Monoid

Associated Types

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

Methods

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

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

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

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

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

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

associatorInv :: forall (a :: MONOID m) (b :: MONOID m) (c :: MONOID m). (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 #

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

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') => PIso ((Unit :: k) ** a) ((Unit :: k) ** a') a a' Source Github #

rightUnitorIso :: forall k (a :: k) (a' :: k). (Monoidal k, Ob a, Ob a') => PIso (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') => PIso ((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

type family NFold (n :: Nat) (x :: k) :: k where ... Source Github #

The n-fold tensor power of x: x ** x ** … ** x, n times, terminated by Unit.

Equations

NFold 'Z (x :: k) = Unit :: k
NFold ('S n) (x :: k) = x ** NFold n x

type family NFoldS (n :: Nat) (x :: k) :: [k] where ... Source Github #

The Strictified counterpart of NFold: n copies of x as a list, rather than nested tensors.

Equations

NFoldS 'Z (x :: k) = '[] :: [k]
NFoldS ('S n) (x :: k) = x ': NFoldS n x

withObNFold :: forall {k} (n :: Nat) (a :: k) r. (SNatI n, Ob a, Monoidal k) => (Ob (NFold n a) => r) -> r Source Github #

NFold n a is an object whenever a is.

class ((a ** (Unit :: k)) ~ a, ((Unit :: k) ** a) ~ a, forall (b :: k) (c :: k). 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.

The four unitors then default to id. The defaults need only Unit ** a ~ a and a ** Unit ~ a, so they also fire for a strictly unital category such as MatK or ZX. Both associators can use associatorDefault:

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). 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 #

The identity on a tensor. It is built from withOb2 rather than as obj @a ** obj @b, so that an instance's own ** can use it without calling itself.

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.Limit.BinaryProduct 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 SVG Source Github #
Instance details Defined in Proarrow.Tools.Diagrams.Svg Methods swap :: forall (a :: SVG) (b :: SVG). (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 #
MonoidalOrdinal n => SymMonoidal (ORDINAL n) Source Github #
Instance details Defined in Proarrow.Category.Instance.Ordinal Methods swap :: forall (a :: ORDINAL n) (b :: ORDINAL n). (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 #
(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 #
CommutativeMonoid m => SymMonoidal (MONOID m) Source Github #
Instance details Defined in Proarrow.Category.Instance.Monoid Methods swap :: forall (a :: MONOID m) (b :: MONOID m). (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 #
(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 #
Elems SymMonoidalStructures 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 #
Costrong (Tensor :: SVG -> (SVG, SVG) -> Type) Svg Source Github #	The traced wires loop round the side of the diagram they are nearest to.
Instance details Defined in Proarrow.Tools.Diagrams.Svg Methods coact :: forall (a :: SVG) (x :: SVG) (y :: SVG). (Ob a, Ob x, Ob y) => Svg (Act (Tensor :: SVG -> (SVG, SVG) -> Type) a x) (Act (Tensor :: SVG -> (SVG, SVG) -> Type) a y) -> Svg 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) (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 #
(CopyDiscard k, SNatI n) => Strong (Tensor :: k -> (k, k) -> Type) (Pow n :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.PowerGrate Methods act :: forall (a :: k) (x :: k) (y :: k). Ob a => Pow n x y -> Pow n (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> 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 #
Functor f => Strong (Tensor :: Type -> (Type, Type) -> Type) (Star f :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Star Methods act :: Ob a => Star f x y -> Star f (Act (Tensor :: Type -> (Type, Type) -> Type) a x) (Act (Tensor :: Type -> (Type, Type) -> Type) a y) Source Github #
(SymMonoidal k, Ob m) => Strong (Tensor :: k -> (k, k) -> Type) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Monoid Methods act :: forall (a :: k) (x :: k) (y :: k). Ob a => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) x y -> Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> Type) a y) Source Github #
(Closed k, SymMonoidal k, Ob m) => Strong (Tensor :: k -> (k, k) -> Type) (Rep (Exp m) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods act :: forall (a :: k) (x :: k) (y :: k). Ob a => Rep (Exp m) x y -> Rep (Exp m) (Act (Tensor :: k -> (k, k) -> Type) a x) (Act (Tensor :: k -> (k, k) -> Type) a y) Source Github #
(CopyDiscard k, Ob r) => Strong (Tensor :: k -> (k, k) -> Type) (Rep (Constant r) :: k -> k -> Type) Source Github #	The constant functor ignores the acting object: discard it. Only copying/discarding is needed, so this works in biproduct categories as well as cartesian ones.
Instance details Defined in Proarrow.Category.Monoidal.CopyDiscard Methods act :: forall (a :: k) (x :: k) (y :: k). Ob a => Rep (Constant r) x y -> Rep (Constant r) (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 #
(Monoidal k, Ob a, Ob b, Flavor w, forall (m :: k). Ob m => w (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m))) => Costrong (Tensor :: k -> (k, k) -> Type) (ExOptic w a b :: k -> k -> Type) Source Github #	The generic carrier absorbs the residual of a `Costrong` action whenever the flavor contains the tracer generator: one more tensor-action layer, composed onto the witnesses. With it, profunctor-class-flavored tracers (`PTracer`) eliminate through `ExOptic` too.
Instance details Defined in Proarrow.Optic.Tracer Methods coact :: forall (a0 :: k) (x :: k) (y :: k). (Ob a0, Ob x, Ob y) => ExOptic w a b (Act (Tensor :: k -> (k, k) -> Type) a0 x) (Act (Tensor :: k -> (k, k) -> Type) a0 y) -> ExOptic w a b x y Source Github #
(Monoidal k, Ob a, Ob b, Flavor w, forall (x :: k). Ob x => w (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) x)) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) x))) => Strong (Tensor :: k -> (k, k) -> Type) (ExOptic w a b :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalTraversal Methods act :: forall (a0 :: k) (x :: k) (y :: k). Ob a0 => ExOptic w a b x y -> ExOptic w a b (Act (Tensor :: k -> (k, k) -> Type) a0 x) (Act (Tensor :: k -> (k, k) -> Type) a0 y) Source Github #
(SymMonoidal k, Monoid m) => MonoidalProfunctor (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #	Tensoring with a monoid, `m ** -`, is an applicative functor: the monoid's unit is `pure` and its multiplication is ``. Rendered on the representable profunctor `Rep (ActionAt Tensor m)` (legs `a ~> m * b`) this is a `StrongDistributiveProfunctor`, the Writer applicative of the literature. (The `Constant` instances above are the degenerate case `b = Unit`.)
Instance details Defined in Proarrow.Monoid Methods one :: Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) (Unit :: k) (Unit :: k) Source Github # () :: forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k). Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) x1 x2 -> Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) y1 y2 -> Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) (x1 y1) (x2 ** y2) Source Github #
ProLaws (Costrong (Tensor :: j -> (j, j) -> Type) :: (j +-> j) -> Constraint) Source Github #	The laws of costrength for the tensor acting on its own category: `coact` is natural in the element and dinatural in the acting object (sliding), and coacting by the `Unit` or by a tensor is doing nothing or coacting twice (vanishing). An element with tensored endpoints is made from the drawn element `p` with arbitrary arrows into and out of it.
Instance details Defined in Proarrow.Category.Monoidal.Strength Methods proLaws :: [ProLaw (Costrong (Tensor :: j -> (j, j) -> Type))] Source Github #
ProLaws (Strong (Tensor :: j -> (j, j) -> Type) :: (j +-> j) -> Constraint) Source Github #	The laws of strength for the tensor acting on its own category: acting by the `Unit` does nothing and acting by a tensor is acting twice, up to the unitor and the associator, and `act` is natural in the element and dinatural in the acting object.
Instance details Defined in Proarrow.Category.Monoidal.Strength Methods proLaws :: [ProLaw (Strong (Tensor :: j -> (j, j) -> Type))] Source Github #
(OplaxMonoidalRep m, Algebra m x, Comonoid x) => AlgLensFl (m :: k +-> k) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) x) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) x) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Action Methods withAlgP :: forall (s :: k) (a :: k) (b :: k) (t :: k) r. Rep (ActionAt (Tensor :: k -> (k, k) -> Type) x) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) x) b t -> (forall (x0 :: k). Ob x0 => ((m % x0) ~> x0) -> (s ~> (x0 a)) -> ((x0 b) ~> t) -> r) -> r Source Github #
(OplaxMonoidalRep l, Algebra l x, Monoid x, Comonoid x, SymMonoidal k, HasCoproducts k) => ClassifyFl (l :: k +-> k) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) x) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) x) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Action
Comonoid m => AffineFoldFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #	The tensor-action witness pair `Rep`/`Corep` `(ActionAt Tensor m)` views (and previews) when the residual `m` is a `Comonoid`: discard it with the counit. (Its setter and traversal instances live in Proarrow.Optic.Setter and Proarrow.Optic.Traversal.)
Instance details Defined in Proarrow.Optic.MonoidalLens Methods previewP :: forall (s :: k) (a :: k). Bicartesian k => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> s ~> (a \|\| (TerminalObject :: k)) Source Github #
(FoldFl p1 q1, FoldFl p2 q2, Monoidal k) => FoldFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods foldMapP :: forall (m :: k) (s :: k) (a :: k). Monoid m => Beside p1 p2 s a -> (a ~> m) -> s ~> m Source Github #
Comonoid m => FoldFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #	The tensor-action witness pair `Rep`/`Corep` `(ActionAt Tensor m)` with a comonoid residual `m` (legs `s ~> m a`, `m b ~> t`) is a (monoidal) traversal witness. It folds by discarding the residual with the counit, and distributes a `StrongDistributiveProfunctor` by its own strength `act @Tensor`, so neither product strength nor `tensor = product` is needed. Only `m` must be a `Comonoid`, so this works in `LINEAR` for the duplicable objects. It is also the monoidal-lens witness (Proarrow.Optic.MonoidalLens).
Instance details Defined in Proarrow.Optic.Traversal Methods foldMapP :: forall (m0 :: k) (s :: k) (a :: k). Monoid m0 => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> (a ~> m0) -> s ~> m0 Source Github #
Comonoid m => GetterFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalLens Methods getP :: forall (s :: k) (a :: k). Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> s ~> a Source Github #
Comonoid m => AffineTravFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #	In a cartesian category the tensor is the product, so the comonoidal residual can be projected out and put back: `affineSet` and `glassP` carry that assumption in their own constraints (`Bicartesian`, `CCC`), which is why these instances exist while a `LensFl` one cannot (`putP` has only `HasBinaryProducts`).
Instance details Defined in Proarrow.Optic.MonoidalLens Methods affineMatch :: forall (s :: k) (a :: k) (b :: k) (t :: k). Bicartesian k => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> s ~> (t \|\| a) Source Github # affineSet :: forall (s :: k) (a :: k) (b :: k) (t :: k). Bicartesian k => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> (s && b) ~> t Source Github #
Comonoid m => GlassFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalLens Methods glassP :: forall (s :: k) (a :: k) (b :: k) (t :: k). CCC k => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> (s && Mod s a b) ~> t Source Github #
(SymMonoidal k, HasCoproducts k, Monoid m) => CotravFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #	The tensor-action pair for a monoid residual: `m ** -` is the writer applicative.
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods cotravP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). Cotraversable r => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> r a b -> r s t Source Github #
(SymMonoidal k, HasCoproducts k, Monoid m) => KaleidoFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods kaleidoP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). Kaleidoscopic r => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> r a b -> r s t Source Github #
Comonoid m => MonLensFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalLens Methods withMonLensP :: forall (s :: k) (a :: k) (b :: k) (t :: k) r. SymMonoidal k => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> (forall (m0 :: k). Ob m0 => ComonoidOn m0 -> (s ~> (m0 a)) -> ((m0 b) ~> t) -> r) -> r Source Github #
(SetterFl p1 q1, SetterFl p2 q2, Monoidal k) => SetterFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods overP :: forall (s :: k) (a :: k) (b :: k) (t :: k). Beside p1 p2 s a -> CoBeside q1 q2 b t -> (a ~> b) -> s ~> t Source Github #
(TracedMonoidal k, Ob m) => SetterFl (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #	The tracer witness: the tensor-action pair read the other way round, `Corep (ActionAt Tensor m)` on the left and `Rep (ActionAt Tensor m)` on the right. Its `overP` is the trace of `m s ~> a ~> b ~> m t` over `m`, so it needs the category to be `TracedMonoidal`.
Instance details Defined in Proarrow.Optic.Tracer Methods overP :: forall (s :: k) (a :: k) (b :: k) (t :: k). Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> (a ~> b) -> s ~> t Source Github #
(Monoidal k, Ob a) => SetterFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) a) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) a) :: k -> k -> Type) Source Github #	The tensor-action witness pair `Rep`/`Corep` `(ActionAt Tensor a)`: the focus `x` sits inside `a x` with the residual `a` carried on the left (legs `s ~> a x` and `a ** x ~> t`). It is a setter witness by mapping under the tensor, and the tensor-strength generator for the free traversal profunctor (see Proarrow.Optic.MonoidalTraversal); read the other way round it is the tracer witness (see Proarrow.Optic.Tracer).
Instance details Defined in Proarrow.Optic.Setter Methods overP :: forall (s :: k) (a0 :: k) (b :: k) (t :: k). Rep (ActionAt (Tensor :: k -> (k, k) -> Type) a) s a0 -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) a) b t -> (a0 ~> b) -> s ~> t Source Github #
(TracedMonoidal k, Ob m) => TracerFl (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Tracer Methods withTracerP :: forall (s :: k) (a :: k) (b :: k) (t :: k) r. Monoidal k => Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> (forall (m0 :: k). Ob m0 => ((m0 s) ~> a) -> (b ~> (m0 t)) -> r) -> r Source Github #
(MonTravFl p1 q1, MonTravFl p2 q2, Monoidal k) => MonTravFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods monTravP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). StrongDistributiveProfunctor r => Beside p1 p2 s a -> CoBeside q1 q2 b t -> r a b -> r s t Source Github #
Comonoid m => MonTravFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods monTravP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). StrongDistributiveProfunctor r => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> r a b -> r s t Source Github #
(TravFl p1 q1, TravFl p2 q2, Monoidal k) => TravFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods travP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). (StrongDistributiveProfunctor r, Strong (ProdAction :: k -> (PROD k, k) -> Type) r) => Beside p1 p2 s a -> CoBeside q1 q2 b t -> r a b -> r s t Source Github #
Comonoid m => TravFl (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) (Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods travP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). (StrongDistributiveProfunctor r, Strong (ProdAction :: k -> (PROD k, k) -> Type) r) => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) s a -> Corep (ActionAt (Tensor :: k -> (k, k) -> Type) m) b t -> r a b -> r s t Source Github #
(Monoidal k, HasCoproducts k, Monoid m) => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Monoid Methods act :: forall (a :: COPROD k) (x :: k) (y :: k). Ob a => Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) x y -> Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m) (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a x) (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a y) Source Github #
(Monoidal k, HasCoproducts k, Ob m) => MonoidalProfunctor (Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) :: COPROD k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Monoid Methods one :: Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # () :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) x1 x2 -> Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) y1 y2 -> Coprod (Rep (ActionAt (Tensor :: k -> (k, k) -> Type) m)) (x1 y1) (x2 ** y2) Source Github #
Monoidal k => FunctorForRep (MultRep :: k -> (k, k) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods fmap :: forall (a :: (k, k)) (b :: (k, k)). (a ~> b) -> ((MultRep :: k -> (k, k) -> Type) @ a) ~> ((MultRep :: k -> (k, k) -> Type) @ b) Source Github #
type (MultRep :: k -> (k, k) -> Type) @ ('(a, b) :: (k, k)) Source Github #
Instance details Defined in Proarrow.Category.Monoidal type (MultRep :: k -> (k, k) -> Type) @ ('(a, b) :: (k, k)) = a ** b

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 lowerOb :: forall k' (f :: k +-> k') r. (Representable f, All cs k') => (Ob (Lower f (UnitF :: FREE cs p)) => r) -> r Source Github #
type Lower (f :: k +-> k') (UnitF :: FREE cs p) Source Github #
Instance details Defined in Proarrow.Category.Monoidal type Lower (f :: k +-> k') (UnitF :: FREE cs p) = Unit :: k'

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

Instances

Instances details

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

type SymMonoidalStructures = '[Monoidal, SymMonoidal] Source Github #

The structures the free category needs for SymMonoidal, and those its laws are stated for.