Data.Semigroup.Traversable.Class

Documentation

class (Bifoldable1 t, Bitraversable t) => Bitraversable1 t where

Minimal complete definition

bitraverse1 | bisequence1

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> t a c -> f (t b d)

bisequence1 :: Apply f => t (f a) (f b) -> f (t a b)

Instances

Bitraversable1 Either

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Either a c -> f (Either b d)

bisequence1 :: Apply f => Either (f a) (f b) -> f (Either a b)

Bitraversable1 (,)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> (a, c) -> f (b, d)

bisequence1 :: Apply f => (f a, f b) -> f (a, b)

Bitraversable1 Arg

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Arg a c -> f (Arg b d)

bisequence1 :: Apply f => Arg (f a) (f b) -> f (Arg a b)

Bitraversable1 ((,,) x)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> (x, a, c) -> f (x, b, d)

bisequence1 :: Apply f => (x, f a, f b) -> f (x, a, b)

Bitraversable1 (Const *)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Const * a c -> f (Const * b d)

bisequence1 :: Apply f => Const * (f a) (f b) -> f (Const * a b)

Bitraversable1 (Tagged *)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Tagged * a c -> f (Tagged * b d)

bisequence1 :: Apply f => Tagged * (f a) (f b) -> f (Tagged * a b)

Bitraversable1 ((,,,) x y)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> (x, y, a, c) -> f (x, y, b, d)

bisequence1 :: Apply f => (x, y, f a, f b) -> f (x, y, a, b)

Bitraversable1 ((,,,,) x y z)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> (x, y, z, a, c) -> f (x, y, z, b, d)

bisequence1 :: Apply f => (x, y, z, f a, f b) -> f (x, y, z, a, b)

Bitraversable1 p => Bitraversable1 (WrappedBifunctor * * p)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> WrappedBifunctor * * p a c -> f (WrappedBifunctor * * p b d)

bisequence1 :: Apply f => WrappedBifunctor * * p (f a) (f b) -> f (WrappedBifunctor * * p a b)

Traversable1 g => Bitraversable1 (Joker * * g)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Joker * * g a c -> f (Joker * * g b d)

bisequence1 :: Apply f => Joker * * g (f a) (f b) -> f (Joker * * g a b)

Bitraversable1 p => Bitraversable1 (Flip * * p)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Flip * * p a c -> f (Flip * * p b d)

bisequence1 :: Apply f => Flip * * p (f a) (f b) -> f (Flip * * p a b)

Traversable1 f => Bitraversable1 (Clown * * f)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Clown * * f a c -> f (Clown * * f b d)

bisequence1 :: Apply f => Clown * * f (f a) (f b) -> f (Clown * * f a b)

(Bitraversable1 f, Bitraversable1 g) => Bitraversable1 (Product * * f g)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Product * * f g a c -> f (Product * * f g b d)

bisequence1 :: Apply f => Product * * f g (f a) (f b) -> f (Product * * f g a b)

(Traversable1 f, Bitraversable1 p) => Bitraversable1 (Tannen * * * f p)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Tannen * * * f p a c -> f (Tannen * * * f p b d)

bisequence1 :: Apply f => Tannen * * * f p (f a) (f b) -> f (Tannen * * * f p a b)

(Bitraversable1 p, Traversable1 f, Traversable1 g) => Bitraversable1 (Biff * * * * p f g)

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Biff * * * * p f g a c -> f (Biff * * * * p f g b d)

bisequence1 :: Apply f => Biff * * * * p f g (f a) (f b) -> f (Biff * * * * p f g a b)

class (Foldable1 t, Traversable t) => Traversable1 t where

Minimal complete definition

traverse1 | sequence1

Methods

traverse1 :: Apply f => (a -> f b) -> t a -> f (t b)

sequence1 :: Apply f => t (f b) -> f (t b)

Instances

Traversable1 V1

Methods

traverse1 :: Apply f => (a -> f b) -> V1 a -> f (V1 b)

sequence1 :: Apply f => V1 (f b) -> f (V1 b)

Traversable1 Par1

Methods

traverse1 :: Apply f => (a -> f b) -> Par1 a -> f (Par1 b)

sequence1 :: Apply f => Par1 (f b) -> f (Par1 b)

Traversable1 Identity

Methods

traverse1 :: Apply f => (a -> f b) -> Identity a -> f (Identity b)

sequence1 :: Apply f => Identity (f b) -> f (Identity b)

Traversable1 NonEmpty

Methods

traverse1 :: Apply f => (a -> f b) -> NonEmpty a -> f (NonEmpty b)

sequence1 :: Apply f => NonEmpty (f b) -> f (NonEmpty b)

Traversable1 Complex

Methods

traverse1 :: Apply f => (a -> f b) -> Complex a -> f (Complex b)

sequence1 :: Apply f => Complex (f b) -> f (Complex b)

Traversable1 Tree

Methods

traverse1 :: Apply f => (a -> f b) -> Tree a -> f (Tree b)

sequence1 :: Apply f => Tree (f b) -> f (Tree b)

Traversable1 f => Traversable1 (Rec1 f)

Methods

traverse1 :: Apply f => (a -> f b) -> Rec1 f a -> f (Rec1 f b)

sequence1 :: Apply f => Rec1 f (f b) -> f (Rec1 f b)

Traversable1 ((,) a)

Methods

traverse1 :: Apply f => (a -> f b) -> (a, a) -> f (a, b)

sequence1 :: Apply f => (a, f b) -> f (a, b)

Traversable1 f => Traversable1 (Lift f)

Methods

traverse1 :: Apply f => (a -> f b) -> Lift f a -> f (Lift f b)

sequence1 :: Apply f => Lift f (f b) -> f (Lift f b)

(Traversable1 f, Traversable1 g) => Traversable1 ((:+:) f g)

Methods

traverse1 :: Apply f => (a -> f b) -> (f :+: g) a -> f ((f :+: g) b)

sequence1 :: Apply f => (f :+: g) (f b) -> f ((f :+: g) b)

(Traversable1 f, Traversable1 g) => Traversable1 ((:*:) f g)

Methods

traverse1 :: Apply f => (a -> f b) -> (f :*: g) a -> f ((f :*: g) b)

sequence1 :: Apply f => (f :*: g) (f b) -> f ((f :*: g) b)

(Traversable1 f, Traversable1 g) => Traversable1 ((:.:) f g)

Methods

traverse1 :: Apply f => (a -> f b) -> (f :.: g) a -> f ((f :.: g) b)

sequence1 :: Apply f => (f :.: g) (f b) -> f ((f :.: g) b)

Bitraversable1 p => Traversable1 (Join * p)

Methods

traverse1 :: Apply f => (a -> f b) -> Join * p a -> f (Join * p b)

sequence1 :: Apply f => Join * p (f b) -> f (Join * p b)

Traversable1 f => Traversable1 (IdentityT * f)

Methods

traverse1 :: Apply f => (a -> f b) -> IdentityT * f a -> f (IdentityT * f b)

sequence1 :: Apply f => IdentityT * f (f b) -> f (IdentityT * f b)

Traversable1 (Tagged * a)

Methods

traverse1 :: Apply f => (a -> f b) -> Tagged * a a -> f (Tagged * a b)

sequence1 :: Apply f => Tagged * a (f b) -> f (Tagged * a b)

Traversable1 f => Traversable1 (Reverse * f)

Methods

traverse1 :: Apply f => (a -> f b) -> Reverse * f a -> f (Reverse * f b)

sequence1 :: Apply f => Reverse * f (f b) -> f (Reverse * f b)

Traversable1 f => Traversable1 (Backwards * f)

Methods

traverse1 :: Apply f => (a -> f b) -> Backwards * f a -> f (Backwards * f b)

sequence1 :: Apply f => Backwards * f (f b) -> f (Backwards * f b)

Traversable1 f => Traversable1 (M1 i c f)

Methods

traverse1 :: Apply f => (a -> f b) -> M1 i c f a -> f (M1 i c f b)

sequence1 :: Apply f => M1 i c f (f b) -> f (M1 i c f b)

(Traversable1 f, Traversable1 g) => Traversable1 (Sum * f g)

Methods

traverse1 :: Apply f => (a -> f b) -> Sum * f g a -> f (Sum * f g b)

sequence1 :: Apply f => Sum * f g (f b) -> f (Sum * f g b)

(Traversable1 f, Traversable1 g) => Traversable1 (Product * f g)

Methods

traverse1 :: Apply f => (a -> f b) -> Product * f g a -> f (Product * f g b)

sequence1 :: Apply f => Product * f g (f b) -> f (Product * f g b)

(Traversable1 f, Traversable1 g) => Traversable1 (Compose * * f g)

Methods

traverse1 :: Apply f => (a -> f b) -> Compose * * f g a -> f (Compose * * f g b)

sequence1 :: Apply f => Compose * * f g (f b) -> f (Compose * * f g b)

Traversable1 g => Traversable1 (Joker * * g a)

Methods

traverse1 :: Apply f => (a -> f b) -> Joker * * g a a -> f (Joker * * g a b)

sequence1 :: Apply f => Joker * * g a (f b) -> f (Joker * * g a b)