Safe Haskell | None |
---|---|
Language | Haskell2010 |
- class (Choice p, Strong p) => Traversing p where
- traverse' :: Traversable f => p a b -> p (f a) (f b)
- wander :: (forall f. Applicative f => (a -> f b) -> s -> f t) -> p a b -> p s t
- newtype CofreeTraversing p a b = CofreeTraversing {
- runCofreeTraversing :: forall f. Traversable f => p (f a) (f b)
- data FreeTraversing p a b where
- FreeTraversing :: Traversable f => (f y -> b) -> p x y -> (a -> f x) -> FreeTraversing p a b
- firstTraversing :: Traversing p => p a b -> p (a, c) (b, c)
- secondTraversing :: Traversing p => p a b -> p (c, a) (c, b)
- leftTraversing :: Traversing p => p a b -> p (Either a c) (Either b c)
- rightTraversing :: Traversing p => p a b -> p (Either c a) (Either c b)
Documentation
class (Choice p, Strong p) => Traversing p where
Note: Definitions in terms of wander
are much more efficient!
traverse' :: Traversable f => p a b -> p (f a) (f b)
wander :: (forall f. Applicative f => (a -> f b) -> s -> f t) -> p a b -> p s t
Traversing (->) | |
Monad m => Traversing (Kleisli m) | |
Applicative m => Traversing (Star m) | |
Traversing (FreeTraversing p) | |
Profunctor p => Traversing (CofreeTraversing p) | |
Traversing (FreeMapping p) | |
Profunctor p => Traversing (CofreeMapping p) |
newtype CofreeTraversing p a b
CofreeTraversing | |
|
ProfunctorComonad CofreeTraversing | |
ProfunctorFunctor CofreeTraversing | |
Profunctor p => Profunctor (CofreeTraversing p) | |
Profunctor p => Strong (CofreeTraversing p) | |
Profunctor p => Choice (CofreeTraversing p) | |
Profunctor p => Traversing (CofreeTraversing p) |
data FreeTraversing p a b where
FreeTraversing -| CofreeTraversing
FreeTraversing :: Traversable f => (f y -> b) -> p x y -> (a -> f x) -> FreeTraversing p a b |
Strong in terms of Traversing
firstTraversing :: Traversing p => p a b -> p (a, c) (b, c)
secondTraversing :: Traversing p => p a b -> p (c, a) (c, b)
Choice in terms of Traversing
leftTraversing :: Traversing p => p a b -> p (Either a c) (Either b c)
rightTraversing :: Traversing p => p a b -> p (Either c a) (Either c b)