until -package:numeric-prelude -package:base-prelude -package:distribution-opensuse -package:extra -package:ghc -package:linear-base -package:mixed-types-num -package:yesod-paginator -package:LambdaHack -package:IfElse -package:dimensional
base Prelude GHC.Base,
amazonka-core Amazonka.Prelude,
hedgehog Hedgehog.Internal.Prelude,
base-compat Prelude.Compat,
protolude Protolude Protolude.Base,
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,
elerea FRP.Elerea.Simple.Pure,
rebase Rebase.Prelude,
xmonad-contrib XMonad.Config.Prime,
cabal-install-solver Distribution.Solver.Compat.Prelude,
faktory Faktory.Prelude,
hledger-web Hledger.Web.Import,
termonad Termonad.Prelude until p f yields the result of applying
f
until
p holds.
repeat action until result fulfills condition
until p f yields the result of applying
f
until
p holds.
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 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.
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.
Repeatedly run a computation until it produces a
Just value.
This can be useful when paired with a monad that has side effects.
For example, we may have
genId :: IO (Maybe Id) that uses a
random number generator to allocate ids, but fails if it finds a
collision. We can repeatedly run this with
retract (untilJust genId) :: IO Id
Run the supplied
Maybe computation repeatedly until it returns
a value. Returns that value.
Execute an action repeatedly until the condition expression returns
True. The condition is evaluated after the loop body. Collects results
into a list. Parameters are arranged for infix usage. eg. do {...}
untilM_ ...
Execute an action repeatedly until the condition expression returns
True. The condition is evaluated after the loop body. Collects results
into a
MonadPlus value. Parameters are arranged for infix
usage. eg. do {...}
untilM_ ...
Execute an action repeatedly until the condition expression returns
True. The condition is evaluated after the loop body. Discards
results. Parameters are arranged for infix usage. eg. do {...}
untilM_ ...
Repeat action until
f does not give
Nothing when applied
to result.
Repeat action until predicate
f is
True when applied to
result.
This utility function run a list of IO actions and returns the first
that return a
Just, if no one does, returns
Nothing
Keep running an effectful computation until it returns a
Right value, collecting the Left's using a supplied
Monoid instance.
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.