AbstractSpool

abstract def head: A

The first element of the spool.

abstract def isEmpty: Boolean

abstract def tail: Future[Spool[A]]

The (deferred) tail of the spool.

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[B >: A](that: ⇒ Future[Spool[B]]): Future[Spool[B]]

Concatenates two spools.

def ++[B >: A](that: ⇒ Spool[B]): Spool[B]

Concatenates two spools.

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[B](f: PartialFunction[A, B]): Future[Spool[B]]

The standard Scala collect, in order to implement map & filter.

def concat[B >: A](that: Future[Spool[B]]): Future[Spool[B]]

def concat[B >: A](that: Spool[B]): Spool[B]

def distinctBy[B](fn: (A) ⇒ B): Spool[A]

Builds a new Spool from this one by filtering out duplicate elements, elements for which fn returns the same value.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(f: (A) ⇒ Boolean): Future[Spool[A]]

def finalize(): Unit

def flatMap[B](f: (A) ⇒ Future[Spool[B]]): Future[Spool[B]]

Applies a function that generates a spool for each element in this spool, flattening the result into a single spool.

def foldLeft[B](z: B)(f: (B, A) ⇒ B): Future[B]

def force: Future[Unit]

Eagerly executes all computation represented by this Spool (presumably for side-effects), and returns a Future representing its completion.

def foreach[B](f: (A) ⇒ B): Future[Unit]

Apply {{f}} for each item in the spool, until the end.

def foreachElem[B](f: (Option[A]) ⇒ B): Future[Unit]

A version of {{foreach}} that wraps each element in an {{Option}}, terminating the stream (EOF) with {{None}}.

final def getClass(): Class[_]

def hashCode(): Int

def headOption: Option[A]

The first element of the spool if it is non-empty.

final def isInstanceOf[T0]: Boolean

def map[B](f: (A) ⇒ B): Spool[B]

def mapFuture[B](f: (A) ⇒ Future[B]): Future[Spool[B]]

Applies a function that generates a Future[B] for each element of this spool.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reduceLeft[B >: A](f: (B, A) ⇒ B): Future[B]

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

def take(n: Int): Spool[A]

Take the first n elements of the Spool as another Spool (adapted from Stream.take)

def takeWhile(f: (A) ⇒ Boolean): Spool[A]

Take elements from the head of the Spool (lazily), while the given condition is true.

def toSeq: Future[Seq[A]]

Fully buffer the spool to a {{Seq}}.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip[B](that: Spool[B]): Spool[(A, B)]

Zips two Spools returning a Spool of Tuple2s.