Return

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def >>= [B] (f: (A) ⇒ Free[S, B]): Free[S, B]

Alias for flatMap

val a : A

def asInstanceOf [T0] : T0

def canEqual (arg0: Any): Boolean

def clone (): AnyRef

def collect [B, C >: A] (implicit ev: $less$tilde$less[Free[S, C], Source[B, C]], S: Functor[S]): (Vector[B], C)

Runs a Source all the way to the end, tail-recursively, collecting the produced values.

def drain [E, B, C >: A] (source: Source[E, B])(implicit ev: $less$tilde$less[Free[S, C], Sink[E, C]], S: Functor[S]): (C, B)

Feed the given source to this Sink.

def drive [E, B, C >: A] (sink: Sink[Option[E], B])(implicit ev: $less$tilde$less[Free[S, C], Source[E, C]], S: Functor[S]): (C, B)

Drive this Source with the given Sink.

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def feed [E, C >: A] (ss: Stream[E])(implicit ev: $less$tilde$less[Free[S, C], Sink[E, C]], S: Functor[S]): C

Feed the given stream to this Source.

def finalize (): Unit

def flatMap [B] (f: (A) ⇒ Free[S, B]): Free[S, B]

Binds the given continuation to the result of this computation.

def getClass (): java.lang.Class[_]

def hashCode (): Int

def isInstanceOf [T0] : Boolean

def map [B] (f: (A) ⇒ B): Free[S, B]

def mapSuspension [T[+_]] (f: ~>[S, T])(implicit S: Functor[S]): Free[T, A]

Modifies the suspension with the given natural transformation.

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

def productArity : Int

def productElement (arg0: Int): Any

def productIterator : Iterator[Any]

def productPrefix : String

def resume (implicit S: Functor[S]): Either[S[Free[S, A]], A]

Evaluates a single layer of the free monad.

def run [B >: A] (implicit ev: $less$tilde$less[Free[S, B], Trampoline[B]], S: Functor[S]): B

Runs a trampoline all the way to the end, tail-recursively.

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

def toString (): String

def wait (): Unit

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

def wait (arg0: Long): Unit

def zipWith [B, C] (tb: Free[S, B], f: (A, B) ⇒ C)(implicit S: Functor[S]): Free[S, C]

Interleave this computation with another, combining the results with the given function.

def productElements : Iterator[Any]