Hoogle Search

Within LTS Haskell 24.51 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)

   base	Control.Monad

   Evaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see sequence_.

   Examples

   Basic usage: The first two examples are instances where the input and and output of sequence are isomorphic.

   >>> sequence $ Right [1,2,3,4]
   [Right 1,Right 2,Right 3,Right 4]
   

   >>> sequence $ [Right 1,Right 2,Right 3,Right 4]
   Right [1,2,3,4]
   

   The following examples demonstrate short circuit behavior for sequence.

   >>> sequence $ Left [1,2,3,4]
   Left [1,2,3,4]
   

   >>> sequence $ [Left 0, Right 1,Right 2,Right 3,Right 4]
   Left 0
   

2. sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

   base	Control.Monad

   Evaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequence. sequence_ is just like sequenceA_, but specialised to monadic actions.

3. bisequenceA_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()

   base	Data.Bifoldable

   Alias for bisequence_.

4. bisequence_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()

   base	Data.Bifoldable

   Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results, see bisequence.

   Examples

   Basic usage:

   >>> bisequence_ (print "Hello", print "World")
   "Hello"
   "World"
   

   >>> bisequence_ (Left (print "Hello"))
   "Hello"
   

   >>> bisequence_ (Right (print "World"))
   "World"
   

5. bisequence :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b)

   base	Data.Bitraversable

   Sequences all the actions in a structure, building a new structure with the same shape using the results of the actions. For a version that ignores the results, see bisequence_.

   bisequence ≡ bitraverse id id
   

   Examples

   Basic usage:

   >>> bisequence (Just 4, Nothing)
   Nothing
   

   >>> bisequence (Just 4, Just 5)
   Just (4,5)
   

   >>> bisequence ([1, 2, 3], [4, 5])
   [(1,4),(1,5),(2,4),(2,5),(3,4),(3,5)]
   

6. bisequenceA :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b)

   base	Data.Bitraversable

   Alias for bisequence.

7. sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()

   base	Data.Foldable

   Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequenceA. sequenceA_ is just like sequence_, but generalised to Applicative actions.

   Examples

   Basic usage:

   >>> sequenceA_ [print "Hello", print "world", print "!"]
   "Hello"
   "world"
   "!"
   

8. sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

   base	Data.Foldable

   Evaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequence. sequence_ is just like sequenceA_, but specialised to monadic actions.

9. liftEq :: Eq1 f => (a -> b -> Bool) -> f a -> f b -> Bool

   base	Data.Functor.Classes

   Lift an equality test through the type constructor. The function will usually be applied to an equality function, but the more general type ensures that the implementation uses it to compare elements of the first container with elements of the second.

10. liftEq2 :: Eq2 f => (a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool

    base	Data.Functor.Classes

    Lift equality tests through the type constructor. The function will usually be applied to equality functions, but the more general type ensures that the implementation uses them to compare elements of the first container with elements of the second.

Page 134 of many | Previous | Next