Event

abstract def register(s: Witness[T]): Closable

Register the given Witness to this Event.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def build[U >: T, That](implicit cbf: CanBuild[U, That]): Event[That]

Progressively build a collection of events using the passed-in builder.

def clone(): AnyRef

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

Build a new Event by applying the given function to each value observed.

def dedup: Event[T]

Builds a new Event by keeping only the Events where the previous and current values are not == to each other.

def dedupWith(eq: (T, T) ⇒ Boolean): Event[T]

Build a new Event by keeping only those Event values where the equality predicate eq applied to the current and new values does not match.

def diff[CC[_], U](implicit arg0: Diffable[CC], toCC: <:<[T, CC[U]]): Event[Diff[CC, U]]

The Event that stores the difference between successive updates to the parent event.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(p: (T) ⇒ Boolean): Event[T]

Build a new Event by keeping only those Event values that match the predicate p.

def finalize(): Unit

def foldLeft[U](z: U)(f: (U, T) ⇒ U): Event[U]

Build a new Event by incrementally accumulating over events, starting with value z.

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def joinLast[U](other: Event[U]): Event[(T, U)]

Join two events into a new Event which notifies a tuple of the last value in each underlying event.

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

Build a new Event by transforming each new event value with f.

def merge[U >: T](other: Event[U]): Event[U]

Merge two events; the resulting event interleaves events from this and other.

def mergeMap[U](f: (T) ⇒ Event[U]): Event[U]

The Event which merges the events resulting from f applied to each element in this Event.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def patch[CC[_], U](implicit arg0: Diffable[CC], ev: <:<[T, Diff[CC, U]]): Event[CC[U]]

Patch up an Event of differences (like those produced by Event.diff) into an Event that reflects the current version of a data structure.

final def respond(s: (T) ⇒ Unit): Closable

Observe this event with function s.

def select[U](other: Event[U]): Event[Either[T, U]]

Merge two Events of different types.

def sliding(n: Int): Event[Seq[T]]

Build a new Event representing a sliding window of at-most n.

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

def take(howmany: Int): Event[T]

An event which consists of the first howmany values in the parent Event.

def toFuture(): Future[T]

A Future which is satisfied by the first value observed.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

Merge two event streams in lock-step, combining corresponding event values.