Safe Haskell	None
Language	GHC2024

Proarrow.Category.Enriched.Thin

Synopsis

class Profunctor p => ThinProfunctor (p :: j +-> k) where
- type HasArrow (p :: j +-> k) (a :: k) (b :: j)
- arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow p a b) => p a b
- withArr :: forall (a :: k) (b :: j) r. p a b -> ((HasArrow p a b, Ob a, Ob b) => r) -> r
class (ThinProfunctor (Hom k), CategoryOf k) => Thin k
class (ThinProfunctor p, Ob a, Ob b, HasArrow p a b) => HasArrow' (p :: j +-> k) (a :: k) (b :: j) where
- arr' :: p a b
class (ThinProfunctor p, forall (c :: k) (d :: j). (Ob c, Ob d) => HasArrow' p c d, Codiscrete j, Codiscrete k) => CodiscreteProfunctor (p :: j +-> k) where
- anyArr :: forall (a :: k) (b :: j). (Ob a, Ob b) => p a b
type Codiscrete k = CodiscreteProfunctor (Hom k)
class (c => d, d => c) => c <=> d
class (HasArrow p a b => Bottom) => HasNoArrow (p :: j +-> k) (a :: k) (b :: j) where
- arrowIsBottomProof :: HasArrow p a b => r
class (ThinProfunctor p, forall (a :: k) (b :: j). (Ob a, Ob b) => HasNoArrow p a b) => DiscreteProfunctor (p :: j +-> k) where
- exfalso :: forall (a :: k) (b :: j) r. p a b -> r
class HasArrow (Hom k) c d <=> (c ~ d) => ArrowIsId k (c :: k) (d :: k) where
- arrowIsIdProof :: HasArrow (Hom k) c d => (c ~ d => r) -> r
class (Thin k, forall (c :: k) (d :: k). (Ob c, Ob d) => ArrowIsId k c d) => Discrete k where
- withEq :: forall (a :: k) (b :: k) r. (a ~> b) -> (a ~ b => r) -> r

Documentation

class Profunctor p => ThinProfunctor (p :: j +-> k) where Source Github #

Associated Types

type HasArrow (p :: j +-> k) (a :: k) (b :: j) Source Github #

type HasArrow (p :: j +-> k) (a :: k) (b :: j) = ()

Methods

arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow p a b) => p a b Source Github #

withArr :: forall (a :: k) (b :: j) r. p a b -> ((HasArrow p a b, Ob a, Ob b) => r) -> r Source Github #

Instances

Instances details

ThinProfunctor Booleans Source Github #

Instance details

Defined in Proarrow.Category.Instance.Bool

Associated Types

type HasArrow Booleans (a :: BOOL) (b :: BOOL)
Instance details Defined in Proarrow.Category.Instance.Bool type HasArrow Booleans (a :: BOOL) (b :: BOOL) = IsBoolArr a b

Methods

arr :: forall (a :: BOOL) (b :: BOOL). (Ob a, Ob b, HasArrow Booleans a b) => Booleans a b Source Github #

withArr :: forall (a :: BOOL) (b :: BOOL) r. Booleans a b -> ((HasArrow Booleans a b, Ob a, Ob b) => r) -> r Source Github #

ThinProfunctor (:-) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Constraint

Associated Types

type HasArrow (:-) (a :: CONSTRAINT) (b :: CONSTRAINT)
Instance details Defined in Proarrow.Category.Instance.Constraint type HasArrow (:-) (a :: CONSTRAINT) (b :: CONSTRAINT) = UN 'CNSTRNT a :=> UN 'CNSTRNT b

Methods

arr :: forall (a :: CONSTRAINT) (b :: CONSTRAINT). (Ob a, Ob b, HasArrow (:-) a b) => a :- b Source Github #

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

ThinProfunctor GTE Source Github #

Instance details

Defined in Proarrow.Category.Instance.Cost

Associated Types

type HasArrow GTE (a :: COST) (b :: COST)
Instance details Defined in Proarrow.Category.Instance.Cost type HasArrow GTE (a :: COST) (b :: COST) = HasCostArrow a b

Methods

arr :: forall (a :: COST) (b :: COST). (Ob a, Ob b, HasArrow GTE a b) => GTE a b Source Github #

withArr :: forall (a :: COST) (b :: COST) r. GTE a b -> ((HasArrow GTE a b, Ob a, Ob b) => r) -> r Source Github #

ThinProfunctor Zero Source Github #

Instance details

Defined in Proarrow.Category.Enriched.Thin

Associated Types

type HasArrow Zero (a :: VOID) (b :: VOID)
Instance details Defined in Proarrow.Category.Enriched.Thin type HasArrow Zero (a :: VOID) (b :: VOID) = ()

Methods

arr :: forall (a :: VOID) (b :: VOID). (Ob a, Ob b, HasArrow Zero a b) => Zero a b Source Github #

withArr :: forall (a :: VOID) (b :: VOID) r. Zero a b -> ((HasArrow Zero a b, Ob a, Ob b) => r) -> r Source Github #

ThinProfunctor Unit Source Github #

Instance details

Defined in Proarrow.Category.Instance.Unit

Associated Types

type HasArrow Unit (a :: ()) (b :: ())
Instance details Defined in Proarrow.Category.Instance.Unit type HasArrow Unit (a :: ()) (b :: ()) = a ~ b

Methods

arr :: forall (a :: ()) (b :: ()). (Ob a, Ob b, HasArrow Unit a b) => Unit a b Source Github #

withArr :: forall (a :: ()) (b :: ()) r. Unit a b -> ((HasArrow Unit a b, Ob a, Ob b) => r) -> r Source Github #

Thin k => ThinProfunctor (Id :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Identity

Methods

arr :: forall (a :: k) (b :: k). (Ob a, Ob b, HasArrow (Id :: k -> k -> Type) a b) => Id a b Source Github #

withArr :: forall (a :: k) (b :: k) r. Id a b -> ((HasArrow (Id :: k -> k -> Type) a b, Ob a, Ob b) => r) -> r Source Github #

(Thin j, Thin k) => ThinProfunctor (InitialProfunctor :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Initial

Methods

arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow (InitialProfunctor :: k -> j -> Type) a b) => InitialProfunctor a b Source Github #

withArr :: forall (a :: k) (b :: j) r. InitialProfunctor a b -> ((HasArrow (InitialProfunctor :: k -> j -> Type) a b, Ob a, Ob b) => r) -> r Source Github #

(CategoryOf j, CategoryOf k) => ThinProfunctor (TerminalProfunctor :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Terminal

Methods

arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow (TerminalProfunctor :: k -> j -> Type) a b) => TerminalProfunctor a b Source Github #

withArr :: forall (a :: k) (b :: j) r. TerminalProfunctor a b -> ((HasArrow (TerminalProfunctor :: k -> j -> Type) a b, Ob a, Ob b) => r) -> r Source Github #

(Thin j, Thin k, ThinProfunctor p) => ThinProfunctor (UnOp p :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Opposite

Methods

arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow (UnOp p) a b) => UnOp p a b Source Github #

withArr :: forall (a :: k) (b :: j) r. UnOp p a b -> ((HasArrow (UnOp p) a b, Ob a, Ob b) => r) -> r Source Github #

Relation p => ThinProfunctor (Converse p :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Rel

Methods

arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow (Converse p) a b) => Converse p a b Source Github #

withArr :: forall (a :: k) (b :: j) r. Converse p a b -> ((HasArrow (Converse p) a b, Ob a, Ob b) => r) -> r Source Github #

(Functor f, Thin j) => ThinProfunctor (Costar f :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Costar

Methods

arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow (Costar f) a b) => Costar f a b Source Github #

withArr :: forall (a :: k) (b :: j) r. Costar f a b -> ((HasArrow (Costar f) a b, Ob a, Ob b) => r) -> r Source Github #

(Functor f, Thin k) => ThinProfunctor (Star f :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Star

Methods

arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow (Star f) a b) => Star f a b Source Github #

withArr :: forall (a :: k) (b :: j) r. Star f a b -> ((HasArrow (Star f) a b, Ob a, Ob b) => r) -> r Source Github #

(FunctorForRep f, Thin k) => ThinProfunctor (Rep f :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Representable

Methods

arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow (Rep f) a b) => Rep f a b Source Github #

withArr :: forall (a :: k) (b :: j) r. Rep f a b -> ((HasArrow (Rep f) a b, Ob a, Ob b) => r) -> r Source Github #

(Representable p, Thin j) => ThinProfunctor (RepCostar p :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Representable

Methods

arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow (RepCostar p) a b) => RepCostar p a b Source Github #

withArr :: forall (a :: k) (b :: j) r. RepCostar p a b -> ((HasArrow (RepCostar p) a b, Ob a, Ob b) => r) -> r Source Github #

(ThinProfunctor p, ThinProfunctor q, Discrete j, Discrete k) => ThinProfunctor (p :~>: q :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Exponential

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, Ob a, Ob b) => r) -> r Source Github #

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

Instance details

Defined in Proarrow.Profunctor.Instance.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, Ob a, Ob b) => r) -> r Source Github #

(Thin k, FunctorForRep f, FunctorForRep g) => ThinProfunctor (Direp f g :: j -> i -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Direp

Methods

arr :: forall (a :: j) (b :: i). (Ob a, Ob b, HasArrow (Direp f g) a b) => Direp f g a b Source Github #

withArr :: forall (a :: j) (b :: i) r. Direp f g a b -> ((HasArrow (Direp f g) a b, Ob a, Ob b) => r) -> r Source Github #

ThinProfunctor (Codiscrete :: CODISCRETE k -> CODISCRETE k -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Discrete

Methods

arr :: forall (a :: CODISCRETE k) (b :: CODISCRETE k). (Ob a, Ob b, HasArrow (Codiscrete :: CODISCRETE k -> CODISCRETE k -> Type) a b) => Codiscrete a b Source Github #

withArr :: forall (a :: CODISCRETE k) (b :: CODISCRETE k) r. Codiscrete a b -> ((HasArrow (Codiscrete :: CODISCRETE k -> CODISCRETE k -> Type) a b, Ob a, Ob b) => r) -> r Source Github #

ThinProfunctor (Discrete :: DISCRETE k -> DISCRETE k -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Discrete

Methods

arr :: forall (a :: DISCRETE k) (b :: DISCRETE k). (Ob a, Ob b, HasArrow (Discrete :: DISCRETE k -> DISCRETE k -> Type) a b) => Discrete a b Source Github #

withArr :: forall (a :: DISCRETE k) (b :: DISCRETE k) r. Discrete a b -> ((HasArrow (Discrete :: DISCRETE k -> DISCRETE k -> Type) a b, Ob a, Ob b) => r) -> r Source Github #

ThinProfunctor (LTE :: FIN n -> FIN n -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Fin

Methods

arr :: forall (a :: FIN n) (b :: FIN n). (Ob a, Ob b, HasArrow (LTE :: FIN n -> FIN n -> Type) a b) => LTE a b Source Github #

withArr :: forall (a :: FIN n) (b :: FIN n) r. LTE a b -> ((HasArrow (LTE :: FIN n -> FIN n -> Type) a b, Ob a, Ob b) => r) -> r Source Github #

ThinProfunctor p => ThinProfunctor (Op p :: OPPOSITE j -> OPPOSITE k -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Opposite

Methods

arr :: forall (a :: OPPOSITE j) (b :: OPPOSITE k). (Ob a, Ob b, HasArrow (Op p) a b) => Op p a b Source Github #

withArr :: forall (a :: OPPOSITE j) (b :: OPPOSITE k) r. Op p a b -> ((HasArrow (Op p) a b, Ob a, Ob b) => r) -> r Source Github #

(ThinProfunctor p, Promonad p) => ThinProfunctor (Kleisli :: KLEISLI p -> KLEISLI p -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Kleisli

Methods

arr :: forall (a :: KLEISLI p) (b :: KLEISLI p). (Ob a, Ob b, HasArrow (Kleisli :: KLEISLI p -> KLEISLI p -> Type) a b) => Kleisli a b Source Github #

withArr :: forall (a :: KLEISLI p) (b :: KLEISLI p) r. Kleisli a b -> ((HasArrow (Kleisli :: KLEISLI p -> KLEISLI p -> Type) a b, Ob a, Ob b) => r) -> r Source Github #

Thin k => ThinProfunctor (Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) :: SUBCAT (Representable :: (j +-> k) -> Constraint) -> SUBCAT (Representable :: (j +-> k) -> Constraint) -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Rep

Methods

arr :: forall (a :: REPK j k) (b :: REPK j k). (Ob a, Ob b, HasArrow (Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) :: SUBCAT (Representable :: (j +-> k) -> Constraint) -> SUBCAT (Representable :: (j +-> k) -> Constraint) -> Type) a b) => Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) a b Source Github #

withArr :: forall (a :: REPK j k) (b :: REPK j k) r. Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) a b -> ((HasArrow (Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) :: SUBCAT (Representable :: (j +-> k) -> Constraint) -> SUBCAT (Representable :: (j +-> k) -> Constraint) -> Type) a b, Ob a, Ob b) => r) -> r Source Github #

(ThinProfunctor p, ThinProfunctor q) => ThinProfunctor (p :**: q :: (k1, k2) -> (j1, j2) -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Product

Methods

arr :: forall (a :: (k1, k2)) (b :: (j1, j2)). (Ob a, Ob b, HasArrow (p :**: q) a b) => (p :**: q) a b Source Github #

withArr :: forall (a :: (k1, k2)) (b :: (j1, j2)) r. (p :**: q) a b -> ((HasArrow (p :**: q) a b, Ob a, Ob b) => r) -> r Source Github #

(Thin j, Thin k, ThinProfunctor p) => ThinProfunctor (Collage :: COLLAGE p -> COLLAGE p -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Collage

Methods

arr :: forall (a :: COLLAGE p) (b :: COLLAGE p). (Ob a, Ob b, HasArrow (Collage :: COLLAGE p -> COLLAGE p -> Type) a b) => Collage a b Source Github #

withArr :: forall (a :: COLLAGE p) (b :: COLLAGE p) r. Collage a b -> ((HasArrow (Collage :: COLLAGE p -> COLLAGE p -> Type) a b, Ob a, Ob b) => r) -> r Source Github #

class (ThinProfunctor (Hom k), CategoryOf k) => Thin k Source Github #

Instances

Instances details

(ThinProfunctor (Hom k), CategoryOf k) => Thin k Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin

class (ThinProfunctor p, Ob a, Ob b, HasArrow p a b) => HasArrow' (p :: j +-> k) (a :: k) (b :: j) where Source Github #

Methods

arr' :: p a b Source Github #

Instances

Instances details

(ThinProfunctor p, Ob a, Ob b, HasArrow p a b) => HasArrow' (p :: j +-> k) (a :: k) (b :: j) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin Methods arr' :: p a b Source Github #

class (ThinProfunctor p, forall (c :: k) (d :: j). (Ob c, Ob d) => HasArrow' p c d, Codiscrete j, Codiscrete k) => CodiscreteProfunctor (p :: j +-> k) where Source Github #

Methods

anyArr :: forall (a :: k) (b :: j). (Ob a, Ob b) => p a b Source Github #

Instances

Instances details

(ThinProfunctor p, forall (c :: k) (d :: j). (Ob c, Ob d) => HasArrow' p c d, Codiscrete j, Codiscrete k) => CodiscreteProfunctor (p :: j +-> k) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin Methods anyArr :: forall (a :: k) (b :: j). (Ob a, Ob b) => p a b Source Github #

type Codiscrete k = CodiscreteProfunctor (Hom k) Source Github #

class (c => d, d => c) => c <=> d Source Github #

Instances

Instances details

(c => d, d => c) => c <=> d Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin

class (HasArrow p a b => Bottom) => HasNoArrow (p :: j +-> k) (a :: k) (b :: j) where Source Github #

Methods

arrowIsBottomProof :: HasArrow p a b => r Source Github #

Instances

Instances details

(HasArrow p a b => Bottom) => HasNoArrow (p :: j +-> k) (a :: k) (b :: j) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin Methods arrowIsBottomProof :: HasArrow p a b => r Source Github #

class (ThinProfunctor p, forall (a :: k) (b :: j). (Ob a, Ob b) => HasNoArrow p a b) => DiscreteProfunctor (p :: j +-> k) where Source Github #

Methods

exfalso :: forall (a :: k) (b :: j) r. p a b -> r Source Github #

Instances

Instances details

(ThinProfunctor p, forall (a :: k) (b :: j). (Ob a, Ob b) => HasNoArrow p a b) => DiscreteProfunctor (p :: j +-> k) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin Methods exfalso :: forall (a :: k) (b :: j) r. p a b -> r Source Github #

class HasArrow (Hom k) c d <=> (c ~ d) => ArrowIsId k (c :: k) (d :: k) where Source Github #

Methods

arrowIsIdProof :: HasArrow (Hom k) c d => (c ~ d => r) -> r Source Github #

Instances

Instances details

HasArrow (Hom k) c d <=> (c ~ d) => ArrowIsId k (c :: k) (d :: k) Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin Methods arrowIsIdProof :: HasArrow (Hom k) c d => (c ~ d => r) -> r Source Github #

class (Thin k, forall (c :: k) (d :: k). (Ob c, Ob d) => ArrowIsId k c d) => Discrete k where Source Github #

Note: Discrete k is not the same as DiscreteProfunctor (Hom k)!

Methods

withEq :: forall (a :: k) (b :: k) r. (a ~> b) -> (a ~ b => r) -> r Source Github #

Instances

Instances details

(Thin k, forall (c :: k) (d :: k). (Ob c, Ob d) => ArrowIsId k c d) => Discrete k Source Github #
Instance details Defined in Proarrow.Category.Enriched.Thin Methods withEq :: forall (a :: k) (b :: k) r. (a ~> b) -> (a ~ b => r) -> r Source Github #