Safe Haskell	None
Language	GHC2024

Proarrow.Category.Monoidal.Action

Synopsis

class (MonoidalAction m c, MonoidalAction m d, Profunctor p) => Strong m (p :: c +-> d) where
- act :: forall (a :: m) (b :: m) (x :: d) (y :: c). (a ~> b) -> p x y -> p (Act a x) (Act b y)
class (Monoidal m, CategoryOf k, Strong m (Hom k)) => MonoidalAction m k where
- type Act (a :: m) (x :: k) :: k
- withObAct :: forall (a :: m) (x :: k) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r
- unitor :: forall (x :: k). Ob x => Act (Unit :: m) x ~> x
- unitorInv :: forall (x :: k). Ob x => x ~> Act (Unit :: m) x
- multiplicator :: forall (a :: m) (b :: m) (x :: k). (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x)
- multiplicatorInv :: forall (a :: m) (b :: m) (x :: k). (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x
newtype Action (a :: m) (x :: j) (y :: j) = Action (Rep (Action' a) x y)
data family Action' :: m -> k +-> k
par0Action :: forall m k (x :: k). (MonoidalAction m k, Ob x) => Action (Unit :: m) x x
parAction :: forall {m} {k} (a :: m) (b :: m) (x :: k) (y :: k) (z :: k). (MonoidalAction m k, Ob a, Ob b) => Action a x y -> Action b y z -> Action (a ** b) x z
class (MonoidalAction m k, SymMonoidal m) => SymMonoidalAction m k
class Act a b ~ (a ** b) => ActIsTensor (a :: k) (b :: k)
class (Act a (Act b c) ~ (a ** (b ** c)), (a ** Act b c) ~ (a ** (b ** c)), Act a (b ** c) ~ (a ** (b ** c))) => ActIsTensor3 (a :: k) (b :: k) (c :: k)
class (SymMonoidalAction k k, Strong k ((~>) :: CAT k), forall (a :: k) (b :: k). ActIsTensor a b, forall (a :: k) (b :: k) (c :: k). ActIsTensor3 a b c) => SelfAction k
toSelfAct :: forall {k} (a :: k) (b :: k). (SelfAction k, Ob a, Ob b) => (a ** b) ~> Act a b
fromSelfAct :: forall {k} (a :: k) (b :: k). (SelfAction k, Ob a, Ob b) => Act a b ~> (a ** b)
composeActs :: forall {m} {k} (x :: m) (y :: m) (c :: k) (a :: k) (b :: k). (MonoidalAction m k, Ob x, Ob y, Ob c) => (a ~> Act x b) -> (b ~> Act y c) -> a ~> Act (x ** y) c
decomposeActs :: forall {m} {k} (x :: m) (y :: m) (c :: k) (a :: k) (b :: k). (MonoidalAction m k, Ob x, Ob y, Ob c) => (Act y c ~> b) -> (Act x b ~> a) -> Act (x ** y) c ~> a
first' :: forall {k} {p} (c :: k) (a :: k) (b :: k). (SelfAction k, Strong k p, Ob c) => p a b -> p (a ** c) (b ** c)
second' :: forall {k} {p} (c :: k) (a :: k) (b :: k). (SelfAction k, Strong k p, Ob c) => p a b -> p (c ** a) (c ** b)
strength :: forall {k1} {k2} {m} (p :: k1 +-> k2) (a :: m) (b :: k1). (Representable p, Strong m p, Ob a, Ob b) => Act a (p % b) ~> (p % Act a b)
costrength :: forall {k1} {k2} {m} (p :: k1 +-> k2) (a :: m) (b :: k2). (Corepresentable p, Strong m p, Ob a, Ob b) => (p %% Act a b) ~> Act a (p %% b)
prepar :: forall {k} {p} (a :: k) (b :: k) (c :: k) (d :: k). (SelfAction k, Strong k p, Promonad p) => p a b -> p c d -> p (a ** c) (b ** d)
strongPar0 :: forall {k} {p} (a :: k). (SelfAction k, Strong k p, MonoidalProfunctor p, Ob a) => p a a
class (MonoidalAction m c, MonoidalAction m d, Profunctor p) => Costrong m (p :: c +-> d) where
- coact :: forall (a :: m) (x :: d) (y :: c). (Ob a, Ob x, Ob y) => p (Act a x) (Act a y) -> p x y
trace :: forall {k} p (u :: k) (x :: k) (y :: k). (SelfAction k, Costrong k p, Ob x, Ob y, Ob u) => p (x ** u) (y ** u) -> p x y
class (SelfAction k, Costrong k (Hom k)) => TracedMonoidal k

Documentation

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

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

Methods

act :: forall (a :: m) (b :: m) (x :: d) (y :: c). (a ~> b) -> p x y -> p (Act a x) (Act b y) Source Github #

Instances

Instances details

Strong Nat ZX Source Github #
Instance details Defined in Proarrow.Category.Instance.ZX Methods act :: forall (a :: Nat) (b :: Nat) (x :: Nat) (y :: Nat). (a ~> b) -> ZX x y -> ZX (Act a x) (Act b y) Source Github #
Strong KIND Cat Source Github #
Instance details Defined in Proarrow.Category.Instance.Cat Methods act :: forall (a :: KIND) (b :: KIND) (x :: KIND) (y :: KIND). (a ~> b) -> Cat x y -> Cat (Act a x) (Act b y) Source Github #
Strong FINREL FinRel Source Github #
Instance details Defined in Proarrow.Category.Instance.FinRel Methods act :: forall (a :: FINREL) (b :: FINREL) (x :: FINREL) (y :: FINREL). (a ~> b) -> FinRel x y -> FinRel (Act a x) (Act b y) Source Github #
Strong DOT Dot Source Github #
Instance details Defined in Proarrow.Tools.Diagrams.Dot Methods act :: forall (a :: DOT) (b :: DOT) (x :: DOT) (y :: DOT). (a ~> b) -> Dot x y -> Dot (Act a x) (Act b y) Source Github #
Monad m => Strong Type (Kleisli m :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Arrow Methods act :: (a ~> b) -> Kleisli m x y -> Kleisli m (Act a x) (Act b y) Source Github #
Arrow arr => Strong Type (Arr arr :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Arrow Methods act :: (a ~> b) -> Arr arr x y -> Arr arr (Act a x) (Act b y) Source Github #
(MonoidalAction m k, Strong m (Hom k)) => Strong m (Id :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Identity Methods act :: forall (a :: m) (b :: m) (x :: k) (y :: k). (a ~> b) -> Id x y -> Id (Act a x) (Act b y) Source Github #
Strong Type (Previewing a b :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: (a0 ~> b0) -> Previewing a b x y -> Previewing a b (Act a0 x) (Act b0 y) Source Github #
Strong Type (Replacing a b :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: (a0 ~> b0) -> Replacing a b x y -> Replacing a b (Act a0 x) (Act b0 y) Source Github #
Strong Type (Cont r :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Cont Methods act :: (a ~> b) -> Cont r x y -> Cont r (Act a x) (Act b y) Source Github #
Strong Type (->) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods act :: (a ~> b) -> (x -> y) -> Act a x -> Act b y Source Github #
Strong m p => Strong m (Fix p :: c -> c -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Fix Methods act :: forall (a :: m) (b :: m) (x :: c) (y :: c). (a ~> b) -> Fix p x y -> Fix p (Act a x) (Act b y) Source Github #
(Ob r, SelfAction k) => Strong k (Reader ('OP r) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Reader Methods act :: forall (a :: k) (b :: k) (x :: k) (y :: k). (a ~> b) -> Reader ('OP r) x y -> Reader ('OP r) (Act a x) (Act b y) Source Github #
(Ob w, SelfAction k) => Strong k (Writer w :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Writer Methods act :: forall (a :: k) (b :: k) (x :: k) (y :: k). (a ~> b) -> Writer w x y -> Writer w (Act a x) (Act b y) Source Github #
(Cartesian k, SelfAction k, Ob c) => Strong k (Rep (Constant c) :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: forall (a :: k) (b :: k) (x :: k) (y :: k). (a ~> b) -> Rep (Constant c) x y -> Rep (Constant c) (Act a x) (Act b y) Source Github #
(Strong m p, Strong m q) => Strong m (p :+: q :: d -> c -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Coproduct Methods act :: forall (a :: m) (b :: m) (x :: d) (y :: c). (a ~> b) -> (p :+: q) x y -> (p :+: q) (Act a x) (Act b y) Source Github #
(Strong m p, Strong m q) => Strong m (p :*: q :: d -> c -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Product Methods act :: forall (a :: m) (b :: m) (x :: d) (y :: c). (a ~> b) -> (p :: q) x y -> (p :: q) (Act a x) (Act b y) Source Github #
(MonoidalAction m j, MonoidalAction m k, Profunctor p) => Strong m (Pastro m p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.PastroTambara Methods act :: forall (a :: m) (b :: m) (x :: k) (y :: j). (a ~> b) -> Pastro m p x y -> Pastro m p (Act a x) (Act b y) Source Github #
(MonoidalAction m j, MonoidalAction m k, Profunctor p) => Strong m (Tambara m p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.PastroTambara Methods act :: forall (a :: m) (b :: m) (x :: k) (y :: j). (a ~> b) -> Tambara m p x y -> Tambara m p (Act a x) (Act b y) Source Github #
IsOptic m c d => Strong m (ExOptic m a b :: d -> c -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: forall (a0 :: m) (b0 :: m) (x :: d) (y :: c). (a0 ~> b0) -> ExOptic m a b x y -> ExOptic m a b (Act a0 x) (Act b0 y) Source Github #
Costrong m p => Strong m (Re p s t :: d -> c -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: forall (a :: m) (b :: m) (x :: d) (y :: c). (a ~> b) -> Re p s t x y -> Re p s t (Act a x) (Act b y) Source Github #
(Strong m p, Strong m q) => Strong m (p :.: q :: d -> c -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Composition Methods act :: forall (a :: m) (b :: m) (x :: d) (y :: c). (a ~> b) -> (p :.: q) x y -> (p :.: q) (Act a x) (Act b y) Source Github #
Strong (COPROD LINEAR) Linear Source Github #
Instance details Defined in Proarrow.Category.Instance.Linear Methods act :: forall (a :: COPROD LINEAR) (b :: COPROD LINEAR) (x :: LINEAR) (y :: LINEAR). (a ~> b) -> Linear x y -> Linear (Act a x) (Act b y) Source Github #
MonadPlus m => Strong (COPROD Type) (Kleisli m :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Arrow Methods act :: forall (a :: COPROD Type) (b :: COPROD Type) x y. (a ~> b) -> Kleisli m x y -> Kleisli m (Act a x) (Act b y) Source Github #
(CoprodAction k, BiCCC k) => Strong (COPROD k) (Fold :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Fold Methods act :: forall (a :: COPROD k) (b :: COPROD k) (x :: k) (y :: k). (a ~> b) -> Fold x y -> Fold (Act a x) (Act b y) Source Github #
Strong (COPROD Type) (Previewing a b :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: forall (a0 :: COPROD Type) (b0 :: COPROD Type) x y. (a0 ~> b0) -> Previewing a b x y -> Previewing a b (Act a0 x) (Act b0 y) Source Github #
Strong (COPROD Type) (Replacing a b :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: forall (a0 :: COPROD Type) (b0 :: COPROD Type) x y. (a0 ~> b0) -> Replacing a b x y -> Replacing a b (Act a0 x) (Act b0 y) Source Github #
Strong (COPROD Type) (->) Source Github #
Instance details Defined in Proarrow.Object.BinaryCoproduct Methods act :: forall (a :: COPROD Type) (b :: COPROD Type) x y. (a ~> b) -> (x -> y) -> Act a x -> Act b y Source Github #
Strong (PROD Type) (->) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods act :: forall (a :: PROD Type) (b :: PROD Type) x y. (a ~> b) -> (x -> y) -> Act a x -> Act b y Source Github #
Strong (COPROD Type) (Rep (Constant (First c)) :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: forall (a :: COPROD Type) (b :: COPROD Type) x y. (a ~> b) -> Rep (Constant (First c)) x y -> Rep (Constant (First c)) (Act a x) (Act b y) Source Github #
Functor f => Strong (PROD Type) (Star (Prelude f) :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Star Methods act :: forall (a :: PROD Type) (b :: PROD Type) x y. (a ~> b) -> Star (Prelude f) x y -> Star (Prelude f) (Act a x) (Act b y) Source Github #
SubMonoidal ob => Strong (SUBCAT ob) Unit Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Action Methods act :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (x :: ()) (y :: ()). (a ~> b) -> Unit x y -> Unit (Act a x) (Act b y) Source Github #
(ob Identity, forall (a :: Type -> Type) (b :: Type -> Type). (ob a, ob b) => ob (Compose a b)) => Strong (SUBCAT ob) (->) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods act :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) x y. (a ~> b) -> (x -> y) -> Act a x -> Act b y Source Github #
SubMonoidal ob => Strong (SUBCAT ob) (->) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Action Methods act :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) x y. (a ~> b) -> (x -> y) -> Act a x -> Act b y Source Github #
Strong (Type -> Type) (Replacing a b :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: forall (a0 :: Type -> Type) (b0 :: Type -> Type) x y. (a0 ~> b0) -> Replacing a b x y -> Replacing a b (Act a0 x) (Act b0 y) Source Github #
Strong (Type -> Type) (->) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods act :: forall (a :: Type -> Type) (b :: Type -> Type) x y. (a ~> b) -> (x -> y) -> Act a x -> Act b y Source Github #
Applicative f => Strong (SUBCAT Traversable) (Star (Prelude f) :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Star Methods act :: forall (a :: SUBCAT Traversable) (b :: SUBCAT Traversable) x y. (a ~> b) -> Star (Prelude f) x y -> Star (Prelude f) (Act a x) (Act b y) Source Github #
Monad m => Strong (SUBCAT (Algebra m)) (Classifying m a b :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: forall (a0 :: SUBCAT (Algebra m)) (b0 :: SUBCAT (Algebra m)) x y. (a0 ~> b0) -> Classifying m a b x y -> Classifying m a b (Act a0 x) (Act b0 y) Source Github #
Monad m => Strong Type (Updating a b :: Type -> KlCat m -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods act :: forall a0 b0 x (y :: KlCat m). (a0 ~> b0) -> Updating a b x y -> Updating a b (Act a0 x) (Act b0 y) Source Github #
Strong Type (Coprod (Id :: Type -> Type -> Type)) Source Github #
Instance details Defined in Proarrow.Object.BinaryCoproduct Methods act :: forall a b (x :: COPROD Type) (y :: COPROD Type). (a ~> b) -> Coprod (Id :: Type -> Type -> Type) x y -> Coprod (Id :: Type -> Type -> Type) (Act a x) (Act b y) Source Github #
Num a => Strong (MatK a) (Mat :: MatK a -> MatK a -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Mat Methods act :: forall (a0 :: MatK a) (b :: MatK a) (x :: MatK a) (y :: MatK a). (a0 ~> b) -> Mat x y -> Mat (Act a0 x) (Act b y) Source Github #
Strong k2 p => Strong (OPPOSITE k2) (Op p :: OPPOSITE j -> OPPOSITE k1 -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Action Methods act :: forall (a :: OPPOSITE k2) (b :: OPPOSITE k2) (x :: OPPOSITE j) (y :: OPPOSITE k1). (a ~> b) -> Op p x y -> Op p (Act a x) (Act b y) Source Github #
(Promonad p, MonoidalProfunctor p) => Strong Type (Kleisli :: KLEISLI p -> KLEISLI p -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Kleisli Methods act :: forall a b (x :: KLEISLI p) (y :: KLEISLI p). (a ~> b) -> Kleisli x y -> Kleisli (Act a x) (Act b y) Source Github #
(CategoryOf j, CategoryOf k) => Strong (PROD (j +-> k)) (Prof :: (j +-> k) -> (j +-> k) -> Type) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods act :: forall (a :: PROD (j +-> k)) (b :: PROD (j +-> k)) (x :: j +-> k) (y :: j +-> k). (a ~> b) -> Prof x y -> Prof (Act a x) (Act b y) Source Github #
(Monoidal j, Monoidal k) => Strong (j +-> k) (Prof :: (j +-> k) -> (j +-> k) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Day Methods act :: forall (a :: j +-> k) (b :: j +-> k) (x :: j +-> k) (y :: j +-> k). (a ~> b) -> Prof x y -> Prof (Act a x) (Act b y) Source Github #

class (Monoidal m, CategoryOf k, Strong m (Hom k)) => MonoidalAction m k where Source Github #

Associated Types

type Act (a :: m) (x :: k) :: k Source Github #

Methods

withObAct :: forall (a :: m) (x :: k) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: k). Ob x => Act (Unit :: m) x ~> x Source Github #

unitorInv :: forall (x :: k). Ob x => x ~> Act (Unit :: m) x Source Github #

multiplicator :: forall (a :: m) (b :: m) (x :: k). (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: m) (b :: m) (x :: k). (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

Instances

Instances details

MonoidalAction Nat Nat Source Github #

Instance details

Defined in Proarrow.Category.Instance.ZX

Associated Types

type Act (p :: Nat) (x :: Nat)
Instance details Defined in Proarrow.Category.Instance.ZX type Act (p :: Nat) (x :: Nat) = p ** x

Methods

withObAct :: forall (a :: Nat) (x :: Nat) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: Nat). Ob x => Act (Unit :: Nat) x ~> x Source Github #

unitorInv :: forall (x :: Nat). Ob x => x ~> Act (Unit :: Nat) x Source Github #

multiplicator :: forall (a :: Nat) (b :: Nat) (x :: Nat). (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: Nat) (b :: Nat) (x :: Nat). (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

MonoidalAction KIND KIND Source Github #

Instance details

Defined in Proarrow.Category.Instance.Cat

Associated Types

type Act (a :: KIND) (x :: KIND)
Instance details Defined in Proarrow.Category.Instance.Cat type Act (a :: KIND) (x :: KIND) = a ** x

Methods

withObAct :: forall (a :: KIND) (x :: KIND) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: KIND). Ob x => Act (Unit :: KIND) x ~> x Source Github #

unitorInv :: forall (x :: KIND). Ob x => x ~> Act (Unit :: KIND) x Source Github #

multiplicator :: forall (a :: KIND) (b :: KIND) (x :: KIND). (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: KIND) (b :: KIND) (x :: KIND). (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

MonoidalAction FINREL FINREL Source Github #

Instance details

Defined in Proarrow.Category.Instance.FinRel

Associated Types

type Act (p :: FINREL) (x :: FINREL)
Instance details Defined in Proarrow.Category.Instance.FinRel type Act (p :: FINREL) (x :: FINREL) = p ** x

Methods

withObAct :: forall (a :: FINREL) (x :: FINREL) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: FINREL). Ob x => Act (Unit :: FINREL) x ~> x Source Github #

unitorInv :: forall (x :: FINREL). Ob x => x ~> Act (Unit :: FINREL) x Source Github #

multiplicator :: forall (a :: FINREL) (b :: FINREL) (x :: FINREL). (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: FINREL) (b :: FINREL) (x :: FINREL). (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

MonoidalAction DOT DOT Source Github #

Instance details

Defined in Proarrow.Tools.Diagrams.Dot

Associated Types

type Act (a :: DOT) (x :: DOT)
Instance details Defined in Proarrow.Tools.Diagrams.Dot type Act (a :: DOT) (x :: DOT) = a ** x

Methods

withObAct :: forall (a :: DOT) (x :: DOT) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: DOT). Ob x => Act (Unit :: DOT) x ~> x Source Github #

unitorInv :: forall (x :: DOT). Ob x => x ~> Act (Unit :: DOT) x Source Github #

multiplicator :: forall (a :: DOT) (b :: DOT) (x :: DOT). (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: DOT) (b :: DOT) (x :: DOT). (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

(CategoryOf k, Strong () (Hom k)) => MonoidalAction () k Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Action

Methods

withObAct :: forall (a :: ()) (x :: k) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: k). Ob x => Act (Unit :: ()) x ~> x Source Github #

unitorInv :: forall (x :: k). Ob x => x ~> Act (Unit :: ()) x Source Github #

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

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

MonoidalAction Type Type Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Associated Types

type Act (p :: Type) (x :: Type)
Instance details Defined in Proarrow.Object.BinaryProduct type Act (p :: Type) (x :: Type) = p ** x

Methods

withObAct :: (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: Ob x => Act (Unit :: Type) x ~> x Source Github #

unitorInv :: Ob x => x ~> Act (Unit :: Type) x Source Github #

multiplicator :: (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

MonoidalAction Type (COPROD Type) Source Github #

Instance details

Defined in Proarrow.Object.BinaryCoproduct

Associated Types

type Act (p :: Type) ('COPR x :: COPROD Type)
Instance details Defined in Proarrow.Object.BinaryCoproduct type Act (p :: Type) ('COPR x :: COPROD Type) = 'COPR (p ** x)

Methods

withObAct :: forall a (x :: COPROD Type) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: COPROD Type). Ob x => Act (Unit :: Type) x ~> x Source Github #

unitorInv :: forall (x :: COPROD Type). Ob x => x ~> Act (Unit :: Type) x Source Github #

multiplicator :: forall a b (x :: COPROD Type). (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall a b (x :: COPROD Type). (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

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

Instance details

Defined in Proarrow.Category.Instance.Kleisli

Methods

withObAct :: forall a (x :: KLEISLI p) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: KLEISLI p). Ob x => Act (Unit :: Type) x ~> x Source Github #

unitorInv :: forall (x :: KLEISLI p). Ob x => x ~> Act (Unit :: Type) x Source Github #

multiplicator :: forall a b (x :: KLEISLI p). (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall a b (x :: KLEISLI p). (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

(HasCoproducts k, Strong (COPROD k) ((~>) :: CAT k)) => MonoidalAction (COPROD k) k Source Github #

Instance details

Defined in Proarrow.Object.BinaryCoproduct

Methods

withObAct :: forall (a :: COPROD k) (x :: k) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: k). Ob x => Act (Unit :: COPROD k) x ~> x Source Github #

unitorInv :: forall (x :: k). Ob x => x ~> Act (Unit :: COPROD k) x Source Github #

multiplicator :: forall (a :: COPROD k) (b :: COPROD k) (x :: k). (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: COPROD k) (b :: COPROD k) (x :: k). (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

(HasProducts k, Strong (PROD k) (Hom k)) => MonoidalAction (PROD k) k Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Methods

withObAct :: forall (a :: PROD k) (x :: k) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: k). Ob x => Act (Unit :: PROD k) x ~> x Source Github #

unitorInv :: forall (x :: k). Ob x => x ~> Act (Unit :: PROD k) x Source Github #

multiplicator :: forall (a :: PROD k) (b :: PROD k) (x :: k). (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: PROD k) (b :: PROD k) (x :: k). (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

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

Instance details

Defined in Proarrow.Category.Instance.Mat

Methods

withObAct :: forall (a0 :: MatK a) (x :: MatK a) r. (Ob a0, Ob x) => (Ob (Act a0 x) => r) -> r Source Github #

unitor :: forall (x :: MatK a). Ob x => Act (Unit :: MatK a) x ~> x Source Github #

unitorInv :: forall (x :: MatK a). Ob x => x ~> Act (Unit :: MatK a) x Source Github #

multiplicator :: forall (a0 :: MatK a) (b :: MatK a) (x :: MatK a). (Ob a0, Ob b, Ob x) => Act (a0 ** b) x ~> Act a0 (Act b x) Source Github #

multiplicatorInv :: forall (a0 :: MatK a) (b :: MatK a) (x :: MatK a). (Ob a0, Ob b, Ob x) => Act a0 (Act b x) ~> Act (a0 ** b) x Source Github #

MonoidalAction m k => MonoidalAction (OPPOSITE m) (OPPOSITE k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Action

Methods

withObAct :: forall (a :: OPPOSITE m) (x :: OPPOSITE k) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: OPPOSITE k). Ob x => Act (Unit :: OPPOSITE m) x ~> x Source Github #

unitorInv :: forall (x :: OPPOSITE k). Ob x => x ~> Act (Unit :: OPPOSITE m) x Source Github #

multiplicator :: forall (a :: OPPOSITE m) (b :: OPPOSITE m) (x :: OPPOSITE k). (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: OPPOSITE m) (b :: OPPOSITE m) (x :: OPPOSITE k). (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

(Monoidal (SUBCAT ob), Strong (SUBCAT ob) ((~>) :: CAT Type)) => MonoidalAction (SUBCAT ob) Type Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

Methods

withObAct :: forall (a :: SUBCAT ob) x r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: Ob x => Act (Unit :: SUBCAT ob) x ~> x Source Github #

unitorInv :: Ob x => x ~> Act (Unit :: SUBCAT ob) x Source Github #

multiplicator :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) x. (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) x. (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

(Monoidal k, Monoidal (SUBCAT ob), Strong (SUBCAT ob) (Hom k)) => MonoidalAction (SUBCAT ob) k Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Action

Methods

withObAct :: forall (a :: SUBCAT ob) (x :: k) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: k). Ob x => Act (Unit :: SUBCAT ob) x ~> x Source Github #

unitorInv :: forall (x :: k). Ob x => x ~> Act (Unit :: SUBCAT ob) x Source Github #

multiplicator :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (x :: k). (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (x :: k). (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

MonoidalAction (Type -> Type) Type Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

Associated Types

type Act (p :: Type -> Type) (x :: Type)
Instance details Defined in Proarrow.Category.Instance.Nat type Act (p :: Type -> Type) (x :: Type) = p x

Methods

withObAct :: forall (a :: Type -> Type) x r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: Ob x => Act (Unit :: Type -> Type) x ~> x Source Github #

unitorInv :: Ob x => x ~> Act (Unit :: Type -> Type) x Source Github #

multiplicator :: forall (a :: Type -> Type) (b :: Type -> Type) x. (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: Type -> Type) (b :: Type -> Type) x. (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

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

Instance details

Defined in Proarrow.Profunctor.Day

Methods

withObAct :: forall (a :: j +-> k) (x :: j +-> k) r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: forall (x :: j +-> k). Ob x => Act (Unit :: j +-> k) x ~> x Source Github #

unitorInv :: forall (x :: j +-> k). Ob x => x ~> Act (Unit :: j +-> k) x Source Github #

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

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

newtype Action (a :: m) (x :: j) (y :: j) Source Github #

Constructors

Action (Rep (Action' a) x y)

Instances

Instances details

(Ob a, MonoidalAction m k) => Profunctor (Action a :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Action Methods dimap :: forall (c :: k) (a0 :: k) (b :: k) (d :: k). (c ~> a0) -> (b ~> d) -> Action a a0 b -> Action a c d Source Github # (\\) :: forall (a0 :: k) (b :: k) r. ((Ob a0, Ob b) => r) -> Action a a0 b -> r Source Github #
(Ob a, MonoidalAction m k) => Representable (Action a :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Action Methods index :: forall (a0 :: k) (b :: k). Action a a0 b -> a0 ~> ((Action a :: k -> k -> Type) % b) Source Github # tabulate :: forall (b :: k) (a0 :: k). Ob b => (a0 ~> ((Action a :: k -> k -> Type) % b)) -> Action a a0 b Source Github # repMap :: forall (a0 :: k) (b :: k). (a0 ~> b) -> ((Action a :: k -> k -> Type) % a0) ~> ((Action a :: k -> k -> Type) % b) Source Github #
type (Action a1 :: k -> k -> Type) % (a2 :: k) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Action type (Action a1 :: k -> k -> Type) % (a2 :: k) = Rep (Action' a1) % a2

data family Action' :: m -> k +-> k Source Github #

Instances

Instances details

(MonoidalAction m k, Ob a) => FunctorForRep (Action' a :: k +-> k) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Action Methods fmap :: forall (a0 :: k) (b :: k). (a0 ~> b) -> (Action' a @ a0) ~> (Action' a @ b) Source Github #
type (Action' a :: k +-> k) @ (x :: k) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Action type (Action' a :: k +-> k) @ (x :: k) = Act a x

par0Action :: forall m k (x :: k). (MonoidalAction m k, Ob x) => Action (Unit :: m) x x Source Github #

parAction :: forall {m} {k} (a :: m) (b :: m) (x :: k) (y :: k) (z :: k). (MonoidalAction m k, Ob a, Ob b) => Action a x y -> Action b y z -> Action (a ** b) x z Source Github #

class (MonoidalAction m k, SymMonoidal m) => SymMonoidalAction m k Source Github #

Instances

Instances details

(MonoidalAction m k, SymMonoidal m) => SymMonoidalAction m k Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Action

class Act a b ~ (a ** b) => ActIsTensor (a :: k) (b :: k) Source Github #

Instances

Instances details

Act a b ~ (a ** b) => ActIsTensor (a :: k) (b :: k) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Action

class (Act a (Act b c) ~ (a ** (b ** c)), (a ** Act b c) ~ (a ** (b ** c)), Act a (b ** c) ~ (a ** (b ** c))) => ActIsTensor3 (a :: k) (b :: k) (c :: k) Source Github #

Instances

Instances details

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

class (SymMonoidalAction k k, Strong k ((~>) :: CAT k), forall (a :: k) (b :: k). ActIsTensor a b, forall (a :: k) (b :: k) (c :: k). ActIsTensor3 a b c) => SelfAction k Source Github #

Instances

Instances details

(SymMonoidalAction k k, Strong k ((~>) :: CAT k), forall (a :: k) (b :: k). ActIsTensor a b, forall (a :: k) (b :: k) (c :: k). ActIsTensor3 a b c) => SelfAction k Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Action

toSelfAct :: forall {k} (a :: k) (b :: k). (SelfAction k, Ob a, Ob b) => (a ** b) ~> Act a b Source Github #

fromSelfAct :: forall {k} (a :: k) (b :: k). (SelfAction k, Ob a, Ob b) => Act a b ~> (a ** b) Source Github #

composeActs :: forall {m} {k} (x :: m) (y :: m) (c :: k) (a :: k) (b :: k). (MonoidalAction m k, Ob x, Ob y, Ob c) => (a ~> Act x b) -> (b ~> Act y c) -> a ~> Act (x ** y) c Source Github #

decomposeActs :: forall {m} {k} (x :: m) (y :: m) (c :: k) (a :: k) (b :: k). (MonoidalAction m k, Ob x, Ob y, Ob c) => (Act y c ~> b) -> (Act x b ~> a) -> Act (x ** y) c ~> a Source Github #

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

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

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

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

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

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

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

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

strongPar0 :: forall {k} {p} (a :: k). (SelfAction k, Strong k p, MonoidalProfunctor p, Ob a) => p a a Source Github #

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

Methods

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

Instances

Instances details

Costrong 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 a x) (Act a y) -> ZX x y Source Github #
Costrong KIND Cat Source Github #
Instance details Defined in Proarrow.Category.Instance.Cat Methods coact :: forall (a :: KIND) (x :: KIND) (y :: KIND). (Ob a, Ob x, Ob y) => Cat (Act a x) (Act a y) -> Cat x y Source Github #
Costrong 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 a x) (Act a y) -> FinRel x y Source Github #
Costrong DOT 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 a x) (Act a y) -> Dot x y Source Github #
MonadFix m => Costrong Type (Kleisli m :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Arrow Methods coact :: (Ob a, Ob x, Ob y) => Kleisli m (Act a x) (Act a y) -> Kleisli m x y Source Github #
ArrowLoop arr => Costrong Type (Arr arr :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Arrow Methods coact :: (Ob a, Ob x, Ob y) => Arr arr (Act a x) (Act a y) -> Arr arr x y Source Github #
ProdAction k => Costrong k (Fold :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Fold Methods coact :: forall (a :: k) (x :: k) (y :: k). (Ob a, Ob x, Ob y) => Fold (Act a x) (Act a y) -> Fold x y Source Github #
(MonoidalAction m k, Costrong m (Hom k)) => Costrong m (Id :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Identity Methods coact :: forall (a :: m) (x :: k) (y :: k). (Ob a, Ob x, Ob y) => Id (Act a x) (Act a y) -> Id x y Source Github #
Costrong Type (->) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods coact :: (Ob a, Ob x, Ob y) => (Act a x -> Act a y) -> x -> y Source Github #
Strong m p => Costrong m (Re p s t :: d -> c -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Optic Methods coact :: forall (a :: m) (x :: d) (y :: c). (Ob a, Ob x, Ob y) => Re p s t (Act a x) (Act a y) -> Re p s t x y Source Github #
Costrong (COPROD LINEAR) 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 a x) (Act a y) -> Linear x y Source Github #
Costrong (COPROD Type) (Id :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Object.BinaryCoproduct Methods coact :: forall (a :: COPROD Type) x y. (Ob a, Ob x, Ob y) => Id (Act a x) (Act a y) -> Id x y Source Github #
Num a => Costrong (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 a0 x) (Act a0 y) -> Mat x y Source Github #

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

class (SelfAction k, Costrong k (Hom k)) => TracedMonoidal k Source Github #

Instances

Instances details

(SelfAction k, Costrong k (Hom k)) => TracedMonoidal k Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Action