beam-core
API
Generated with
beam-core/beam/Stream

Stream

beam.Stream
See theStream companion object
sealed abstract class Stream[+A, -U]

Attributes

Companion
object
Graph
Supertypes
class Object
trait Matchable
class Any

Members list

Value members

Concrete methods

final def ++[B >: A, V <: U](that: => Stream[B, V]): Stream[B, V]
final def collect[B](f: PartialFunction[A, B]): Stream[B, U]
final def collectEff[B, V <: U](f: PartialFunction[A, Computation[B, V]]): Stream[B, V]
final def concat[B >: A, V <: U](that: => Stream[B, V]): Stream[B, V]
final def decons: Option[(Vector[A], Computation[Stream[A, U], U])]
final def deconsChunk: (Vector[A], Computation[Stream[A, U], U])
final def deconsSkip: Computation[Option[(Vector[A], Computation[Stream[A, U], U])], U]
final def drain: Computation[Unit, U]
final def drop(count: Long): Stream[A, U]
final def filter(f: A => Boolean): Stream[A, U]
final def filterEff[V <: U](f: A => Computation[Boolean, V]): Stream[A, V]
final def filterNot(f: A => Boolean): Stream[A, U]
final def filterNotEff[V <: U](f: A => Computation[Boolean, V]): Stream[A, V]
final def flatMap[B, V <: U](f: A => Stream[B, V]): Stream[B, V]
final def flatMapEff[B, V <: U](f: A => Computation[Stream[B, V], V]): Stream[B, V]
final def foldLeft[B](zero: B)(op: (B, A) => B): Computation[B, U]
final def foldLeftEff[B, V <: U](zero: B)(op: (B, A) => Computation[B, V]): Computation[B, V]
final def foreach(f: A => Unit): Stream[A, U]
final def foreachEff[V <: U](f: A => Computation[Unit, V]): Stream[A, V]
final def forsome(f: PartialFunction[A, Unit]): Stream[A, U]
final def forsomeEff[V <: U](f: PartialFunction[A, Computation[Unit, V]]): Stream[A, V]
final def head: Computation[A, U]
final def headOption: Computation[Option[A], U]
final def map[B](f: A => B): Stream[B, U]
final def mapChunk[B](f: (Vector[A]) => Vector[B]): Stream[B, U]
final def mapChunkEff[B, V <: U](f: (Vector[A]) => Computation[Vector[B], V]): Stream[B, V]
final def mapEff[B, V <: U](f: A => Computation[B, V]): Stream[B, V]
final def mapFilter[B](f: A => Option[B]): Stream[B, U]
final def mapFilterEff[B, V <: U](f: A => Computation[Option[B], V]): Stream[B, V]
final def reduce[B >: A](f: (B, B) => B): Computation[B, U]
final def reduceOption[B >: A](f: (B, B) => B): Computation[Option[B], U]
final def reduceOptionEff[B >: A, V <: U](f: (B, B) => Computation[B, V]): Computation[Option[B], V]
final def tail: Stream[A, U]
final def take(count: Long): Stream[A, U]
final def toList: Computation[List[A], U]
final def toVector: Computation[Vector[A], U]
Generated with