FreeT

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

implicit def catsFreeAlternativeForFreeT[S[_], M[_]](implicit arg0: Alternative[M], arg1: Monad[M]): Alternative[[γ$12$]FreeT[S, M, γ$12$]]

implicit def catsFreeFlatMapForFreeT[S[_], M[_]](implicit M0: Applicative[M]): FlatMap[[γ$11$]FreeT[S, M, γ$11$]]

implicit def catsFreeMonadErrorForFreeT[S[_], M[_], E](implicit E: MonadError[M, E]): MonadError[[γ$8$]FreeT[S, M, γ$8$], E]

implicit def catsFreeMonadForFreeT[S[_], M[_]](implicit M0: Applicative[M]): Monad[[γ$10$]FreeT[S, M, γ$10$]]

implicit def catsFreeSemigroupKForFreeT[S[_], M[_]](implicit arg0: Applicative[M], arg1: SemigroupK[M]): SemigroupK[[γ$14$]FreeT[S, M, γ$14$]]

def clone(): AnyRef

def compile[S[_], T[_], M[_]](st: FunctionK[S, T])(implicit arg0: Functor[M]): FunctionK[[γ$0$]FreeT[S, M, γ$0$], [γ$1$]FreeT[T, M, γ$1$]]

def defer[S[_], M[_], A](a: M[Either[A, S[FreeT[S, M, A]]]])(implicit M: Applicative[M]): FreeT[S, M, A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def foldMap[S[_], M[_]](fk: FunctionK[S, M])(implicit arg0: Monad[M]): FunctionK[[γ$5$]FreeT[S, M, γ$5$], M]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def liftF[S[_], M[_], A](value: S[A])(implicit M: Applicative[M]): FreeT[S, M, A]

Suspends a value within a functor in a single step.

def liftInject[M[_], G[_]]: FreeTLiftInjectKPartiallyApplied[M, G]

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

def liftT[S[_], M[_], A](value: M[A])(implicit M: Functor[M]): FreeT[S, M, A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pure[S[_], M[_], A](value: A)(implicit M: Applicative[M]): FreeT[S, M, A]

Return the given value in the free monad.

def roll[S[_], M[_], A](value: S[FreeT[S, M, A]])(implicit M: Applicative[M]): FreeT[S, M, A]

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

def tailRecM[S[_], M[_], A, B](a: A)(f: (A) ⇒ FreeT[S, M, Either[A, B]])(implicit arg0: Applicative[M]): FreeT[S, M, B]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def suspend[S[_], M[_], A](a: M[Either[A, S[FreeT[S, M, A]]]])(implicit M: Applicative[M]): FreeT[S, M, A]