Safe Haskell	None
Language	GHC2024

Proarrow.Profunctor.Product

Documentation

data ((p :: j +-> k) :*: (q :: j +-> k)) (a :: k) (b :: j) where Source Github #

Constructors

(:*:)
Fields :: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) (q :: j +-> k). { fstP :: p a b , sndP :: q a b } -> (p :*: q) a b

Instances

Instances details

(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 #
(ThinProfunctor p, ThinProfunctor q) => ThinProfunctor (p :*: q :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Product Methods arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow (p :: q) a b) => (p :: q) a b Source Github # withArr :: forall (a :: k) (b :: j) r. (p :: q) a b -> (HasArrow (p :: q) a b => r) -> r Source Github #
(MonoidalProfunctor p, MonoidalProfunctor q) => MonoidalProfunctor (p :*: q :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Product Methods par0 :: (p :: q) (Unit :: k) (Unit :: j) Source Github # par :: forall (x1 :: k) (x2 :: j) (y1 :: k) (y2 :: j). (p :: q) x1 x2 -> (p :: q) y1 y2 -> (p :: q) (x1 y1) (x2 y2) Source Github #
(Profunctor p, Profunctor q) => Profunctor (p :*: q :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Product Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> (p :: q) a b -> (p :: q) c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> (p :: q) a b -> (p :: q) c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> (p :: q) a b -> (p :: q) a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> (p :*: q) a b -> r Source Github #
(HasBinaryCoproducts j, Corepresentable p, Corepresentable q) => Corepresentable (p :*: q :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Object.BinaryCoproduct Methods coindex :: forall (a :: k) (b :: j). (p :: q) a b -> ((p :: q) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => (((p :: q) %% a) ~> b) -> (p :: q) a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> ((p :: q) %% a) ~> ((p :: q) %% b) Source Github # trivialCorep :: forall (a :: k). Ob a => (p :: q) a ((p :: q) %% a) Source Github #
(HasBinaryProducts k, Representable p, Representable q) => Representable (p :*: q :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods index :: forall (a :: k) (b :: j). (p :: q) a b -> a ~> ((p :: q) % b) Source Github # tabulate :: forall (b :: j) (a :: k). Ob b => (a ~> ((p :: q) % b)) -> (p :: q) a b Source Github # repMap :: forall (a :: j) (b :: j). (a ~> b) -> ((p :: q) % a) ~> ((p :: q) % b) Source Github # trivialRep :: forall (a :: j). Ob a => (p :: q) ((p :: q) % a) a Source Github #
(DaggerProfunctor p, DaggerProfunctor q) => DaggerProfunctor (p :*: q :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Product Methods dagger :: forall (a :: k) (b :: k). (p :: q) a b -> (p :: q) b a Source Github #
(HasBinaryCoproducts k, Cotraversable p, Cotraversable q) => Cotraversable (p :*: q :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Distributive Methods cotraverse :: forall (p0 :: k +-> k). StrongDistributiveProfunctor p0 => (p0 :.: (p :: q)) :~> ((p :: q) :.: p0) Source Github #
(Cartesian k, Traversable p, Traversable q) => Traversable (p :*: q :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Distributive Methods traverse :: forall (p0 :: k +-> k). StrongDistributiveProfunctor p0 => ((p :: q) :.: p0) :~> (p0 :.: (p :: q)) Source Github #
Profunctor p => Functor ((:*:) p :: (j +-> k) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Product Methods map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> (p :: a) ~> (p :: b) Source Github #
Profunctor p => Promonad (Costar ((:*:) p) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Costar Methods id :: forall (a :: j +-> k). Ob a => Costar ((::) p) a a Source Github # (.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Costar ((::) p) b c -> Costar ((::) p) a b -> Costar ((::) p) a c Source Github #
type (p :*: q :: k -> j -> Type) %% (a :: k) Source Github #
Instance details Defined in Proarrow.Object.BinaryCoproduct type (p :*: q :: k -> j -> Type) %% (a :: k) = (p %% a) \|\| (q %% a)
type (p :*: q :: k -> j -> Type) % (a :: j) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct type (p :*: q :: k -> j -> Type) % (a :: j) = (p % a) && (q % a)
type HasArrow (p :*: q :: k -> j -> Type) (a :: k) (b :: j) Source Github #
Instance details Defined in Proarrow.Profunctor.Product type HasArrow (p :*: q :: k -> j -> Type) (a :: k) (b :: j) = (HasArrow p a b, HasArrow q a b)

prod :: forall {k} {j} (r :: k -> j -> Type) (p :: k -> j -> Type) (q :: k -> j -> Type). (r :~> p) -> (r :~> q) -> r :~> (p :*: q) Source Github #