Stream

abstract def fold[E1 >: E, A1 >: A, S]: Fold[E1, A1, S]

Executes an effectful fold over the stream of values.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ++[E1 >: E, A1 >: A](that: ⇒ Stream[E1, A1]): Stream[E1, A1]

Concatenates the specified stream to this stream.

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[B](pf: PartialFunction[A, B]): Stream[E, B]

Performs a filter and map in a single step.

final def drop(n: Int): Stream[E, A]

Drops the specified number of elements from this stream.

def dropWhile(pred: (A) ⇒ Boolean): Stream[E, A]

Drops all elements of the stream for as long as the specified predicate evaluates to true.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(pred: (A) ⇒ Boolean): Stream[E, A]

Filters this stream by the specified predicate, retaining all elements for which the predicate evaluates to true.

final def filterNot(pred: (A) ⇒ Boolean): Stream[E, A]

Filters this stream by the specified predicate, removing all elements for which the predicate evaluates to true.

def finalize(): Unit

final def flatMap[E1 >: E, B](f: (A) ⇒ Stream[E1, B]): Stream[E1, B]

Maps each element of this stream to another stream, and returns the concatenation of those streams.

def foldLeft[A1 >: A, S](s: S)(f: (S, A1) ⇒ S): IO[E, S]

final def foreach[E1 >: E](f: (A) ⇒ IO[E1, Unit]): IO[E1, Unit]

Consumes all elements of the stream, passing them to the specified callback.

final def foreach0[E1 >: E](f: (A) ⇒ IO[E1, Boolean]): IO[E1, Unit]

Consumes elements of the stream, passing them to the specified callback, and terminating consumption when the callback returns false.

def forever: Stream[E, A]

Repeats this stream forever.

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[B](f: (A) ⇒ B): Stream[E, B]

Maps over elements of the stream with the specified function.

def mapAccum[S1, B](s1: S1)(f1: (S1, A) ⇒ (S1, B)): Stream[E, B]

Statefully maps over the elements of this stream to produce new elements.

final def mapAccumM[E1 >: E, S1, B](s1: S1)(f1: (S1, A) ⇒ IO[E1, (S1, B)]): Stream[E1, B]

Statefully and effectfully maps over the elements of this stream to produce new elements.

def mapConcat[B](f: (A) ⇒ Chunk[B]): Stream[E, B]

Maps each element to a chunk, and flattens the chunks into the output of this stream.

final def mapM[E1 >: E, B](f: (A) ⇒ IO[E1, B]): Stream[E1, B]

Maps over elements of the stream with the specified effectful function.

final def merge[E1 >: E, A1 >: A](that: Stream[E1, A1], capacity: Int = 1): Stream[E1, A1]

Merges this stream and the specified stream together.

final def mergeEither[E1 >: E, B](that: Stream[E1, B], capacity: Int = 1): Stream[E1, Either[A, B]]

Merges this stream and the specified stream together to produce a stream of eithers.

final def mergeWith[E1 >: E, B, C](that: Stream[E1, B], capacity: Int = 1)(l: (A) ⇒ C, r: (B) ⇒ C): Stream[E1, C]

Merges this stream and the specified stream together to a common element type with the specified mapping functions.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def peel[E1 >: E, A1 >: A, R](sink: Sink[E1, A1, A1, R]): Managed[E1, (R, Stream[E1, A1])]

Peels off enough material from the stream to construct an R using the provided Sink, and then returns both the R and the remainder of the Stream in a managed resource.

def repeat(schedule: Schedule[Unit, _], clock: Clock = Clock.Live): Stream[E, A]

Repeats the entire stream using the specified schedule.

def repeatElems[B](schedule: Schedule[A, B], clock: Clock = Clock.Live): Stream[E, A]

Repeats elements of the stream using the provided schedule.

def run[E1 >: E, A0, A1 >: A, B](sink: Sink[E1, A0, A1, B]): IO[E1, B]

Runs the sink on the stream to produce either the sink's result or an error.

final def synchronized[T0](arg0: ⇒ T0): T0

final def take(n: Int): Stream[E, A]

Takes the specified number of elements from this stream.

def takeWhile(pred: (A) ⇒ Boolean): Stream[E, A]

Takes all elements of the stream for as long as the specified predicate evaluates to true.

final def toQueue[E1 >: E, A1 >: A](capacity: Int = 1): Managed[Nothing, Queue[Take[E1, A1]]]

Converts the stream to a managed queue.

def toString(): String

final def transduce[E1 >: E, A1 >: A, C](sink: Sink[E1, A1, A1, C]): Stream[E1, C]

Applies a transducer to the stream, which converts one or more elements of type A into elements of type C.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def withEffect[E1 >: E](f: (A) ⇒ IO[E1, Unit]): Stream[E1, A]

Adds an effect to consumption of every element of the stream.

final def zip[E1 >: E, B](that: Stream[E1, B], lc: Int = 1, rc: Int = 1): Stream[E1, (A, B)]

Zips this stream together with the specified stream.

final def zipWith[E1 >: E, B, C](that: Stream[E1, B], lc: Int = 1, rc: Int = 1)(f: (Option[A], Option[B]) ⇒ Option[C]): Stream[E1, C]

Zips two streams together with a specified function.

def zipWithIndex: Stream[E, (A, Int)]

Zips this stream together with the index of elements of the stream.