RootChannel

abstract def flush(f: (T) ⇒ Unit): Unit

final def !=(arg0: Any): Boolean

final def ##(): Int

def :=(value: T): Unit

def <<[U](ch: ReadChannel[T], ignore: ReadChannel[U]): ReadChannel[Unit]

def <<(ch: ReadChannel[T]): ReadChannel[Unit]

def <<>>(other: Channel[T], ignoreOther: ReadChannel[Unit]): Unit

def <<>>(other: Channel[T]): Unit

final def ==(arg0: Any): Boolean

def >>(ch: WriteChannel[T]): ReadChannel[Unit]

def all(value: T): ReadChannel[Boolean]

All elements are equal to value

def any(value: T): ReadChannel[Boolean]

At least one element is equal to value

final def asInstanceOf[T0]: T0

def attach(f: (T) ⇒ Unit): ReadChannel[Unit]

def biMap[U](f: (T) ⇒ U, g: (U) ⇒ T): Channel[U]

def bind(other: Channel[T], ignoreOther: ReadChannel[Unit]): Unit

def bind(other: Channel[T]): Unit

Two-way binding; synchronises this and other.

def buffer: Buffer[T]

Buffers all produced elements

def cache(default: T): ReadStateChannel[T]

def cache: ReadPartialChannel[T]

def child(): ReadChannel[T]

def clone(): AnyRef

def collect[U](f: PartialFunction[T, U]): ReadChannel[U]

Applies partial function f on each element; if the function is not defined for the current input, it is filtered out

def count(value: T): ReadChannel[Int]

Count number of occurrence of value.

def detach(ch: ChildChannel[T, _]): Unit

def dispose(): Unit

def distinct: ReadChannel[T]

Filters out (merges) duplicates

def drop(count: Int): ReadChannel[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(f: (T) ⇒ Boolean): ReadChannel[Boolean]

Checks for existence of a value for which f is true

def filter(f: (T) ⇒ Boolean): ReadChannel[T]

Only include elements for which f is true

def filterCycles: ReadChannel[T]

def filterNot(f: (T) ⇒ Boolean): ReadChannel[T]

def finalize(): Unit

def flatMap[U](f: (T) ⇒ ReadChannel[U]): ReadChannel[U]

Applies f on each element and flatten its result into the stream

def flatMapBuf[U](f: (T) ⇒ ReadBuffer[U]): ReadBuffer[U]

def flatMapCh[U](f: (T) ⇒ Channel[U]): Channel[U]

flatMap with back-propagation.

def flatMapSeq[U](f: (T) ⇒ Seq[U]): ReadChannel[U]

def flatProduce[U](value: Option[T], ignore: ReadChannel[U]*): Unit

def flatProduce(value: Option[T]): Unit

def foldLeft[U](acc: U)(f: (U, T) ⇒ U): ReadChannel[U]

def forall(f: (T) ⇒ Boolean): ReadChannel[Boolean]

Checks whether f is true for all elements

def forkBi[U](fwd: Observer[T, U], bwd: Observer[U, T], silent: Boolean = false): Channel[U]

Bi-directional fork for values

def forkBiFlat[U](obs: Observer[T, Channel[U]]): Channel[U]

Bi-directional fork for channels

def forkUni[U](observer: Observer[T, U], filterCycles: Boolean = false): ReadChannel[U]

Uni-directional fork for values

def forkUniFlat[U](observer: Observer[T, ReadChannel[U]]): ReadChannel[U]

Uni-directional fork for channels

def forkUniState[U](observer: Observer[T, U], onFlush: ⇒ Option[U]): ReadChannel[U]

final def getClass(): Class[_]

def has(value: T): ReadChannel[Boolean]

Stream contains at least one occurrence of value.

def hashCode(): Int

def head: ReadChannel[T]

Wraps first element as a channel

def is(value: T): ReadChannel[Boolean]

Current value is equal to value

def isEmpty: ReadChannel[Boolean]

def isHead(value: T): ReadChannel[Boolean]

Checks whether the given element is the first produced value

final def isInstanceOf[T0]: Boolean

def isNot(value: T): ReadChannel[Boolean]

Current value is not equal to value

def map[U](f: (T) ⇒ U): ReadChannel[U]

Applies f on each element

def mapTo[U](f: (T) ⇒ U): DeltaDict[T, U]

Map f on each element and turn stream into a dictionary

def max[U >: T](init: U)(implicit num: Numeric[U]): ReadChannel[U]

Calculates maximum value

def merge(ch: ReadChannel[T]): ReadChannel[T]

def min[U >: T](init: U)(implicit num: Numeric[U]): ReadChannel[U]

Calculates minimum value

final def ne(arg0: AnyRef): Boolean

def nonEmpty: ReadChannel[Boolean]

Negation of isEmpty

final def notify(): Unit

final def notifyAll(): Unit

def or(ch: ReadChannel[_]): ReadChannel[Unit]

def partialBiMap[U](f: (T) ⇒ Option[U], g: (U) ⇒ Option[T]): Channel[U]

def partition(f: (T) ⇒ Boolean): (ReadChannel[T], ReadChannel[T])

Partitions stream into two sub-stream

def produce[U](value: T, ignore: ReadChannel[U]*): Unit

def produce(value: T): Unit

def product[U >: T](implicit num: Numeric[U]): ReadChannel[U]

Calculates product

def publish[U](ch: WriteChannel[T], ignore: ReadChannel[U]): ReadChannel[Unit]

def publish(ch: WriteChannel[T]): ReadChannel[Unit]

def silentAttach(f: (T) ⇒ Unit): ReadChannel[Unit]

def size: ReadChannel[Int]

def subscribe[U](ch: ReadChannel[T], ignore: ReadChannel[U]): ReadChannel[Unit]

def subscribe(ch: ReadChannel[T]): ReadChannel[Unit]

Redirect stream from other to this.

def sum[U >: T](implicit num: Numeric[U]): ReadChannel[U]

Sums over all elements

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

def tail: ReadChannel[T]

Skips first element

def take(count: Int): ReadChannel[T]

def takeUntil(ch: ReadChannel[_]): ReadChannel[T]

Take all elements until ch produces any value

def toBuffer: Buffer[T]

Buffers only current element

def toOpt: Opt[T]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def writeTo(write: WriteChannel[T]): Channel[T]

def zip[U](other: ReadChannel[U]): ReadChannel[(T, U)]

def |(ch: ReadChannel[_]): ReadChannel[Unit]