Hoogle Search

Within LTS Haskell 24.6 (ghc-9.10.2)

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

  1. sequence_ :: forall m a (n :: Nat) . (Monad m, Unbox (m a)) => Vector n (m a) -> m ()

    vector-sized Data.Vector.Unboxed.Sized

    Evaluate each action and discard the results.

  2. sequenceConcurrently :: forall t (r :: EffectRow) a . (Traversable t, Member Async r) => t (Sem r a) -> Sem r (t (Maybe a))

    polysemy Polysemy.Async

    Perform a sequence of effectful actions concurrently.

  3. sequence_ :: forall m (n :: Nat) a . Monad m => ListN n (m a) -> m ()

    basement Basement.Sized.List

    Evaluate each monadic action in the list sequentially, and ignore the results.

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

    ghc-internal GHC.Internal.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.

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

    ghc-internal GHC.Internal.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"
"!"

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

    ghc-internal GHC.Internal.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.

  7. sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)

    ghc-internal GHC.Internal.Data.Traversable

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

    Examples

    Basic usage: For the first two examples we show sequenceA fully evaluating a a structure and collecting the results. 
    >>> sequenceA [Just 1, Just 2, Just 3]
Just [1,2,3]

    >>> sequenceA [Right 1, Right 2, Right 3]
Right [1,2,3]
    The next two example show Nothing and Just will short circuit the resulting structure if present in the input. For more context, check the Traversable instances for Either and Maybe. 
    >>> sequenceA [Just 1, Just 2, Just 3, Nothing]
Nothing

    >>> sequenceA [Right 1, Right 2, Right 3, Left 4]
Left 4

  8. sequenceA :: forall r ix e r' f . (Source r' (f e), Manifest r e, Index ix, Applicative f) => Array r' ix (f e) -> f (Array r ix e)

    massiv Data.Massiv.Array

    Sequence actions in a source array.

  9. sequenceA_ :: forall r ix e f . (Index ix, Source r (f e), Applicative f) => Array r ix (f e) -> f ()

    massiv Data.Massiv.Array

    Sequence actions in a source array, while discarding the result.

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

    protolude Protolude

    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"
"!"

Page 33 of many | Previous | Next