com.twitter.concurrent

Spool

sealed trait Spool[+A] extends AnyRef

A spool is an asynchronous stream. It more or less mimics the scala {{Stream}} collection, but with cons cells that have either eager or deferred tails.

Construction of eager Spools is done with either Spool.cons or the {{**::}} operator. To construct a lazy/deferred Spool which materializes its tail on demand, use the {{*::}} operator. In order to use these operators for deconstruction, they must be imported explicitly (ie: {{import Spool.{*::, **:: }}} )

def fill(rest: Promise[Spool[Int]]) {
  asyncProcess foreach { result =>
    if (result.last) {
      rest() = Return(result **:: Spool.empty)
    } else {
      val next = new Promise[Spool[Int]]
      rest() = Return(result *:: next)
      fill(next)
    }
  }
}
val rest = new Promise[Spool[Int]]
fill(rest)
firstElem *:: rest

explicitly (ie: {{import Spool.{*::, **:: }}}

def fill(rest: Promise[Spool[Int]]) {
  asyncProcess foreach { result =>
    if (result.last) {
      rest() = Return(result **:: Spool.empty)
    } else {
      val next = new Promise[Spool[Int]]
      rest() = Return(result *:: next)
      fill(next)
    }
  }
}
val rest = new Promise[Spool[Int]]
fill(rest)
firstElem *:: rest
Linear Supertypes
AnyRef, Any
Known Subclasses
Cons, Empty
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Spool
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def head: A

    The first element of the spool.

    The first element of the spool. Invalid for empty spools.

  2. abstract def isEmpty: Boolean

  3. abstract def tail: Future[Spool[A]]

    The (deferred) tail of the spool.

    The (deferred) tail of the spool. Invalid for empty spools.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  2. final def ##(): Int

    Definition Classes
    AnyRef → Any

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

    Concatenates two spools.

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

    Concatenates two spools.

  5. final def ==(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  6. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  7. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

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

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

    It may seem unnatural to return a Future[…] here, but we cannot know whether the first element exists until we have applied its filter.

  9. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  10. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

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

  12. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

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

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

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

  15. def force: Future[Unit]

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

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

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

    Apply {{f}} for each item in the spool, until the end. {{f}} is applied as the items become available.

  17. 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}}.

  18. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any

  19. def hashCode(): Int

    Definition Classes
    AnyRef → Any

  20. def headOption: Option[A]

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

  21. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

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

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

    Applies a function that generates a Future[B] to each element of this spool The returned future is satisfied with the head of the resulting spool is available

  24. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  25. final def notify(): Unit

    Definition Classes
    AnyRef

  26. final def notifyAll(): Unit

    Definition Classes
    AnyRef

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

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

    Definition Classes
    AnyRef

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

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

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

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

  31. def toSeq: Future[Seq[A]]

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

    Fully buffer the spool to a {{Seq}}. The returned future is satisfied when the entire result is ready.

  32. def toString(): String

    Definition Classes
    AnyRef → Any

  33. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  35. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped