Free

abstract def canEqual(that: Any): Boolean

abstract def productArity: Int

abstract def productElement(n: Int): Any

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def compile[T[_]](f: FunctionK[S, T]): Free[T, A]

Compile your free monad into another language by changing the suspension functor using the given natural transformation f.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

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

Bind the given continuation to the result of this computation.

final def fold[B](r: (A) ⇒ B, s: (S[Free[S, A]]) ⇒ B)(implicit S: Functor[S]): B

Catamorphism.

final def foldMap[M[_]](f: FunctionK[S, M])(implicit M: Monad[M]): M[A]

Catamorphism for Free.

final def getClass(): Class[_]

final def go(f: (S[Free[S, A]]) ⇒ Free[S, A])(implicit S: Functor[S]): A

Run to completion, using a function that extracts the resumption from its suspension functor.

def hashCode(): Int

final def inject[G[_]](implicit ev: InjectK[S, G]): Free[G, A]

Lift into G (typically a EitherK) given InjectK.

scala> type Lo[A] = cats.data.EitherK[List, Option, A]
defined type alias Lo

scala> val fo = Free.liftF(Option("foo"))
fo: cats.free.Free[Option,String] = Free(...)

scala> fo.inject[Lo]
res4: cats.free.Free[Lo,String] = Free(...)

final def isInstanceOf[T0]: Boolean

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

final def mapK[T[_]](f: ~>[S, T]): Free[T, A]

Modify the functor context S using transformation f.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def productIterator: Iterator[Any]

def productPrefix: String

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

Evaluate a single layer of the free monad.

final def run(implicit S: Comonad[S]): A

Run to completion, using the given comonad to extract the resumption.

final def runM[M[_]](f: (S[Free[S, A]]) ⇒ M[Free[S, A]])(implicit S: Functor[S], M: Monad[M]): M[A]

Run to completion, using a function that maps the resumption from S to a monad M.

final def runTailRec(implicit S: Monad[S]): S[A]

Run to completion, using monadic recursion to evaluate the resumption in the context of S.

final def step: Free[S, A]

Takes one evaluation step in the Free monad, re-associating left-nested binds in the process.

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