Hoogle Search

Within LTS Haskell 24.36 (ghc-9.10.3)

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

  1. 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.

  2. 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.

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

  4. 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.

  5. 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

  6. 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.

  7. 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.

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

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

    protolude Protolude

    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.

  10. sequence' :: Monad f => [f a] -> f [a]

    hledger-lib Hledger.Utils

    This is a version of sequence based on difference lists. It is slightly faster but we mostly use it because it uses the heap instead of the stack. This has the advantage that Neil Mitchell’s trick of limiting the stack size to discover space leaks doesn’t show this as a false positive.

Page 33 of many | Previous | Next