Safe Haskell	None
Language	GHC2024

Proarrow.Category.Monoidal.Strength

Description

Profunctor strength for a monoidal action: Strong t p lets p absorb the action of t via act, with MonStrong the self-action (tensor) case; Costrong is the dual, and a TracedMonoidal category is one whose hom-profunctor is costrong for its own tensor.

Synopsis

class (MonoidalAction t, Profunctor p) => Strong (t :: (m, k) +-> k) (p :: k +-> k) where
- act :: forall (a :: m) (x :: k) (y :: k). Ob a => p x y -> p (Act t a x) (Act t a y)
type MonStrong (p :: k +-> k) = (Strong (Tensor :: k -> (k, k) -> Type) p, SymMonoidal k)
strength :: forall {k} {m} (t :: (m, k) +-> k) (p :: k +-> k) (a :: m) (b :: k). (Representable p, Strong t p, Ob a, Ob b) => Act t a (p % b) ~> (p % Act t a b)
costrength :: forall {j} {m} (t :: (m, j) +-> j) (p :: j +-> j) (a :: m) (b :: j). (Corepresentable p, Strong t p, Ob a, Ob b) => (p %% Act t a b) ~> Act t a (p %% b)
first' :: forall {k} {p} (c :: k) (a :: k) (b :: k). (MonStrong p, Ob c) => p a b -> p (a ** c) (b ** c)
second' :: forall {k} {p} (c :: k) (a :: k) (b :: k). (MonStrong p, Ob c) => p a b -> p (c ** a) (c ** b)
left' :: forall {k} p (c :: k) (a :: k) (b :: k). (Strong (CoprodAction :: k -> (COPROD k, k) -> Type) p, HasBinaryCoproducts k, Ob c) => p a b -> p (a || c) (b || c)
right' :: forall {k} p (c :: k) (a :: k) (b :: k). (Strong (CoprodAction :: k -> (COPROD k, k) -> Type) p, Ob c) => p a b -> p (c || a) (c || b)
premon :: forall {k} {p} (a :: k) (b :: k) (c :: k) (d :: k). (MonStrong p, Promonad p) => p a b -> p c d -> p (a ** c) (b ** d)
strongId :: forall {k} {p} (a :: k). (MonStrong p, MonoidalProfunctor p, Ob a) => p a a
monActDefault :: forall {k} {p} (a :: k) (x :: k) (y :: k). (MonoidalProfunctor p, Promonad p, Ob a) => p x y -> p (a ** x) (a ** y)
class (MonoidalAction t, Profunctor p) => Costrong (t :: (m, k) +-> k) (p :: k +-> k) where
- coact :: forall (a :: m) (x :: k) (y :: k). (Ob a, Ob x, Ob y) => p (Act t a x) (Act t a y) -> p x y
trace :: forall {k} p (u :: k) (x :: k) (y :: k). (Costrong (Tensor :: k -> (k, k) -> Type) p, Ob x, Ob y, Ob u, SymMonoidal k) => p (x ** u) (y ** u) -> p x y
class (Costrong (Tensor :: k -> (k, k) -> Type) (Hom k), SymMonoidal k) => TracedMonoidal k
type TracedStructures = '[Monoidal, SymMonoidal, TracedMonoidal]

Documentation

class (MonoidalAction t, Profunctor p) => Strong (t :: (m, k) +-> k) (p :: k +-> k) where Source Github #

Profunctorial strength for a monoidal action. Gives functorial strength for representable profunctors, and functorial costrength for corepresentable profunctors.

Methods

act :: forall (a :: m) (x :: k) (y :: k). Ob a => p x y -> p (Act t a x) (Act t a y) Source Github #

Instances

Instances details

MonoidalAction t => Strong (t :: (m, k) +-> k) (Id :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Strength Methods act :: forall (a :: m) (x :: k) (y :: k). Ob a => Id x y -> Id (Act t a x) (Act t a y) Source Github #
Strong t p => Strong (t :: (m, k) +-> k) (Fix p :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Fix Methods act :: forall (a :: m) (x :: k) (y :: k). Ob a => Fix p x y -> Fix p (Act t a x) (Act t a y) Source Github #
(Strong t p, Strong t q) => Strong (t :: (m, j) +-> j) (p :+: q :: j -> j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Strength Methods act :: forall (a :: m) (x :: j) (y :: j). Ob a => (p :+: q) x y -> (p :+: q) (Act t a x) (Act t a y) Source Github #
(Strong t p, Strong t q) => Strong (t :: (m, j) +-> j) (p :*: q :: j -> j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Strength Methods act :: forall (a :: m) (x :: j) (y :: j). Ob a => (p :: q) x y -> (p :: q) (Act t a x) (Act t a y) Source Github #
(Strong t p, Strong t q) => Strong (t :: (m, i) +-> i) (p :.: q :: i -> i -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Strength Methods act :: forall (a :: m) (x :: i) (y :: i). Ob a => (p :.: q) x y -> (p :.: q) (Act t a x) (Act t a 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 #
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.Monoid 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 (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 #
MonadPlus m => Strong (CoprodAction :: Type -> (COPROD Type, Type) -> Type) (Kleisli m :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Arrow Methods act :: forall (a :: COPROD Type) x y. Ob a => Kleisli m x y -> Kleisli m (Act (CoprodAction :: Type -> (COPROD Type, Type) -> Type) a x) (Act (CoprodAction :: Type -> (COPROD Type, Type) -> Type) a y) Source Github #
BiCCC k => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (Fold :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Fold Methods act :: forall (a :: COPROD k) (x :: k) (y :: k). Ob a => Fold x y -> Fold (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a x) (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a y) Source Github #
(CopyDiscard k, HasCoproducts k, SNatI n) => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (Pow n :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.PowerGrate Methods act :: forall (a :: COPROD k) (x :: k) (y :: k). Ob a => Pow n x y -> Pow n (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a x) (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a y) Source Github #
Applicative f => Strong (CoprodAction :: Type -> (COPROD Type, Type) -> Type) (Star f :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Star Methods act :: forall (a :: COPROD Type) x y. Ob a => Star f x y -> Star f (Act (CoprodAction :: Type -> (COPROD Type, Type) -> Type) a x) (Act (CoprodAction :: Type -> (COPROD Type, Type) -> Type) a y) 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 #
(Closed k, HasCoproducts k, Comonoid m) => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (Rep (Exp 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 (Exp m) x y -> Rep (Exp m) (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a x) (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a y) Source Github #
(CopyDiscard k, HasCoproducts k, Monoid r) => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (Rep (Constant r) :: k -> k -> Type) Source Github #	The constant functor absorbs a coproduct action: the injected summand is discarded onto the monoid's unit, so this needs only copying/discarding on the tensor side and coproducts.
Instance details Defined in Proarrow.Category.Monoidal.Distributive Methods act :: forall (a :: COPROD k) (x :: k) (y :: k). Ob a => Rep (Constant r) x y -> Rep (Constant r) (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a x) (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a y) Source Github #
Functor f => Strong (ProdAction :: Type -> (PROD Type, Type) -> Type) (Star (Prelude f) :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Star Methods act :: forall (a :: PROD Type) x y. Ob a => Star (Prelude f) x y -> Star (Prelude f) (Act (ProdAction :: Type -> (PROD Type, Type) -> Type) a x) (Act (ProdAction :: Type -> (PROD Type, Type) -> Type) a y) Source Github #
(HasCoproducts k, Ob a, Ob b, Flavor w, forall (t :: k). Ob t => w (Rep (Coproduct t)) (Corep (Coproduct t))) => Strong (CoprodAction :: k -> (COPROD k, k) -> Type) (ExOptic w a b :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalTraversal Methods act :: forall (a0 :: COPROD k) (x :: k) (y :: k). Ob a0 => ExOptic w a b x y -> ExOptic w a b (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a0 x) (Act (CoprodAction :: k -> (COPROD k, k) -> Type) a0 y) Source Github #
(HasProducts k, Ob a, Ob b, Flavor w, forall (s :: k). Ob s => w (Rep (Product s)) (Corep (Product s))) => Strong (ProdAction :: k -> (PROD k, k) -> Type) (ExOptic w a b :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.MonoidalTraversal Methods act :: forall (a0 :: PROD k) (x :: k) (y :: k). Ob a0 => ExOptic w a b x y -> ExOptic w a b (Act (ProdAction :: k -> (PROD k, k) -> Type) a0 x) (Act (ProdAction :: k -> (PROD k, k) -> Type) a0 y) Source Github #
(CategoryOf j, CategoryOf k) => Strong (ProdAction :: (j +-> k) -> (PROD (j +-> k), j +-> k) -> Type) (Prof :: (j +-> k) -> (j +-> k) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Strength Methods act :: forall (a :: PROD (j +-> k)) (x :: j +-> k) (y :: j +-> k). Ob a => Prof x y -> Prof (Act (ProdAction :: (j +-> k) -> (PROD (j +-> k), j +-> k) -> Type) a x) (Act (ProdAction :: (j +-> k) -> (PROD (j +-> k), j +-> k) -> Type) a y) Source Github #
Applicative f => Strong (SubAction Traversable ApplyAction) (Star (Prelude f) :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Star Methods act :: forall (a :: SUBCAT Traversable) x y. Ob a => Star (Prelude f) x y -> Star (Prelude f) (Act (SubAction Traversable ApplyAction) a x) (Act (SubAction Traversable ApplyAction) a y) Source Github #

type MonStrong (p :: k +-> k) = (Strong (Tensor :: k -> (k, k) -> Type) p, SymMonoidal k) Source Github #

strength :: forall {k} {m} (t :: (m, k) +-> k) (p :: k +-> k) (a :: m) (b :: k). (Representable p, Strong t p, Ob a, Ob b) => Act t a (p % b) ~> (p % Act t a b) Source Github #

If a strong profunctor is representable, we get the usual strength for the representing functor.

costrength :: forall {j} {m} (t :: (m, j) +-> j) (p :: j +-> j) (a :: m) (b :: j). (Corepresentable p, Strong t p, Ob a, Ob b) => (p %% Act t a b) ~> Act t a (p %% b) Source Github #

If a strong profunctor is corepresentable, we get the usual costrength for the representing functor.

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

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

left' :: forall {k} p (c :: k) (a :: k) (b :: k). (Strong (CoprodAction :: k -> (COPROD k, k) -> Type) p, HasBinaryCoproducts k, Ob c) => p a b -> p (a || c) (b || c) Source Github #

right' :: forall {k} p (c :: k) (a :: k) (b :: k). (Strong (CoprodAction :: k -> (COPROD k, k) -> Type) p, Ob c) => p a b -> p (c || a) (c || b) Source Github #

premon :: forall {k} {p} (a :: k) (b :: k) (c :: k) (d :: k). (MonStrong p, Promonad p) => p a b -> p c d -> p (a ** c) (b ** d) Source Github #

This is not monoidal ** but premonoidal, i.e. no sliding. So with `premon f g` the effects of f happen before the effects of g. p needs to be a commutative promonad for this to be monoidal **.

strongId :: forall {k} {p} (a :: k). (MonStrong p, MonoidalProfunctor p, Ob a) => p a a Source Github #

monActDefault :: forall {k} {p} (a :: k) (x :: k) (y :: k). (MonoidalProfunctor p, Promonad p, Ob a) => p x y -> p (a ** x) (a ** y) Source Github #

A monoidal promonad is automatically strong.

class (MonoidalAction t, Profunctor p) => Costrong (t :: (m, k) +-> k) (p :: k +-> k) where Source Github #

Methods

coact :: forall (a :: m) (x :: k) (y :: k). (Ob a, Ob x, Ob y) => p (Act t a x) (Act t a y) -> p x y Source Github #

Instances

Instances details

MonoidalAction t => Costrong (t :: (Nat, Nat) +-> Nat) ZX Source Github #
Instance details Defined in Proarrow.Category.Instance.ZX Methods coact :: forall (a :: Nat) (x :: Nat) (y :: Nat). (Ob a, Ob x, Ob y) => ZX (Act t a x) (Act t a y) -> ZX x y Source Github #
MonoidalAction t => Costrong (t :: (FINREL, FINREL) +-> FINREL) FinRel Source Github #
Instance details Defined in Proarrow.Category.Instance.FinRel Methods coact :: forall (a :: FINREL) (x :: FINREL) (y :: FINREL). (Ob a, Ob x, Ob y) => FinRel (Act t a x) (Act t a y) -> FinRel x y Source Github #
(MonoidalAction t, Costrong t (Hom k)) => Costrong (t :: (m, k) +-> k) (Id :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Strength Methods coact :: forall (a :: m) (x :: k) (y :: k). (Ob a, Ob x, Ob y) => Id (Act t a x) (Act t a y) -> Id x y 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 #
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 #
(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 #
Costrong (CoprodAction :: LINEAR -> (COPROD LINEAR, LINEAR) -> Type) Linear Source Github #
Instance details Defined in Proarrow.Category.Instance.Linear Methods coact :: forall (a :: COPROD LINEAR) (x :: LINEAR) (y :: LINEAR). (Ob a, Ob x, Ob y) => Linear (Act (CoprodAction :: LINEAR -> (COPROD LINEAR, LINEAR) -> Type) a x) (Act (CoprodAction :: LINEAR -> (COPROD LINEAR, LINEAR) -> Type) a y) -> Linear x y Source Github #
Cartesian k => Costrong (ProdAction :: k -> (PROD k, k) -> Type) (Fold :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Fold Methods coact :: forall (a :: PROD k) (x :: k) (y :: k). (Ob a, Ob x, Ob y) => Fold (Act (ProdAction :: k -> (PROD k, k) -> Type) a x) (Act (ProdAction :: k -> (PROD k, k) -> Type) a y) -> Fold x y Source Github #
(Num a, MonoidalAction t) => Costrong (t :: (MatK a, MatK a) +-> MatK a) (Mat :: MatK a -> MatK a -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Mat Methods coact :: forall (a0 :: MatK a) (x :: MatK a) (y :: MatK a). (Ob a0, Ob x, Ob y) => Mat (Act t a0 x) (Act t a0 y) -> Mat x y Source Github #

trace :: forall {k} p (u :: k) (x :: k) (y :: k). (Costrong (Tensor :: k -> (k, k) -> Type) p, Ob x, Ob y, Ob u, SymMonoidal k) => p (x ** u) (y ** u) -> p x y Source Github #

class (Costrong (Tensor :: k -> (k, k) -> Type) (Hom k), SymMonoidal k) => TracedMonoidal k Source Github #

Instances

Instances details

(Costrong (Tensor :: k -> (k, k) -> Type) (Hom k), SymMonoidal k) => TracedMonoidal k Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Strength

type TracedStructures = '[Monoidal, SymMonoidal, TracedMonoidal] Source Github #

The structures the laws of a traced monoidal category are stated for.