Suspend
Related Doc:
package Iterant
Appends a stream to the end of the source, effectively concatenating them.
Appends a stream to the end of the source, effectively concatenating them.
The right hand side is suspended in the F[_] data type, thus
allowing for laziness.
Example:
// Yields 1, 2, 3, 4 Iterant[Task].of(1, 2) ++ Task.suspend { Iterant[Task].of(3, 4) }
is the iterant to append at the end of our source.
Appends the given stream to the end of the source, effectively concatenating them.
Appends the given stream to the end of the source, effectively concatenating them.
Example:
// Yields 1, 2, 3, 4 Iterant[Task].of(1, 2) ++ Iterant[Task].of(3, 4)
is the (right hand side) iterant to concatenate at the end of this iterant.
Prepends an element to the iterant, returning a new
iterant that will start with the given head and then
continue with the source.
Prepends an element to the iterant, returning a new
iterant that will start with the given head and then
continue with the source.
Example:
// Yields 1, 2, 3, 4 1 +: Iterant[Task].of(2, 3, 4)
is the element to prepend at the start of this iterant
Converts the source Iterant that emits A elements into an
iterant that emits Either[Throwable, A], thus materializing
whatever error that might interrupt the stream.
Converts the source Iterant that emits A elements into an
iterant that emits Either[Throwable, A], thus materializing
whatever error that might interrupt the stream.
Example:
// Yields Right(1), Right(2), Right(3) Iterant[Task].of(1, 2, 3).attempt // Yields Right(1), Right(2), Left(DummyException()) (Iterant[Task].of(1, 2) ++ Iterant[Task].raiseError(DummyException())).attempt
Builds a new iterant by applying a partial function to all elements of the source on which the function is defined.
Builds a new iterant by applying a partial function to all elements of the source on which the function is defined.
Example:
// Yields 2, 4, 6 Iterant[Task].of(1, 2, 3, 4, 5, 6) .map { x => Option(x).filter(_ % 2 == 0) } .collect { case Some(x) => x }
the element type of the returned iterant.
the partial function that filters and maps the iterant
a new iterant resulting from applying the partial
function pf to each element on which it is defined and
collecting the results. The order of the elements is
preserved.
Upon evaluation of the result, consumes this iterant to completion.
Upon evaluation of the result, consumes this iterant to completion.
Example:
val onFinish: Task[Unit] = iterant.completeL >> Task.eval(println("Done!"))
Alias for concat.
Alias for flatMap.
Given a routine make sure to execute it whenever
the consumer executes the current stop action.
Given a routine make sure to execute it whenever
the consumer executes the current stop action.
Example:
iterant.doOnEarlyStop(Task.eval {
println("Was stopped early!")
})is the function to execute on early stop
Returns a new enumerator in which f is scheduled to be executed
on halt or on earlyStop.
Returns a new enumerator in which f is scheduled to be executed
on halt or on earlyStop.
This would typically be used to release any resources acquired by this enumerator.
Note that doOnEarlyStop is subsumed under this operation,
the given f being evaluated on both reaching the end or
canceling early.
Example:
iterant.doOnEarlyStop(err => Task.eval { err match { case Some(e) => log.error(e) case None => println("Was consumed successfully!") } })
is the function to execute on early stop
Drops the first n elements (from the start).
Drops the first n elements (from the start).
Example:
// Yields 4, 5 Iterant[Task].of(1, 2, 3, 4, 5).drop(3)
the number of elements to drop
a new iterant that drops the first n elements emitted by the source
Drops the longest prefix of elements that satisfy the given predicate and returns a new iterant that emits the rest.
Drops the longest prefix of elements that satisfy the given predicate and returns a new iterant that emits the rest.
Example:
// Yields 4, 5 Iterant[Task].of(1, 2, 3, 4, 5).dropWhile(_ < 4)
is the predicate used to test whether the current
element should be dropped, if true, or to interrupt
the dropping process, if false
a new iterant that drops the elements of the source
until the first time the given predicate returns false
Returns a computation that should be evaluated in case the streaming must stop before reaching the end.
Filters the iterant by the given predicate function, returning only those elements that match.
Filters the iterant by the given predicate function, returning only those elements that match.
Example:
// Yields 2, 4, 6 Iterant[Task].of(1, 2, 3, 4, 5, 6).filter(_ % 2 == 0)
the predicate used to test elements.
a new iterant consisting of all elements that satisfy the given predicate. The order of the elements is preserved.
Applies the function to the elements of the source and concatenates the results.
Applies the function to the elements of the source and concatenates the results.
This operation is the monadic "bind", with all laws it entails.
Also note that the implementation can use constant memory depending on usage, thus it can be used in tail recursive loops.
Example:
// Effectively equivalent with .filter Iterant[Task].of(1, 2, 3, 4, 5, 6).flatMap { elem => if (elem % 2 == 0) Iterant[Task].pure(elem) else Iterant[Task].empty }
is the function mapping elements from the source to iterants
Given an Iterant that generates Iterant elements, concatenates
all the generated iterants.
Given an Iterant that generates Iterant elements, concatenates
all the generated iterants.
Equivalent with: source.flatMap(x => x)
Left associative fold using the function f.
Left associative fold using the function f.
On execution the stream will be traversed from left to right, and the given function will be called with the prior result, accumulating state until the end, when the summary is returned.
Example:
// Yields 15 (1 + 2 + 3 + 4 + 5) Iterant[Task].of(1, 2, 3, 4, 5).foldLeftL(0)(_ + _)
is the start value
is the binary operator
the result of inserting op between consecutive
elements of this iterant, going from left to right with
the seed as the start value, or seed if the iterant
is empty.
Consumes the source iterable, executing the given callback for each element.
Consumes the source iterable, executing the given callback for each element.
Example:
// Prints all elements, each one on a different line Iterant[Task].of(1, 2, 3).foreachL { elem => println("Elem: " + elem.toString) }
is the callback to call for each element emitted by the source.
Optionally selects the first element.
Optionally selects the first element.
// Yields Some(1) Iterant[Task].of(1, 2, 3, 4).headOptionL // Yields None Iterant[Task].empty[Int].headOptionL
the first element of this iterant if it is nonempty, or
None if it is empty, in the F context.
Returns a new stream by mapping the supplied function over the elements of the source.
Returns a new stream by mapping the supplied function over the elements of the source.
// Yields 2, 4, 6 Iterant[Task].of(1, 2, 3).map(_ * 2)
is the mapping function that transforms the source
a new iterant that's the result of mapping the given function over the source
Given a mapping function that returns a possibly lazy or asynchronous result, applies it over the elements emitted by the stream.
Given a mapping function that returns a possibly lazy or asynchronous result, applies it over the elements emitted by the stream.
Iterant[Task].of(1, 2, 3, 4).mapEval { elem => Task.eval { println("Received: " + elem.toString) elem * 2 } }
is the mapping function that transforms the source
a new iterant that's the result of mapping the given function over the source,
Returns an Iterant that mirrors the behavior of the source,
unless the source is terminated with an error, in which
case the streaming of events fallbacks to an iterant
emitting a single element generated by the backup function.
Returns an Iterant that mirrors the behavior of the source,
unless the source is terminated with an error, in which
case the streaming of events fallbacks to an iterant
emitting a single element generated by the backup function.
Example:
val prefix = Iterant[Task].of(1, 2, 3, 4) val suffix = Iterant[Task].raiseError(DummyException("dummy")) val fa = prefix ++ suffix fa.onErrorHandle { _ => 5 }
See onErrorRecover for the version that takes a partial function as a parameter.
is a function that matches errors with a backup element that is emitted when the source throws an error.
Returns an Iterant that mirrors the behavior of the source,
unless the source is terminated with an error, in which case
the streaming of events continues with the specified backup
sequence generated by the given function.
Returns an Iterant that mirrors the behavior of the source,
unless the source is terminated with an error, in which case
the streaming of events continues with the specified backup
sequence generated by the given function.
Example:
val prefix = Iterant[Task].of(1, 2, 3, 4) val suffix = Iterant[Task].raiseError(DummyException("dummy")) val fa = prefix ++ suffix fa.onErrorHandleWith { case _: DummyException => Iterant[Task].pure(5) case other => Iterant[Task].raiseError(other) }
See onErrorRecoverWith for the version that takes a partial function as a parameter.
is a function that matches errors with a backup throwable that is subscribed when the source throws an error.
Returns a new Iterant that mirrors the source, but ignores
any errors in case they happen.
Returns a new Iterant that mirrors the source, but ignores
any errors in case they happen.
Returns an Iterant that mirrors the behavior of the source,
unless the source is terminated with an error, in which
case the streaming of events fallbacks to an iterant
emitting a single element generated by the backup function.
Returns an Iterant that mirrors the behavior of the source,
unless the source is terminated with an error, in which
case the streaming of events fallbacks to an iterant
emitting a single element generated by the backup function.
The created Iterant mirrors the behavior of the source
in case the source does not end with an error or if the
thrown Throwable is not matched.
Example:
val prefix = Iterant[Task].of(1, 2, 3, 4) val suffix = Iterant[Task].raiseError(DummyException("dummy")) val fa = prefix ++ suffix fa.onErrorRecover { case _: DummyException => 5 }
See onErrorHandle for the version that takes a total function as a parameter.
- a function that matches errors with a backup element that is emitted when the source throws an error.
Returns an Iterant that mirrors the behavior of the source,
unless the source is terminated with an error, in which case
the streaming of events continues with the specified backup
sequence generated by the given partial function.
Returns an Iterant that mirrors the behavior of the source,
unless the source is terminated with an error, in which case
the streaming of events continues with the specified backup
sequence generated by the given partial function.
The created Iterant mirrors the behavior of the source in
case the source does not end with an error or if the thrown
Throwable is not matched.
Example:
val prefix = Iterant[Task].of(1, 2, 3, 4) val suffix = Iterant[Task].raiseError(DummyException("dummy")) val fa = prefix ++ suffix fa.onErrorRecoverWith { case _: DummyException => Iterant[Task].pure(5) }
See onErrorHandleWith for the version that takes a total function as a parameter.
is a function that matches errors with a backup throwable that is subscribed when the source throws an error.
is the next state in the sequence that will produce the rest of the stream when evaluated
Skips over Iterant.Suspend states, along with Iterant.NextCursor and Iterant.NextBatch states that signal empty collections.
Skips over Iterant.Suspend states, along with Iterant.NextCursor and Iterant.NextBatch states that signal empty collections.
Will mirror the source, except that the emitted internal states might be different. Can be used as an optimization if necessary.
is a computation to be executed in case streaming is stopped prematurely, giving it a chance to do resource cleanup (e.g.
is a computation to be executed in case streaming is stopped prematurely, giving it a chance to do resource cleanup (e.g. close file handles)
Drops the first element of the source iterant, emitting the rest.
Drops the first element of the source iterant, emitting the rest.
Example:
// Yields 2, 3, 4 Iterant[Task].of(1, 2, 3, 4).tail
a new iterant that upon evaluation will emit all elements of the source, except for the head
Creates a new iterant that upon evaluation will select
the first n elements from the source and then stop,
in the order they are emitted by the source.
Creates a new iterant that upon evaluation will select
the first n elements from the source and then stop,
in the order they are emitted by the source.
Example:
// Yields 1, 2, 3 Iterant[Task].of(1, 2, 3, 4, 5, 6).take(3)
is the number of elements to take from this iterant
a new iterant instance that on evaluation will emit
only the first n elements of this iterant
Creates a new iterable that only emits the last n elements
emitted by the source.
Creates a new iterable that only emits the last n elements
emitted by the source.
In case the source triggers an error, then the underlying buffer gets dropped and the error gets emitted immediately.
Example:
// Yields 1, 2, 3 Iterant[Task].of(1, 2, 3, 4, 5, 6).take(3)
is the number of elements to take from the end of the stream.
a new iterant instance that on evaluation will emit the
last n elements of the source
Takes longest prefix of elements that satisfy the given predicate and returns a new iterant that emits those elements.
Takes longest prefix of elements that satisfy the given predicate and returns a new iterant that emits those elements.
Example:
// Yields 1, 2, 3 Iterant[Task].of(1, 2, 3, 4, 5, 6).takeWhile(_ < 4)
is the function that tests each element, stopping
the streaming on the first false result
a new iterant instance that on evaluation will all
elements of the source for as long as the given predicate
returns true, stopping upon the first false result
Aggregates all elements in a List and preserves order.
Aggregates all elements in a List and preserves order.
Example:
// Yields List(1, 2, 3, 4) Iterant[Task].of(1, 2, 3, 4).toListL
Note that this operation is dangerous, since if the iterant is infinite then this operation is non-terminating, the process probably blowing up with an out of memory error sooner or later.
Applies the function to the elements of the source and concatenates the results.
Applies the function to the elements of the source and concatenates the results.
This variant of flatMap is not referentially transparent,
because it tries to apply function f immediately, in case the
Iterant is in a NextCursor or NextBatch state.
To be used for optimizations, but keep in mind it's unsafe, as its application isn't referentially transparent.
is the function mapping elements from the source to iterants
Explicit covariance operator.
Explicit covariance operator.
The Iterant type isn't covariant in type param A, because
covariance doesn't play well with a higher-kinded type like
F[_]. So in case you have an Iterant[F, A], but need an
Iterant[F, B], knowing that A extends B, then you can do an
upcast.
Example:
val source: Iterant[Task, List[Int]] = ??? // This will trigger an error because of the invariance: val sequences: Iterant[Task, Seq[Int]] = source // But this will work just fine: val sequences: Iterant[Task, Seq[Int]] = source.upcast[Seq[Int]]
Lazily zip two iterants together.
Lazily zip two iterants together.
The length of the result will be the shorter of the two arguments.
Example:
val lh = Iterant[Task].of(11, 12, 13, 14) val rh = Iterant[Task].of(21, 22, 23, 24, 25) // Yields (11, 21), (12, 22), (13, 23), (14, 24) lh.zip(rh)
is the other iterant to zip the source with (the right hand side)
Lazily zip two iterants together, using the given function f to
produce output values.
Lazily zip two iterants together, using the given function f to
produce output values.
The length of the result will be the shorter of the two arguments.
Example:
val lh = Iterant[Task].of(11, 12, 13, 14) val rh = Iterant[Task].of(21, 22, 23, 24, 25) // Yields 32, 34, 36, 38 lh.zipMap(rh) { (a, b) => a + b }
is the other iterant to zip the source with (the right hand side)
is the mapping function to transform the zipped
(A, B) elements
Builds a stream state equivalent with Iterant.NextCursor.
The Suspend state of the Iterant represents a suspended stream to be evaluated in the
Fcontext. It is useful to delay the evaluation of a stream by deferring toF.is the next state in the sequence that will produce the rest of the stream when evaluated
is a computation to be executed in case streaming is stopped prematurely, giving it a chance to do resource cleanup (e.g. close file handles)