Data.Profunctor

Documentation

class Profunctor p where

Methods

dimap :: (a -> b) -> (c -> d) -> p b c -> p a d

lmap :: (a -> b) -> p b c -> p a c

rmap :: (b -> c) -> p a b -> p a c

Instances

Functor f => Profunctor (Kleisli f)

Methods

dimap :: (a -> b) -> (c -> d) -> Kleisli f b c -> Kleisli f a d

lmap :: (a -> b) -> Kleisli f b c -> Kleisli f a c

rmap :: (b -> c) -> Kleisli f a b -> Kleisli f a c

Profunctor ((->) LiftedRep LiftedRep)

Methods

dimap :: (a -> b) -> (c -> d) -> (LiftedRep -> LiftedRep) b c -> (LiftedRep -> LiftedRep) a d

lmap :: (a -> b) -> (LiftedRep -> LiftedRep) b c -> (LiftedRep -> LiftedRep) a c

rmap :: (b -> c) -> (LiftedRep -> LiftedRep) a b -> (LiftedRep -> LiftedRep) a c

Functor f => Profunctor (Cokleisli * f)

Methods

dimap :: (a -> b) -> (c -> d) -> Cokleisli * f b c -> Cokleisli * f a d

lmap :: (a -> b) -> Cokleisli * f b c -> Cokleisli * f a c

rmap :: (b -> c) -> Cokleisli * f a b -> Cokleisli * f a c

(^>>) :: Profunctor p => (a -> b) -> p b c -> p a c infixr 1

(>>^) :: Profunctor p => p a b -> (b -> c) -> p a c infixr 1

(<<^) :: Profunctor p => p b c -> (a -> b) -> p a c infixr 1

(^<<) :: Profunctor p => (b -> c) -> p a b -> p a c infixr 1

class Profunctor p => Strong f p where

Minimal complete definition

strong

Methods

strong :: p a₁ b₁ -> p a₂ b₂ -> p (f a₁ a₂) (f b₁ b₂)

Instances

Functor f => Strong Either (Kleisli f)

Methods

strong :: Kleisli f a₁ b₁ -> Kleisli f a₂ b₂ -> Kleisli f (Either a₁ a₂) (Either b₁ b₂)

Applicative p => Strong (,) (Kleisli p)

Methods

strong :: Kleisli p a₁ b₁ -> Kleisli p a₂ b₂ -> Kleisli p (a₁, a₂) (b₁, b₂)

Strong Either ((->) LiftedRep LiftedRep)

Methods

strong :: (LiftedRep -> LiftedRep) a₁ b₁ -> (LiftedRep -> LiftedRep) a₂ b₂ -> (LiftedRep -> LiftedRep) (Either a₁ a₂) (Either b₁ b₂)

Comonad ɯ => Strong Either (Cokleisli * ɯ)

Methods

strong :: Cokleisli * ɯ a₁ b₁ -> Cokleisli * ɯ a₂ b₂ -> Cokleisli * ɯ (Either a₁ a₂) (Either b₁ b₂)

Strong (,) ((->) LiftedRep LiftedRep)

Methods

strong :: (LiftedRep -> LiftedRep) a₁ b₁ -> (LiftedRep -> LiftedRep) a₂ b₂ -> (LiftedRep -> LiftedRep) (a₁, a₂) (b₁, b₂)

(***) :: Strong (,) p => p a₁ b₁ -> p a₂ b₂ -> p (a₁, a₂) (b₁, b₂) infixr 3

(&&&) :: Strong (,) p => p a b₁ -> p a b₂ -> p a (b₁, b₂) infixr 3

(+++) :: Strong Either p => p a₁ b₁ -> p a₂ b₂ -> p (Either a₁ a₂) (Either b₁ b₂) infixr 2

(|||) :: Strong Either p => p a₁ b -> p a₂ b -> p (Either a₁ a₂) b infixr 2

class Profunctor p => Costrong f p where

Methods

costrongL :: p (f a c) (f b c) -> p a b

costrongR :: p (f a b) (f a c) -> p b c

costrongL :: Braided f => p (f a c) (f b c) -> p a b

costrongR :: Braided f => p (f a b) (f a c) -> p b c

Instances

Monad m => Costrong Either (Kleisli m)

Methods

costrongL :: Kleisli m (Either a c) (Either b c) -> Kleisli m a b

costrongR :: Kleisli m (Either a b) (Either a c) -> Kleisli m b c

MonadFix m => Costrong (,) (Kleisli m)

Methods

costrongL :: Kleisli m (a, c) (b, c) -> Kleisli m a b

costrongR :: Kleisli m (a, b) (a, c) -> Kleisli m b c

Costrong Either ((->) LiftedRep LiftedRep)

Methods

costrongL :: (LiftedRep -> LiftedRep) (Either a c) (Either b c) -> (LiftedRep -> LiftedRep) a b

costrongR :: (LiftedRep -> LiftedRep) (Either a b) (Either a c) -> (LiftedRep -> LiftedRep) b c

Functor f => Costrong Either (Cokleisli * f)

Methods

costrongL :: Cokleisli * f (Either a c) (Either b c) -> Cokleisli * f a b

costrongR :: Cokleisli * f (Either a b) (Either a c) -> Cokleisli * f b c

Costrong (,) ((->) LiftedRep LiftedRep)

Methods

costrongL :: (LiftedRep -> LiftedRep) (a, c) (b, c) -> (LiftedRep -> LiftedRep) a b

costrongR :: (LiftedRep -> LiftedRep) (a, b) (a, c) -> (LiftedRep -> LiftedRep) b c

class Profunctor p => Closed f p where

Minimal complete definition

closed

Methods

closed :: p a b -> p (f a) (f b)

Instances

(Traversable f, Applicative p) => Closed f (Kleisli p)

Methods

closed :: Kleisli p a b -> Kleisli p (f a) (f b)

(Cotraversable f, Functor ɯ) => Closed f (Cokleisli * ɯ)

Methods

closed :: Cokleisli * ɯ a b -> Cokleisli * ɯ (f a) (f b)

Functor f => Closed f ((->) LiftedRep LiftedRep)

Methods

closed :: (LiftedRep -> LiftedRep) a b -> (LiftedRep -> LiftedRep) (f a) (f b)