Safe Haskell	None
Language	GHC2024

Proarrow.Object.BinaryProduct

Contents

Orphan instances

Synopsis

class CategoryOf k => HasBinaryProducts k where
- type (a :: k) && (b :: k) :: k
- withObProd :: forall (a :: k) (b :: k) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r
- fst :: forall (a :: k) (b :: k). (Ob a, Ob b) => (a && b) ~> a
- snd :: forall (a :: k) (b :: k). (Ob a, Ob b) => (a && b) ~> b
- (&&&) :: forall (a :: k) (x :: k) (y :: k). (a ~> x) -> (a ~> y) -> a ~> (x && y)
- (***) :: forall (a :: k) (b :: k) (x :: k) (y :: k). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y)
fst' :: forall {k} (a :: k) (a' :: k) (b :: k). HasBinaryProducts k => (a ~> a') -> Obj b -> (a && b) ~> a'
snd' :: forall {k} (a :: k) (b :: k) (b' :: k). HasBinaryProducts k => Obj a -> (b ~> b') -> (a && b) ~> b'
first :: forall {k} (c :: k) (a :: k) (b :: k). (HasBinaryProducts k, Ob c) => (a ~> b) -> (a && c) ~> (b && c)
second :: forall {k} (c :: k) (a :: k) (b :: k). (HasBinaryProducts k, Ob c) => (a ~> b) -> (c && a) ~> (c && b)
diag :: forall {k} (a :: k). (HasBinaryProducts k, Ob a) => a ~> (a && a)
type HasProducts k = (HasTerminalObject k, HasBinaryProducts k)
class (a ** b) ~ (a && b) => TensorIsProduct (a :: k) (b :: k)
class (HasProducts k, SymMonoidal k, Semicartesian k, forall (a :: k) (b :: k). TensorIsProduct a b) => Cartesian k
leftUnitorProd :: forall {k} (a :: k). (HasProducts k, Ob a) => ((TerminalObject :: k) && a) ~> a
leftUnitorProdInv :: forall {k} (a :: k). (HasProducts k, Ob a) => a ~> ((TerminalObject :: k) && a)
rightUnitorProd :: forall {k} (a :: k). (HasProducts k, Ob a) => (a && (TerminalObject :: k)) ~> a
rightUnitorProdInv :: forall {k} (a :: k). (HasProducts k, Ob a) => a ~> (a && (TerminalObject :: k))
associatorProd :: forall {k} (a :: k) (b :: k) (c :: k). (HasProducts k, Ob a, Ob b, Ob c) => ((a && b) && c) ~> (a && (b && c))
associatorProdInv :: forall {k} (a :: k) (b :: k) (c :: k). (HasProducts k, Ob a, Ob b, Ob c) => (a && (b && c)) ~> ((a && b) && c)
swapProd' :: forall k (a :: k) (a' :: k) (b :: k) (b' :: k). HasBinaryProducts k => (a ~> a') -> (b ~> b') -> (a && b) ~> (b' && a')
swapProd :: forall {k} (a :: k) (b :: k). (HasBinaryProducts k, Ob a, Ob b) => (a && b) ~> (b && a)
newtype PROD k = PR k
data Prod (p :: j +-> k) (a :: PROD k) (b :: PROD j) where
- Prod :: forall {j} {k} (p :: j +-> k) (a1 :: k) (b1 :: j). {..} -> Prod p ('PR a1) ('PR b1)
class Act a b ~ (a && b) => ActIsProd (a :: k) (b :: k)
class Act a (Act b c) ~ (a && (b && c)) => ActIsProd3 (a :: k) (b :: k) (c :: k)
class (Cartesian k, SelfAction k, forall (a :: k) (b :: k). ActIsProd a b, forall (a :: k) (b :: k) (c :: k). ActIsProd3 a b c) => ProdAction k
class (Strong k p, ProdAction k) => StrongProd (p :: CAT k)
data family (a :: k) *! (b :: k) :: k

Documentation

class CategoryOf k => HasBinaryProducts k where Source Github #

Minimal complete definition

withObProd, fst, snd, (&&&)

Associated Types

type (a :: k) && (b :: k) :: k infixl 5 Source Github #

Methods

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

fst :: forall (a :: k) (b :: k). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: k) (b :: k). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: k) (x :: k) (y :: k). (a ~> x) -> (a ~> y) -> a ~> (x && y) infixl 5 Source Github #

(***) :: forall (a :: k) (b :: k) (x :: k) (y :: k). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) infixl 5 Source Github #

Instances

Instances details

HasBinaryProducts BOOL Source Github #

Instance details

Defined in Proarrow.Category.Instance.Bool

Associated Types

type 'FLS && (b :: BOOL)
Instance details Defined in Proarrow.Category.Instance.Bool type 'FLS && (b :: BOOL) = 'FLS
type 'TRU && (b :: BOOL)
Instance details Defined in Proarrow.Category.Instance.Bool type 'TRU && (b :: BOOL) = b
type (a :: BOOL) && 'FLS
Instance details Defined in Proarrow.Category.Instance.Bool type (a :: BOOL) && 'FLS = 'FLS
type (a :: BOOL) && 'TRU
Instance details Defined in Proarrow.Category.Instance.Bool type (a :: BOOL) && 'TRU = a

Methods

withObProd :: forall (a :: BOOL) (b :: BOOL) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: BOOL) (b :: BOOL). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: BOOL) (b :: BOOL). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: BOOL) (x :: BOOL) (y :: BOOL). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: BOOL) (b :: BOOL) (x :: BOOL) (y :: BOOL). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts KIND Source Github #

Instance details

Defined in Proarrow.Category.Instance.Cat

Associated Types

type ('K l :: KIND) && ('K r :: KIND)
Instance details Defined in Proarrow.Category.Instance.Cat type ('K l :: KIND) && ('K r :: KIND) = 'K (l, r)

Methods

withObProd :: forall (a :: KIND) (b :: KIND) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: KIND) (b :: KIND). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: KIND) (b :: KIND). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: KIND) (x :: KIND) (y :: KIND). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: KIND) (b :: KIND) (x :: KIND) (y :: KIND). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts CONSTRAINT Source Github #

Instance details

Defined in Proarrow.Category.Instance.Constraint

Associated Types

type ('CNSTRNT l :: CONSTRAINT) && ('CNSTRNT r :: CONSTRAINT)
Instance details Defined in Proarrow.Category.Instance.Constraint type ('CNSTRNT l :: CONSTRAINT) && ('CNSTRNT r :: CONSTRAINT) = 'CNSTRNT (l, r)

Methods

withObProd :: forall (a :: CONSTRAINT) (b :: CONSTRAINT) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: CONSTRAINT) (b :: CONSTRAINT). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: CONSTRAINT) (b :: CONSTRAINT). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: CONSTRAINT) (x :: CONSTRAINT) (y :: CONSTRAINT). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: CONSTRAINT) (b :: CONSTRAINT) (x :: CONSTRAINT) (y :: CONSTRAINT). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts COST Source Github #

Instance details

Defined in Proarrow.Category.Instance.Cost

Associated Types

type ('C a :: COST) && ('C b :: COST)
Instance details Defined in Proarrow.Category.Instance.Cost type ('C a :: COST) && ('C b :: COST) = 'C (Max 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

withObProd :: forall (a :: COST) (b :: COST) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: COST) (b :: COST). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: COST) (b :: COST). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: COST) (x :: COST) (y :: COST). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: COST) (b :: COST) (x :: COST) (y :: COST). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts FINREL Source Github #

Instance details

Defined in Proarrow.Category.Instance.FinRel

Associated Types

type (a :: FINREL) && (b :: FINREL)
Instance details Defined in Proarrow.Category.Instance.FinRel type (a :: FINREL) && (b :: FINREL) = 'FR (Plus (UN 'FR a) (UN 'FR b))

Methods

withObProd :: forall (a :: FINREL) (b :: FINREL) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: FINREL) (b :: FINREL). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: FINREL) (b :: FINREL). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: FINREL) (x :: FINREL) (y :: FINREL). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: FINREL) (b :: FINREL) (x :: FINREL) (y :: FINREL). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts FINSET Source Github #

Instance details

Defined in Proarrow.Category.Instance.FinSet

Associated Types

type (a :: FINSET) && (b :: FINSET)
Instance details Defined in Proarrow.Category.Instance.FinSet type (a :: FINSET) && (b :: FINSET) = 'FS (Mult (UN 'FS a) (UN 'FS b))

Methods

withObProd :: forall (a :: FINSET) (b :: FINSET) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: FINSET) (b :: FINSET). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: FINSET) (b :: FINSET). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: FINSET) (x :: FINSET) (y :: FINSET). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: FINSET) (b :: FINSET) (x :: FINSET) (y :: FINSET). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts LINEAR Source Github #

Instance details

Defined in Proarrow.Category.Instance.Linear

Associated Types

type ('L a :: LINEAR) && ('L b :: LINEAR)
Instance details Defined in Proarrow.Category.Instance.Linear type ('L a :: LINEAR) && ('L b :: LINEAR) = 'L (With a b)

Methods

withObProd :: forall (a :: LINEAR) (b :: LINEAR) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: LINEAR) (b :: LINEAR). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: LINEAR) (b :: LINEAR). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: LINEAR) (x :: LINEAR) (y :: LINEAR). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: LINEAR) (b :: LINEAR) (x :: LINEAR) (y :: LINEAR). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts POINTED Source Github #

Instance details

Defined in Proarrow.Category.Instance.PointedHask

Associated Types

type ('P a :: POINTED) && ('P b :: POINTED)
Instance details Defined in Proarrow.Category.Instance.PointedHask type ('P a :: POINTED) && ('P b :: POINTED) = 'P (These a b)

Methods

withObProd :: forall (a :: POINTED) (b :: POINTED) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: POINTED) (b :: POINTED). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: POINTED) (b :: POINTED). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: POINTED) (x :: POINTED) (y :: POINTED). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: POINTED) (b :: POINTED) (x :: POINTED) (y :: POINTED). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts () Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Associated Types

type '() && '()
Instance details Defined in Proarrow.Object.BinaryProduct type '() && '() = '()

Methods

withObProd :: forall (a :: ()) (b :: ()) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: ()) (b :: ()). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: ()) (b :: ()). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: ()) (x :: ()) (y :: ()). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: ()) (b :: ()) (x :: ()) (y :: ()). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts Type Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Associated Types

type (a :: Type) && (b :: Type)
Instance details Defined in Proarrow.Object.BinaryProduct type (a :: Type) && (b :: Type) = (a, b)

Methods

withObProd :: (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall a b x y. (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts k => HasBinaryProducts (FAM k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Fam

Methods

withObProd :: forall (a :: FAM k) (b :: FAM k) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: FAM k) (b :: FAM k). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: FAM k) (b :: FAM k). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: FAM k) (x :: FAM k) (y :: FAM k). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: FAM k) (b :: FAM k) (x :: FAM k) (y :: FAM k). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts (FIN ('S n)) => HasBinaryProducts (FIN ('S ('S n))) Source Github #

Minimum

Instance details

Defined in Proarrow.Category.Instance.Fin

Methods

withObProd :: forall (a :: FIN ('S ('S n))) (b :: FIN ('S ('S n))) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: FIN ('S ('S n))) (b :: FIN ('S ('S n))). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: FIN ('S ('S n))) (b :: FIN ('S ('S n))). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: FIN ('S ('S n))) (x :: FIN ('S ('S n))) (y :: FIN ('S ('S n))). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: FIN ('S ('S n))) (b :: FIN ('S ('S n))) (x :: FIN ('S ('S n))) (y :: FIN ('S ('S n))). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts (FIN ('S 'Z)) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Fin

Associated Types

type ('FZ :: FIN ('S 'Z)) && ('FZ :: FIN ('S 'Z))
Instance details Defined in Proarrow.Category.Instance.Fin type ('FZ :: FIN ('S 'Z)) && ('FZ :: FIN ('S 'Z)) = 'FZ :: FIN ('S 'Z)

Methods

withObProd :: forall (a :: FIN ('S 'Z)) (b :: FIN ('S 'Z)) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: FIN ('S 'Z)) (b :: FIN ('S 'Z)). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: FIN ('S 'Z)) (b :: FIN ('S 'Z)). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: FIN ('S 'Z)) (x :: FIN ('S 'Z)) (y :: FIN ('S 'Z)). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: FIN ('S 'Z)) (b :: FIN ('S 'Z)) (x :: FIN ('S 'Z)) (y :: FIN ('S 'Z)). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts (FIN 'Z) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Fin

Associated Types

type (a :: FIN 'Z) && (b :: FIN 'Z)
Instance details Defined in Proarrow.Category.Instance.Fin type (a :: FIN 'Z) && (b :: FIN 'Z) = a

Methods

withObProd :: forall (a :: FIN 'Z) (b :: FIN 'Z) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: FIN 'Z) (b :: FIN 'Z). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: FIN 'Z) (b :: FIN 'Z). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: FIN 'Z) (x :: FIN 'Z) (y :: FIN 'Z). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: FIN 'Z) (b :: FIN 'Z) (x :: FIN 'Z) (y :: FIN 'Z). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

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

Instance details

Defined in Proarrow.Category.Instance.Mat

Methods

withObProd :: forall (a0 :: MatK a) (b :: MatK a) r. (Ob a0, Ob b) => (Ob (a0 && b) => r) -> r Source Github #

fst :: forall (a0 :: MatK a) (b :: MatK a). (Ob a0, Ob b) => (a0 && b) ~> a0 Source Github #

snd :: forall (a0 :: MatK a) (b :: MatK a). (Ob a0, Ob b) => (a0 && b) ~> b Source Github #

(&&&) :: forall (a0 :: MatK a) (x :: MatK a) (y :: MatK a). (a0 ~> x) -> (a0 ~> y) -> a0 ~> (x && y) Source Github #

(***) :: forall (a0 :: MatK a) (b :: MatK a) (x :: MatK a) (y :: MatK a). (a0 ~> x) -> (b ~> y) -> (a0 && b) ~> (x && y) Source Github #

HasBinaryCoproducts k => HasBinaryProducts (OPPOSITE k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryCoproduct

Methods

withObProd :: forall (a :: OPPOSITE k) (b :: OPPOSITE k) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: OPPOSITE k) (b :: OPPOSITE k). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: OPPOSITE k) (b :: OPPOSITE k). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: OPPOSITE k) (x :: OPPOSITE k) (y :: OPPOSITE k). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: OPPOSITE k) (b :: OPPOSITE k) (x :: OPPOSITE k) (y :: OPPOSITE k). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts k => HasBinaryProducts (PROD k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Methods

withObProd :: forall (a :: PROD k) (b :: PROD k) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: PROD k) (b :: PROD k). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: PROD k) (b :: PROD k). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: PROD k) (x :: PROD k) (y :: PROD k). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: PROD k) (b :: PROD k) (x :: PROD k) (y :: PROD k). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

(Applicative f, HasBinaryProducts k) => HasBinaryProducts (AP f k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Ap

Methods

withObProd :: forall (a :: AP f k) (b :: AP f k) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: AP f k) (b :: AP f k). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: AP f k) (b :: AP f k). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: AP f k) (x :: AP f k) (y :: AP f k). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: AP f k) (b :: AP f k) (x :: AP f k) (y :: AP f k). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

(Cartesian k, Promonad p, MonoidalProfunctor p) => HasBinaryProducts (KLEISLI p) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Kleisli

Methods

withObProd :: forall (a :: KLEISLI p) (b :: KLEISLI p) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: KLEISLI p) (b :: KLEISLI p). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: KLEISLI p) (b :: KLEISLI p). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: KLEISLI p) (x :: KLEISLI p) (y :: KLEISLI p). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: KLEISLI p) (b :: KLEISLI p) (x :: KLEISLI p) (y :: KLEISLI p). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

(CategoryOf j, CategoryOf k) => HasBinaryProducts (j +-> k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Methods

withObProd :: forall (a :: j +-> k) (b :: j +-> k) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: j +-> k) (b :: j +-> k). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: j +-> k) (b :: j +-> k). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: j +-> k) (x :: j +-> k) (y :: j +-> k). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: j +-> k) (b :: j +-> k) (x :: j +-> k) (y :: j +-> k). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

Monoid m => HasBinaryProducts (MONOIDK m) Source Github #

Instance details

Defined in Proarrow.Monoid

Methods

withObProd :: forall (a :: MONOIDK m) (b :: MONOIDK m) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: MONOIDK m) (b :: MONOIDK m). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: MONOIDK m) (b :: MONOIDK m). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: MONOIDK m) (x :: MONOIDK m) (y :: MONOIDK m). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: MONOIDK m) (b :: MONOIDK m) (x :: MONOIDK m) (y :: MONOIDK m). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

(HasBinaryProducts j, HasBinaryProducts k) => HasBinaryProducts (j, k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Methods

withObProd :: forall (a :: (j, k)) (b :: (j, k)) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: (j, k)) (b :: (j, k)). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: (j, k)) (b :: (j, k)). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: (j, k)) (x :: (j, k)) (y :: (j, k)). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: (j, k)) (b :: (j, k)) (x :: (j, k)) (y :: (j, k)). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

HasBinaryProducts (k1 -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

Methods

withObProd :: forall (a :: k1 -> Type) (b :: k1 -> Type) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: k1 -> Type) (b :: k1 -> Type). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: k1 -> Type) (b :: k1 -> Type). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: k1 -> Type) (x :: k1 -> Type) (y :: k1 -> Type). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: k1 -> Type) (b :: k1 -> Type) (x :: k1 -> Type) (y :: k1 -> Type). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

(Ok cs p, Elem HasBinaryProducts cs) => HasBinaryProducts (FREE cs p) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Methods

withObProd :: forall (a :: FREE cs p) (b :: FREE cs p) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: FREE cs p) (b :: FREE cs p). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: FREE cs p) (b :: FREE cs p). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: FREE cs p) (x :: FREE cs p) (y :: FREE cs p). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: FREE cs p) (b :: FREE cs p) (x :: FREE cs p) (y :: FREE cs p). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

fst' :: forall {k} (a :: k) (a' :: k) (b :: k). HasBinaryProducts k => (a ~> a') -> Obj b -> (a && b) ~> a' Source Github #

snd' :: forall {k} (a :: k) (b :: k) (b' :: k). HasBinaryProducts k => Obj a -> (b ~> b') -> (a && b) ~> b' Source Github #

first :: forall {k} (c :: k) (a :: k) (b :: k). (HasBinaryProducts k, Ob c) => (a ~> b) -> (a && c) ~> (b && c) Source Github #

second :: forall {k} (c :: k) (a :: k) (b :: k). (HasBinaryProducts k, Ob c) => (a ~> b) -> (c && a) ~> (c && b) Source Github #

diag :: forall {k} (a :: k). (HasBinaryProducts k, Ob a) => a ~> (a && a) Source Github #

type HasProducts k = (HasTerminalObject k, HasBinaryProducts k) Source Github #

class (a ** b) ~ (a && b) => TensorIsProduct (a :: k) (b :: k) Source Github #

Instances

Instances details

(a ** b) ~ (a && b) => TensorIsProduct (a :: k) (b :: k) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct

class (HasProducts k, SymMonoidal k, Semicartesian k, forall (a :: k) (b :: k). TensorIsProduct a b) => Cartesian k Source Github #

Instances

Instances details

(HasProducts k, SymMonoidal k, Semicartesian k, forall (a :: k) (b :: k). TensorIsProduct a b) => Cartesian k Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct

leftUnitorProd :: forall {k} (a :: k). (HasProducts k, Ob a) => ((TerminalObject :: k) && a) ~> a Source Github #

leftUnitorProdInv :: forall {k} (a :: k). (HasProducts k, Ob a) => a ~> ((TerminalObject :: k) && a) Source Github #

rightUnitorProd :: forall {k} (a :: k). (HasProducts k, Ob a) => (a && (TerminalObject :: k)) ~> a Source Github #

rightUnitorProdInv :: forall {k} (a :: k). (HasProducts k, Ob a) => a ~> (a && (TerminalObject :: k)) Source Github #

associatorProd :: forall {k} (a :: k) (b :: k) (c :: k). (HasProducts k, Ob a, Ob b, Ob c) => ((a && b) && c) ~> (a && (b && c)) Source Github #

associatorProdInv :: forall {k} (a :: k) (b :: k) (c :: k). (HasProducts k, Ob a, Ob b, Ob c) => (a && (b && c)) ~> ((a && b) && c) Source Github #

swapProd' :: forall k (a :: k) (a' :: k) (b :: k) (b' :: k). HasBinaryProducts k => (a ~> a') -> (b ~> b') -> (a && b) ~> (b' && a') Source Github #

swapProd :: forall {k} (a :: k) (b :: k). (HasBinaryProducts k, Ob a, Ob b) => (a && b) ~> (b && a) Source Github #

newtype PROD k Source Github #

Constructors

PR k

Instances

Instances details

CategoryOf k => Functor ('PR :: k -> PROD k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Methods

map :: forall (a :: k) (b :: k). (a ~> b) -> 'PR a ~> 'PR b Source Github #

HasProducts k => Monoidal (PROD k) Source Github #

Products as monoidal structure.

Instance details

Defined in Proarrow.Object.BinaryProduct

Associated Types

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

HasProducts k => SymMonoidal (PROD k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Methods

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

HasProducts k => CopyDiscard (PROD k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.CopyDiscard

Methods

copy :: forall (a :: PROD k). Ob a => a ~> (a ** a) Source Github #

discard :: forall (a :: PROD k). Ob a => a ~> (Unit :: PROD k) Source Github #

BiCCC k => Distributive (PROD k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Distributive

Methods

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

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

distL0 :: forall (a :: PROD k). Ob a => (a ** (InitialObject :: PROD k)) ~> (InitialObject :: PROD k) Source Github #

distR0 :: forall (a :: PROD k). Ob a => ((InitialObject :: PROD k) ** a) ~> (InitialObject :: PROD k) Source Github #

CategoryOf k => CategoryOf (PROD k) Source Github #

The same category as the category of k, but with products as the tensor.

Instance details

Defined in Proarrow.Object.BinaryProduct

Associated Types

type (~>)
Instance details Defined in Proarrow.Object.BinaryProduct type (~>) = Prod ((~>) :: CAT k)

HasBinaryCoproducts k => HasBinaryCoproducts (PROD k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryCoproduct

Methods

withObCoprod :: forall (a :: PROD k) (b :: PROD k) r. (Ob a, Ob b) => (Ob (a || b) => r) -> r Source Github #

lft :: forall (a :: PROD k) (b :: PROD k). (Ob a, Ob b) => a ~> (a || b) Source Github #

rgt :: forall (a :: PROD k) (b :: PROD k). (Ob a, Ob b) => b ~> (a || b) Source Github #

(|||) :: forall (x :: PROD k) (a :: PROD k) (y :: PROD k). (x ~> a) -> (y ~> a) -> (x || y) ~> a Source Github #

(+++) :: forall (a :: PROD k) (b :: PROD k) (x :: PROD k) (y :: PROD k). (a ~> x) -> (b ~> y) -> (a || b) ~> (x || y) Source Github #

HasBinaryProducts k => HasBinaryProducts (PROD k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Methods

withObProd :: forall (a :: PROD k) (b :: PROD k) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: PROD k) (b :: PROD k). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: PROD k) (b :: PROD k). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: PROD k) (x :: PROD k) (y :: PROD k). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: PROD k) (b :: PROD k) (x :: PROD k) (y :: PROD k). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

(CategoryOf j, CategoryOf k) => Closed (PROD (j +-> k)) Source Github #

Instance details

Defined in Proarrow.Profunctor.Exponential

Methods

withObExp :: forall (a :: PROD (j +-> k)) (b :: PROD (j +-> k)) r. (Ob a, Ob b) => (Ob (a ~~> b) => r) -> r Source Github #

curry :: forall (a :: PROD (j +-> k)) (b :: PROD (j +-> k)) (c :: PROD (j +-> k)). (Ob a, Ob b) => ((a ** b) ~> c) -> a ~> (b ~~> c) Source Github #

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

(^^^) :: forall (a :: PROD (j +-> k)) (b :: PROD (j +-> k)) (x :: PROD (j +-> k)) (y :: PROD (j +-> k)). (b ~> y) -> (x ~> a) -> (a ~~> b) ~> (x ~~> y) Source Github #

CategoryOf k1 => Closed (PROD (k1 -> Type)) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

Methods

withObExp :: forall (a :: PROD (k1 -> Type)) (b :: PROD (k1 -> Type)) r. (Ob a, Ob b) => (Ob (a ~~> b) => r) -> r Source Github #

curry :: forall (a :: PROD (k1 -> Type)) (b :: PROD (k1 -> Type)) (c :: PROD (k1 -> Type)). (Ob a, Ob b) => ((a ** b) ~> c) -> a ~> (b ~~> c) Source Github #

apply :: forall (a :: PROD (k1 -> Type)) (b :: PROD (k1 -> Type)). (Ob a, Ob b) => ((a ~~> b) ** a) ~> b Source Github #

(^^^) :: forall (a :: PROD (k1 -> Type)) (b :: PROD (k1 -> Type)) (x :: PROD (k1 -> Type)) (y :: PROD (k1 -> Type)). (b ~> y) -> (x ~> a) -> (a ~~> b) ~> (x ~~> y) Source Github #

HasInitialObject k => HasInitialObject (PROD k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Associated Types

type InitialObject
Instance details Defined in Proarrow.Object.BinaryProduct type InitialObject = 'PR (InitialObject :: k)

Methods

initiate :: forall (a :: PROD k). Ob a => (InitialObject :: PROD k) ~> a Source Github #

HasTerminalObject k => HasTerminalObject (PROD k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Associated Types

type TerminalObject
Instance details Defined in Proarrow.Object.BinaryProduct type TerminalObject = 'PR (TerminalObject :: k)

Methods

terminate :: forall (a :: PROD k). Ob a => a ~> (TerminalObject :: PROD k) Source Github #

(HasProducts k, Strong (PROD k) ((~>) :: CAT 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 #

HasProducts k => MonoidalProfunctor (Cone :: PROD k -> LIST k -> Type) Source Github #

Instance details

Defined in Proarrow.Object.Pullback

Methods

par0 :: Cone (Unit :: PROD k) (Unit :: LIST k) Source Github #

par :: 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 #

CategoryOf k => Profunctor (Cone :: PROD k -> LIST k -> Type) Source Github #

Instance details

Defined in Proarrow.Object.Pullback

Methods

dimap :: forall (c :: PROD k) (a :: PROD k) (b :: LIST k) (d :: LIST k). (c ~> a) -> (b ~> d) -> Cone a b -> Cone c d Source Github #

(\\) :: forall (a :: PROD k) (b :: LIST k) r. ((Ob a, Ob b) => r) -> Cone a b -> r Source Github #

(HasProducts k, cat ~ Hom k) => MonoidalProfunctor (Prod cat :: PROD k -> PROD k -> Type) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Methods

par0 :: Prod cat (Unit :: PROD k) (Unit :: PROD k) Source Github #

par :: 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 => Profunctor (Prod p :: PROD k -> PROD j -> Type) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Methods

dimap :: forall (c :: PROD k) (a :: PROD k) (b :: PROD j) (d :: PROD j). (c ~> a) -> (b ~> d) -> Prod p a b -> Prod p c d Source Github #

(\\) :: forall (a :: PROD k) (b :: PROD j) r. ((Ob a, Ob b) => r) -> Prod p a b -> r Source Github #

Representable p => Representable (Prod p :: PROD k -> PROD j -> Type) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Methods

index :: forall (a :: PROD k) (b :: PROD j). Prod p a b -> a ~> (Prod p % b) Source Github #

tabulate :: forall (b :: PROD j) (a :: PROD k). Ob b => (a ~> (Prod p % b)) -> Prod p a b Source Github #

repMap :: forall (a :: PROD j) (b :: PROD j). (a ~> b) -> (Prod p % a) ~> (Prod p % b) Source Github #

(HasProducts k, Ob a) => Comonoid ('PR a :: PROD k) Source Github #

Instance details

Defined in Proarrow.Monoid

Methods

counit :: 'PR a ~> (Unit :: PROD k) Source Github #

comult :: 'PR a ~> ('PR a ** 'PR a) Source Github #

Promonad p => Promonad (Prod p :: PROD j -> PROD j -> Type) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

Methods

id :: forall (a :: PROD j). Ob a => Prod p a a Source Github #

(.) :: forall (b :: PROD j) (c :: PROD j) (a :: PROD j). Prod p b c -> Prod p a b -> Prod p a c 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 #

type UN ('PR :: j -> PROD j) ('PR k :: PROD j) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

type UN ('PR :: j -> PROD j) ('PR k :: PROD j) = k

type Unit Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

type Unit = TerminalObject :: PROD k

type (~>) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

type (~>) = Prod ((~>) :: CAT k)

type InitialObject Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

type InitialObject = 'PR (InitialObject :: k)

type TerminalObject Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

type TerminalObject = 'PR (TerminalObject :: k)

type Ob (a :: PROD k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

type Ob (a :: PROD k) = (Is ('PR :: k -> PROD k) a, Ob (UN ('PR :: k -> PROD k) a))

type (a :: PROD k) ** (b :: PROD k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

type (a :: PROD k) ** (b :: PROD k) = a && b

type (a :: PROD k) && (b :: PROD k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

type (a :: PROD k) && (b :: PROD k) = 'PR (UN ('PR :: k -> PROD k) a && UN ('PR :: k -> PROD k) b)

type (p :: PROD (k -> j -> Type)) ~~> (q :: PROD (k -> j -> Type)) Source Github #

Instance details

Defined in Proarrow.Profunctor.Exponential

type (p :: PROD (k -> j -> Type)) ~~> (q :: PROD (k -> j -> Type)) = 'PR (UN ('PR :: (k -> j -> Type) -> PROD (k -> j -> Type)) p :~>: UN ('PR :: (k -> j -> Type) -> PROD (k -> j -> Type)) q)

type (f :: PROD (k1 -> Type)) ~~> (g :: PROD (k1 -> Type)) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

type (f :: PROD (k1 -> Type)) ~~> (g :: PROD (k1 -> Type)) = 'PR (UN ('PR :: (k1 -> Type) -> PROD (k1 -> Type)) f :~>: UN ('PR :: (k1 -> Type) -> PROD (k1 -> Type)) g)

type Act ('PR x :: PROD k) (y :: k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

type Act ('PR x :: PROD k) (y :: k) = x && y

type (Prod p :: PROD k -> PROD j -> Type) % ('PR a :: PROD j) Source Github #

Instance details

Defined in Proarrow.Object.BinaryProduct

type (Prod p :: PROD k -> PROD j -> Type) % ('PR a :: PROD j) = 'PR (p % a)

type ('PR a :: PROD k) || ('PR b :: PROD k) Source Github #

Instance details

Defined in Proarrow.Object.BinaryCoproduct

type ('PR a :: PROD k) || ('PR b :: PROD k) = 'PR (a || b)

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

Constructors

Prod
Fields :: forall {j} {k} (p :: j +-> k) (a1 :: k) (b1 :: j). { unProd :: p a1 b1 } -> Prod p ('PR a1) ('PR b1)

Instances

Instances details

(HasProducts k, cat ~ Hom k) => MonoidalProfunctor (Prod cat :: PROD k -> PROD k -> Type) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods par0 :: Prod cat (Unit :: PROD k) (Unit :: PROD k) Source Github # par :: 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 => Profunctor (Prod p :: PROD k -> PROD j -> Type) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods dimap :: forall (c :: PROD k) (a :: PROD k) (b :: PROD j) (d :: PROD j). (c ~> a) -> (b ~> d) -> Prod p a b -> Prod p c d Source Github # (\\) :: forall (a :: PROD k) (b :: PROD j) r. ((Ob a, Ob b) => r) -> Prod p a b -> r Source Github #
Representable p => Representable (Prod p :: PROD k -> PROD j -> Type) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods index :: forall (a :: PROD k) (b :: PROD j). Prod p a b -> a ~> (Prod p % b) Source Github # tabulate :: forall (b :: PROD j) (a :: PROD k). Ob b => (a ~> (Prod p % b)) -> Prod p a b Source Github # repMap :: forall (a :: PROD j) (b :: PROD j). (a ~> b) -> (Prod p % a) ~> (Prod p % b) Source Github #
Promonad p => Promonad (Prod p :: PROD j -> PROD j -> Type) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct Methods id :: forall (a :: PROD j). Ob a => Prod p a a Source Github # (.) :: forall (b :: PROD j) (c :: PROD j) (a :: PROD j). Prod p b c -> Prod p a b -> Prod p a c Source Github #
type (Prod p :: PROD k -> PROD j -> Type) % ('PR a :: PROD j) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct type (Prod p :: PROD k -> PROD j -> Type) % ('PR a :: PROD j) = 'PR (p % a)

class Act a b ~ (a && b) => ActIsProd (a :: k) (b :: k) Source Github #

Products as monoidal structure.

Instances

Instances details

Act a b ~ (a && b) => ActIsProd (a :: k) (b :: k) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct

class Act a (Act b c) ~ (a && (b && c)) => ActIsProd3 (a :: k) (b :: k) (c :: k) Source Github #

Instances

Instances details

Act a (Act b c) ~ (a && (b && c)) => ActIsProd3 (a :: k) (b :: k) (c :: k) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct

class (Cartesian k, SelfAction k, forall (a :: k) (b :: k). ActIsProd a b, forall (a :: k) (b :: k) (c :: k). ActIsProd3 a b c) => ProdAction k Source Github #

Instances

Instances details

(Cartesian k, SelfAction k, forall (a :: k) (b :: k). ActIsProd a b, forall (a :: k) (b :: k) (c :: k). ActIsProd3 a b c) => ProdAction k Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct

class (Strong k p, ProdAction k) => StrongProd (p :: CAT k) Source Github #

Instances

Instances details

(Strong k p, ProdAction k) => StrongProd (p :: k +-> k) Source Github #
Instance details Defined in Proarrow.Object.BinaryProduct

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

Instances

Instances details

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

Orphan instances

Monoidal Type Source Github #

Products as monoidal structure.

Instance details

Associated Types

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

SymMonoidal Type Source Github #

Instance details

Methods

swap :: (Ob a, Ob b) => (a ** b) ~> (b ** a) Source Github #

MonoidalAction Type Type Source Github #

Instance details

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 #

Costrong Type (->) Source Github #

Instance details

Methods

coact :: (Ob a, Ob x, Ob y) => (Act a x -> Act a y) -> x -> y Source Github #

Strong Type (->) Source Github #

Instance details

Methods

act :: (a ~> b) -> (x -> y) -> Act a x -> Act b y Source Github #

MonoidalProfunctor (->) Source Github #

Instance details

Methods

par0 :: (Unit :: Type) -> (Unit :: Type) Source Github #

par :: (x1 -> x2) -> (y1 -> y2) -> (x1 ** y1) -> (x2 ** y2) Source Github #

(HasBinaryProducts k, Representable p, Representable q) => Representable (p :*: q :: k -> j -> Type) Source Github #

Instance details

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 #