Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

2.  final def ##(): Int

   Definition Classes

   AnyRef → Any

3.  final def ==(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

4.  final def asInstanceOf[T0]: T0

   Definition Classes

   Any

5.  def buffer[F[_], I](n: Int): (Stream[F, I]) ⇒ Stream[F, I]

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

6.  def bufferAll[F[_], I]: Pipe[F, I, I]

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

7.  def bufferBy[F[_], I](f: (I) ⇒ Boolean): Pipe[F, I, I]

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

8.  def changes[F[_], I](eqf: (I, I) ⇒ Boolean): (Stream[F, I]) ⇒ Stream[F, I]

   Outputs first value, and then any changed value from the last value.

   Outputs first value, and then any changed value from the last value. eqf is used for equality. *

9.  def chunkLimit[F[_], I](n: Int): (Stream[F, I]) ⇒ Stream[F, Chunk[I]]

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

10.  def chunkN[F[_], I](n: Int, allowFewer: Boolean = true): (Stream[F, I]) ⇒ Stream[F, List[Chunk[I]]]

    Outputs a list of chunks, the total size of all chunks is limited and split as necessary.

11.  def chunks[F[_], I]: (Stream[F, I]) ⇒ Stream[F, Chunk[I]]

    Output all chunks from the input Handle.

12.  def clone(): AnyRef

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

13.  def collect[F[_], I, I2](pf: PartialFunction[I, I2]): (Stream[F, I]) ⇒ Stream[F, I2]

    Map/filter simultaneously.

    Map/filter simultaneously. Calls collect on each Chunk in the stream.

14.  def collectFirst[F[_], I, I2](pf: PartialFunction[I, I2]): (Stream[F, I]) ⇒ Stream[F, I2]

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

15.  def covary[F[_], I, O](p: (Stream[Pure, I]) ⇒ Stream[Pure, O]): Pipe[F, I, O]
16.  def delete[F[_], I](p: (I) ⇒ Boolean): (Stream[F, I]) ⇒ Stream[F, I]

    Skip the first element that matches the predicate.

17.  def drop[F[_], I](n: Long): (Stream[F, I]) ⇒ Stream[F, I]

    Drop n elements of the input, then echo the rest.

18.  def dropLast[F[_], I]: Pipe[F, I, I]

    Drops the last element.

19.  def dropLastIf[F[_], I](p: (I) ⇒ Boolean): Pipe[F, I, I]

    Drops the last element if the predicate evaluates to true.

20.  def dropRight[F[_], I](n: Int): (Stream[F, I]) ⇒ Stream[F, I]

    Emits all but the last n elements of the input.

21.  def dropWhile[F[_], I](p: (I) ⇒ Boolean): (Stream[F, I]) ⇒ Stream[F, I]

    Drop the elements of the input until the predicate p fails, then echo the rest.

22.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

23.  def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

24.  def exists[F[_], I](p: (I) ⇒ Boolean): (Stream[F, I]) ⇒ Stream[F, Boolean]

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

25.  def filter[F[_], I](f: (I) ⇒ Boolean): (Stream[F, I]) ⇒ Stream[F, I]

    Emit only inputs which match the supplied predicate.

26.  def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

27.  def find[F[_], I](f: (I) ⇒ Boolean): (Stream[F, I]) ⇒ Stream[F, I]

    Emits the first input (if any) which matches the supplied predicate, to the output of the returned Pull

28.  def fold[F[_], I, O](z: O)(f: (O, I) ⇒ O): (Stream[F, I]) ⇒ Stream[F, O]

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

29.  def fold1[F[_], I](f: (I, I) ⇒ I): (Stream[F, I]) ⇒ Stream[F, I]

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

30.  def forall[F[_], I](p: (I) ⇒ Boolean): (Stream[F, I]) ⇒ Stream[F, Boolean]

    Emits a single true value if all input matches the predicate.

    Emits a single true value if all input matches the predicate. Halts with false as soon as a non-matching element is received.

31.  final def getClass(): Class[_]

    Definition Classes

    AnyRef → Any

32.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

33.  def id[F[_], I]: (Stream[F, I]) ⇒ Stream[F, I]

    Write all inputs to the output of the returned Pull.

34.  def intersperse[F[_], I](separator: I): (Stream[F, I]) ⇒ Stream[F, I]

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

35.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

36.  def last[F[_], I]: (Stream[F, I]) ⇒ Stream[F, Option[I]]

    Return the last element of the input Handle, if nonempty.

37.  def lastOr[F[_], I](li: ⇒ I): (Stream[F, I]) ⇒ Stream[F, I]

    Return the last element of the input Handle if nonempty, otherwise li.

38.  def lift[F[_], I, O](f: (I) ⇒ O): (Stream[F, I]) ⇒ Stream[F, O]

    Write all inputs to the output of the returned Pull, transforming elements using f.

    Write all inputs to the output of the returned Pull, transforming elements using f. Works in a chunky fashion and creates a Chunk.indexedSeq for each mapped chunk.

39.  def mapAccumulate[F[_], S, I, O](init: S)(f: (S, I) ⇒ (S, O)): (Stream[F, I]) ⇒ Stream[F, (S, O)]

    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))

40.  def mapChunks[F[_], I, O](f: (Chunk[I]) ⇒ Chunk[O]): (Stream[F, I]) ⇒ Stream[F, O]

    Output a transformed version of all chunks from the input Handle.

41.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

42.  final def notify(): Unit

    Definition Classes

    AnyRef

43.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

44.  def prefetch[F[_], I](implicit arg0: Async[F]): (Stream[F, I]) ⇒ Stream[F, I]

    Behaves like id, but starts fetching the next chunk before emitting the current, enabling processing on either side of the prefetch to run in parallel.

45.  def reduce[F[_], I](f: (I, I) ⇒ I): (Stream[F, I]) ⇒ Stream[F, I]

    Alias for pipe.fold1

46.  def rethrow[F[_], I]: (Stream[F, Either[Throwable, I]]) ⇒ Stream[F, I]

    Rethrow any Left(err).

    Rethrow any Left(err). Preserves chunkiness.

47.  def scan[F[_], I, O](z: O)(f: (O, I) ⇒ O): (Stream[F, I]) ⇒ Stream[F, O]

    Left fold which outputs all intermediate results.

    Left fold which outputs all intermediate results. Example: Stream(1,2,3,4) through pipe.scan(0)(_ + _) == Stream(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

    Works in a chunky fashion, and creates a Chunk.indexedSeq for each converted chunk.

48.  def scan1[F[_], I](f: (I, I) ⇒ I): (Stream[F, I]) ⇒ Stream[F, I]

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

49.  def shiftRight[F[_], I](head: I*): (Stream[F, I]) ⇒ Stream[F, I]

    Emit the given values, then echo the rest of the input.

50.  def sliding[F[_], I](n: Int): (Stream[F, I]) ⇒ Stream[F, Vector[I]]

    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[Chunk[Int]] = List(Chunk(1, 2), Chunk(2, 3), Chunk(3, 4))

    Exceptions thrown

    IllegalArgumentException if n <= 0

51.  def split[F[_], I](f: (I) ⇒ Boolean): Pipe[F, I, Vector[I]]

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

    Break 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.

52.  def stepper[I, O](p: (Stream[Pure, I]) ⇒ Stream[Pure, O]): Stepper[I, O]
53.  def sum[F[_], I](implicit ev: Numeric[I]): (Stream[F, I]) ⇒ Stream[F, I]

    Writes the sum of all input elements, or zero if the input is empty.

54.  final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes

    AnyRef

55.  def tail[F[_], I]: (Stream[F, I]) ⇒ Stream[F, I]

    Emits all elements of the input except the first one.

56.  def take[F[_], I](n: Long): (Stream[F, I]) ⇒ Stream[F, I]

    Emit the first n elements of the input Handle and return the new Handle.

57.  def takeRight[F[_], I](n: Long): (Stream[F, I]) ⇒ Stream[F, I]

    Emits the last n elements of the input.

58.  def takeThrough[F[_], I](f: (I) ⇒ Boolean): (Stream[F, I]) ⇒ Stream[F, I]

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

59.  def takeWhile[F[_], I](f: (I) ⇒ Boolean): (Stream[F, I]) ⇒ Stream[F, I]

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

60.  def toString(): String

    Definition Classes

    AnyRef → Any

61.  def unNoneTerminate[F[_], I]: (Stream[F, Option[I]]) ⇒ Stream[F, I]

    Halt the input stream at the first None.

    Halt the input stream at the first None.

    Example:

    1. scala> unNoneTerminate(Stream(Some(1), Some(2), None, Some(3), None)).toVector
       res0: Vector[Int] = Vector(1, 2)

62.  def unchunk[F[_], I]: (Stream[F, I]) ⇒ Stream[F, I]

    Convert the input to a stream of solely 1-element chunks.

63.  def vectorChunkN[F[_], I](n: Int, allowFewer: Boolean = true): (Stream[F, I]) ⇒ Stream[F, Vector[I]]

    Groups inputs into separate Vector objects of size n.

    Groups inputs into separate Vector objects of size n.

    Example:

    1. scala> Stream(1, 2, 3, 4, 5).vectorChunkN(2).toVector
       res0: Vector[Vector[Int]] = Vector(Vector(1, 2), Vector(3, 4), Vector(5))

64.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

65.  final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

66.  final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

67.  def zipWithIndex[F[_], I]: (Stream[F, I]) ⇒ Stream[F, (I, Int)]

    Zip the elements of the input Handle with its indices, and return the new Handle

68.  def zipWithNext[F[_], I]: (Stream[F, I]) ⇒ Stream[F, (I, Option[I])]

    Zip the elements of the input Handle with its next element wrapped into Some, and return the new Handle.

    Zip the elements of the input Handle with its next element wrapped into Some, and return the new Handle. The last element is zipped with None.

69.  def zipWithPrevious[F[_], I]: (Stream[F, I]) ⇒ Stream[F, (Option[I], I)]

    Zip the elements of the input Handle with its previous element wrapped into Some, and return the new Handle.

    Zip the elements of the input Handle with its previous element wrapped into Some, and return the new Handle. The first element is zipped with None.

70.  def zipWithPreviousAndNext[F[_], I]: (Stream[F, I]) ⇒ Stream[F, (Option[I], I, Option[I])]

    Zip the elements of the input Handle with its previous and next elements wrapped into Some, and return the new Handle.

    Zip the elements of the input Handle with its previous and next elements wrapped into Some, and return the new Handle. The first element is zipped with None as the previous element, the last element is zipped with None as the next element.

71.  def zipWithScan[F[_], I, S](z: S)(f: (S, I) ⇒ S): (Stream[F, I]) ⇒ Stream[F, (I, S)]

    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:

    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

72.  def zipWithScan1[F[_], I, S](z: S)(f: (S, I) ⇒ S): (Stream[F, I]) ⇒ Stream[F, (I, S)]

    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:

    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

    zipWithScan

73.  object Stepper