Safe Haskell	None
Language	GHC2024

Proarrow.Functor

Description

Functors between categories of arbitrary kinds: Functor f sends a ~> b to f a ~> f b. Haskell Functors embed via the Prelude wrapper. Only functors into Type can be written directly as type constructors; functors into other kinds are instead encoded as representable profunctors (see Proarrow.Profunctor.Representable and FunctorForRep).

Synopsis

type (.~>) (f :: k -> k1) (g :: k -> k1) = forall (a :: k). Ob a => f a ~> g a
class (CategoryOf k1, CategoryOf k2, forall (a :: k1). Ob a => Ob' (f a)) => Functor (f :: k1 -> k2) where
- map :: forall (a :: k1) (b :: k1). (a ~> b) -> f a ~> f b
newtype Prelude (f :: Type -> Type) a = Prelude {
- unPrelude :: f a
}
newtype FromProfunctor (p :: k -> k1 -> Type) (a :: k) (b :: k1) = FromProfunctor {
- unFromProfunctor :: p a b
}
type Presheaf k = () +-> k
type Copresheaf k = k +-> ()
class (CategoryOf j, CategoryOf k) => FunctorForRep (f :: j +-> k) where
- type (f :: j +-> k) @ (a :: j) :: k
- fmap :: forall (a :: j) (b :: j). (a ~> b) -> (f @ a) ~> (f @ b)
withMappedOb :: forall {j} {k} (f :: j +-> k) (a :: j) r. (FunctorForRep f, Ob a) => (Ob (f @ a) => r) -> r
withObF :: forall {k1} {k2} (f :: k1 -> k2) (a :: k1) r. (Functor f, Ob a) => (Ob (f a) => r) -> r

Documentation

type (.~>) (f :: k -> k1) (g :: k -> k1) = forall (a :: k). Ob a => f a ~> g a infixr 0 Source Github #

Natural transformations between functors: an arrow f a ~> g a for every object a.

class (CategoryOf k1, CategoryOf k2, forall (a :: k1). Ob a => Ob' (f a)) => Functor (f :: k1 -> k2) where Source Github #

Functors between kind-indexed categories: map sends arrows of the source category to arrows of the target category. Only functors landing in a kind of shape ... -> Type can be written as type constructors like this; the rest are encoded as representable profunctors instead (FunctorForRep, Proarrow.Profunctor.Representable).

Methods

map :: forall (a :: k1) (b :: k1). (a ~> b) -> f a ~> f b Source Github #

Instances

Instances details

Functor NonEmpty Source Github #
Instance details Defined in Proarrow.Functor Methods map :: (a ~> b) -> NonEmpty a ~> NonEmpty b Source Github #
Functor Identity Source Github #
Instance details Defined in Proarrow.Functor Methods map :: (a ~> b) -> Identity a ~> Identity b Source Github #
Functor IO Source Github #
Instance details Defined in Proarrow.Functor Methods map :: (a ~> b) -> IO a ~> IO b Source Github #
Functor Ur Source Github #
Instance details Defined in Proarrow.Category.Instance.Linear Methods map :: (a ~> b) -> Ur a ~> Ur b Source Github #
Functor Maybe Source Github #
Instance details Defined in Proarrow.Functor Methods map :: (a ~> b) -> Maybe a ~> Maybe b Source Github #
Functor [] Source Github #
Instance details Defined in Proarrow.Functor Methods map :: (a ~> b) -> [a] ~> [b] Source Github #
Functor (FromPointed (Map k) :: POINTED -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.PointedHask Methods map :: forall (a :: POINTED) (b :: POINTED). (a ~> b) -> FromPointed (Map k) a ~> FromPointed (Map k) b Source Github #
Functor (FromPointed []) Source Github #
Instance details Defined in Proarrow.Category.Instance.PointedHask Methods map :: forall (a :: POINTED) (b :: POINTED). (a ~> b) -> FromPointed [] a ~> FromPointed [] b Source Github #
Functor (Either a :: Type -> Type) Source Github #
Instance details Defined in Proarrow.Functor Methods map :: (a0 ~> b) -> Either a a0 ~> Either a b Source Github #
Functor (CatAsComonoid k :: Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: (a ~> b) -> CatAsComonoid k a ~> CatAsComonoid k b Source Github #
Functor f => Functor (Prelude f :: Type -> Type) Source Github #
Instance details Defined in Proarrow.Functor Methods map :: (a ~> b) -> Prelude f a ~> Prelude f b Source Github #
Functor (ListF x :: Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Fix Methods map :: (a ~> b) -> ListF x a ~> ListF x b Source Github #
Functor ((,) a :: Type -> Type) Source Github #
Instance details Defined in Proarrow.Functor Methods map :: (a0 ~> b) -> (a, a0) ~> (a, b) Source Github #
CategoryOf k => Functor (Const x :: k -> Type) Source Github #
Instance details Defined in Proarrow.Functor Methods map :: forall (a :: k) (b :: k). (a ~> b) -> Const x a ~> Const x b Source Github #
(CategoryOf k, Functor f) => Functor (Ap f :: k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Free Methods map :: forall (a :: k) (b :: k). (a ~> b) -> Ap f a ~> Ap f b Source Github #
Functor ((->) a :: Type -> Type) Source Github #
Instance details Defined in Proarrow.Functor Methods map :: (a0 ~> b) -> (a -> a0) ~> (a -> b) Source Github #
(Functor f, Functor g) => Functor (Product f g :: k1 -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: k1) (b :: k1). (a ~> b) -> Product f g a ~> Product f g b Source Github #
(Functor f, Functor g) => Functor (Sum f g :: k1 -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: k1) (b :: k1). (a ~> b) -> Sum f g a ~> Sum f g b Source Github #
Functor f => Functor (n :*.: f :: k1 -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: k1) (b :: k1). (a ~> b) -> (n :.: f) a ~> (n :.: f) b Source Github #
Functor f => Functor (f :^: n :: k1 -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: k1) (b :: k1). (a ~> b) -> (f :^: n) a ~> (f :^: n) b Source Github #
(Functor f, Functor g) => Functor (f :~>: g :: k1 -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: k1) (b :: k1). (a ~> b) -> (f :~>: g) a ~> (f :~>: g) b Source Github #
CategoryOf k => Functor (Lan j2 f :: k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: k) (b :: k). (a ~> b) -> Lan j2 f a ~> Lan j2 f b Source Github #
CategoryOf k => Functor (Ran j2 h :: k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: k) (b :: k). (a ~> b) -> Ran j2 h a ~> Ran j2 h b Source Github #
(Functor f, Functor g) => Functor (Compose f g :: k1 -> Type) Source Github #
Instance details Defined in Proarrow.Functor Methods map :: forall (a :: k1) (b :: k1). (a ~> b) -> Compose f g a ~> Compose f g b Source Github #
Profunctor p => Functor (FromProfunctor p a :: k1 -> Type) Source Github #
Instance details Defined in Proarrow.Functor Methods map :: forall (a0 :: k1) (b :: k1). (a0 ~> b) -> FromProfunctor p a a0 ~> FromProfunctor p a b Source Github #
CategoryOf k => Functor ('COPR :: k -> COPROD k) Source Github #
Instance details Defined in Proarrow.Colimit.BinaryCoproduct Methods map :: forall (a :: k) (b :: k). (a ~> b) -> 'COPR a ~> 'COPR b Source Github #
CategoryOf k => Functor ('PR :: k -> PROD k) Source Github #
Instance details Defined in Proarrow.Limit.BinaryProduct Methods map :: forall (a :: k) (b :: k). (a ~> b) -> 'PR a ~> 'PR b Source Github #
Functor Either Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: (a ~> b) -> Either a ~> Either b Source Github #
Functor (,) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: (a ~> b) -> (,) a ~> (,) b Source Github #
Monoidal k => Functor (Writer :: k -> k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Writer Methods map :: forall (a :: k) (b :: k). (a ~> b) -> Writer a ~> Writer b Source Github #
Monoidal k => Functor (WriterT :: k -> (k +-> k) -> k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Writer Methods map :: forall (a :: k) (b :: k). (a ~> b) -> WriterT a ~> WriterT b Source Github #
(CategoryOf j, CategoryOf k) => Functor (Yo :: k -> OPPOSITE j -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Yoneda Methods map :: forall (a :: k) (b :: k). (a ~> b) -> (Yo a :: OPPOSITE j -> k -> j -> Type) ~> (Yo b :: OPPOSITE j -> k -> j -> Type) Source Github #
Functor f => Functor (FromProd f :: PROD k -> Type) Source Github #
Instance details Defined in Proarrow.Limit.BinaryProduct Methods map :: forall (a :: PROD k) (b :: PROD k). (a ~> b) -> FromProd f a ~> FromProd f b Source Github #
Profunctor p => Functor (Op p a :: OPPOSITE k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Opposite Methods map :: forall (a0 :: OPPOSITE k) (b :: OPPOSITE k). (a0 ~> b) -> Op p a a0 ~> Op p a b Source Github #
Monoidal k => Functor (Reader :: OPPOSITE k -> k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Reader Methods map :: forall (a :: OPPOSITE k) (b :: OPPOSITE k). (a ~> b) -> Reader a ~> Reader b Source Github #
Monoidal k => Functor (ReaderT :: OPPOSITE k -> (k +-> k) -> k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Reader Methods map :: forall (a :: OPPOSITE k) (b :: OPPOSITE k). (a ~> b) -> ReaderT a ~> ReaderT b 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 #
(CategoryOf j, CategoryOf k) => Functor (PList :: LIST (j +-> k) -> LIST k -> LIST j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Promonoidal Methods map :: forall (a :: LIST (j +-> k)) (b :: LIST (j +-> k)). (a ~> b) -> PList a ~> PList b Source Github #
Functor (Ran :: OPPOSITE (i +-> j) -> (i +-> k) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Ran Methods map :: forall (a :: OPPOSITE (i +-> j)) (b :: OPPOSITE (i +-> j)). (a ~> b) -> (Ran a :: (i +-> k) -> k -> j -> Type) ~> (Ran b :: (i +-> k) -> k -> j -> Type) Source Github #
Functor (Rift :: OPPOSITE (k +-> i) -> (j +-> i) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Rift Methods map :: forall (a :: OPPOSITE (k +-> i)) (b :: OPPOSITE (k +-> i)). (a ~> b) -> (Rift a :: (j +-> i) -> k -> j -> Type) ~> (Rift b :: (j +-> i) -> k -> j -> Type) Source Github #
(CategoryOf j, CategoryOf k) => Functor (Yo a :: OPPOSITE j -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Yoneda Methods map :: forall (a0 :: OPPOSITE j) (b :: OPPOSITE j). (a0 ~> b) -> Yo a a0 ~> Yo a b Source Github #
(Profunctor tk, Profunctor tj) => Functor (Day tk tj :: LIST (j +-> k) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Promonoidal Methods map :: forall (a :: LIST (j +-> k)) (b :: LIST (j +-> k)). (a ~> b) -> Day tk tj a ~> Day tk tj b Source Github #
Functor (Fix :: (k +-> k) -> k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Fix Methods map :: forall (a :: k +-> k) (b :: k +-> k). (a ~> b) -> Fix a ~> Fix b Source Github #
Functor (FreePromonad :: (k -> k -> Type) -> k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Free Methods map :: forall (a :: k -> k -> Type) (b :: k -> k -> Type). (a ~> b) -> FreePromonad a ~> FreePromonad b Source Github #
Functor (Ap :: (k -> Type) -> k -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Free Methods map :: forall (a :: k -> Type) (b :: k -> Type). (a ~> b) -> Ap a ~> Ap b Source Github #
(CategoryOf j, CategoryOf k) => Functor (Star' :: (j .-> k) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Star Methods map :: forall (a :: j .-> k) (b :: j .-> k). (a ~> b) -> Star' a ~> Star' b Source Github #
Functor (Op :: (j +-> k) -> OPPOSITE j -> OPPOSITE k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Opposite Methods map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> Op a ~> Op b Source Github #
Functor (Day :: (j +-> k) -> (j +-> k) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Day Methods map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> Day a ~> Day b Source Github #
Functor (List :: (j +-> k) -> LIST k -> LIST j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.List Methods map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> List a ~> List b Source Github #
Functor (Coyoneda :: (j +-> k) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Coyoneda Methods map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> Coyoneda a ~> Coyoneda b Source Github #
Functor (Yoneda :: (j +-> k) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Yoneda Methods map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> Yoneda a ~> Yoneda b Source Github #
(Monoidal k, Ob r) => Functor (ReaderT r :: (k +-> k) -> k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Reader Methods map :: forall (a :: k +-> k) (b :: k +-> k). (a ~> b) -> ReaderT r a ~> ReaderT r b Source Github #
(Monoidal k, Ob s) => Functor (StateT s :: (k +-> k) -> k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.State Methods map :: forall (a :: k +-> k) (b :: k +-> k). (a ~> b) -> StateT s a ~> StateT s b Source Github #
(Monoidal k, Ob w) => Functor (WriterT w :: (k +-> k) -> k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Writer Methods map :: forall (a :: k +-> k) (b :: k +-> k). (a ~> b) -> WriterT w a ~> WriterT w b Source Github #
Functor (Tambara w :: (j +-> k) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.PastroTambara Methods map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> Tambara w a ~> Tambara w b Source Github #
Functor ((:.:) :: (j +-> k) -> (i +-> j) -> k -> i -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> ((:.:) a :: (i +-> j) -> k -> i -> Type) ~> ((:.:) b :: (i +-> j) -> k -> i -> Type) Source Github #
Profunctor p => Functor ((:+:) p :: (j +-> k) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Coproduct Methods map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> (p :+: a) ~> (p :+: b) Source Github #
Profunctor p => Functor (Day p :: (j +-> k) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Day Methods map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> Day p a ~> Day p b Source Github #
Functor (Pastro t :: (j +-> k) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.PastroTambara Methods map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> Pastro t a ~> Pastro t b Source Github #
Profunctor p => Functor ((:*:) p :: (j +-> k) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Product Methods map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> (p :: a) ~> (p :: b) Source Github #
(Monoidal j, Monoidal k, Profunctor p) => Functor (DayExp p :: (k -> j -> Type) -> k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Day Methods map :: forall (a :: k -> j -> Type) (b :: k -> j -> Type). (a ~> b) -> DayExp p a ~> DayExp p b Source Github #
Profunctor p => Functor ((:.:) p :: (i +-> j) -> k -> i -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Composition Methods map :: forall (a :: i +-> j) (b :: i +-> j). (a ~> b) -> (p :.: a) ~> (p :.: b) Source Github #
Profunctor j2 => Functor (Ran ('OP j2) :: (i +-> k) -> k -> j1 -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Ran Methods map :: forall (a :: i +-> k) (b :: i +-> k). (a ~> b) -> Ran ('OP j2) a ~> Ran ('OP j2) b Source Github #
Profunctor j2 => Functor (Rift ('OP j2) :: (j1 +-> i) -> k -> j1 -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Rift Methods map :: forall (a :: j1 +-> i) (b :: j1 +-> i). (a ~> b) -> Rift ('OP j2) a ~> Rift ('OP j2) b Source Github #

newtype Prelude (f :: Type -> Type) a Source Github #

Makes a base-style Functor (kind Type -> Type) a Functor, to use with deriving via (see the instances below). A direct instance Functor (f :: Type -> Type) would overlap with the Functor instances at every other kind k -> Type, hence the wrapper.

Constructors

Prelude
Fields unPrelude :: f a

Instances

Instances details

Alternative f => Alternative (Prelude f :: Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Applicative Methods empty :: Ob a => (Unit :: Type) ~> Prelude f a Source Github # alt :: (Ob a, Ob b) => ((a \|\| b) ~> c) -> (Prelude f a ** Prelude f b) ~> Prelude f c Source Github #
Applicative f => Applicative (Prelude f :: Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Applicative Methods pure :: ((Unit :: Type) ~> a) -> (Unit :: Type) ~> Prelude f a Source Github # liftA2 :: (Ob a, Ob b) => ((a b) ~> c) -> (Prelude f a Prelude f b) ~> Prelude f c Source Github #
Functor f => Functor (Prelude f :: Type -> Type) Source Github #
Instance details Defined in Proarrow.Functor Methods map :: (a ~> b) -> Prelude f a ~> Prelude f b Source Github #
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 #
Functor f => Prostrong (LensFl :: (Type +-> Type) -> (Type +-> Type) -> Constraint) (Star (Prelude f) :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Lens Methods proact :: forall (f0 :: Type +-> Type) (g :: Type +-> Type). (LensFl f0 g, Profunctor f0, Profunctor g) => ((f0 :.: Star (Prelude f)) :.: g) :~> Star (Prelude f) Source Github #
Monad m => Promonad (Star (Prelude m) :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Star Methods id :: Ob a => Star (Prelude m) a a Source Github # (.) :: Star (Prelude m) b c -> Star (Prelude m) a b -> Star (Prelude m) a c 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 #
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 #
Applicative f => Applicative (Prelude f) Source Github #
Instance details Defined in Proarrow.Functor Methods pure :: a -> Prelude f a Github # (<>) :: Prelude f (a -> b) -> Prelude f a -> Prelude f b Github # liftA2 :: (a -> b -> c) -> Prelude f a -> Prelude f b -> Prelude f c Github # (>) :: Prelude f a -> Prelude f b -> Prelude f b Github # (<*) :: Prelude f a -> Prelude f b -> Prelude f a Github #
Functor f => Functor (Prelude f) Source Github #
Instance details Defined in Proarrow.Functor Methods fmap :: (a -> b) -> Prelude f a -> Prelude f b Github # (<$) :: a -> Prelude f b -> Prelude f a Github #
Foldable f => Foldable (Prelude f) Source Github #
Instance details Defined in Proarrow.Functor Methods fold :: Monoid m => Prelude f m -> m Github # foldMap :: Monoid m => (a -> m) -> Prelude f a -> m Github # foldMap' :: Monoid m => (a -> m) -> Prelude f a -> m Github # foldr :: (a -> b -> b) -> b -> Prelude f a -> b Github # foldr' :: (a -> b -> b) -> b -> Prelude f a -> b Github # foldl :: (b -> a -> b) -> b -> Prelude f a -> b Github # foldl' :: (b -> a -> b) -> b -> Prelude f a -> b Github # foldr1 :: (a -> a -> a) -> Prelude f a -> a Github # foldl1 :: (a -> a -> a) -> Prelude f a -> a Github # toList :: Prelude f a -> [a] Github # null :: Prelude f a -> Bool Github # length :: Prelude f a -> Int Github # elem :: Eq a => a -> Prelude f a -> Bool Github # maximum :: Ord a => Prelude f a -> a Github # minimum :: Ord a => Prelude f a -> a Github # sum :: Num a => Prelude f a -> a Github # product :: Num a => Prelude f a -> a Github #
Traversable f => Traversable (Prelude f) Source Github #
Instance details Defined in Proarrow.Functor Methods traverse :: Applicative f0 => (a -> f0 b) -> Prelude f a -> f0 (Prelude f b) Github # sequenceA :: Applicative f0 => Prelude f (f0 a) -> f0 (Prelude f a) Github # mapM :: Monad m => (a -> m b) -> Prelude f a -> m (Prelude f b) Github # sequence :: Monad m => Prelude f (m a) -> m (Prelude f a) Github #
Functor f => Strong (ProdAction :: Type -> (PROD Type, Type) -> Type) (Star (Prelude f) :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Star Methods act :: forall (a :: PROD Type) x y. Ob a => Star (Prelude f) x y -> Star (Prelude f) (Act (ProdAction :: Type -> (PROD Type, Type) -> Type) a x) (Act (ProdAction :: Type -> (PROD Type, Type) -> Type) a y) Source Github #
Show (f a) => Show (Prelude f a) Source Github #
Instance details Defined in Proarrow.Functor Methods showsPrec :: Int -> Prelude f a -> ShowS Github # show :: Prelude f a -> String Github # showList :: [Prelude f a] -> ShowS Github #
Eq (f a) => Eq (Prelude f a) Source Github #
Instance details Defined in Proarrow.Functor Methods (==) :: Prelude f a -> Prelude f a -> Bool Github # (/=) :: Prelude f a -> Prelude f a -> Bool Github #
Applicative f => Strong (SubAction Traversable ApplyAction) (Star (Prelude f) :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Star Methods act :: forall (a :: SUBCAT Traversable) x y. Ob a => Star (Prelude f) x y -> Star (Prelude f) (Act (SubAction Traversable ApplyAction) a x) (Act (SubAction Traversable ApplyAction) a y) Source Github #

newtype FromProfunctor (p :: k -> k1 -> Type) (a :: k) (b :: k1) Source Github #

Constructors

FromProfunctor
Fields unFromProfunctor :: p a b

Instances

Instances details

Profunctor p => Profunctor (FromProfunctor p :: k -> j -> Type) Source Github #
Instance details Defined in Proarrow.Functor Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> FromProfunctor p a b -> FromProfunctor p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> FromProfunctor p a b -> FromProfunctor p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> FromProfunctor p a b -> FromProfunctor p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> FromProfunctor p a b -> r Source Github #
(DistributiveProfunctor p, Distributive j, Comonoid ('COPR x)) => Alternative (FromProfunctor p x :: j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Applicative Methods empty :: forall (a :: j). Ob a => (Unit :: Type) ~> FromProfunctor p x a Source Github # alt :: forall (a :: j) (b :: j) (c :: j). (Ob a, Ob b) => ((a \|\| b) ~> c) -> (FromProfunctor p x a ** FromProfunctor p x b) ~> FromProfunctor p x c Source Github #
(MonoidalProfunctor p, Comonoid x) => Applicative (FromProfunctor p x :: j -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Applicative Methods pure :: forall (a :: j). ((Unit :: j) ~> a) -> (Unit :: Type) ~> FromProfunctor p x a Source Github # liftA2 :: forall (a :: j) (b :: j) (c :: j). (Ob a, Ob b) => ((a b) ~> c) -> (FromProfunctor p x a FromProfunctor p x b) ~> FromProfunctor p x c Source Github #
Profunctor p => Functor (FromProfunctor p a :: k1 -> Type) Source Github #
Instance details Defined in Proarrow.Functor Methods map :: forall (a0 :: k1) (b :: k1). (a0 ~> b) -> FromProfunctor p a a0 ~> FromProfunctor p a b Source Github #
Promonad p => Category (FromProfunctor p :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Arrow Methods id :: FromProfunctor p a a Github # (.) :: FromProfunctor p b c -> FromProfunctor p a b -> FromProfunctor p a c Github #
Promonad p => Promonad (FromProfunctor p :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Functor Methods id :: forall (a :: k). Ob a => FromProfunctor p a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). FromProfunctor p b c -> FromProfunctor p a b -> FromProfunctor p a c Source Github #
(MonoidalProfunctor p, Promonad p) => Arrow (FromProfunctor p) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Arrow Methods arr :: (b -> c) -> FromProfunctor p b c Github # first :: FromProfunctor p b c -> FromProfunctor p (b, d) (c, d) Github # second :: FromProfunctor p b c -> FromProfunctor p (d, b) (d, c) Github # (***) :: FromProfunctor p b c -> FromProfunctor p b' c' -> FromProfunctor p (b, b') (c, c') Github # (&&&) :: FromProfunctor p b c -> FromProfunctor p b c' -> FromProfunctor p b (c, c') Github #
(Representable p, MonoidalProfunctor p, Promonad p) => ArrowApply (FromProfunctor p) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Arrow Methods app :: FromProfunctor p (FromProfunctor p b c, b) c Github #
(DistributiveProfunctor p, Promonad p) => ArrowChoice (FromProfunctor p) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Arrow Methods left :: FromProfunctor p b c -> FromProfunctor p (Either b d) (Either c d) Github # right :: FromProfunctor p b c -> FromProfunctor p (Either d b) (Either d c) Github # (+++) :: FromProfunctor p b c -> FromProfunctor p b' c' -> FromProfunctor p (Either b b') (Either c c') Github # (\|\|\|) :: FromProfunctor p b d -> FromProfunctor p c d -> FromProfunctor p (Either b c) d Github #
(Costrong (Tensor :: Type -> (Type, Type) -> Type) p, MonoidalProfunctor p, Promonad p) => ArrowLoop (FromProfunctor p) Source Github #
Instance details Defined in Proarrow.Profunctor.Instance.Arrow Methods loop :: FromProfunctor p (b, d) (c, d) -> FromProfunctor p b c Github #
MonoidalProfunctor p => Applicative (FromProfunctor p x) Source Github #
Instance details Defined in Proarrow.Category.Monoidal.Applicative Methods pure :: a -> FromProfunctor p x a Github # (<>) :: FromProfunctor p x (a -> b) -> FromProfunctor p x a -> FromProfunctor p x b Github # liftA2 :: (a -> b -> c) -> FromProfunctor p x a -> FromProfunctor p x b -> FromProfunctor p x c Github # (>) :: FromProfunctor p x a -> FromProfunctor p x b -> FromProfunctor p x b Github # (<*) :: FromProfunctor p x a -> FromProfunctor p x b -> FromProfunctor p x a Github #
Profunctor p => Functor (FromProfunctor p a) Source Github #
Instance details Defined in Proarrow.Functor Methods fmap :: (a0 -> b) -> FromProfunctor p a a0 -> FromProfunctor p a b Github # (<$) :: a0 -> FromProfunctor p a b -> FromProfunctor p a a0 Github #

type Presheaf k = () +-> k Source Github #

Presheaves are functors but it makes more sense in proarrow to represent them as profunctors from the unit category.

type Copresheaf k = k +-> () Source Github #

Copresheaves are functors but it makes more sense in proarrow to represent them as profunctors into the unit category.

class (CategoryOf j, CategoryOf k) => FunctorForRep (f :: j +-> k) where Source Github #

A perfectly valid functor definition, but hard to use. So we only use it to easily make (co)representable profunctors with Rep and Corep.

Associated Types

type (f :: j +-> k) @ (a :: j) :: k Source Github #

Methods

fmap :: forall (a :: j) (b :: j). (a ~> b) -> (f @ a) ~> (f @ b) Source Github #

Instances

Instances details

FunctorForRep Forget Source Github #

Instance details

Defined in Proarrow.Category.Instance.Simplex

Associated Types

type Forget @ (n :: Nat)
Instance details Defined in Proarrow.Category.Instance.Simplex type Forget @ (n :: Nat) = Fin n

Methods

fmap :: forall (a :: Nat) (b :: Nat). (a ~> b) -> (Forget @ a) ~> (Forget @ b) Source Github #

FunctorForRep Fun Source Github #

Instance details

Defined in Proarrow.Category.Instance.FinRel

Associated Types

type Fun @ ('FS a :: FINSET)
Instance details Defined in Proarrow.Category.Instance.FinRel type Fun @ ('FS a :: FINSET) = 'FR a

Methods

fmap :: forall (a :: FINSET) (b :: FINSET). (a ~> b) -> (Fun @ a) ~> (Fun @ b) Source Github #

FunctorForRep Forget Source Github #

Instance details

Defined in Proarrow.Category.Instance.Linear

Associated Types

type Forget @ (a :: LINEAR)
Instance details Defined in Proarrow.Category.Instance.Linear type Forget @ (a :: LINEAR) = UN 'L a

Methods

fmap :: forall (a :: LINEAR) (b :: LINEAR). (a ~> b) -> (Forget @ a) ~> (Forget @ b) Source Github #

CategoryOf k => FunctorForRep (Initiate :: VOID +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Fam

Methods

fmap :: forall (a :: VOID) (b :: VOID). (a ~> b) -> ((Initiate :: VOID +-> k) @ a) ~> ((Initiate :: VOID +-> k) @ b) Source Github #

CategoryOf k => FunctorForRep (Absurd :: VOID +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Zero

Methods

fmap :: forall (a :: VOID) (b :: VOID). (a ~> b) -> ((Absurd :: VOID +-> k) @ a) ~> ((Absurd :: VOID +-> k) @ b) Source Github #

Monoidal k => FunctorForRep (UnitRep :: k -> () -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal

Methods

fmap :: forall (a :: ()) (b :: ()). (a ~> b) -> ((UnitRep :: k -> () -> Type) @ a) ~> ((UnitRep :: k -> () -> Type) @ b) Source Github #

CategoryOf k => FunctorForRep (Id :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Identity

Methods

fmap :: forall (a :: k) (b :: k). (a ~> b) -> ((Id :: k -> k -> Type) @ a) ~> ((Id :: k -> k -> Type) @ b) Source Github #

Monoid m => FunctorForRep (Replicate m :: Nat +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Simplex

Methods

fmap :: forall (a :: Nat) (b :: Nat). (a ~> b) -> (Replicate m @ a) ~> (Replicate m @ b) Source Github #

Corepresentable d => FunctorForRep (CoendLimit d :: Presheaf Type) Source Github #

Instance details

Defined in Proarrow.Colimit

Methods

fmap :: forall (a :: ()) (b :: ()). (a ~> b) -> (CoendLimit d @ a) ~> (CoendLimit d @ b) Source Github #

Representable d => FunctorForRep (EndLimit d :: Presheaf Type) Source Github #

Instance details

Defined in Proarrow.Limit

Methods

fmap :: forall (a :: ()) (b :: ()). (a ~> b) -> (EndLimit d @ a) ~> (EndLimit d @ b) Source Github #

(HasBinaryCoproducts k, Corepresentable d) => FunctorForRep (CoproductColimit d :: Presheaf k) Source Github #

Instance details

Defined in Proarrow.Colimit

Methods

fmap :: forall (a :: ()) (b :: ()). (a ~> b) -> (CoproductColimit d @ a) ~> (CoproductColimit d @ b) Source Github #

(HasBinaryProducts k, Representable d) => FunctorForRep (ProductLimit d :: Presheaf k) Source Github #

Instance details

Defined in Proarrow.Limit

Methods

fmap :: forall (a :: ()) (b :: ()). (a ~> b) -> (ProductLimit d @ a) ~> (ProductLimit d @ b) Source Github #

(Closed k, Ob m) => FunctorForRep (Exp m :: k +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Closed

Methods

fmap :: forall (a :: k) (b :: k). (a ~> b) -> (Exp m @ a) ~> (Exp m @ b) Source Github #

(HasBinaryCoproducts k, Ob a) => FunctorForRep (Coproduct a :: k +-> k) Source Github #

Instance details

Defined in Proarrow.Colimit.BinaryCoproduct

Methods

fmap :: forall (a0 :: k) (b :: k). (a0 ~> b) -> (Coproduct a @ a0) ~> (Coproduct a @ b) Source Github #

(HasBinaryProducts k, Ob a) => FunctorForRep (Product a :: k +-> k) Source Github #

Instance details

Defined in Proarrow.Limit.BinaryProduct

Methods

fmap :: forall (a0 :: k) (b :: k). (a0 ~> b) -> (Product a @ a0) ~> (Product a @ b) Source Github #

(Corepresentable d, Copowered Type k) => FunctorForRep (CopowerLimit n d :: Presheaf k) Source Github #

Instance details

Defined in Proarrow.Colimit

Methods

fmap :: forall (a :: ()) (b :: ()). (a ~> b) -> (CopowerLimit n d @ a) ~> (CopowerLimit n d @ b) Source Github #

(CategoryOf j, CategoryOf k, Ob c) => FunctorForRep (Constant c :: j +-> k) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Constant

Methods

fmap :: forall (a :: j) (b :: j). (a ~> b) -> (Constant c @ a) ~> (Constant c @ b) Source Github #

(Representable d, Powered v k, Ob n) => FunctorForRep (PowerLimit n d :: Presheaf k) Source Github #

Instance details

Defined in Proarrow.Limit

Methods

fmap :: forall (a :: ()) (b :: ()). (a ~> b) -> (PowerLimit n d @ a) ~> (PowerLimit n d @ b) Source Github #

(MonoidalAction act, Ob x) => FunctorForRep (ActionAt act x :: k +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Action

Methods

fmap :: forall (a :: k) (b :: k). (a ~> b) -> (ActionAt act x @ a) ~> (ActionAt act x @ b) Source Github #

(MonoidalAction act, Ob a) => FunctorForRep (Action act a :: m +-> k) Source Github #

Instance details

Defined in Proarrow.Squares

Methods

fmap :: forall (a0 :: m) (b :: m). (a0 ~> b) -> (Action act a @ a0) ~> (Action act a @ b) Source Github #

(FunctorForRep p, FunctorForRep q) => FunctorForRep (p :.: q :: k -> j2 -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Instance.Composition

Methods

fmap :: forall (a :: j2) (b :: j2). (a ~> b) -> ((p :.: q) @ a) ~> ((p :.: q) @ b) Source Github #

CategoryOf k => FunctorForRep (Embed :: k +-> FAM k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Fam

Methods

fmap :: forall (a :: k) (b :: k). (a ~> b) -> ((Embed :: k +-> FAM k) @ a) ~> ((Embed :: k +-> FAM k) @ b) Source Github #

CategoryOf k => FunctorForRep (Diag :: k +-> (k, k)) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Product

Methods

fmap :: forall (a :: k) (b :: k). (a ~> b) -> ((Diag :: k +-> (k, k)) @ a) ~> ((Diag :: k +-> (k, k)) @ b) Source Github #

(CategoryOf j, CategoryOf k) => FunctorForRep (Lft :: j +-> COPRODUCT j k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Coproduct

Methods

fmap :: forall (a :: j) (b :: j). (a ~> b) -> ((Lft :: j +-> COPRODUCT j k) @ a) ~> ((Lft :: j +-> COPRODUCT j k) @ b) Source Github #

(CategoryOf j, CategoryOf k) => FunctorForRep (Rgt :: k +-> COPRODUCT j k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Coproduct

Methods

fmap :: forall (a :: k) (b :: k). (a ~> b) -> ((Rgt :: k +-> COPRODUCT j k) @ a) ~> ((Rgt :: k +-> COPRODUCT j k) @ b) Source Github #

Profunctor p => FunctorForRep (InjL p :: j +-> COLLAGE p) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Collage

Methods

fmap :: forall (a :: j) (b :: j). (a ~> b) -> (InjL p @ a) ~> (InjL p @ b) Source Github #

Profunctor p => FunctorForRep (InjR p :: j1 +-> COLLAGE p) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Collage

Methods

fmap :: forall (a :: j1) (b :: j1). (a ~> b) -> (InjR p @ a) ~> (InjR p @ b) Source Github #

Discrete k => FunctorForRep (Embed :: k +-> FREE ds p) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Free

Methods

fmap :: forall (a :: k) (b :: k). (a ~> b) -> ((Embed :: k +-> FREE ds p) @ a) ~> ((Embed :: k +-> FREE ds p) @ b) Source Github #

Num a => FunctorForRep (App :: MatK a +-> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Mat

Methods

fmap :: forall (a0 :: MatK a) (b :: MatK a). (a0 ~> b) -> ((App :: MatK a +-> Type) @ a0) ~> ((App :: MatK a +-> Type) @ b) Source Github #

FunctorForRep (Pick a :: OPPOSITE Nat +-> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Simplex

Methods

fmap :: forall (a0 :: OPPOSITE Nat) (b :: OPPOSITE Nat). (a0 ~> b) -> (Pick a @ a0) ~> (Pick a @ b) Source Github #

(Closed k, Ob r) => FunctorForRep (Not r :: OPPOSITE k +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Closed

Methods

fmap :: forall (a :: OPPOSITE k) (b :: OPPOSITE k). (a ~> b) -> (Not r @ a) ~> (Not r @ b) Source Github #

(HasPushouts k, HasPullbacks k) => FunctorForRep (Pullback :: COSPAN k +-> SPAN k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Cospan

Methods

fmap :: forall (a :: COSPAN k) (b :: COSPAN k). (a ~> b) -> ((Pullback :: COSPAN k +-> SPAN k) @ a) ~> ((Pullback :: COSPAN k +-> SPAN k) @ b) Source Github #

CategoryOf k => FunctorForRep (IsPresheafSub :: FAM k +-> Presheaf k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Fam

Methods

fmap :: forall (a :: FAM k) (b :: FAM k). (a ~> b) -> ((IsPresheafSub :: FAM k +-> Presheaf k) @ a) ~> ((IsPresheafSub :: FAM k +-> Presheaf k) @ b) Source Github #

RealFloat a => FunctorForRep (Conjugate :: MatK (Complex a) +-> MatK (Complex a)) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Mat

Methods

fmap :: forall (a0 :: MatK (Complex a)) (b :: MatK (Complex a)). (a0 ~> b) -> ((Conjugate :: MatK (Complex a) +-> MatK (Complex a)) @ a0) ~> ((Conjugate :: MatK (Complex a) +-> MatK (Complex a)) @ b) Source Github #

(HasPushouts k, HasPullbacks k) => FunctorForRep (Pushout :: SPAN k +-> COSPAN k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Cospan

Methods

fmap :: forall (a :: SPAN k) (b :: SPAN k). (a ~> b) -> ((Pushout :: SPAN k +-> COSPAN k) @ a) ~> ((Pushout :: SPAN k +-> COSPAN k) @ b) Source Github #

FunctorForRep ApplyAction' Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

Associated Types

type ApplyAction' @ ('(f, x) :: (Type -> Type, Type))
Instance details Defined in Proarrow.Category.Instance.Nat type ApplyAction' @ ('(f, x) :: (Type -> Type, Type)) = f x

Methods

fmap :: forall (a :: (Type -> Type, Type)) (b :: (Type -> Type, Type)). (a ~> b) -> (ApplyAction' @ a) ~> (ApplyAction' @ b) Source Github #

CategoryOf k => FunctorForRep (Codiag :: COPRODUCT k k +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Coproduct

Methods

fmap :: forall (a :: COPRODUCT k k) (b :: COPRODUCT k k). (a ~> b) -> ((Codiag :: COPRODUCT k k +-> k) @ a) ~> ((Codiag :: COPRODUCT k k +-> k) @ b) Source Github #

Closed k => FunctorForRep (ExpRep :: (OPPOSITE k, k) +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Closed

Methods

fmap :: forall (a :: (OPPOSITE k, k)) (b :: (OPPOSITE k, k)). (a ~> b) -> ((ExpRep :: (OPPOSITE k, k) +-> k) @ a) ~> ((ExpRep :: (OPPOSITE k, k) +-> k) @ b) Source Github #

CategoryOf k => FunctorForRep (RepAction' :: (RepSub k, k) +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.EndoProf

Methods

fmap :: forall (a :: (RepSub k, k)) (b :: (RepSub k, k)). (a ~> b) -> ((RepAction' :: (RepSub k, k) +-> k) @ a) ~> ((RepAction' :: (RepSub k, k) +-> k) @ b) Source Github #

CategoryOf k => FunctorForRep (TravAction' :: (TravSub k, k) +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.EndoProf

Methods

fmap :: forall (a :: (TravSub k, k)) (b :: (TravSub k, k)). (a ~> b) -> ((TravAction' :: (TravSub k, k) +-> k) @ a) ~> ((TravAction' :: (TravSub k, k) +-> k) @ b) Source Github #

HasCoproducts k => FunctorForRep (CoprodAction' :: (COPROD k, k) +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Action

Methods

fmap :: forall (a :: (COPROD k, k)) (b :: (COPROD k, k)). (a ~> b) -> ((CoprodAction' :: (COPROD k, k) +-> k) @ a) ~> ((CoprodAction' :: (COPROD k, k) +-> k) @ b) Source Github #

HasProducts k => FunctorForRep (ProdAction' :: (PROD k, k) +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Action

Methods

fmap :: forall (a :: (PROD k, k)) (b :: (PROD k, k)). (a ~> b) -> ((ProdAction' :: (PROD k, k) +-> k) @ a) ~> ((ProdAction' :: (PROD k, k) +-> k) @ b) Source Github #

CategoryOf k => FunctorForRep (NoAction :: ((), k) +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Action

Methods

fmap :: forall (a :: ((), k)) (b :: ((), k)). (a ~> b) -> ((NoAction :: ((), k) +-> k) @ a) ~> ((NoAction :: ((), k) +-> k) @ b) Source Github #

Monoidal k => FunctorForRep (MultRep :: k -> (k, k) -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal

Methods

fmap :: forall (a :: (k, k)) (b :: (k, k)). (a ~> b) -> ((MultRep :: k -> (k, k) -> Type) @ a) ~> ((MultRep :: k -> (k, k) -> Type) @ b) Source Github #

HasBinaryCoproducts k => FunctorForRep (PlusRep :: k -> (k, k) -> Type) Source Github #

Instance details

Defined in Proarrow.Colimit.BinaryCoproduct

Methods

fmap :: forall (a :: (k, k)) (b :: (k, k)). (a ~> b) -> ((PlusRep :: k -> (k, k) -> Type) @ a) ~> ((PlusRep :: k -> (k, k) -> Type) @ b) Source Github #

CategoryOf k => FunctorForRep (Forget ob :: SUBCAT ob +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Sub

Methods

fmap :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (a ~> b) -> (Forget ob @ a) ~> (Forget ob @ b) Source Github #

(CategoryOf j, CategoryOf k) => FunctorForRep (Fst :: (j, k) +-> j) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Product

Methods

fmap :: forall (a :: (j, k)) (b :: (j, k)). (a ~> b) -> ((Fst :: (j, k) +-> j) @ a) ~> ((Fst :: (j, k) +-> j) @ b) Source Github #

(CategoryOf j, CategoryOf k) => FunctorForRep (Snd :: (j, k) +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Product

Methods

fmap :: forall (a :: (j, k)) (b :: (j, k)). (a ~> b) -> ((Snd :: (j, k) +-> k) @ a) ~> ((Snd :: (j, k) +-> k) @ b) Source Github #

(Monoidal k2, Monoidal (SUBCAT ob), Representable t) => FunctorForRep (SubAction' ob t :: (SUBCAT ob, k1) +-> k1) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Action

Methods

fmap :: forall (a :: (SUBCAT ob, k1)) (b :: (SUBCAT ob, k1)). (a ~> b) -> (SubAction' ob t @ a) ~> (SubAction' ob t @ b) Source Github #

(Representable t, CategoryOf m) => FunctorForRep (OpAction t :: (OPPOSITE m, OPPOSITE k) +-> OPPOSITE k) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.Action

Methods

fmap :: forall (a :: (OPPOSITE m, OPPOSITE k)) (b :: (OPPOSITE m, OPPOSITE k)). (a ~> b) -> (OpAction t @ a) ~> (OpAction t @ b) Source Github #

(CategoryOf h, CategoryOf x) => FunctorForRep (Precomp :: (REV (ENDO x), x +-> h) +-> (x +-> h)) Source Github #

Instance details

Defined in Proarrow.Category.Monoidal.EndoProf

Methods

fmap :: forall (a :: (REV (ENDO x), x +-> h)) (b :: (REV (ENDO x), x +-> h)). (a ~> b) -> (Precomp @ a) ~> (Precomp @ b) Source Github #

(CategoryOf j, CategoryOf k, CodiscreteProfunctor p) => FunctorForRep (ProdAsGraph :: (j, k) +-> GRAPH p) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Graph

Methods

fmap :: forall (a :: (j, k)) (b :: (j, k)). (a ~> b) -> ((ProdAsGraph :: (j, k) +-> GRAPH p) @ a) ~> ((ProdAsGraph :: (j, k) +-> GRAPH p) @ b) Source Github #

Profunctor p => FunctorForRep (ProjTo2 p :: COLLAGE p +-> BOOL) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Collage

Methods

fmap :: forall (a :: COLLAGE p) (b :: COLLAGE p). (a ~> b) -> (ProjTo2 p @ a) ~> (ProjTo2 p @ b) Source Github #

ThinProfunctor p => FunctorForRep (ProjK p :: GRAPH p +-> k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Graph

Methods

fmap :: forall (a :: GRAPH p) (b :: GRAPH p). (a ~> b) -> (ProjK p @ a) ~> (ProjK p @ b) Source Github #

ThinProfunctor p => FunctorForRep (ProjJ p :: GRAPH p +-> k2) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Graph

Methods

fmap :: forall (a :: GRAPH p) (b :: GRAPH p). (a ~> b) -> (ProjJ p @ a) ~> (ProjJ p @ b) Source Github #

DiscreteProfunctor p => FunctorForRep (CollageAsCoprod :: COLLAGE p +-> COPRODUCT j k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Collage

Methods

fmap :: forall (a :: COLLAGE p) (b :: COLLAGE p). (a ~> b) -> ((CollageAsCoprod :: COLLAGE p +-> COPRODUCT j k) @ a) ~> ((CollageAsCoprod :: COLLAGE p +-> COPRODUCT j k) @ b) Source Github #

withMappedOb :: forall {j} {k} (f :: j +-> k) (a :: j) r. (FunctorForRep f, Ob a) => (Ob (f @ a) => r) -> r Source Github #

withObF :: forall {k1} {k2} (f :: k1 -> k2) (a :: k1) r. (Functor f, Ob a) => (Ob (f a) => r) -> r Source Github #

Recover Ob (f a) from a Functor f and Ob a, the map-based analog of withMappedOb. The Ob' (f a) superclass of Functor is a quantified constraint, and GHC will not extract its own Ob (f a) superclass on demand, so it is observed from the mapped identity morphism instead.