Clump

abstract def downstream: Future[List[Clump[_]]]

abstract def result: Future[Option[T]]

abstract def upstream: List[Clump[_]]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def apply(): Future[T]

A utility method for automatically unwrapping the underlying value

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fallback[B >: T](default: ⇒ Option[B]): Clump[B]

On any exception, fallback to a default value

def fallbackTo[B >: T](default: ⇒ Clump[B]): Clump[B]

On any exception, fallback to a default clump

def filter[B >: T](f: (B) ⇒ Boolean): Clump[B]

Apply a filter to this clump so that the result will only be defined if the predicate function returns true

def finalize(): Unit

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

Create a new clump by applying a function that returns a clump to the result of this clump

def get: Future[Option[T]]

Trigger execution of a clump.

final def getClass(): Class[_]

def getOrElse[B >: T](default: ⇒ B): Future[B]

Get the result of the clump or provide a fallback value in the case where the result is not defined

def handle[B >: T](f: PartialFunction[Throwable, Option[B]]): Clump[B]

Define a fallback value to use in the case of specified exceptions

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def join[U](other: Clump[U]): Clump[(T, U)]

Join this clump to another clump so that the result is a clump holding a pair of values

def list[B >: T](implicit cbf: CanBuildFrom[Nothing, Nothing, B]): Future[B]

If the underlying value is a list, then this will return Nil instead of None when the result is not defined

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

Create a new clump by applying a function to the result of this clump

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def optional: Clump[Option[T]]

Mark a clump as optional so that its underlying value is an option to avoid lossy joins

def orElse[B >: T](default: ⇒ Clump[B]): Clump[B]

If this clump does not return a value then use the value from a default clump instead

def orElse[B >: T](default: ⇒ B)(implicit arg0: ClassTag[B]): Clump[B]

If this clump does not return a value then use the default instead

def recover[B >: T](f: PartialFunction[Throwable, Option[B]]): Clump[B]

Alias for handle

def recoverWith[B >: T](f: PartialFunction[Throwable, Clump[B]]): Clump[B]

Alias for rescue

def rescue[B >: T](f: PartialFunction[Throwable, Clump[B]]): Clump[B]

Define a fallback clump to use in the case of specified exceptions

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter[B >: T](f: (B) ⇒ Boolean): Clump[B]

Alias for filter used by for-comprehensions