Free

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

implicit def catsFreeFoldableForFree[F[_]](implicit foldableF: Foldable[F]): Foldable[[β$19$]Free[F, β$19$]]

implicit def catsFreeMonadForFree[S[_]]: Monad[[β$14$]Free[S, β$14$]]

Free[S, ?] has a monad for any type constructor S[_].

implicit def catsFreeTraverseForFree[F[_]](implicit traversableF: Traverse[F]): Traverse[[β$20$]Free[F, β$20$]]

def clone(): AnyRef

def compile[F[_], G[_]](fk: FunctionK[F, G]): FunctionK[[β$9$]Free[F, β$9$], [β$10$]Free[G, β$10$]]

a FunctionK, suitable for composition, which calls compile

def defer[F[_], A](value: ⇒ Free[F, A]): Free[F, A]

Defer the creation of a Free[F, A] value.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def foldMap[F[_], M[_]](fk: FunctionK[F, M])(implicit arg0: Monad[M]): FunctionK[[β$11$]Free[F, β$11$], M]

a FunctionK, suitable for composition, which calls foldMap

final def getClass(): Class[_]

def hashCode(): Int

def inject[F[_], G[_]]: FreeInjectKPartiallyApplied[F, G]

This method is used to defer the application of an InjectK[F, G] instance.

def injectRoll[F[_], G[_], A](ga: G[Free[F, A]])(implicit I: InjectK[G, F]): Free[F, A]

final def isInstanceOf[T0]: Boolean

def liftF[F[_], A](value: F[A]): Free[F, A]

Lift an F[A] value into the free monad.

def mapK[F[_], G[_]](fk: FunctionK[F, G]): FunctionK[[β$4$]Free[F, β$4$], [β$5$]Free[G, β$5$]]

a FunctionK, suitable for composition, which calls mapK

def match_[F[_], G[_], A](fa: Free[F, A])(implicit F: Functor[F], I: InjectK[G, F]): Option[G[Free[F, A]]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pure[S[_], A](a: A): Free[S, A]

Lift a pure A value into the free monad.

def roll[F[_], A](value: F[Free[F, A]]): Free[F, A]

Absorb a step into the free monad.

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 suspend[F[_], A](value: ⇒ Free[F, A]): Free[F, A]

Suspend the creation of a Free[F, A] value.