object Stream extends StreamLowPriority
- Source
- Stream.scala
- Alphabetic
- By Inheritance
- Stream
- StreamLowPriority
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- final class CompileOps[F[_], G[_], O] extends AnyRef
Projection of a
Stream
providing various ways to compile aStream[F,O]
to aG[...]
. - sealed trait Compiler[F[_], G[_]] extends AnyRef
Type class which describes compilation of a
Stream[F, O]
to aG[*]
. - final class FallibleOps[O] extends AnyVal
Provides syntax for fallible streams.
- final class FallibleTo[O] extends AnyVal
Provides
to
syntax for fallible streams. - final class IdOps[O] extends AnyVal
Provides syntax for pure pipes based on
cats.Id
. - final class InvariantOps[F[_], O] extends AnyVal
Provides syntax for streams that are invariant in
F
andO
. - implicit final class PipeOps[F[_], I, O] extends AnyVal
Provides operations on effectful pipes for syntactic convenience.
- final class PureOps[O] extends AnyVal
Provides syntax for pure streams.
- implicit final class PurePipe2Ops[I, I2, O] extends AnyVal
Provides operations on pure pipes for syntactic convenience.
- implicit final class PurePipeOps[I, O] extends AnyVal
Provides operations on pure pipes for syntactic convenience.
- final class PureTo[O] extends AnyVal
Provides
to
syntax for pure streams. - final class StepLeg[F[_], O] extends AnyRef
When merging multiple streams, this represents step of one leg.
When merging multiple streams, this represents step of one leg.
It is common to
uncons
, however unlikeuncons
, it keeps track of stream scope independently of the main scope of the stream.This assures, that after each next
stepLeg
each Streamleg
keeps its scope when interpreting.Usual scenarios is to first invoke
stream.pull.stepLeg
and then consume whatever is available inleg.head
. If the next step is requiredleg.stepLeg
will yield nextLeg
.Once the stream will stop to be interleaved (merged), then
stream
allows to return to normal stream invocation. - final class ToPull[F[_], O] extends AnyVal
Projection of a
Stream
providing various ways to get aPull
from theStream
.
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- implicit def FallibleOps[O](s: Stream[Fallible, O]): FallibleOps[O]
Provides syntax for streams with effect type
Fallible
. - implicit def FallibleTo[O](s: Stream[Fallible, O]): FallibleTo[O]
Provides
to
syntax for streams with effect typeFallible
. - implicit def IdOps[O](s: Stream[Id, O]): IdOps[O]
Provides syntax for streams with effect type
cats.Id
. - implicit def InvariantOps[F[_], O](s: Stream[F, O]): InvariantOps[F, O]
Provides syntax for streams that are invariant in
F
andO
. - implicit def PureOps[O](s: Stream[Pure, O]): PureOps[O]
Provides syntax for pure streams.
- implicit def PureTo[O](s: Stream[Pure, O]): PureTo[O]
Provides
to
syntax for pure streams. - implicit def alignInstance[F[_]]: Align[[β$10$]Stream[F, β$10$]]
Align
instance forStream
.Align
instance forStream
. * @examplescala> import cats.syntax.all._ scala> Stream(1,2,3).align(Stream("A","B","C","D","E")).toList res0: List[cats.data.Ior[Int,String]] = List(Both(1,A), Both(2,B), Both(3,C), Right(D), Right(E))
- def apply[F[x] >: Pure[x], O](os: O*): Stream[F, O]
Creates a pure stream that emits the supplied values.
Creates a pure stream that emits the supplied values. To convert to an effectful stream, use
covary
. - final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def attemptEval[F[x] >: Pure[x], O](fo: F[O]): Stream[F, Either[Throwable, O]]
Creates a single element stream that gets its value by evaluating the supplied effect.
Creates a single element stream that gets its value by evaluating the supplied effect. If the effect fails, a
Left
is emitted. Otherwise, aRight
is emitted.Use eval instead if a failure while evaluating the effect should fail the stream.
scala> import cats.effect.IO scala> Stream.attemptEval(IO(10)).compile.toVector.unsafeRunSync() res0: Vector[Either[Throwable,Int]] = Vector(Right(10)) scala> Stream.attemptEval(IO(throw new RuntimeException)).compile.toVector.unsafeRunSync() res1: Vector[Either[Throwable,Nothing]] = Vector(Left(java.lang.RuntimeException))
Example: - def awakeDelay[F[x] >: Pure[x]](d: FiniteDuration)(implicit timer: Timer[F], F: Functor[F]): Stream[F, FiniteDuration]
Light weight alternative to
awakeEvery
that sleeps for durationd
before each pulled element. - def awakeEvery[F[x] >: Pure[x]](d: FiniteDuration)(implicit timer: Timer[F], F: Functor[F]): Stream[F, FiniteDuration]
Discrete stream that every
d
emits elapsed duration since the start time of stream consumption.Discrete stream that every
d
emits elapsed duration since the start time of stream consumption.For example:
awakeEvery[IO](5 seconds)
will return (approximately)5s, 10s, 15s
, and will lie dormant between emitted values.- d
FiniteDuration between emits of the resulting stream
- def bracket[F[x] >: Pure[x], R](acquire: F[R])(release: (R) => F[Unit]): Stream[F, R]
Creates a stream that emits a resource allocated by an effect, ensuring the resource is eventually released regardless of how the stream is used.
Creates a stream that emits a resource allocated by an effect, ensuring the resource is eventually released regardless of how the stream is used.
A typical use case for bracket is working with files or network sockets. The resource effect opens a file and returns a reference to it. One can then flatMap on the returned Stream to access the file, e.g to read bytes and transform them in to some stream of elements (e.g., bytes, strings, lines, etc.). The
release
action then closes the file once the result Stream terminates, even in case of interruption or errors.- acquire
resource to acquire at start of stream
- release
function which returns an effect that releases the resource
- def bracketCase[F[x] >: Pure[x], R](acquire: F[R])(release: (R, ExitCase[Throwable]) => F[Unit]): Stream[F, R]
Like bracket but the release action is passed an
ExitCase[Throwable]
.Like bracket but the release action is passed an
ExitCase[Throwable]
.ExitCase.Canceled
is passed to the release action in the event of either stream interruption or overall compiled effect cancelation. - def bracketCaseWeak[F[x] >: Pure[x], R](acquire: F[R])(release: (R, ExitCase[Throwable]) => F[Unit]): Stream[F, R]
Like bracketCase but no scope is introduced, causing resource finalization to occur at the end of the current scope at the time of acquisition.
- def bracketWeak[F[x] >: Pure[x], R](acquire: F[R])(release: (R) => F[Unit]): Stream[F, R]
Like bracket but no scope is introduced, causing resource finalization to occur at the end of the current scope at the time of acquisition.
- def chunk[F[x] >: Pure[x], O](os: Chunk[O]): Stream[F, O]
Creates a pure stream that emits the elements of the supplied chunk.
Creates a pure stream that emits the elements of the supplied chunk.
scala> Stream.chunk(Chunk(1,2,3)).toList res0: List[Int] = List(1, 2, 3)
Example: - def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- def constant[F[x] >: Pure[x], O](o: O, chunkSize: Int = 256): Stream[F, O]
Creates an infinite pure stream that always returns the supplied value.
Creates an infinite pure stream that always returns the supplied value.
Elements are emitted in finite chunks with
chunkSize
number of elements.scala> Stream.constant(0).take(5).toList res0: List[Int] = List(0, 0, 0, 0, 0)
Example: - implicit def deferInstance[F[_]]: Defer[[β$22$]Stream[F, β$22$]]
Defer
instance forStream
- def duration[F[x] >: Pure[x]](implicit F: Sync[F]): Stream[F, FiniteDuration]
A continuous stream of the elapsed time, computed using
System.nanoTime
.A continuous stream of the elapsed time, computed using
System.nanoTime
. Note that the actual granularity of these elapsed times depends on the OS, for instance the OS may only update the current time every ten milliseconds or so. - def emit[F[x] >: Pure[x], O](o: O): Stream[F, O]
Creates a singleton pure stream that emits the supplied value.
Creates a singleton pure stream that emits the supplied value.
scala> Stream.emit(0).toList res0: List[Int] = List(0)
Example: - def emits[F[x] >: Pure[x], O](os: Seq[O]): Stream[F, O]
Creates a pure stream that emits the supplied values.
Creates a pure stream that emits the supplied values.
scala> Stream.emits(List(1, 2, 3)).toList res0: List[Int] = List(1, 2, 3)
Example: - val empty: Stream[Pure, INothing]
Empty pure stream.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def eval[F[_], O](fo: F[O]): Stream[F, O]
Creates a single element stream that gets its value by evaluating the supplied effect.
Creates a single element stream that gets its value by evaluating the supplied effect. If the effect fails, the returned stream fails.
Use attemptEval instead if a failure while evaluating the effect should be emitted as a value.
scala> import cats.effect.IO scala> Stream.eval(IO(10)).compile.toVector.unsafeRunSync() res0: Vector[Int] = Vector(10) scala> Stream.eval(IO(throw new RuntimeException)).covaryOutput[Int].compile.toVector.attempt.unsafeRunSync() res1: Either[Throwable,Vector[Int]] = Left(java.lang.RuntimeException)
Example: - def evalSeq[F[_], S[A] <: Seq[A], O](fo: F[S[O]]): Stream[F, O]
Like
evals
, but lifts any Seq in the effect. - def evalUnChunk[F[_], O](fo: F[Chunk[O]]): Stream[F, O]
Like
eval
but resulting chunk is flatten efficiently. - def eval_[F[_], A](fa: F[A]): Stream[F, INothing]
Creates a stream that evaluates the supplied
fa
for its effect, discarding the output value.Creates a stream that evaluates the supplied
fa
for its effect, discarding the output value. As a result, the returned stream emits no elements and hence has output typeINothing
.Alias for
eval(fa).drain
.scala> import cats.effect.IO scala> Stream.eval_(IO(println("Ran"))).covaryOutput[Int].compile.toVector.unsafeRunSync() res0: Vector[Int] = Vector()
Example: - def evals[F[_], S[_], O](fo: F[S[O]])(implicit arg0: Foldable[S]): Stream[F, O]
Like
eval
, but lifts a foldable structure. - def every[F[x] >: Pure[x]](d: FiniteDuration)(implicit timer: Timer[F]): Stream[F, Boolean]
A continuous stream which is true after
d, 2d, 3d...
elapsed duration, and false otherwise.A continuous stream which is true after
d, 2d, 3d...
elapsed duration, and false otherwise. If you'd like a 'discrete' stream that will actually block untild
has elapsed, useawakeEvery
instead. - def fixedDelay[F[_]](d: FiniteDuration)(implicit timer: Timer[F]): Stream[F, Unit]
Light weight alternative to fixedRate that sleeps for duration
d
before each pulled element.Light weight alternative to fixedRate that sleeps for duration
d
before each pulled element.Behavior differs from
fixedRate
because the sleep between elements occurs after the next element is pulled whereasfixedRate
accounts for the time it takes to process the emitted unit. This difference can roughly be thought of as the difference betweenscheduleWithFixedDelay
andscheduleAtFixedRate
injava.util.concurrent.Scheduler
.Alias for
sleep(d).repeat
. - def fixedRate[F[_]](d: FiniteDuration)(implicit timer: Timer[F]): Stream[F, Unit]
Discrete stream that emits a unit every
d
.Discrete stream that emits a unit every
d
.See fixedDelay for an alternative that sleeps
d
between elements.- d
FiniteDuration between emits of the resulting stream
- def foldable[F[x] >: Pure[x], G[_], O](os: G[O])(implicit arg0: Foldable[G]): Stream[F, O]
Like
emits
, but works for any G that has aFoldable
instance. - def force[F[_], A](f: F[Stream[F, A]]): Stream[F, A]
Lifts an effect that generates a stream in to a stream.
Lifts an effect that generates a stream in to a stream. Alias for
eval(f).flatMap(_)
.scala> import cats.effect.IO scala> Stream.force(IO(Stream(1,2,3).covary[IO])).compile.toVector.unsafeRunSync() res0: Vector[Int] = Vector(1, 2, 3)
Example: - def fromBlockingIterator[F[_]]: PartiallyAppliedFromBlockingIterator[F]
Lifts an iterator into a Stream, shifting any interaction with the iterator to the supplied Blocker.
- def fromEither[F[_]]: PartiallyAppliedFromEither[F]
Lifts an Either[Throwable, A] to an effectful Stream.
Lifts an Either[Throwable, A] to an effectful Stream.
scala> import cats.effect.IO, scala.util.Try scala> Stream.fromEither[IO](Right(42)).compile.toList.unsafeRunSync() res0: List[Int] = List(42) scala> Try(Stream.fromEither[IO](Left(new RuntimeException)).compile.toList.unsafeRunSync()) res1: Try[List[Nothing]] = Failure(java.lang.RuntimeException)
Example: - def fromIterator[F[_]]: PartiallyAppliedFromIterator[F]
Lifts an iterator into a Stream.
- implicit def functionKInstance[F[_]]: ~>[F, [β$18$]Stream[F, β$18$]]
FunctionK
instance forF ~> Stream[F, *]
FunctionK
instance forF ~> Stream[F, *]
scala> import cats.Id scala> Stream.functionKInstance[Id](42).compile.toList res0: cats.Id[List[Int]] = List(42)
Example: - implicit def functorFilterInstance[F[_]]: FunctorFilter[[β$14$]Stream[F, β$14$]]
FunctorFilter
instance forStream
.FunctorFilter
instance forStream
.scala> import cats.syntax.all._, scala.util._ scala> Stream("1", "2", "NaN").mapFilter(s => Try(s.toInt).toOption).toList res0: List[Int] = List(1, 2)
Example: - final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def getScope[F[x] >: Pure[x]]: Stream[F, Scope[F]]
Gets the current scope, allowing manual leasing or interruption.
Gets the current scope, allowing manual leasing or interruption. This is a low-level method and generally should not be used by user code.
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def iterable[F[x] >: Pure[x], A](os: Iterable[A]): Stream[F, A]
Like
emits
, but works for any class that extendsIterable
- def iterate[F[x] >: Pure[x], A](start: A)(f: (A) => A): Stream[F, A]
An infinite
Stream
that repeatedly applies a given function to a start value.An infinite
Stream
that repeatedly applies a given function to a start value.start
is the first value emitted, followed byf(start)
, thenf(f(start))
, and so on.scala> Stream.iterate(0)(_ + 1).take(10).toList res0: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
Example: - def iterateEval[F[_], A](start: A)(f: (A) => F[A]): Stream[F, A]
Like iterate, but takes an effectful function for producing the next state.
Like iterate, but takes an effectful function for producing the next state.
start
is the first value emitted.scala> import cats.effect.IO scala> Stream.iterateEval(0)(i => IO(i + 1)).take(10).compile.toVector.unsafeRunSync() res0: Vector[Int] = Vector(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
Example: - implicit def monadErrorInstance[F[_]](implicit ev: ApplicativeError[F, Throwable]): MonadError[[β$8$]Stream[F, β$8$], Throwable]
MonadError
instance forStream
.MonadError
instance forStream
.scala> import cats.syntax.all._ scala> Stream(1, -2, 3).fproduct(_.abs).toList res0: List[(Int, Int)] = List((1,1), (-2,2), (3,3))
Example: - implicit def monadInstance[F[_]]: Monad[[β$24$]Stream[F, β$24$]]
- Definition Classes
- StreamLowPriority
- implicit def monoidInstance[F[_], O]: Monoid[Stream[F, O]]
Monoid
instance forStream
. - implicit def monoidKInstance[F[_]]: MonoidK[[β$20$]Stream[F, β$20$]]
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def never[F[_]](implicit F: Async[F]): Stream[F, Nothing]
A stream that never emits and never terminates.
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def raiseError[F[_]](e: Throwable)(implicit arg0: RaiseThrowable[F]): Stream[F, INothing]
Creates a stream that, when run, fails with the supplied exception.
Creates a stream that, when run, fails with the supplied exception.
The
F
type must be explicitly provided (e.g., viaraiseError[IO]
orraiseError[Fallible]
).scala> import cats.effect.IO scala> Stream.raiseError[Fallible](new RuntimeException).toList res0: Either[Throwable,List[INothing]] = Left(java.lang.RuntimeException) scala> Stream.raiseError[IO](new RuntimeException).covaryOutput[Int].compile.drain.attempt.unsafeRunSync() res0: Either[Throwable,Unit] = Left(java.lang.RuntimeException)
Example: - def random[F[_]](implicit F: Sync[F]): Stream[F, Int]
Creates a random stream of integers using a random seed.
- def randomSeeded[F[x] >: Pure[x]](seed: Long): Stream[F, Int]
Creates a random stream of integers using the supplied seed.
Creates a random stream of integers using the supplied seed. Returns a pure stream, as the pseudo random number generator is deterministic based on the supplied seed.
- def range[F[x] >: Pure[x]](start: Int, stopExclusive: Int, by: Int = 1): Stream[F, Int]
Lazily produce the range
[start, stopExclusive)
.Lazily produce the range
[start, stopExclusive)
. If you want to produce the sequence in one chunk, instead of lazily, useemits(start until stopExclusive)
.scala> Stream.range(10, 20, 2).toList res0: List[Int] = List(10, 12, 14, 16, 18)
Example: - def ranges[F[x] >: Pure[x]](start: Int, stopExclusive: Int, size: Int): Stream[F, (Int, Int)]
Lazily produce a sequence of nonoverlapping ranges, where each range contains
size
integers, assuming the upper bound is exclusive.Lazily produce a sequence of nonoverlapping ranges, where each range contains
size
integers, assuming the upper bound is exclusive. Example:ranges(0, 1000, 10)
results in the pairs(0, 10), (10, 20), (20, 30) ... (990, 1000)
Note: The last emitted range may be truncated at
stopExclusive
. For instance,ranges(0,5,4)
results in(0,4), (4,5)
.scala> Stream.ranges(0, 20, 5).toList res0: List[(Int,Int)] = List((0,5), (5,10), (10,15), (15,20))
- Exceptions thrown
IllegalArgumentException
ifsize
<= 0
Example: - def repeatEval[F[_], O](fo: F[O]): Stream[F, O]
Alias for
eval(fo).repeat
. - def resource[F[_], O](r: Resource[F, O]): Stream[F, O]
Converts the supplied resource in to a singleton stream.
- def resourceWeak[F[_], O](r: Resource[F, O]): Stream[F, O]
Like resource but does not introduce a scope, allowing finalization to occur after subsequent appends or other scope-preserving transformations.
Like resource but does not introduce a scope, allowing finalization to occur after subsequent appends or other scope-preserving transformations.
Scopes can be manually introduced via scope if desired.
- def retry[F[_], O](fo: F[O], delay: FiniteDuration, nextDelay: (FiniteDuration) => FiniteDuration, maxAttempts: Int, retriable: (Throwable) => Boolean = scala.util.control.NonFatal.apply)(implicit arg0: Timer[F], arg1: RaiseThrowable[F]): Stream[F, O]
Retries
fo
on failure, returning a singleton stream with the result offo
as soon as it succeeds.Retries
fo
on failure, returning a singleton stream with the result offo
as soon as it succeeds.- delay
Duration of delay before the first retry
- nextDelay
Applied to the previous delay to compute the next, e.g. to implement exponential backoff
- maxAttempts
Number of attempts before failing with the latest error, if
fo
never succeeds- retriable
Function to determine whether a failure is retriable or not, defaults to retry every
NonFatal
. A failed stream is immediately returned when a non-retriable failure is encountered
- def sleep[F[_]](d: FiniteDuration)(implicit timer: Timer[F]): Stream[F, Unit]
A single-element
Stream
that waits for the durationd
before emitting unit.A single-element
Stream
that waits for the durationd
before emitting unit. This uses the implicitTimer
to avoid blocking a thread. - def sleep_[F[_]](d: FiniteDuration)(implicit timer: Timer[F]): Stream[F, INothing]
Alias for
sleep(d).drain
.Alias for
sleep(d).drain
. Often used in conjunction with++
(i.e.,sleep_(..) ++ s
) as a more performant version ofsleep(..) >> s
. - def supervise[F[_], A](fa: F[A])(implicit F: Concurrent[F]): Stream[F, Fiber[F, A]]
Starts the supplied task and cancels it as finalization of the returned stream.
- def suspend[F[_], O](s: => Stream[F, O]): Stream[F, O]
Returns a stream that evaluates the supplied by-name each time the stream is used, allowing use of a mutable value in stream computations.
Returns a stream that evaluates the supplied by-name each time the stream is used, allowing use of a mutable value in stream computations.
Note: it's generally easier to reason about such computations using effectful values. That is, allocate the mutable value in an effect and then use
Stream.eval(fa).flatMap { a => ??? }
.scala> Stream.suspend { | val digest = java.security.MessageDigest.getInstance("SHA-256") | val bytes: Stream[Pure,Byte] = ??? | bytes.chunks.fold(digest) { (d,c) => d.update(c.toBytes.values); d } | }
Example: - final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def unfold[F[x] >: Pure[x], S, O](s: S)(f: (S) => Option[(O, S)]): Stream[F, O]
Creates a stream by successively applying
f
until aNone
is returned, emitting each outputO
and using each outputS
as input to the next invocation off
.Creates a stream by successively applying
f
until aNone
is returned, emitting each outputO
and using each outputS
as input to the next invocation off
.scala> Stream.unfold(0)(i => if (i < 5) Some(i -> (i+1)) else None).toList res0: List[Int] = List(0, 1, 2, 3, 4)
Example: - def unfoldChunk[F[x] >: Pure[x], S, O](s: S)(f: (S) => Option[(Chunk[O], S)]): Stream[F, O]
Like unfold but each invocation of
f
provides a chunk of output.Like unfold but each invocation of
f
provides a chunk of output.scala> Stream.unfoldChunk(0)(i => if (i < 5) Some(Chunk.seq(List.fill(i)(i)) -> (i+1)) else None).toList res0: List[Int] = List(1, 2, 2, 3, 3, 3, 4, 4, 4, 4)
Example: - def unfoldChunkEval[F[_], S, O](s: S)(f: (S) => F[Option[(Chunk[O], S)]]): Stream[F, O]
Like unfoldChunk, but takes an effectful function.
- def unfoldEval[F[_], S, O](s: S)(f: (S) => F[Option[(O, S)]]): Stream[F, O]
Like unfold, but takes an effectful function.
- def unfoldLoop[F[x] <: Pure[x], S, O](s: S)(f: (S) => (O, Option[S])): Stream[F, O]
Creates a stream by successively applying
f
to aS
, emitting each outputO
and using each outputS
as input to the next invocation off
if it is Some, or terminating on NoneCreates a stream by successively applying
f
to aS
, emitting each outputO
and using each outputS
as input to the next invocation off
if it is Some, or terminating on Nonescala> Stream.unfoldLoop(0)(i => (i, if (i < 5) Some(i+1) else None)).toList res0: List[Int] = List(0, 1, 2, 3, 4, 5)
Example: - def unfoldLoopEval[F[_], S, O](s: S)(f: (S) => F[(O, Option[S])]): Stream[F, O]
Like unfoldLoop, but takes an effectful function.
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- object Compiler extends LowPrioCompiler