Packages

final class Stream[+F[_], +O] extends AnyVal

A stream producing output of type O and which may evaluate F effects.

- Purely functional a value of type Stream[F, O] _describes_ an effectful computation. A function that returns a Stream[F, O] builds a _description_ of an effectful computation, but does not perform them. The methods of the Stream class derive new descriptions from others. This is similar to cats.effect.IO, monix.Task, or scalaz.zio.IO.

- Pull: to evaluate a stream, a consumer pulls its values from it, by repeatedly performing one pull step at a time. Each step is a F-effectful computation that may yield some O values (or none), and a stream from which to continue pulling. The consumer controls the evaluation of the stream, which effectful operations are performed, and when.

- Non-Strict: stream evaluation only pulls from the stream a prefix large enough to compute its results. Thus, although a stream may yield an unbounded number of values or, after successfully yielding several values, either raise an error or hang up and never yield any value, the consumer need not reach those points of failure. For the same reason, in general, no effect in F is evaluated unless and until the consumer needs it.

- Abstract: a stream needs not be a plain finite list of fixed effectful computations in F. It can also represent an input or output connection through which data incrementally arrives. It can represent an effectful computation, such as reading the system's time, that can be re-evaluated as often as the consumer of the stream requires.

Special properties for streams

There are some special properties or cases of streams:

  • A stream is finite, or if we can reach the end after a limited number of pull steps, which may yield a finite number of values. It is empty if it terminates and yields no values.
  • A singleton stream is a stream that ends after yielding one single value.
  • A pure stream is one in which the F is Pure, which indicates that it evaluates no effects.
  • A never stream is a stream that never terminates and never yields any value.

Pure Streams and operations

We can sometimes think of streams, naively, as lists of O elements with F-effects. This is particularly true for pure streams, which are instances of Stream which use the Pure effect type. We can convert every pure and finite stream into a List[O] using the .toList method. Also, we can convert pure infinite streams into instances of the Stream[O] class from the Scala standard library.

A method of the Stream class is pure if it can be applied to pure streams. Such methods are identified in that their signature includes no type-class constraint (or implicit parameter) on the F method. Pure methods in Stream[F, O] can be projected naturally to methods in the List class, which means that we can applying the stream's method and converting the result to a list gets the same result as first converting the stream to a list, and then applying list methods.

Some methods that project directly to list methods are, are map, filter, takeWhile, etc. There are other methods, like exists or find, that in the List class they return a value or an Option, but their stream counterparts return an (either empty or singleton) stream. Other methods, like zipWithPrevious, have a more complicated but still pure translation to list methods.

Type-Class instances and laws of the Stream Operations

Laws (using infix syntax):

append forms a monoid in conjunction with empty:

  • empty append s == s and s append empty == s.
  • (s1 append s2) append s3 == s1 append (s2 append s3)

And cons is consistent with using ++ to prepend a single chunk:

  • s.cons(c) == Stream.chunk(c) ++ s

Stream.raiseError propagates until being caught by handleErrorWith:

  • Stream.raiseError(e) handleErrorWith h == h(e)
  • Stream.raiseError(e) ++ s == Stream.raiseError(e)
  • Stream.raiseError(e) flatMap f == Stream.raiseError(e)

Stream forms a monad with emit and flatMap:

  • Stream.emit >=> f == f (left identity)
  • f >=> Stream.emit === f (right identity - note weaker equality notion here)
  • (f >=> g) >=> h == f >=> (g >=> h) (associativity) where Stream.emit(a) is defined as chunk(Chunk.singleton(a)) and f >=> g is defined as a => a flatMap f flatMap g

The monad is the list-style sequencing monad:

  • (a ++ b) flatMap f == (a flatMap f) ++ (b flatMap f)
  • Stream.empty flatMap f == Stream.empty

Technical notes

Note: since the chunk structure of the stream is observable, and s flatMap Stream.emit produces a stream of singleton chunks, the right identity law uses a weaker notion of equality, === which normalizes both sides with respect to chunk structure:

(s1 === s2) = normalize(s1) == normalize(s2) where == is full equality (a == b iff f(a) is identical to f(b) for all f)

normalize(s) can be defined as s.flatMap(Stream.emit), which just produces a singly-chunked stream from any input stream s.

For instance, for a stream s and a function f: A => B, - the result of s.map(f) is a Stream with the same _chunking_ as the s; wheras... - the result of s.flatMap(x => S.emit(f(x))) is a Stream structured as a sequence of singleton chunks. The latter is using the definition of map that is derived from the Monad instance.

This is not unlike equality for maps or sets, which is defined by which elements they contain, not by how these are spread between a tree's branches or a hashtable buckets. However, a Stream structure can be _observed_ through the chunks method, so two streams "_equal_" under that notion may give different results through this method.

Note: For efficiency Stream.map function operates on an entire chunk at a time and preserves chunk structure, which differs from the map derived from the monad (s map f == s flatMap (f andThen Stream.emit)) which would produce singleton chunk. In particular, if f throws errors, the chunked version will fail on the first chunk with an error, while the unchunked version will fail on the first element with an error. Exceptions in pure code like this are strongly discouraged.

Source
Stream.scala
Linear Supertypes
AnyVal, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Stream
  2. AnyVal
  3. Any
Implicitly
  1. by FallibleOps
  2. by any2stringadd
  3. by StringFormat
  4. by Ensuring
  5. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    Any
  2. final def ##(): Int
    Definition Classes
    Any
  3. def +(other: String): String
    Implicit
    This member is added by an implicit conversion from Stream[F, O] to any2stringadd[Stream[F, O]] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  4. def ++[F2[x] >: F[x], O2 >: O](s2: ⇒ Stream[F2, O2]): Stream[F2, O2]

    Appends s2 to the end of this stream.

    Appends s2 to the end of this stream.

    Example: 

    1. scala> ( Stream(1,2,3)++Stream(4,5,6) ).toList
res0: List[Int] = List(1, 2, 3, 4, 5, 6)

      If this stream is not terminating, then the result is equivalent to this.

  5. def ->[B](y: B): (Stream[F, O], B)
    Implicit
    This member is added by an implicit conversion from Stream[F, O] to ArrowAssoc[Stream[F, O]] performed by method ArrowAssoc in scala.Predef. This conversion will take place only if F is a subclass of Pure (F <: Pure).
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  6. final def ==(arg0: Any): Boolean
    Definition Classes
    Any
  7. def >>[F2[x] >: F[x], O2](s2: ⇒ Stream[F2, O2]): Stream[F2, O2]

    Alias for flatMap(_ => s2).

  8. def append[F2[x] >: F[x], O2 >: O](s2: ⇒ Stream[F2, O2]): Stream[F2, O2]

    Appends s2 to the end of this stream.

    Appends s2 to the end of this stream. Alias for s1 ++ s2.

  9. def as[O2](o2: O2): Stream[F, O2]

    Alias for _.map(_ => o2).

    Alias for _.map(_ => o2).

    Example: 

    1. scala> Stream(1,2,3).as(0).toList
res0: List[Int] = List(0, 0, 0)
  10. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  11. def attempt: Stream[F, Either[Throwable, O]]

    Returns a stream of O values wrapped in Right until the first error, which is emitted wrapped in Left.

    Returns a stream of O values wrapped in Right until the first error, which is emitted wrapped in Left.

    Example: 

    1. scala> (Stream(1,2,3) ++ Stream.raiseError[cats.effect.IO](new RuntimeException) ++ Stream(4,5,6)).attempt.compile.toList.unsafeRunSync()
res0: List[Either[Throwable,Int]] = List(Right(1), Right(2), Right(3), Left(java.lang.RuntimeException))

      rethrow is the inverse of attempt, with the caveat that anything after the first failure is discarded.

  12. def attempts[F2[x] >: F[x]](delays: Stream[F2, FiniteDuration])(implicit arg0: Timer[F2]): Stream[F2, Either[Throwable, O]]

    Retries on failure, returning a stream of attempts that can be manipulated with standard stream operations such as take, collectFirst and interruptWhen.

    Retries on failure, returning a stream of attempts that can be manipulated with standard stream operations such as take, collectFirst and interruptWhen.

    Note: The resulting stream does *not* automatically halt at the first successful attempt. Also see retry.

  13. def balance[F2[x] >: F[x]](chunkSize: Int)(implicit arg0: Concurrent[F2]): Stream[F2, Stream[F2, O]]

    Returns a stream of streams where each inner stream sees an even portion of the elements of the source stream relative to the number of inner streams taken from the outer stream.

    Returns a stream of streams where each inner stream sees an even portion of the elements of the source stream relative to the number of inner streams taken from the outer stream. For example, src.balance(chunkSize).take(2) results in two inner streams, each which see roughly half of the elements of the source stream.

    The chunkSize parameter specifies the maximum chunk size from the source stream that should be passed to an inner stream. For completely fair distribution of elements, use a chunk size of 1. For best performance, use a chunk size of Int.MaxValue.

    See fs2.concurrent.Balance.apply for more details.

    Alias for through(Balance(chunkSize)).

  14. def balanceAvailable[F2[x] >: F[x]](implicit arg0: Concurrent[F2]): Stream[F2, Stream[F2, O]]

    Like balance but uses an unlimited chunk size.

    Like balance but uses an unlimited chunk size.

    Alias for through(Balance(Int.MaxValue)).

  15. def balanceThrough[F2[x] >: F[x], O2](chunkSize: Int, maxConcurrent: Int)(pipe: Pipe[F2, O, O2])(implicit arg0: Concurrent[F2]): Stream[F2, O2]

    Variant of balanceThrough that takes number of concurrency required and single pipe

    Variant of balanceThrough that takes number of concurrency required and single pipe

    chunkSize

    max size of chunks taken from the source stream

    maxConcurrent

    maximum number of pipes to run concurrently

  16. def balanceThrough[F2[x] >: F[x], O2](chunkSize: Int)(pipes: Pipe[F2, O, O2]*)(implicit arg0: Concurrent[F2]): Stream[F2, O2]

    Alias for through(Balance.through(chunkSize)(pipes).

  17. def balanceTo[F2[x] >: F[x]](chunkSize: Int, maxConcurrent: Int)(sink: Sink[F2, O])(implicit arg0: Concurrent[F2]): Stream[F2, Unit]

    Variant of balanceTo that broadcasts to maxConcurrent instances of a single sink.

    Variant of balanceTo that broadcasts to maxConcurrent instances of a single sink.

    chunkSize

    max size of chunks taken from the source stream

    maxConcurrent

    maximum number of sinks to run concurrently

  18. def balanceTo[F2[x] >: F[x]](chunkSize: Int)(sinks: Sink[F2, O]*)(implicit arg0: Concurrent[F2]): Stream[F2, Unit]

    Like balance but instead of providing a stream of sources, runs each sink.

    Like balance but instead of providing a stream of sources, runs each sink.

    The sinks are run concurrently with each other. Hence, the parallelism factor is equal to the number of sinks. Each sink may have a different implementation, if required; for example one sink may process elements while another may send elements for processing to another machine.

    Each sink is guaranteed to see all O pulled from the source stream, unlike broadcast, where workers see only the elements after the start of each worker evaluation.

    Note: the resulting stream will not emit values, even if the sinks do. If you need to emit Unit values, consider using balanceThrough.

    sinks

    sinks that will concurrently process the work

  19. def broadcast[F2[x] >: F[x]](implicit arg0: Concurrent[F2]): Stream[F2, Stream[F2, O]]

    Returns a stream of streams where each inner stream sees all elements of the source stream (after the inner stream has started evaluation).

    Returns a stream of streams where each inner stream sees all elements of the source stream (after the inner stream has started evaluation). For example, src.broadcast.take(2) results in two inner streams, each of which see every element of the source.

    Alias for through(Broadcast(1))./

  20. def broadcastThrough[F2[x] >: F[x], O2](maxConcurrent: Int)(pipe: Pipe[F2, O, O2])(implicit arg0: Concurrent[F2]): Stream[F2, O2]

    Variant of broadcastTo that broadcasts to maxConcurrent instances of the supplied pipe.

  21. def broadcastThrough[F2[x] >: F[x], O2](pipes: Pipe[F2, O, O2]*)(implicit arg0: Concurrent[F2]): Stream[F2, O2]

    Alias for through(Broadcast.through(pipes)).

  22. def broadcastTo[F2[x] >: F[x]](maxConcurrent: Int)(sink: Sink[F2, O])(implicit arg0: Concurrent[F2]): Stream[F2, Unit]

    Variant of broadcastTo that broadcasts to maxConcurrent instances of a single sink.

  23. def broadcastTo[F2[x] >: F[x]](sinks: Sink[F2, O]*)(implicit arg0: Concurrent[F2]): Stream[F2, Unit]

    Like broadcast but instead of providing a stream of sources, runs each sink.

    Like broadcast but instead of providing a stream of sources, runs each sink.

    The sinks are run concurrently with each other. Hence, the parallelism factor is equal to the number of sinks. Each sink may have a different implementation, if required; for example one sink may process elements while another may send elements for processing to another machine.

    Each sink is guaranteed to see all O pulled from the source stream, unlike broadcast, where workers see only the elements after the start of each worker evaluation.

    Note: the resulting stream will not emit values, even if the sinks do. If you need to emit Unit values, consider using broadcastThrough.

    Note: Elements are pulled as chunks from the source and the next chunk is pulled when all workers are done with processing the current chunk. This behaviour may slow down processing of incoming chunks by faster workers. If this is not desired, consider using the prefetch and prefetchN combinators on workers to compensate for slower workers.

    sinks

    Sinks that will concurrently process the work.

  24. def buffer(n: Int): Stream[F, O]

    Behaves like the identity function, but requests n elements at a time from the input.

    Behaves like the identity function, but requests n elements at a time from the input.

    Example: 

    1. scala> import cats.effect.IO
scala> val buf = new scala.collection.mutable.ListBuffer[String]()
scala> Stream.range(0, 100).covary[IO].
     |   evalMap(i => IO { buf += s">$i"; i }).
     |   buffer(4).
     |   evalMap(i => IO { buf += s"<$i"; i }).
     |   take(10).
     |   compile.toVector.unsafeRunSync
res0: Vector[Int] = Vector(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
scala> buf.toList
res1: List[String] = List(>0, >1, >2, >3, <0, <1, <2, <3, >4, >5, >6, >7, <4, <5, <6, <7, >8, >9, >10, >11, <8, <9)
  25. def bufferAll: Stream[F, O]

    Behaves like the identity stream, but emits no output until the source is exhausted.

    Behaves like the identity stream, but emits no output until the source is exhausted.

    Example: 

    1. scala> import cats.effect.IO
scala> val buf = new scala.collection.mutable.ListBuffer[String]()
scala> Stream.range(0, 10).covary[IO].
     |   evalMap(i => IO { buf += s">$i"; i }).
     |   bufferAll.
     |   evalMap(i => IO { buf += s"<$i"; i }).
     |   take(4).
     |   compile.toVector.unsafeRunSync
res0: Vector[Int] = Vector(0, 1, 2, 3)
scala> buf.toList
res1: List[String] = List(>0, >1, >2, >3, >4, >5, >6, >7, >8, >9, <0, <1, <2, <3)
  26. def bufferBy(f: (O) ⇒ Boolean): Stream[F, O]

    Behaves like the identity stream, but requests elements from its input in blocks that end whenever the predicate switches from true to false.

    Behaves like the identity stream, but requests elements from its input in blocks that end whenever the predicate switches from true to false.

    Example: 

    1. scala> import cats.effect.IO
scala> val buf = new scala.collection.mutable.ListBuffer[String]()
scala> Stream.range(0, 10).covary[IO].
     |   evalMap(i => IO { buf += s">$i"; i }).
     |   bufferBy(_ % 2 == 0).
     |   evalMap(i => IO { buf += s"<$i"; i }).
     |   compile.toVector.unsafeRunSync
res0: Vector[Int] = Vector(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
scala> buf.toList
res1: List[String] = List(>0, >1, <0, <1, >2, >3, <2, <3, >4, >5, <4, <5, >6, >7, <6, <7, >8, >9, <8, <9)
  27. def changes[O2 >: O](implicit eq: Eq[O2]): Stream[F, O2]

    Emits only elements that are distinct from their immediate predecessors, using natural equality for comparison.

    Emits only elements that are distinct from their immediate predecessors, using natural equality for comparison.

    Example: 

    1. scala> import cats.implicits._
scala> Stream(1,1,2,2,2,3,3).changes.toList
res0: List[Int] = List(1, 2, 3)
  28. def changesBy[O2](f: (O) ⇒ O2)(implicit eq: Eq[O2]): Stream[F, O]

    Emits only elements that are distinct from their immediate predecessors according to f, using natural equality for comparison.

    Emits only elements that are distinct from their immediate predecessors according to f, using natural equality for comparison.

    Note that f is called for each element in the stream multiple times and hence should be fast (e.g., an accessor). It is not intended to be used for computationally intensive conversions. For such conversions, consider something like: src.map(o => (o, f(o))).changesBy(_._2).map(_._1)

    Example: 

    1. scala> import cats.implicits._
scala> Stream(1,1,2,4,6,9).changesBy(_ % 2).toList
res0: List[Int] = List(1, 2, 9)
  29. def chunkLimit(n: Int): Stream[F, Chunk[O]]

    Outputs chunk with a limited maximum size, splitting as necessary.

    Outputs chunk with a limited maximum size, splitting as necessary.

    Example: 

    1. scala> (Stream(1) ++ Stream(2, 3) ++ Stream(4, 5, 6)).chunkLimit(2).toList
res0: List[Chunk[Int]] = List(Chunk(1), Chunk(2, 3), Chunk(4, 5), Chunk(6))
  30. def chunkN(n: Int, allowFewer: Boolean = true): Stream[F, Chunk[O]]

    Outputs chunks of size n.

    Outputs chunks of size n.

    Chunks from the source stream are split as necessary. If allowFewer is true, the last chunk that is emitted may have less than n elements.

    Example: 

    1. scala> Stream(1,2,3).repeat.chunkN(2).take(5).toList
res0: List[Chunk[Int]] = List(Chunk(1, 2), Chunk(3, 1), Chunk(2, 3), Chunk(1, 2), Chunk(3, 1))
  31. def chunks: Stream[F, Chunk[O]]

    Outputs all chunks from the source stream.

    Outputs all chunks from the source stream.

    Example: 

    1. scala> (Stream(1) ++ Stream(2, 3) ++ Stream(4, 5, 6)).chunks.toList
res0: List[Chunk[Int]] = List(Chunk(1), Chunk(2, 3), Chunk(4, 5, 6))
  32. def collect[O2](pf: PartialFunction[O, O2]): Stream[F, O2]

    Filters and maps simultaneously.

    Filters and maps simultaneously. Calls collect on each chunk in the stream.

    Example: 

    1. scala> Stream(Some(1), Some(2), None, Some(3), None, Some(4)).collect { case Some(i) => i }.toList
res0: List[Int] = List(1, 2, 3, 4)
  33. def collectFirst[O2](pf: PartialFunction[O, O2]): Stream[F, O2]

    Emits the first element of the stream for which the partial function is defined.

    Emits the first element of the stream for which the partial function is defined.

    Example: 

    1. scala> Stream(None, Some(1), Some(2), None, Some(3)).collectFirst { case Some(i) => i }.toList
res0: List[Int] = List(1)
  34. def compile[F2[x] >: F[x], G[_], O2 >: O](implicit compiler: Compiler[F2, G]): CompileOps[F2, G, O2]

    Gets a projection of this stream that allows converting it to an F[..] in a number of ways.

    Gets a projection of this stream that allows converting it to an F[..] in a number of ways.

    Example: 

    1. scala> import cats.effect.IO
scala> val prg: IO[Vector[Int]] = Stream.eval(IO(1)).append(Stream(2,3,4)).compile.toVector
scala> prg.unsafeRunSync
res2: Vector[Int] = Vector(1, 2, 3, 4)
  35. def concurrently[F2[x] >: F[x], O2](that: Stream[F2, O2])(implicit F: Concurrent[F2]): Stream[F2, O]

    Runs the supplied stream in the background as elements from this stream are pulled.

    Runs the supplied stream in the background as elements from this stream are pulled.

    The resulting stream terminates upon termination of this stream. The background stream will be interrupted at that point. Early termination of that does not terminate the resulting stream.

    Any errors that occur in either this or that stream result in the overall stream terminating with an error.

    Upon finalization, the resulting stream will interrupt the background stream and wait for it to be finalized.

    This method is equivalent to this mergeHaltL that.drain, just more efficient for this and that evaluation.

    Example: 

    1. scala> import cats.effect.{ContextShift, IO}
scala> implicit val cs: ContextShift[IO] = IO.contextShift(scala.concurrent.ExecutionContext.Implicits.global)
scala> val data: Stream[IO,Int] = Stream.range(1, 10).covary[IO]
scala> Stream.eval(fs2.concurrent.SignallingRef[IO,Int](0)).flatMap(s => Stream(s).concurrently(data.evalMap(s.set))).flatMap(_.discrete).takeWhile(_ < 9, true).compile.last.unsafeRunSync
res0: Option[Int] = Some(9)
  36. def cons[O2 >: O](c: Chunk[O2]): Stream[F, O2]

    Prepends a chunk onto the front of this stream.

    Prepends a chunk onto the front of this stream.

    Example: 

    1. scala> Stream(1,2,3).cons(Chunk(-1, 0)).toList
res0: List[Int] = List(-1, 0, 1, 2, 3)
  37. def cons1[O2 >: O](o: O2): Stream[F, O2]

    Prepends a single value onto the front of this stream.

    Prepends a single value onto the front of this stream.

    Example: 

    1. scala> Stream(1,2,3).cons1(0).toList
res0: List[Int] = List(0, 1, 2, 3)
  38. def consChunk[O2 >: O](c: Chunk[O2]): Stream[F, O2]

    Prepends a chunk onto the front of this stream.

    Prepends a chunk onto the front of this stream.

    Example: 

    1. scala> Stream(1,2,3).consChunk(Chunk.vector(Vector(-1, 0))).toList
res0: List[Int] = List(-1, 0, 1, 2, 3)
  39. def covaryAll[F2[x] >: F[x], O2 >: O]: Stream[F2, O2]

    Lifts this stream to the specified effect and output types.

    Lifts this stream to the specified effect and output types.

    Example: 

    1. scala> import cats.effect.IO
scala> Stream.empty.covaryAll[IO,Int]
res0: Stream[IO,Int] = Stream(..)
  40. def covaryOutput[O2 >: O]: Stream[F, O2]

    Lifts this stream to the specified output type.

    Lifts this stream to the specified output type.

    Example: 

    1. scala> Stream(Some(1), Some(2), Some(3)).covaryOutput[Option[Int]]
res0: Stream[Pure,Option[Int]] = Stream(..)
  41. def debounce[F2[x] >: F[x]](d: FiniteDuration)(implicit F: Concurrent[F2], timer: Timer[F2]): Stream[F2, O]

    Debounce the stream with a minimum period of d between each element.

    Debounce the stream with a minimum period of d between each element.

    Example: 

    1. scala> import scala.concurrent.duration._, cats.effect.{ContextShift, IO, Timer}
scala> implicit val cs: ContextShift[IO] = IO.contextShift(scala.concurrent.ExecutionContext.Implicits.global)
scala> implicit val timer: Timer[IO] = IO.timer(scala.concurrent.ExecutionContext.Implicits.global)
scala> val s = Stream(1, 2, 3) ++ Stream.sleep_[IO](500.millis) ++ Stream(4, 5) ++ Stream.sleep_[IO](10.millis) ++ Stream(6)
scala> val s2 = s.debounce(100.milliseconds)
scala> s2.compile.toVector.unsafeRunSync
res0: Vector[Int] = Vector(3, 6)
  42. def delayBy[F2[x] >: F[x]](d: FiniteDuration)(implicit arg0: Timer[F2]): Stream[F2, O]

    Returns a stream that when run, sleeps for duration d and then pulls from this stream.

    Returns a stream that when run, sleeps for duration d and then pulls from this stream.

    Alias for sleep_[F](d) ++ this.

  43. def delete(p: (O) ⇒ Boolean): Stream[F, O]

    Skips the first element that matches the predicate.

    Skips the first element that matches the predicate.

    Example: 

    1. scala> Stream.range(1, 10).delete(_ % 2 == 0).toList
res0: List[Int] = List(1, 3, 4, 5, 6, 7, 8, 9)
  44. def drain: Stream[F, INothing]

    Removes all output values from this stream.

    Removes all output values from this stream.

    Often used with merge to run one side of the merge for its effect while getting outputs from the opposite side of the merge.

    Example: 

    1. scala> import cats.effect.IO
scala> Stream.eval(IO(println("x"))).drain.compile.toVector.unsafeRunSync
res0: Vector[INothing] = Vector()
  45. def drop(n: Long): Stream[F, O]

    Drops n elements of the input, then echoes the rest.

    Drops n elements of the input, then echoes the rest.

    Example: 

    1. scala> Stream.range(0,10).drop(5).toList
res0: List[Int] = List(5, 6, 7, 8, 9)
  46. def dropLast: Stream[F, O]

    Drops the last element.

    Drops the last element.

    Example: 

    1. scala> Stream.range(0,10).dropLast.toList
res0: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7, 8)
  47. def dropLastIf(p: (O) ⇒ Boolean): Stream[F, O]

    Drops the last element if the predicate evaluates to true.

    Drops the last element if the predicate evaluates to true.

    Example: 

    1. scala> Stream.range(0,10).dropLastIf(_ > 5).toList
res0: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7, 8)
  48. def dropRight(n: Int): Stream[F, O]

    Outputs all but the last n elements of the input.

    Outputs all but the last n elements of the input.

    This is a pure stream operation: if s a finite pure stream, then s.dropRight(n).toList is equal to this.toList.reverse.drop(n).reverse.

    Example: 

    1. scala> Stream.range(0,10).dropRight(5).toList
res0: List[Int] = List(0, 1, 2, 3, 4)
  49. def dropThrough(p: (O) ⇒ Boolean): Stream[F, O]

    Like dropWhile, but drops the first value which tests false.

    Like dropWhile, but drops the first value which tests false.

    Example: 

    1. scala> Stream.range(0,10).dropThrough(_ != 4).toList
res0: List[Int] = List(5, 6, 7, 8, 9)

      Pure: if this is a finite pure stream, then this.dropThrough(p).toList is equal to this.toList.dropWhile(p).drop(1)

  50. def dropWhile(p: (O) ⇒ Boolean): Stream[F, O]

    Drops elements from the head of this stream until the supplied predicate returns false.

    Drops elements from the head of this stream until the supplied predicate returns false.

    Example: 

    1. scala> Stream.range(0,10).dropWhile(_ != 4).toList
res0: List[Int] = List(4, 5, 6, 7, 8, 9)

      Pure this operation maps directly to List.dropWhile

  51. def either[F2[x] >: F[x], O2](that: Stream[F2, O2])(implicit arg0: Concurrent[F2]): Stream[F2, Either[O, O2]]

    Like merge, but tags each output with the branch it came from.

    Like merge, but tags each output with the branch it came from.

    Example: 

    1. scala> import scala.concurrent.duration._, cats.effect.{ContextShift, IO, Timer}
scala> implicit val cs: ContextShift[IO] = IO.contextShift(scala.concurrent.ExecutionContext.Implicits.global)
scala> implicit val timer: Timer[IO] = IO.timer(scala.concurrent.ExecutionContext.Implicits.global)
scala> val s1 = Stream.awakeEvery[IO](1000.millis).scan(0)((acc, i) => acc + 1)
scala> val s = s1.either(Stream.sleep_[IO](500.millis) ++ s1).take(10)
scala> s.take(10).compile.toVector.unsafeRunSync
res0: Vector[Either[Int,Int]] = Vector(Left(0), Right(0), Left(1), Right(1), Left(2), Right(2), Left(3), Right(3), Left(4), Right(4))
  52. def ensuring(cond: (Stream[F, O]) ⇒ Boolean, msg: ⇒ Any): Stream[F, O]
    Implicit
    This member is added by an implicit conversion from Stream[F, O] to Ensuring[Stream[F, O]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  53. def ensuring(cond: (Stream[F, O]) ⇒ Boolean): Stream[F, O]
    Implicit
    This member is added by an implicit conversion from Stream[F, O] to Ensuring[Stream[F, O]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  54. def ensuring(cond: Boolean, msg: ⇒ Any): Stream[F, O]
    Implicit
    This member is added by an implicit conversion from Stream[F, O] to Ensuring[Stream[F, O]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  55. def ensuring(cond: Boolean): Stream[F, O]
    Implicit
    This member is added by an implicit conversion from Stream[F, O] to Ensuring[Stream[F, O]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  56. def evalMap[F2[x] >: F[x], O2](f: (O) ⇒ F2[O2]): Stream[F2, O2]

    Alias for flatMap(o => Stream.eval(f(o))).

    Alias for flatMap(o => Stream.eval(f(o))).

    Example: 

    1. scala> import cats.effect.IO
scala> Stream(1,2,3,4).evalMap(i => IO(println(i))).compile.drain.unsafeRunSync
res0: Unit = ()
  57. def evalMapAccumulate[F2[x] >: F[x], S, O2](s: S)(f: (S, O) ⇒ F2[(S, O2)]): Stream[F2, (S, O2)]

    Like Stream#mapAccumulate, but accepts a function returning an F[_].

    Like Stream#mapAccumulate, but accepts a function returning an F[_].

    Example: 

    1. scala> import cats.effect.IO
scala> Stream(1,2,3,4).covary[IO].evalMapAccumulate(0)((acc,i) => IO((i, acc + i))).compile.toVector.unsafeRunSync
res0: Vector[(Int, Int)] = Vector((1,1), (2,3), (3,5), (4,7))
  58. def evalScan[F2[x] >: F[x], O2](z: O2)(f: (O2, O) ⇒ F2[O2]): Stream[F2, O2]

    Like Stream#scan, but accepts a function returning an F[_].

    Like Stream#scan, but accepts a function returning an F[_].

    Example: 

    1. scala> import cats.effect.IO
scala> Stream(1,2,3,4).covary[IO].evalScan(0)((acc,i) => IO(acc + i)).compile.toVector.unsafeRunSync
res0: Vector[Int] = Vector(0, 1, 3, 6, 10)
  59. def evalTap[F2[x] >: F[x]](f: (O) ⇒ F2[Unit])(implicit arg0: Functor[F2]): Stream[F2, O]

    Like observe but observes with a function O => F[Unit] instead of a sink.

    Like observe but observes with a function O => F[Unit] instead of a sink. Not as powerful as observe since not all sinks can be represented by O => F[Unit], but much faster. Alias for evalMap(o => f(o).as(o)).

  60. def exists(p: (O) ⇒ Boolean): Stream[F, Boolean]

    Emits true as soon as a matching element is received, else false if no input matches.

    Emits true as soon as a matching element is received, else false if no input matches. Pure: this operation maps to List.exists

    Example: 

    1. scala> Stream.range(0,10).exists(_ == 4).toList
res0: List[Boolean] = List(true)
scala> Stream.range(0,10).exists(_ == 10).toList
res1: List[Boolean] = List(false)
  61. def filter(p: (O) ⇒ Boolean): Stream[F, O]

    Emits only inputs which match the supplied predicate.

    Emits only inputs which match the supplied predicate.

    This is a pure operation, that projects directly into List.filter

    Example: 

    1. scala> Stream.range(0,10).filter(_ % 2 == 0).toList
res0: List[Int] = List(0, 2, 4, 6, 8)
  62. def filterWithPrevious(f: (O, O) ⇒ Boolean): Stream[F, O]

    Like filter, but the predicate f depends on the previously emitted and current elements.

    Like filter, but the predicate f depends on the previously emitted and current elements.

    Example: 

    1. scala> Stream(1, -1, 2, -2, 3, -3, 4, -4).filterWithPrevious((previous, current) => previous < current).toList
res0: List[Int] = List(1, 2, 3, 4)
  63. def find(f: (O) ⇒ Boolean): Stream[F, O]

    Emits the first input (if any) which matches the supplied predicate.

    Emits the first input (if any) which matches the supplied predicate.

    Example: 

    1. scala> Stream.range(1,10).find(_ % 2 == 0).toList
res0: List[Int] = List(2)

      Pure if s is a finite pure stream, s.find(p).toList is equal to s.toList.find(p).toList, where the second toList is to turn Option into List.

  64. def flatMap[F2[x] >: F[x], O2](f: (O) ⇒ Stream[F2, O2]): Stream[F2, O2]

    Creates a stream whose elements are generated by applying f to each output of the source stream and concatenated all of the results.

    Creates a stream whose elements are generated by applying f to each output of the source stream and concatenated all of the results.

    Example: 

    1. scala> Stream(1, 2, 3).flatMap { i => Stream.chunk(Chunk.seq(List.fill(i)(i))) }.toList
res0: List[Int] = List(1, 2, 2, 3, 3, 3)
  65. def flatten[F2[x] >: F[x], O2](implicit ev: <:<[O, Stream[F2, O2]]): Stream[F2, O2]

    Flattens a stream of streams in to a single stream by concatenating each stream.

    Flattens a stream of streams in to a single stream by concatenating each stream. See parJoin and parJoinUnbounded for concurrent flattening of 'n' streams.

  66. def fold[O2](z: O2)(f: (O2, O) ⇒ O2): Stream[F, O2]

    Folds all inputs using an initial value z and supplied binary operator, and emits a single element stream.

    Folds all inputs using an initial value z and supplied binary operator, and emits a single element stream.

    Example: 

    1. scala> Stream(1, 2, 3, 4, 5).fold(0)(_ + _).toList
res0: List[Int] = List(15)
  67. def fold1[O2 >: O](f: (O2, O2) ⇒ O2): Stream[F, O2]

    Folds all inputs using the supplied binary operator, and emits a single-element stream, or the empty stream if the input is empty, or the never stream if the input is non-terminating.

    Folds all inputs using the supplied binary operator, and emits a single-element stream, or the empty stream if the input is empty, or the never stream if the input is non-terminating.

    Example: 

    1. scala> Stream(1, 2, 3, 4, 5).fold1(_ + _).toList
res0: List[Int] = List(15)
  68. def foldMap[O2](f: (O) ⇒ O2)(implicit O2: Monoid[O2]): Stream[F, O2]

    Alias for map(f).foldMonoid.

    Alias for map(f).foldMonoid.

    Example: 

    1. scala> import cats.implicits._
scala> Stream(1, 2, 3, 4, 5).foldMap(_ => 1).toList
res0: List[Int] = List(5)
  69. def foldMonoid[O2 >: O](implicit O: Monoid[O2]): Stream[F, O2]

    Folds this stream with the monoid for O.

    Folds this stream with the monoid for O.

    Example: 

    1. scala> import cats.implicits._
scala> Stream(1, 2, 3, 4, 5).foldMonoid.toList
res0: List[Int] = List(15)
  70. def forall(p: (O) ⇒ Boolean): Stream[F, Boolean]

    Emits false and halts as soon as a non-matching element is received; or emits a single true value if it reaches the stream end and every input before that matches the predicate; or hangs without emitting values if the input is infinite and all inputs match the predicate.

    Emits false and halts as soon as a non-matching element is received; or emits a single true value if it reaches the stream end and every input before that matches the predicate; or hangs without emitting values if the input is infinite and all inputs match the predicate.

    Example: 

    1. scala> Stream(1, 2, 3, 4, 5).forall(_ < 10).toList
res0: List[Boolean] = List(true)
  71. def formatted(fmtstr: String): String
    Implicit
    This member is added by an implicit conversion from Stream[F, O] to StringFormat[Stream[F, O]] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()
  72. def getClass(): Class[_ <: AnyVal]
    Definition Classes
    AnyVal → Any
  73. def groupAdjacentBy[O2](f: (O) ⇒ O2)(implicit eq: Eq[O2]): Stream[F, (O2, Chunk[O])]

    Partitions the input into a stream of chunks according to a discriminator function.

    Partitions the input into a stream of chunks according to a discriminator function.

    Each chunk in the source stream is grouped using the supplied discriminator function and the results of the grouping are emitted each time the discriminator function changes values.

    Example: 

    1. scala> import cats.implicits._
scala> Stream("Hello", "Hi", "Greetings", "Hey").groupAdjacentBy(_.head).toList.map { case (k,vs) => k -> vs.toList }
res0: List[(Char,List[String])] = List((H,List(Hello, Hi)), (G,List(Greetings)), (H,List(Hey)))
  74. def groupWithin[F2[x] >: F[x]](n: Int, d: FiniteDuration)(implicit timer: Timer[F2], F: Concurrent[F2]): Stream[F2, Chunk[O]]

    Divide this streams into groups of elements received within a time window, or limited by the number of the elements, whichever happens first.

    Divide this streams into groups of elements received within a time window, or limited by the number of the elements, whichever happens first. Empty groups, which can occur if no elements can be pulled from upstream in a given time window, will not be emitted.

    Note: a time window starts each time downstream pulls.

  75. def handleErrorWith[F2[x] >: F[x], O2 >: O](h: (Throwable) ⇒ Stream[F2, O2]): Stream[F2, O2]

    If this terminates with Stream.raiseError(e), invoke h(e).

    If this terminates with Stream.raiseError(e), invoke h(e).

    Example: 

    1. scala> Stream(1, 2, 3).append(Stream.raiseError[cats.effect.IO](new RuntimeException)).handleErrorWith(t => Stream(0)).compile.toList.unsafeRunSync()
res0: List[Int] = List(1, 2, 3, 0)
  76. def head: Stream[F, O]

    Emits the first element of this stream (if non-empty) and then halts.

    Emits the first element of this stream (if non-empty) and then halts.

    Example: 

    1. scala> Stream(1, 2, 3).head.toList
res0: List[Int] = List(1)
  77. def hold[F2[x] >: F[x], O2 >: O](initial: O2)(implicit F: Concurrent[F2]): Stream[F2, Signal[F2, O2]]

    Converts a discrete stream to a signal.

    Converts a discrete stream to a signal. Returns a single-element stream.

    Resulting signal is initially initial, and is updated with latest value produced by source. If the source stream is empty, the resulting signal will always be initial.

  78. def holdOption[F2[x] >: F[x], O2 >: O](implicit arg0: Concurrent[F2]): Stream[F2, Signal[F2, Option[O2]]]

    Like hold but does not require an initial value, and hence all output elements are wrapped in Some.

  79. def interleave[F2[x] >: F[x], O2 >: O](that: Stream[F2, O2]): Stream[F2, O2]

    Determinsitically interleaves elements, starting on the left, terminating when the end of either branch is reached naturally.

    Determinsitically interleaves elements, starting on the left, terminating when the end of either branch is reached naturally.

    Example: 

    1. scala> Stream(1, 2, 3).interleave(Stream(4, 5, 6, 7)).toList
res0: List[Int] = List(1, 4, 2, 5, 3, 6)
  80. def interleaveAll[F2[x] >: F[x], O2 >: O](that: Stream[F2, O2]): Stream[F2, O2]

    Determinsitically interleaves elements, starting on the left, terminating when the ends of both branches are reached naturally.

    Determinsitically interleaves elements, starting on the left, terminating when the ends of both branches are reached naturally.

    Example: 

    1. scala> Stream(1, 2, 3).interleaveAll(Stream(4, 5, 6, 7)).toList
res0: List[Int] = List(1, 4, 2, 5, 3, 6, 7)
  81. def interruptAfter[F2[x] >: F[x]](duration: FiniteDuration)(implicit arg0: Concurrent[F2], arg1: Timer[F2]): Stream[F2, O]

    Interrupts this stream after the specified duration has passed.

  82. def interruptScope[F2[x] >: F[x]](implicit arg0: Concurrent[F2]): Stream[F2, O]

    Creates a scope that may be interrupted by calling scope#interrupt.

  83. def interruptWhen[F2[x] >: F[x]](haltOnSignal: F2[Either[Throwable, Unit]])(implicit F2: Concurrent[F2]): Stream[F2, O]

    Interrupts the stream, when haltOnSignal finishes its evaluation.

  84. def interruptWhen[F2[x] >: F[x]](haltWhenTrue: Signal[F2, Boolean])(implicit arg0: Concurrent[F2]): Stream[F2, O]

    Alias for interruptWhen(haltWhenTrue.discrete).

  85. def interruptWhen[F2[x] >: F[x]](haltWhenTrue: Deferred[F2, Either[Throwable, Unit]])(implicit arg0: Concurrent[F2]): Stream[F2, O]

    Alias for interruptWhen(haltWhenTrue.get).

  86. def interruptWhen[F2[x] >: F[x]](haltWhenTrue: Stream[F2, Boolean])(implicit F2: Concurrent[F2]): Stream[F2, O]

    Let through the s2 branch as long as the s1 branch is false, listening asynchronously for the left branch to become true.

    Let through the s2 branch as long as the s1 branch is false, listening asynchronously for the left branch to become true. This halts as soon as either branch halts.

    Consider using the overload that takes a Signal, Deferred or F[Either[Throwable, Unit]].

  87. def intersperse[O2 >: O](separator: O2): Stream[F, O2]

    Emits the specified separator between every pair of elements in the source stream.

    Emits the specified separator between every pair of elements in the source stream.

    Example: 

    1. scala> Stream(1, 2, 3, 4, 5).intersperse(0).toList
res0: List[Int] = List(1, 0, 2, 0, 3, 0, 4, 0, 5)
  88. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  89. def last: Stream[F, Option[O]]

    Returns the last element of this stream, if non-empty.

    Returns the last element of this stream, if non-empty.

    Example: 

    1. scala> Stream(1, 2, 3).last.toList
res0: List[Option[Int]] = List(Some(3))
  90. def lastOr[O2 >: O](fallback: ⇒ O2): Stream[F, O2]

    Returns the last element of this stream, if non-empty, otherwise the supplied fallback value.

    Returns the last element of this stream, if non-empty, otherwise the supplied fallback value.

    Example: 

    1. scala> Stream(1, 2, 3).lastOr(0).toList
res0: List[Int] = List(3)
scala> Stream.empty.lastOr(0).toList
res1: List[Int] = List(0)
  91. def lift[F[_]](implicit F: ApplicativeError[F, Throwable]): Stream[F, O]

    Lifts this stream to the specified effect type.

    Lifts this stream to the specified effect type.

    Implicit
    This member is added by an implicit conversion from Stream[F, O] to FallibleOps[O] performed by method FallibleOps in fs2.Stream. This conversion will take place only if F is a subclass of Fallible (F <: Fallible).
    Definition Classes
    FallibleOps
  92. def map[O2](f: (O) ⇒ O2): Stream[F, O2]

    Applies the specified pure function to each input and emits the result.

    Applies the specified pure function to each input and emits the result.

    Example: 

    1. scala> Stream("Hello", "World!").map(_.size).toList
res0: List[Int] = List(5, 6)
  93. def mapAccumulate[S, O2](init: S)(f: (S, O) ⇒ (S, O2)): Stream[F, (S, O2)]

    Maps a running total according to S and the input with the function f.

    Maps a running total according to S and the input with the function f.

    Example: 

    1. scala> Stream("Hello", "World").mapAccumulate(0)((l, s) => (l + s.length, s.head)).toVector
res0: Vector[(Int, Char)] = Vector((5,H), (10,W))
  94. def mapAsync[F2[x] >: F[x], O2](maxConcurrent: Int)(f: (O) ⇒ F2[O2])(implicit arg0: Concurrent[F2]): Stream[F2, O2]

    Alias for parEvalMap.

  95. def mapAsyncUnordered[F2[x] >: F[x], O2](maxConcurrent: Int)(f: (O) ⇒ F2[O2])(implicit arg0: Concurrent[F2]): Stream[F2, O2]

    Alias for parEvalMapUnordered.

  96. def mapChunks[O2](f: (Chunk[O]) ⇒ Chunk[O2]): Stream[F, O2]

    Applies the specified pure function to each chunk in this stream.

    Applies the specified pure function to each chunk in this stream.

    Example: 

    1. scala> Stream(1, 2, 3).append(Stream(4, 5, 6)).mapChunks { c => val ints = c.toInts; for (i <- 0 until ints.values.size) ints.values(i) = 0; ints }.toList
res0: List[Int] = List(0, 0, 0, 0, 0, 0)
  97. def mask: Stream[F, O]

    Behaves like the identity function but halts the stream on an error and does not return the error.

    Behaves like the identity function but halts the stream on an error and does not return the error.

    Example: 

    1. scala> (Stream(1,2,3) ++ Stream.raiseError[cats.effect.IO](new RuntimeException) ++ Stream(4, 5, 6)).mask.compile.toList.unsafeRunSync()
res0: List[Int] = List(1, 2, 3)
  98. def merge[F2[x] >: F[x], O2 >: O](that: Stream[F2, O2])(implicit F2: Concurrent[F2]): Stream[F2, O2]

    Interleaves the two inputs nondeterministically.

    Interleaves the two inputs nondeterministically. The output stream halts after BOTH s1 and s2 terminate normally, or in the event of an uncaught failure on either s1 or s2. Has the property that merge(Stream.empty, s) == s and merge(raiseError(e), s) will eventually terminate with raiseError(e), possibly after emitting some elements of s first.

    The implementation always tries to pull one chunk from each side before waiting for it to be consumed by resulting stream. As such, there may be up to two chunks (one from each stream) waiting to be processed while the resulting stream is processing elements.

    Also note that if either side produces empty chunk, the processing on that side continues, w/o downstream requiring to consume result.

    If either side does not emit anything (i.e. as result of drain) that side will continue to run even when the resulting stream did not ask for more data.

    Note that even when this is equivalent to Stream(this, that).parJoinUnbounded, this implementation is little more efficient

    Example: 

    1. scala> import scala.concurrent.duration._, cats.effect.{ContextShift, IO, Timer}
scala> implicit val cs: ContextShift[IO] = IO.contextShift(scala.concurrent.ExecutionContext.Implicits.global)
scala> implicit val timer: Timer[IO] = IO.timer(scala.concurrent.ExecutionContext.Implicits.global)
scala> val s1 = Stream.awakeEvery[IO](500.millis).scan(0)((acc, i) => acc + 1)
scala> val s = s1.merge(Stream.sleep_[IO](250.millis) ++ s1)
scala> s.take(6).compile.toVector.unsafeRunSync
res0: Vector[Int] = Vector(0, 0, 1, 1, 2, 2)
  99. def mergeHaltBoth[F2[x] >: F[x], O2 >: O](that: Stream[F2, O2])(implicit arg0: Concurrent[F2]): Stream[F2, O2]

    Like merge, but halts as soon as _either_ branch halts.

  100. def mergeHaltL[F2[x] >: F[x], O2 >: O](that: Stream[F2, O2])(implicit arg0: Concurrent[F2]): Stream[F2, O2]

    Like merge, but halts as soon as the s1 branch halts.

  101. def mergeHaltR[F2[x] >: F[x], O2 >: O](that: Stream[F2, O2])(implicit arg0: Concurrent[F2]): Stream[F2, O2]

    Like merge, but halts as soon as the s2 branch halts.

  102. def metered[F2[x] >: F[x]](rate: FiniteDuration)(implicit arg0: Timer[F2]): Stream[F2, O]

    Throttles the stream to the specified rate.

    Throttles the stream to the specified rate. Unlike debounce, metered doesn't drop elements.

    Provided rate should be viewed as maximum rate: resulting rate can't exceed the output rate of this stream.

  103. def noneTerminate: Stream[F, Option[O]]

    Emits each output wrapped in a Some and emits a None at the end of the stream.

    Emits each output wrapped in a Some and emits a None at the end of the stream.

    s.noneTerminate.unNoneTerminate == s

    Example: 

    1. scala> Stream(1,2,3).noneTerminate.toList
res0: List[Option[Int]] = List(Some(1), Some(2), Some(3), None)
  104. def onComplete[F2[x] >: F[x], O2 >: O](s2: ⇒ Stream[F2, O2]): Stream[F2, O2]

    Run s2 after this, regardless of errors during this, then reraise any errors encountered during this.

    Run s2 after this, regardless of errors during this, then reraise any errors encountered during this.

    Note: this should *not* be used for resource cleanup! Use bracket or onFinalize instead.

    Example: 

    1. scala> Stream(1, 2, 3).onComplete(Stream(4, 5)).toList
res0: List[Int] = List(1, 2, 3, 4, 5)
  105. def onFinalize[F2[x] >: F[x]](f: F2[Unit])(implicit F2: Applicative[F2]): Stream[F2, O]

    Run the supplied effectful action at the end of this stream, regardless of how the stream terminates.

  106. def onFinalizeCase[F2[x] >: F[x]](f: (ExitCase[Throwable]) ⇒ F2[Unit])(implicit F2: Applicative[F2]): Stream[F2, O]

    Like onFinalize but provides the reason for finalization as an ExitCase[Throwable].

  107. def parEvalMap[F2[x] >: F[x], O2](maxConcurrent: Int)(f: (O) ⇒ F2[O2])(implicit arg0: Concurrent[F2]): Stream[F2, O2]

    Like Stream#evalMap, but will evaluate effects in parallel, emitting the results downstream in the same order as the input stream.

    Like Stream#evalMap, but will evaluate effects in parallel, emitting the results downstream in the same order as the input stream. The number of concurrent effects is limited by the maxConcurrent parameter.

    See Stream#parEvalMapUnordered if there is no requirement to retain the order of the original stream.

    Example: 

    1. scala> import cats.effect.{ContextShift, IO}
scala> implicit val cs: ContextShift[IO] = IO.contextShift(scala.concurrent.ExecutionContext.Implicits.global)
scala> Stream(1,2,3,4).covary[IO].parEvalMap(2)(i => IO(println(i))).compile.drain.unsafeRunSync
res0: Unit = ()
  108. def parEvalMapUnordered[F2[x] >: F[x], O2](maxConcurrent: Int)(f: (O) ⇒ F2[O2])(implicit arg0: Concurrent[F2]): Stream[F2, O2]

    Like Stream#evalMap, but will evaluate effects in parallel, emitting the results downstream.

    Like Stream#evalMap, but will evaluate effects in parallel, emitting the results downstream. The number of concurrent effects is limited by the maxConcurrent parameter.

    See Stream#parEvalMap if retaining the original order of the stream is required.

    Example: 

    1. scala> import cats.effect.{ContextShift, IO}
scala> implicit val cs: ContextShift[IO] = IO.contextShift(scala.concurrent.ExecutionContext.Implicits.global)
scala> Stream(1,2,3,4).covary[IO].parEvalMapUnordered(2)(i => IO(println(i))).compile.drain.unsafeRunSync
res0: Unit = ()
  109. def parJoin[F2[_], O2](maxOpen: Int)(implicit ev: <:<[O, Stream[F2, O2]], ev2: <:<[F[_], F2[_]], F2: Concurrent[F2]): Stream[F2, O2]

    Nondeterministically merges a stream of streams (outer) in to a single stream, opening at most maxOpen streams at any point in time.

    Nondeterministically merges a stream of streams (outer) in to a single stream, opening at most maxOpen streams at any point in time.

    The outer stream is evaluated and each resulting inner stream is run concurrently, up to maxOpen stream. Once this limit is reached, evaluation of the outer stream is paused until one or more inner streams finish evaluating.

    When the outer stream stops gracefully, all inner streams continue to run, resulting in a stream that will stop when all inner streams finish their evaluation.

    When the outer stream fails, evaluation of all inner streams is interrupted and the resulting stream will fail with same failure.

    When any of the inner streams fail, then the outer stream and all other inner streams are interrupted, resulting in stream that fails with the error of the stream that caused initial failure.

    Finalizers on each inner stream are run at the end of the inner stream, concurrently with other stream computations.

    Finalizers on the outer stream are run after all inner streams have been pulled from the outer stream but not before all inner streams terminate -- hence finalizers on the outer stream will run AFTER the LAST finalizer on the very last inner stream.

    Finalizers on the returned stream are run after the outer stream has finished and all open inner streams have finished.

    maxOpen

    Maximum number of open inner streams at any time. Must be > 0.

  110. def parJoinUnbounded[F2[_], O2](implicit ev: <:<[O, Stream[F2, O2]], ev2: <:<[F[_], F2[_]], F2: Concurrent[F2]): Stream[F2, O2]

    Like parJoin but races all inner streams simultaneously.

  111. def pauseWhen[F2[x] >: F[x]](pauseWhenTrue: Signal[F2, Boolean])(implicit arg0: Concurrent[F2]): Stream[F2, O]

    Alias for pauseWhen(pauseWhenTrue.discrete).

  112. def pauseWhen[F2[x] >: F[x]](pauseWhenTrue: Stream[F2, Boolean])(implicit F2: Concurrent[F2]): Stream[F2, O]

    Like interrupt but resumes the stream when left branch goes to true.

  113. def prefetch[F2[x] >: F[x]](implicit arg0: Concurrent[F2]): Stream[F2, O]

    Alias for prefetchN(1).

  114. def prefetchN[F2[x] >: F[x]](n: Int)(implicit arg0: Concurrent[F2]): Stream[F2, O]

    Behaves like identity, but starts fetches up to n chunks in parallel with downstream consumption, enabling processing on either side of the prefetchN to run in parallel.

  115. def reduce[O2 >: O](f: (O2, O2) ⇒ O2): Stream[F, O2]

    Alias for fold1.

  116. def reduceSemigroup[O2 >: O](implicit S: Semigroup[O2]): Stream[F, O2]

    Reduces this stream with the Semigroup for O.

    Reduces this stream with the Semigroup for O.

    Example: 

    1. scala> import cats.implicits._
scala> Stream("The", "quick", "brown", "fox").intersperse(" ").reduceSemigroup.toList
res0: List[String] = List(The quick brown fox)
  117. def repartition[O2 >: O](f: (O2) ⇒ Chunk[O2])(implicit S: Semigroup[O2]): Stream[F, O2]

    Repartitions the input with the function f.

    Repartitions the input with the function f. On each step f is applied to the input and all elements but the last of the resulting sequence are emitted. The last element is then appended to the next input using the Semigroup S.

    Example: 

    1. scala> import cats.implicits._
scala> Stream("Hel", "l", "o Wor", "ld").repartition(s => Chunk.array(s.split(" "))).toList
res0: List[String] = List(Hello, World)
  118. def repeat: Stream[F, O]

    Repeat this stream an infinite number of times.

    Repeat this stream an infinite number of times.

    s.repeat == s ++ s ++ s ++ ...

    Example: 

    1. scala> Stream(1,2,3).repeat.take(8).toList
res0: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2)
  119. def rethrow[F2[x] >: F[x], O2](implicit ev: <:<[O, Either[Throwable, O2]], rt: RaiseThrowable[F2]): Stream[F2, O2]

    Converts a Stream[F,Either[Throwable,O]] to a Stream[F,O], which emits right values and fails upon the first Left(t).

    Converts a Stream[F,Either[Throwable,O]] to a Stream[F,O], which emits right values and fails upon the first Left(t). Preserves chunkiness.

    Example: 

    1. scala> Stream(Right(1), Right(2), Left(new RuntimeException), Right(3)).rethrow[cats.effect.IO, Int].handleErrorWith(t => Stream(-1)).compile.toList.unsafeRunSync
res0: List[Int] = List(-1)
  120. def scan[O2](z: O2)(f: (O2, O) ⇒ O2): Stream[F, O2]

    Left fold which outputs all intermediate results.

    Left fold which outputs all intermediate results.

    Example: 

    1. scala> Stream(1,2,3,4).scan(0)(_ + _).toList
res0: List[Int] = List(0, 1, 3, 6, 10)

      More generally: Stream().scan(z)(f) == Stream(z) Stream(x1).scan(z)(f) == Stream(z, f(z,x1)) Stream(x1,x2).scan(z)(f) == Stream(z, f(z,x1), f(f(z,x1),x2)) etc

  121. def scan1[O2 >: O](f: (O2, O2) ⇒ O2): Stream[F, O2]

    Like scan, but uses the first element of the stream as the seed.

    Like scan, but uses the first element of the stream as the seed.

    Example: 

    1. scala> Stream(1,2,3,4).scan1(_ + _).toList
res0: List[Int] = List(1, 3, 6, 10)
  122. def scanChunks[S, O2 >: O, O3](init: S)(f: (S, Chunk[O2]) ⇒ (S, Chunk[O3])): Stream[F, O3]

    Like scan but f is applied to each chunk of the source stream.

    Like scan but f is applied to each chunk of the source stream. The resulting chunk is emitted and the result of the chunk is used in the next invocation of f.

    Many stateful pipes can be implemented efficiently (i.e., supporting fusion) with this method.

  123. def scanChunksOpt[S, O2 >: O, O3](init: S)(f: (S) ⇒ Option[(Chunk[O2]) ⇒ (S, Chunk[O3])]): Stream[F, O3]

    More general version of scanChunks where the current state (i.e., S) can be inspected to determine if another chunk should be pulled or if the stream should terminate.

    More general version of scanChunks where the current state (i.e., S) can be inspected to determine if another chunk should be pulled or if the stream should terminate. Termination is signaled by returning None from f. Otherwise, a function which consumes the next chunk is returned wrapped in Some.

    Example: 

    1. scala> def take[F[_],O](s: Stream[F,O], n: Int): Stream[F,O] =
     |   s.scanChunksOpt(n) { n => if (n <= 0) None else Some(c => if (c.size < n) (n - c.size, c) else (0, c.take(n))) }
scala> take(Stream.range(0,100), 5).toList
res0: List[Int] = List(0, 1, 2, 3, 4)
  124. def scope: Stream[F, O]

    Scopes are typically inserted automatically, at the boundary of a pull (i.e., when a pull is converted to a stream).

    Scopes are typically inserted automatically, at the boundary of a pull (i.e., when a pull is converted to a stream). This method allows a scope to be explicitly demarcated so that resources can be freed earlier than when using automatically inserted scopes. This is useful when using streamNoScope to convert from Pull to Stream -- i.e., by choosing to *not* have scopes inserted automatically, you may end up needing to demarcate scopes manually at a higher level in the stream structure.

    Note: see the disclaimer about the use of streamNoScope.

  125. def sliding(n: Int): Stream[F, Queue[O]]

    Groups inputs in fixed size chunks by passing a "sliding window" of size n over them.

    Groups inputs in fixed size chunks by passing a "sliding window" of size n over them. If the input contains less than or equal to n elements, only one chunk of this size will be emitted.

    Example: 

    1. scala> Stream(1, 2, 3, 4).sliding(2).toList
res0: List[scala.collection.immutable.Queue[Int]] = List(Queue(1, 2), Queue(2, 3), Queue(3, 4))
    Exceptions thrown

    scala.IllegalArgumentException if n <= 0

  126. def spawn[F2[x] >: F[x]](implicit arg0: Concurrent[F2]): Stream[F2, Fiber[F2, Unit]]

    Starts this stream and cancels it as finalization of the returned stream.

  127. def split(f: (O) ⇒ Boolean): Stream[F, Chunk[O]]

    Breaks the input into chunks where the delimiter matches the predicate.

    Breaks the input into chunks where the delimiter matches the predicate. The delimiter does not appear in the output. Two adjacent delimiters in the input result in an empty chunk in the output.

    Example: 

    1. scala> Stream.range(0, 10).split(_ % 4 == 0).toList
res0: List[Chunk[Int]] = List(Chunk(), Chunk(1, 2, 3), Chunk(5, 6, 7), Chunk(9))
  128. def switchMap[F2[x] >: F[x], O2](f: (O) ⇒ Stream[F2, O2])(implicit F2: Concurrent[F2]): Stream[F2, O2]

    Like Stream.flatMap but interrupts the inner stream when new elements arrive in the outer stream.

    Like Stream.flatMap but interrupts the inner stream when new elements arrive in the outer stream.

    The implementation will try to preserve chunks like Stream.merge.

    Finializers of each inner stream are guaranteed to run before the next inner stream starts.

    When the outer stream stops gracefully, the currently running inner stream will continue to run.

    When an inner stream terminates/interrupts, nothing happens until the next element arrives in the outer stream(i.e the outer stream holds the stream open during this time or else the stream terminates)

    When either the inner or outer stream fails, the entire stream fails and the finalizer of the inner stream runs before the outer one.

  129. def tail: Stream[F, O]

    Emits all elements of the input except the first one.

    Emits all elements of the input except the first one.

    Example: 

    1. scala> Stream(1,2,3).tail.toList
res0: List[Int] = List(2, 3)
  130. def take(n: Long): Stream[F, O]

    Emits the first n elements of this stream.

    Emits the first n elements of this stream.

    Example: 

    1. scala> Stream.range(0,1000).take(5).toList
res0: List[Int] = List(0, 1, 2, 3, 4)
  131. def takeRight(n: Int): Stream[F, O]

    Emits the last n elements of the input.

    Emits the last n elements of the input.

    Example: 

    1. scala> Stream.range(0,1000).takeRight(5).toList
res0: List[Int] = List(995, 996, 997, 998, 999)
  132. def takeThrough(p: (O) ⇒ Boolean): Stream[F, O]

    Like takeWhile, but emits the first value which tests false.

    Like takeWhile, but emits the first value which tests false.

    Example: 

    1. scala> Stream.range(0,1000).takeThrough(_ != 5).toList
res0: List[Int] = List(0, 1, 2, 3, 4, 5)
  133. def takeWhile(p: (O) ⇒ Boolean, takeFailure: Boolean = false): Stream[F, O]

    Emits the longest prefix of the input for which all elements test true according to f.

    Emits the longest prefix of the input for which all elements test true according to f.

    Example: 

    1. scala> Stream.range(0,1000).takeWhile(_ != 5).toList
res0: List[Int] = List(0, 1, 2, 3, 4)
  134. def through[F2[x] >: F[x], O2](f: (Stream[F, O]) ⇒ Stream[F2, O2]): Stream[F2, O2]

    Transforms this stream using the given Pipe.

    Transforms this stream using the given Pipe.

    Example: 

    1. scala> Stream("Hello", "world").through(text.utf8Encode).toVector.toArray
res0: Array[Byte] = Array(72, 101, 108, 108, 111, 119, 111, 114, 108, 100)
  135. def through2[F2[x] >: F[x], O2, O3](s2: Stream[F2, O2])(f: (Stream[F, O], Stream[F2, O2]) ⇒ Stream[F2, O3]): Stream[F2, O3]

    Transforms this stream and s2 using the given Pipe2.

  136. def to[C[_]](implicit cbf: CanBuildFrom[Nothing, O, C[O]]): Either[Throwable, C[O]]

    Runs this fallible stream and returns the emitted elements in a collection of the specified type.

    Runs this fallible stream and returns the emitted elements in a collection of the specified type. Note: this method is only available on fallible streams.

    Implicit
    This member is added by an implicit conversion from Stream[F, O] to FallibleOps[O] performed by method FallibleOps in fs2.Stream. This conversion will take place only if F is a subclass of Fallible (F <: Fallible).
    Definition Classes
    FallibleOps
  137. def to[F2[x] >: F[x]](f: (Stream[F, O]) ⇒ Stream[F2, Unit]): Stream[F2, Unit]

    Applies the given sink to this stream.

    Applies the given sink to this stream.

    Example: 

    1. scala> import cats.effect.IO, cats.implicits._
scala> Stream(1,2,3).covary[IO].to(Sink.showLinesStdOut).compile.drain.unsafeRunSync
res0: Unit = ()
  138. def toChunk: Either[Throwable, Chunk[O]]

    Runs this fallible stream and returns the emitted elements in a chunk.

    Runs this fallible stream and returns the emitted elements in a chunk. Note: this method is only available on fallible streams.

    Implicit
    This member is added by an implicit conversion from Stream[F, O] to FallibleOps[O] performed by method FallibleOps in fs2.Stream. This conversion will take place only if F is a subclass of Fallible (F <: Fallible).
    Definition Classes
    FallibleOps
  139. def toList: Either[Throwable, List[O]]

    Runs this fallible stream and returns the emitted elements in a list.

    Runs this fallible stream and returns the emitted elements in a list. Note: this method is only available on fallible streams.

    Implicit
    This member is added by an implicit conversion from Stream[F, O] to FallibleOps[O] performed by method FallibleOps in fs2.Stream. This conversion will take place only if F is a subclass of Fallible (F <: Fallible).
    Definition Classes
    FallibleOps
  140. def toString(): String
    Definition Classes
    Stream → Any
  141. def toVector: Either[Throwable, Vector[O]]

    Runs this fallible stream and returns the emitted elements in a vector.

    Runs this fallible stream and returns the emitted elements in a vector. Note: this method is only available on fallible streams.

    Implicit
    This member is added by an implicit conversion from Stream[F, O] to FallibleOps[O] performed by method FallibleOps in fs2.Stream. This conversion will take place only if F is a subclass of Fallible (F <: Fallible).
    Definition Classes
    FallibleOps
  142. def translate[F2[x] >: F[x], G[_]](u: ~>[F2, G]): Stream[G, O]

    Translates effect type from F to G using the supplied FunctionK.

  143. def unNone[O2](implicit ev: <:<[O, Option[O2]]): Stream[F, O2]

    Filters any 'None'.

    Filters any 'None'.

    Example: 

    1. scala> Stream(Some(1), Some(2), None, Some(3), None).unNone.toList
res0: List[Int] = List(1, 2, 3)
  144. def unNoneTerminate[O2](implicit ev: <:<[O, Option[O2]]): Stream[F, O2]

    Halts the input stream at the first None.

    Halts the input stream at the first None.

    Example: 

    1. scala> Stream(Some(1), Some(2), None, Some(3), None).unNoneTerminate.toList
res0: List[Int] = List(1, 2)
  145. def unchunk: Stream[F, O]

    Converts the input to a stream of 1-element chunks.

    Converts the input to a stream of 1-element chunks.

    Example: 

    1. scala> (Stream(1,2,3) ++ Stream(4,5,6)).unchunk.chunks.toList
res0: List[Chunk[Int]] = List(Chunk(1), Chunk(2), Chunk(3), Chunk(4), Chunk(5), Chunk(6))
  146. def zip[F2[x] >: F[x], O2](that: Stream[F2, O2]): Stream[F2, (O, O2)]

    Determinsitically zips elements, terminating when the end of either branch is reached naturally.

    Determinsitically zips elements, terminating when the end of either branch is reached naturally.

    Example: 

    1. scala> Stream(1, 2, 3).zip(Stream(4, 5, 6, 7)).toList
res0: List[(Int,Int)] = List((1,4), (2,5), (3,6))
  147. def zipAll[F2[x] >: F[x], O2 >: O, O3](that: Stream[F2, O3])(pad1: O2, pad2: O3): Stream[F2, (O2, O3)]

    Determinsitically zips elements, terminating when the ends of both branches are reached naturally, padding the left branch with pad1 and padding the right branch with pad2 as necessary.

    Determinsitically zips elements, terminating when the ends of both branches are reached naturally, padding the left branch with pad1 and padding the right branch with pad2 as necessary.

    Example: 

    1. scala> Stream(1,2,3).zipAll(Stream(4,5,6,7))(0,0).toList
res0: List[(Int,Int)] = List((1,4), (2,5), (3,6), (0,7))
  148. def zipAllWith[F2[x] >: F[x], O2 >: O, O3, O4](that: Stream[F2, O3])(pad1: O2, pad2: O3)(f: (O2, O3) ⇒ O4): Stream[F2, O4]

    Determinsitically zips elements with the specified function, terminating when the ends of both branches are reached naturally, padding the left branch with pad1 and padding the right branch with pad2 as necessary.

    Determinsitically zips elements with the specified function, terminating when the ends of both branches are reached naturally, padding the left branch with pad1 and padding the right branch with pad2 as necessary.

    Example: 

    1. scala> Stream(1,2,3).zipAllWith(Stream(4,5,6,7))(0, 0)(_ + _).toList
res0: List[Int] = List(5, 7, 9, 7)
  149. def zipLeft[F2[x] >: F[x], O2](that: Stream[F2, O2]): Stream[F2, O]

    Like zip, but selects the left values only.

    Like zip, but selects the left values only. Useful with timed streams, the example below will emit a number every 100 milliseconds.

    Example: 

    1. scala> import scala.concurrent.duration._, cats.effect.{ContextShift, IO, Timer}
scala> implicit val cs: ContextShift[IO] = IO.contextShift(scala.concurrent.ExecutionContext.Implicits.global)
scala> implicit val timer: Timer[IO] = IO.timer(scala.concurrent.ExecutionContext.Implicits.global)
scala> val s = Stream.range(0, 5) zipLeft Stream.fixedDelay(100.millis)
scala> s.compile.toVector.unsafeRunSync
res0: Vector[Int] = Vector(0, 1, 2, 3, 4)
  150. def zipRight[F2[x] >: F[x], O2](that: Stream[F2, O2]): Stream[F2, O2]

    Like zip, but selects the right values only.

    Like zip, but selects the right values only. Useful with timed streams, the example below will emit a number every 100 milliseconds.

    Example: 

    1. scala> import scala.concurrent.duration._, cats.effect.{ContextShift, IO, Timer}
scala> implicit val cs: ContextShift[IO] = IO.contextShift(scala.concurrent.ExecutionContext.Implicits.global)
scala> implicit val timer: Timer[IO] = IO.timer(scala.concurrent.ExecutionContext.Implicits.global)
scala> val s = Stream.fixedDelay(100.millis) zipRight Stream.range(0, 5)
scala> s.compile.toVector.unsafeRunSync
res0: Vector[Int] = Vector(0, 1, 2, 3, 4)
  151. def zipWith[F2[x] >: F[x], O2 >: O, O3, O4](that: Stream[F2, O3])(f: (O2, O3) ⇒ O4): Stream[F2, O4]

    Determinsitically zips elements using the specified function, terminating when the end of either branch is reached naturally.

    Determinsitically zips elements using the specified function, terminating when the end of either branch is reached naturally.

    Example: 

    1. scala> Stream(1, 2, 3).zipWith(Stream(4, 5, 6, 7))(_ + _).toList
res0: List[Int] = List(5, 7, 9)
  152. def zipWithIndex: Stream[F, (O, Long)]

    Zips the elements of the input stream with its indices, and returns the new stream.

    Zips the elements of the input stream with its indices, and returns the new stream.

    Example: 

    1. scala> Stream("The", "quick", "brown", "fox").zipWithIndex.toList
res0: List[(String,Long)] = List((The,0), (quick,1), (brown,2), (fox,3))
  153. def zipWithNext: Stream[F, (O, Option[O])]

    Zips each element of this stream with the next element wrapped into Some.

    Zips each element of this stream with the next element wrapped into Some. The last element is zipped with None.

    Example: 

    1. scala> Stream("The", "quick", "brown", "fox").zipWithNext.toList
res0: List[(String,Option[String])] = List((The,Some(quick)), (quick,Some(brown)), (brown,Some(fox)), (fox,None))
  154. def zipWithPrevious: Stream[F, (Option[O], O)]

    Zips each element of this stream with the previous element wrapped into Some.

    Zips each element of this stream with the previous element wrapped into Some. The first element is zipped with None.

    Example: 

    1. scala> Stream("The", "quick", "brown", "fox").zipWithPrevious.toList
res0: List[(Option[String],String)] = List((None,The), (Some(The),quick), (Some(quick),brown), (Some(brown),fox))
  155. def zipWithPreviousAndNext: Stream[F, (Option[O], O, Option[O])]

    Zips each element of this stream with its previous and next element wrapped into Some.

    Zips each element of this stream with its previous and next element wrapped into Some. The first element is zipped with None as the previous element, the last element is zipped with None as the next element.

    Example: 

    1. scala> Stream("The", "quick", "brown", "fox").zipWithPreviousAndNext.toList
res0: List[(Option[String],String,Option[String])] = List((None,The,Some(quick)), (Some(The),quick,Some(brown)), (Some(quick),brown,Some(fox)), (Some(brown),fox,None))
  156. def zipWithScan[O2](z: O2)(f: (O2, O) ⇒ O2): Stream[F, (O, O2)]

    Zips the input with a running total according to S, up to but not including the current element.

    Zips the input with a running total according to S, up to but not including the current element. Thus the initial z value is the first emitted to the output:

    Example: 

    1. scala> Stream("uno", "dos", "tres", "cuatro").zipWithScan(0)(_ + _.length).toList
res0: List[(String,Int)] = List((uno,0), (dos,3), (tres,6), (cuatro,10))
    See also

    zipWithScan1

  157. def zipWithScan1[O2](z: O2)(f: (O2, O) ⇒ O2): Stream[F, (O, O2)]

    Zips the input with a running total according to S, including the current element.

    Zips the input with a running total according to S, including the current element. Thus the initial z value is the first emitted to the output:

    Example: 

    1. scala> Stream("uno", "dos", "tres", "cuatro").zipWithScan1(0)(_ + _.length).toList
res0: List[(String, Int)] = List((uno,3), (dos,6), (tres,10), (cuatro,16))
    See also

    zipWithScan

  158. def →[B](y: B): (Stream[F, O], B)
    Implicit
    This member is added by an implicit conversion from Stream[F, O] to ArrowAssoc[Stream[F, O]] performed by method ArrowAssoc in scala.Predef. This conversion will take place only if F is a subclass of Pure (F <: Pure).
    Definition Classes
    ArrowAssoc

Inherited from AnyVal

Inherited from Any

Inherited by implicit conversion FallibleOps from Stream[F, O] to FallibleOps[O]

Inherited by implicit conversion any2stringadd from Stream[F, O] to any2stringadd[Stream[F, O]]

Inherited by implicit conversion StringFormat from Stream[F, O] to StringFormat[Stream[F, O]]

Inherited by implicit conversion Ensuring from Stream[F, O] to Ensuring[Stream[F, O]]

Inherited by implicit conversion ArrowAssoc from Stream[F, O] to ArrowAssoc[Stream[F, O]]

Ungrouped