until -package:numeric-prelude -package:util -package:xmonad-contrib -package:LambdaHack -package:mixed-types-num -package:llvm-hs-pure -package:free -package:scalpel-core -package:dunai -package:monad-loops

until :: (a -> Bool) -> (a -> a) -> a -> a
base Prelude GHC.Base, amazonka-core Amazonka.Prelude, hedgehog Hedgehog.Internal.Prelude, base-compat Prelude.Compat, protolude Protolude Protolude.Base, base-prelude BasePrelude, classy-prelude ClassyPrelude, Cabal-syntax Distribution.Compat.Prelude, basic-prelude CorePrelude, ihaskell IHaskellPrelude, github GitHub.Internal.Prelude, numhask NumHask.Prelude, clash-prelude Clash.HaskellPrelude, foundation Foundation, ghc-lib-parser GHC.Prelude.Basic, dimensional Numeric.Units.Dimensional.Prelude, elerea FRP.Elerea.Simple.Pure, rebase Rebase.Prelude, linear-base Prelude.Linear, cabal-install-solver Distribution.Solver.Compat.Prelude, faktory Faktory.Prelude, yesod-paginator Yesod.Paginator.Prelude, distribution-opensuse OpenSuse.Prelude, hledger-web Hledger.Web.Import, termonad Termonad.Prelude
until p f yields the result of applying f until p holds.
until :: (a -> Bool) -> (a -> a) -> a -> a
ghc GHC.Prelude.Basic
until :: Monad m => (a -> Bool) -> m a -> m a
utility-ht Control.Monad.HT
repeat action until result fulfills condition
until :: () => (a -> Bool) -> (a -> a) -> a -> a
prelude-compat Prelude2010
until p f yields the result of applying f until p holds.
until :: (Monoid e) => Wire s e m (a, Event b) a
netwire Control.Wire.Interval
Produce until the given event occurs. When it occurs, inhibit with its value forever.
  • Depends: now until event occurs.
  • Inhibits: forever after event occurs.
until :: Firstable es es' (ISig s (es :+: es') a r) r' => Sig s es a r -> React s es' r' -> Sig s (es :+: es') a (Either r (a, r'))
moffy Control.Moffy Control.Moffy.NoThreadId
until :: Integral a => a -> Stream Bool -> Stream Bool -> Stream Bool
copilot-libraries Copilot.Library.LTL
until n s0 s1 means that eventually n s1, and up until at least the period before s1 holds, s0 continuously holds. Note: Both argument streams must have sufficient history to drop n values from them.
until :: (Typed a, Integral a) => a -> a -> Stream a -> a -> Stream Bool -> Stream Bool -> Stream Bool
copilot-libraries Copilot.Library.MTL
True until another stream is true, within the time bounds specified. until l u clk dist s0 s1 is true at time t iff there exists a d, with l <= d <= u, such that s1 is true at time (t + d), and for all times t' with t <= t' < t + d, s0 is true at those times.
type family Until (a1 :: a ~> Bool) (a2 :: a ~> a) (a3 :: a) :: a
singletons-base Prelude.Singletons
untilJustM :: Monad m => m (Maybe a) -> m a
extra Control.Monad.Extra Extra
Keep running an operation until it becomes a Just, then return the value inside the Just as the result of the overall loop.
untilM :: Monad m => (a -> Bool) -> m a -> m a
utility-ht Control.Monad.HT
Deprecated: use M.until
untilEOL :: Parser ByteString
snap-core Snap.Internal.Parsing
untilJust :: (Monad m, Applicative f) => m (Maybe r) -> Stream f m r
streaming Streaming Streaming.Internal
Repeat a
untilLeft :: Monad m => m (Either r a) -> Stream (Of a) m r
streaming Streaming.Prelude
untilRight :: Monad m => m (Either a r) -> Stream (Of a) m r
streaming Streaming.Prelude
untilMaybe :: Monad m => (a -> Maybe b) -> m a -> m b
hosc Sound.Osc Sound.Osc.Wait
Repeat action until f does not give Nothing when applied to result.
untilPredicate :: Monad m => (a -> Bool) -> m a -> m a
hosc Sound.Osc Sound.Osc.Wait
Repeat action until predicate f is True when applied to result.
untilM :: Monad m => m Bool -> m () -> m ()
IfElse Control.Monad.IfElse
Negation of whileM: execute an action so long as the boolean returns false.
untilJust :: [IO (Maybe a)] -> IO (Maybe a)
conferer Conferer.Config.Internal
This utility function run a list of IO actions and returns the first that return a Just, if no one does, returns Nothing
untilRight :: (Monoid a, Selective f) => f (Either a b) -> f (a, b)
selective Control.Selective, rebase Rebase.Prelude
Keep running an effectful computation until it returns a Right value, collecting the Left's using a supplied Monoid instance.
untilInput :: (MonadIO m, MonadMask m) => (a -> Bool) -> InputT m a -> InputT m a
simple-prompt SimplePrompt.Internal
loop prompt until check
untilJust :: forall f m r . (Monad m, Applicative f) => m (Maybe r) -> Stream f m r
linear-base Streaming.Linear
untilRight :: forall m a r . Monad m => m (Either (Ur a) r) -> Stream (Of a) m r
linear-base Streaming.Prelude.Linear
until_ :: Firstable es es' (ISig s (es :+: es') a r) r' => React s (es :+: es') (ThreadId, ThreadId) -> Sig s es a r -> React s es' r' -> Sig s (es :+: es') a (Either r (a, r'))
moffy Control.Moffy.Internal.Sig
untilBack :: forall str (m :: Type -> Type) a b . (StringLike str, Monad m) => ScraperT str m a -> SerialScraperT str m b -> SerialScraperT str m b
scalpel Text.HTML.Scalpel
Create a new serial context by moving the focus backward and collecting nodes until the scraper matches the focused node. The serial scraper is then executed on the collected nodes.