AsyncStream
Related Docs:
object AsyncStream
| package concurrent
Concatenates two streams.
Concatenates two streams.
Note: If this stream is infinite, we never process the concatenated stream; effectively: m ++ k == m.
concat for Java users.
++
Returns the suffix of this stream after the first n elements, or
AsyncStream.empty if n is larger than the number of elements in the
stream.
Returns the suffix of this stream after the first n elements, or
AsyncStream.empty if n is larger than the number of elements in the
stream.
Note: this forces all of the intermediate dropped elements.
Given a predicate p returns the suffix remaining after takeWhile(p):
Given a predicate p returns the suffix remaining after takeWhile(p):
AsyncStream(1, 2, 3, 4, 1).dropWhile(_ < 3) = AsyncStream(3, 4, 1) AsyncStream(1, 2, 3).dropWhile(_ < 5) = AsyncStream.empty AsyncStream(1, 2, 3).dropWhile(_ < 0) = AsyncStream(1, 2, 3)
Returns a stream of elements that satisfy the predicate p.
Returns a stream of elements that satisfy the predicate p.
Note: forces the stream up to the first element which satisfies the predicate. This operation may block forever on infinite streams in which no elements match.
Map a function f over the elements in this stream and concatenate the
results.
Concatenate a stream of streams.
Concatenate a stream of streams.
val a = AsyncStream(1) AsyncStream(a, a, a).flatten = AsyncStream(1, 1, 1)
Java users see AsyncStream.flattens.
Applies a binary operator to a start value and all elements of the stream, from head to tail.
Applies a binary operator to a start value and all elements of the stream, from head to tail.
Note: forces the stream. If the stream is infinite, the resulting future is equivalent to Future.never.
the starting value.
a binary operator applied to elements of this stream.
Like foldLeft, except that its result is encapsulated in a Future.
Like foldLeft, except that its result is encapsulated in a Future.
foldLeftF works from head to tail over the stream.
Note: forces the stream. If the stream is infinite, the resulting future is equivalent to Future.never.
the starting value.
a binary operator applied to elements of this stream.
This is a powerful and expert level function.
This is a powerful and expert level function. A fold operation
encapsulated in a Future. Like foldRight on normal lists, it replaces
every cons with the folded function f, and the empty element with z.
Note: For clarity, we imagine that surrounding a function with backticks (`) allows infix usage.
(1 +:: 2 +:: 3 +:: empty).foldRight(z)(f) = 1 `f` flatMap (2 `f` flatMap (3 `f` z))
Note: if f always forces the second parameter, for infinite streams the
future never resolves.
the parameter that replaces the end of the list.
a binary operator applied to elements of this stream. Note that the second paramter is call-by-name.
Force the entire stream.
Force the entire stream. If you hold a reference to the head of the stream, this will cause the entire stream to be held in memory. The resulting Future will be satisfied once the entire stream has been consumed.
This is useful when you want the side-effects of consuming the stream to occur, but do not need to do anything with the resulting values.
Note: forces the stream.
Note: forces the stream. For infinite streams, the future never resolves.
Maps each element of the stream to a Future action, resolving them from head to tail.
Maps each element of the stream to a Future action, resolving them from head to tail. The resulting Future completes when the action completes for the last element.
Note: forces the stream. For infinite streams, the future never resolves.
Convert the stream into a stream of groups of items.
Convert the stream into a stream of groups of items. This
facilitates batch processing of the items in the stream. In all
cases, this method should act like
<http://www.scala-lang.org/api/current/index.html#scala.collection.IterableLike@grouped(size:Int):Iterator[Repr]>
The resulting stream will cause this original stream to be
evaluated group-wise, so calling this method will cause the first
groupSize cells to be evaluated (even without examining the
result), and accessing each subsequent element will evaluate a
further groupSize elements from the stream.
must be a positive number, or an IllegalArgumentException will be thrown.
Returns the head of this stream if not empty.
Returns true if there are no elements in the stream.
stream.map(f) is the stream obtained by applying f to each element of
stream.
Map over this stream with the given concurrency.
Map over this stream with the given concurrency. The items will
likely not be processed in order. concurrencyLevel specifies an
"eagerness factor", and that many actions will be started when this
method is called. Forcing the stream will yield the results of
completed actions, and will block if none of the actions has yet
completed.
This method is useful for speeding up calculations over a stream
where executing the actions in order is not important. To implement
a concurrent fold, first call mapConcurrent and then fold that
stream. Similarly, concurrent foreachF can be achieved by
applying mapConcurrent and then foreach.
Constructs a new stream by mapping each element of this stream to a Future action, evaluated from head to tail.
Attempts to transform the stream into a Seq, and in the case of failure,
observe returns whatever was able to be transformed up to the point of
failure along with the exception.
Attempts to transform the stream into a Seq, and in the case of failure,
observe returns whatever was able to be transformed up to the point of
failure along with the exception. As a result, this Future never fails,
and if there are errors they can be accessed via the Option.
Note: forces the stream. For infinite streams, the future never resolves.
Similar to foldLeft, but produces a stream from the result of each successive fold:
Similar to foldLeft, but produces a stream from the result of each successive fold:
AsyncStream(1, 2, ...).scanLeft(z)(f) == z +:: f(z, 1) +:: f(f(z, 1), 2) +:: ...
Note that for an AsyncStream as:
as.scanLeft(z)(f).last == as.foldLeft(z)(f)
The resulting stream always begins with the initial value z,
not subject to the fate of the underlying future, i.e.:
val never = AsyncStream.fromFuture(Future.never) never.scanLeft(z)(f) == z +:: never // logical equality
Eagerly consume the entire stream and return the number of elements that are in it.
Eagerly consume the entire stream and return the number of elements that are in it. If you hold a reference to the head of the stream, this will cause the entire stream to be held in memory.
Note: forces the stream. If the stream is infinite, the resulting future is equivalent to Future.never.
Add up the values of all of the elements in this stream.
Add up the values of all of the elements in this stream. If you hold a reference to the head of the stream, this will cause the entire stream to be held in memory.
Note: forces the stream. If the stream is infinite, the resulting future is equivalent to Future.never.
Note: forces the first element of the tail.
Returns the prefix of this stream of length n, or the stream itself if
n is larger than the number of elements in the stream.
Given a predicate p, returns the longest prefix (possibly empty) of this
stream that satisfes p:
Given a predicate p, returns the longest prefix (possibly empty) of this
stream that satisfes p:
AsyncStream(1, 2, 3, 4, 1).takeWhile(_ < 3) = AsyncStream(1, 2) AsyncStream(1, 2, 3).takeWhile(_ < 5) = AsyncStream(1, 2, 3) AsyncStream(1, 2, 3).takeWhile(_ < 0) = AsyncStream.empty
A Future of the stream realized as a list.
A Future of the stream realized as a list. This future completes when all elements of the stream are resolved.
Note: forces the entire stream. If one asynchronous call fails, it fails the aggregated result.
The head and tail of this stream, if not empty.
The head and tail of this stream, if not empty. Note the tail thunk which preserves the tail's laziness.
empty.uncons == Future.None (a +:: m).uncons == Future.value(Some(a, () => m))
Execute the specified effect as each element of the resulting stream is demanded.
Execute the specified effect as each element of the resulting stream is demanded. This method does not force the stream. Since the head of the stream is not lazy, the effect will happen to the first item in the stream (if any) right away.
The effects will occur as the resulting stream is demanded and will not occur if the original stream is demanded.
This is useful for e.g. counting the number of items that were consumed from a stream by a consuming process, regardless of whether the entire stream is consumed.
filter
A representation of a lazy (and possibly infinite) sequence of asynchronous values. We provide combinators for non-blocking computation over the sequence of values.
It is composable with Future, Seq and Option.
All of its operations are lazy and don't force evaluation, unless otherwise noted.
The stream is persistent and can be shared safely by multiple threads.