Safe Haskell	None
Language	GHC2024

Proarrow.Profunctor.Instance.Costar

Description

Costar embeds a functor f as a profunctor with the functor on the source side: Costar f a b = f a ~> b. It is the corepresentable profunctor of f, dual to Star.

Documentation

data Costar' (f :: OPPOSITE (j .-> k)) (a :: j) (b :: k) where Source Github #

Constructors

Costar' :: forall {j} {k} (a :: j) (f1 :: j -> k) (b :: k). Ob a => (f1 a ~> b) -> Costar' ('OP ('NT f1)) a b

Instances

Instances details

Traversable t => Prostrong (KaleidoFl :: (Type +-> Type) -> (Type +-> Type) -> Constraint) (Costar (Prelude t) :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods proact :: forall (f :: Type +-> Type) (g :: Type +-> Type). (KaleidoFl f g, Profunctor f, Profunctor g) => ((f :.: Costar (Prelude t)) :.: g) :~> Costar (Prelude t) Source Github #
Prostrong (KaleidoFl :: (Type +-> Type) -> (Type +-> Type) -> Constraint) (Costar []) Source Github #
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods proact :: forall (f :: Type +-> Type) (g :: Type +-> Type). (KaleidoFl f g, Profunctor f, Profunctor g) => ((f :.: Costar []) :.: g) :~> Costar [] Source Github #
(Cartesian k, Functor f) => Prostrong (PowerGrateFl :: (k +-> k) -> (k +-> k) -> Constraint) (Costar f :: k -> k -> Type) Source Github #	The carrier of the literature's kaleidoscope eliminator (`>-`): `Costar f`, i.e. `f a -> b` for any functor `f` on a cartesian category. Power grates distribute any `MonoidalProfunctor`, and `Costar f` is one, so this is `powerGrateP` at that carrier. It is an instance (and not only reachable through `powerGrateOf`) so that a power grate composed with another flavor that also runs at `Costar f`, an algebraic lens say, can be eliminated there directly.
Instance details Defined in Proarrow.Optic.PowerGrate Methods proact :: forall (f0 :: k +-> k) (g :: k +-> k). (PowerGrateFl f0 g, Profunctor f0, Profunctor g) => ((f0 :.: Costar f) :.: g) :~> Costar f Source Github #
(Functor f, DecidableProfunctor (Hom j)) => DecidableProfunctor (Costar f :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Costar Methods decide :: forall (a :: k) (b :: j). (Ob a, Ob b) => Decision (Costar f) a b (Holds (Costar f) a b) Source Github # toHolds :: forall (a :: k) (b :: j) r. Costar f a b -> ((Holds (Costar f) a b ~ 'TRU, 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 #
(Cartesian j, Cartesian k, Functor f) => MonoidalProfunctor (Costar f :: j -> k -> Type) Source Github #	Every functor between cartesian categories is a colax monoidal functor.
Instance details Defined in Proarrow.Profunctor.Instance.Costar Methods one :: Costar f (Unit :: j) (Unit :: k) Source Github # () :: forall (x1 :: j) (x2 :: k) (y1 :: j) (y2 :: k). Costar f x1 x2 -> Costar f y1 y2 -> Costar f (x1 y1) (x2 ** y2) Source Github #
Functor f => Profunctor (Costar f :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Costar Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Costar f a b -> Costar f c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Costar f a b -> Costar f c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Costar f a b -> Costar f a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Costar f a b -> r Source Github #
Functor f => Corepresentable (Costar f :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Costar Methods coindex :: forall (a :: k) (b :: j). Costar f a b -> (Costar f %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: j). Ob a => ((Costar f %% a) ~> b) -> Costar f a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Costar f %% a) ~> (Costar f %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Costar f a (Costar f %% a) Source Github #
Representable (Costar ((,) a) :: Type -> Type -> Type) Source Github #	The right adjoint of `(,) a` is `((->) a)`.
Instance details Defined in Proarrow.Adjunction Methods index :: Costar ((,) a) a0 b -> a0 ~> (Costar ((,) a) % b) Source Github # tabulate :: Ob b => (a0 ~> (Costar ((,) a) % b)) -> Costar ((,) a) a0 b Source Github # repMap :: (a0 ~> b) -> (Costar ((,) a) % a0) ~> (Costar ((,) a) % b) Source Github # repUniv :: Ob a0 => Costar ((,) a) (Costar ((,) a) % a0) a0 Source Github #
Functor f => Proadjunction (Star f :: k -> j -> Type) (Costar f :: j -> k -> Type) Source Github #
Instance details Defined in Proarrow.Adjunction Methods unit :: forall (a :: j). Ob a => (Costar f :.: Star f) a a Source Github # counit :: (Star f :.: Costar f) :~> ((~>) :: CAT k) Source Github #
(Functor t, Traversable (Star t)) => Cotraversable (Costar t :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Costar Methods cotraverse :: forall (p :: k +-> k). StrongDistributiveProfunctor p => (p :.: Costar t) :~> (Costar t :.: p) Source Github #
Traversable t => Kaleidoscopic (Costar (Prelude t) :: Type -> Type -> Type) Source Github #	`Costar (Prelude t)` for a traversable `t`: sequence the applicative through `t`, then aggregate. This carrier is not `Cotraversable`, see the module header.
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods kaleidoAct :: forall (p :: Type +-> Type) a b. (Representable p, StrongDistributiveProfunctor p) => Costar (Prelude t) a b -> Costar (Prelude t) (p % a) (p % b) Source Github #
Kaleidoscopic (Costar []) Source Github #	The same for `[]`, which is a `Functor` in its own right, so the literature's aggregating carrier can be written as a plain `[a] -> b`.
Instance details Defined in Proarrow.Optic.Kaleidoscope Methods kaleidoAct :: forall (p :: Type +-> Type) a b. (Representable p, StrongDistributiveProfunctor p) => Costar [] a b -> Costar [] (p % a) (p % b) Source Github #
Monad m => Procomonad (Costar (Prelude m) :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Costar Methods proextract :: Costar (Prelude m) :~> ((~>) :: CAT Type) Source Github # produplicate :: Costar (Prelude m) :~> (Costar (Prelude m) :.: Costar (Prelude m)) Source Github #
Functor (Costar' :: OPPOSITE (j .-> k) -> j -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Costar Methods map :: forall (a :: OPPOSITE (j .-> k)) (b :: OPPOSITE (j .-> k)). (a ~> b) -> Costar' a ~> Costar' b Source Github #
Promonad (Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Coyoneda Methods id :: forall (a :: j +-> k). Ob a => Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) a a Source Github # (.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) b c -> Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) a b -> Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) a c Source Github #
Flavor w => Promonad (Costar (Tambara w) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.PastroTambara Methods id :: forall (a :: j +-> k). Ob a => Costar (Tambara w) a a Source Github # (.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Costar (Tambara w) b c -> Costar (Tambara w) a b -> Costar (Tambara w) a c Source Github #
Profunctor p => Promonad (Costar ((:*:) p) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.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 #
Promonad (Costar (Yoneda :: (j +-> k) -> k -> j -> Type) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Yoneda Methods id :: forall (a :: j +-> k). Ob a => Costar (Yoneda :: (j +-> k) -> k -> j -> Type) a a Source Github # (.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Costar (Yoneda :: (j +-> k) -> k -> j -> Type) b c -> Costar (Yoneda :: (j +-> k) -> k -> j -> Type) a b -> Costar (Yoneda :: (j +-> k) -> k -> j -> Type) a c Source Github #
type (Costar f :: k -> j -> Type) %% (a :: k) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Costar type (Costar f :: k -> j -> Type) %% (a :: k) = f a
type (Costar ((,) a) :: Type -> Type -> Type) % (b :: Type) Source Github #
Instance details Defined in Proarrow.Adjunction type (Costar ((,) a) :: Type -> Type -> Type) % (b :: Type) = a -> b
type HasArrow (Costar f :: k -> j -> Type) (a :: k) (b :: j) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Costar type HasArrow (Costar f :: k -> j -> Type) (a :: k) (b :: j) = HasArrow (Hom j) (f a) b
type Holds (Costar f :: k -> j -> Type) (a :: k) (b :: j) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Costar type Holds (Costar f :: k -> j -> Type) (a :: k) (b :: j) = Holds (Hom j) (f a) b

type Costar (f :: j -> k) = Costar' ('OP ('NT f)) Source Github #

pattern Costar :: forall {j} {k} a (f :: j -> k) b. () => Ob a => (f a ~> b) -> Costar f a b Source Github #

unCostar :: forall {j} {k} (f :: j -> k) (a :: j) (b :: k). Costar f a b -> f a ~> b Source Github #

composeCostar :: forall {k} {j} (g :: k -> Type) (f :: j -> k). Functor g => (Costar f :.: Costar g) :~> Costar (Compose g f) Source Github #