:: f (Maybe a) -> f a -package:pinch

untilJustM :: Monad m => m (Maybe a) -> m a
extra Control.Monad.Extra Extra, distribution-opensuse OpenSuse.Prelude
Keep running an operation until it becomes a Just, then return the value inside the Just as the result of the overall loop.
untilJust :: Monad m => m (Maybe a) -> m a
monad-loops Control.Monad.Loops
Run the supplied Maybe computation repeatedly until it returns a value. Returns that value.
catMaybes :: (IsSequence (f (Maybe t)), Functor f, Element (f (Maybe t)) ~ Maybe t) => f (Maybe t) -> f t
mono-traversable Data.Sequences
Takes all of the Just values from a sequence of Maybe ts and concatenates them into an unboxed sequence of ts. Since 0.6.2
whileJustM :: (Monad m, Monoid a) => m (Maybe a) -> m a
extra Control.Monad.Extra Extra, distribution-opensuse OpenSuse.Prelude
Keep running an operation until it becomes a Nothing, accumulating the monoid results inside the Justs as the result of the overall loop.
maybeToDefinite :: (Monoid a, Functor m) => m (Maybe a) -> m a
xmonad-contrib XMonad.Hooks.ManageHelpers
converts MaybeManageHooks to ManageHooks
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
base Prelude Data.Traversable, hedgehog Hedgehog.Internal.Prelude, base-compat Prelude.Compat, relude Relude.Foldable.Reexport, base-prelude BasePrelude, classy-prelude ClassyPrelude, Cabal-syntax Distribution.Compat.Prelude, universum Universum.Base, numhask NumHask.Prelude, ghc-lib-parser GHC.Prelude.Basic, ghc-internal GHC.Internal.Data.Traversable, dimensional Numeric.Units.Dimensional.Prelude, rebase Rebase.Prelude, mixed-types-num Numeric.MixedTypes.PreludeHiding, xmonad-contrib XMonad.Config.Prime, constrained-categories Control.Category.Constrained.Prelude Control.Category.Hask, copilot-language Copilot.Language.Prelude, incipit-base Incipit.Base, LambdaHack Game.LambdaHack.Core.Prelude, cabal-install-solver Distribution.Solver.Compat.Prelude, faktory Faktory.Prelude, vcr Imports, verset Verset, distribution-opensuse OpenSuse.Prelude, termonad Termonad.Prelude
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
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
ghc GHC.Prelude.Basic
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
rio RIO.Prelude, clash-prelude Clash.HaskellPrelude, yesod-paginator Yesod.Paginator.Prelude
Evaluate each action in the structure from left to right, and collect the results. For a version that ignores the results see sequenceA_.
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
basic-prelude BasicPrelude
Evaluate each action in the structure from left to right, and and collect the results. For a version that ignores the results see sequenceA_.
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
base Prelude Control.Monad Data.Traversable, hedgehog Hedgehog.Internal.Prelude, base-compat Control.Monad.Compat Prelude.Compat, relude Relude.Foldable.Reexport, base-prelude BasePrelude, classy-prelude ClassyPrelude, universum Universum.Base, ihaskell IHaskellPrelude, numhask NumHask.Prelude, base-compat-batteries Control.Monad.Compat, ghc-lib-parser GHC.Prelude.Basic, ghc-internal GHC.Internal.Control.Monad GHC.Internal.Data.Traversable, dimensional Numeric.Units.Dimensional.Prelude, rebase Rebase.Prelude, mixed-types-num Numeric.MixedTypes.PreludeHiding, xmonad-contrib XMonad.Config.Prime, constrained-categories Control.Category.Hask, copilot-language Copilot.Language.Prelude, massiv-test Test.Massiv.Utils, incipit-base Incipit.Base, LambdaHack Game.LambdaHack.Core.Prelude Game.LambdaHack.Core.Prelude, faktory Faktory.Prelude, can-i-haz Control.Monad.Except.CoHas Control.Monad.Reader.Has, vcr Imports, distribution-opensuse OpenSuse.Prelude OpenSuse.Prelude, termonad Termonad.Prelude
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
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
ghc GHC.Prelude.Basic
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
rio RIO.Prelude, numeric-prelude NumericPrelude NumericPrelude.Base, basic-prelude BasicPrelude, clash-prelude Clash.HaskellPrelude, prelude-compat Prelude2010, yesod-paginator Yesod.Paginator.Prelude
Evaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see sequence_.
sequence :: (Monad m, Vector v a, Vector v (m a)) => v (m a) -> m (v a)
rio RIO.Vector
Evaluate each action and collect the results
sequence :: (Vector v a, Vector v (f a), Applicative f) => v (f a) -> f (v a)
fixed-vector Data.Vector.Fixed
Evaluate every action in the vector from left to right.
sequenceA :: (Vector v a, Vector v (f a), Applicative f) => v (f a) -> f (v a)
fixed-vector Data.Vector.Fixed
Analog of sequenceA from Traversable.
distribute :: (Vector v a, Vector v (f a), Functor f) => f (v a) -> v (f a)
fixed-vector Data.Vector.Fixed