Safe Haskell | None |
---|---|
Language | Haskell2010 |
Synopsis
- arr :: (Profunctor p, Category p) => (a -> b) -> p a b
- (***) :: (Category p, Strong p) => p b c -> p b' c' -> p (b, b') (c, c')
- (&&&) :: (Category p, Strong p) => p b c -> p b c' -> p b (c, c')
- (^>>) :: (Profunctor p, Category p) => (b -> c) -> p c d -> p b d
- (>>^) :: (Profunctor p, Category p) => p b c -> (c -> d) -> p b d
- (<<^) :: (Profunctor p, Category p) => p c d -> (b -> c) -> p b d
- (^<<) :: (Profunctor p, Category p) => (c -> d) -> p b c -> p b d
- (+++) :: (Choice p, Category p) => p b c -> p b' c' -> p (Either b b') (Either c c')
- (|||) :: (Choice p, Category p) => p b d -> p c d -> p (Either b c) d
- class Profunctor p => ProfunctorZero p where
- zeroProfunctor :: p a b
- class ProfunctorZero p => ProfunctorPlus p where
- (<+>) :: p a b -> p a b -> p a b
- class Profunctor p => ProfunctorApply p where
- app :: p (p a b, a) b
Documentation
arr :: (Profunctor p, Category p) => (a -> b) -> p a b Source #
(***) :: (Category p, Strong p) => p b c -> p b' c' -> p (b, b') (c, c') Source #
Split the input between the two argument profunctors and combine their output.
(&&&) :: (Category p, Strong p) => p b c -> p b c' -> p b (c, c') Source #
Fanout: send the input to both argument arrows and combine their output.
(^>>) :: (Profunctor p, Category p) => (b -> c) -> p c d -> p b d Source #
Precomposition with a pure function.
(>>^) :: (Profunctor p, Category p) => p b c -> (c -> d) -> p b d Source #
Postcomposition with a pure function.
(<<^) :: (Profunctor p, Category p) => p c d -> (b -> c) -> p b d Source #
Precomposition with a pure function (right-to-left variant).
(^<<) :: (Profunctor p, Category p) => (c -> d) -> p b c -> p b d Source #
Postcomposition with a pure function (right-to-left variant).
class Profunctor p => ProfunctorZero p where Source #
zeroProfunctor :: p a b Source #
Instances
class ProfunctorZero p => ProfunctorPlus p where Source #
Instances
class Profunctor p => ProfunctorApply p where Source #
Instances
Monad m => ProfunctorApply (Kleisli m) Source # | |
Functor f => ProfunctorApply (Star f) Source # | |
(Arrow p, ArrowApply p) => ProfunctorApply (WrappedArrow p) Source # | |
Defined in Data.Profunctor.Arrow app :: WrappedArrow p (WrappedArrow p a b, a) b Source # | |
ProfunctorApply (Forget r) Source # | |
ProfunctorApply (ContP r) Source # | |
ProfunctorApply ((->) :: Type -> Type -> Type) Source # | |
Defined in Data.Profunctor.Arrow | |
Alternative g => ProfunctorApply (Joker g :: Type -> Type -> Type) Source # | |