Recursive

abstract def getClass(): Class[_]

abstract def project[F[_]](t: T[F])(implicit arg0: Functor[F]): F[T[F]]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def all[F[_]](t: T[F])(p: (T[F]) ⇒ Boolean)(implicit arg0: Functor[F], arg1: Foldable[F]): Boolean

def any[F[_]](t: T[F])(p: (T[F]) ⇒ Boolean)(implicit arg0: Functor[F], arg1: Foldable[F]): Boolean

final def asInstanceOf[T0]: T0

def attributeTopDown[F[_], A](t: T[F], z: A)(f: (A, F[T[F]]) ⇒ A)(implicit arg0: Functor[F]): Cofree[F, A]

Attribute a tree via an algebra starting from the root.

def attributeTopDownM[F[_], M[_], A](t: T[F], z: A)(f: (A, F[T[F]]) ⇒ M[A])(implicit arg0: Traverse[F], arg1: Monad[M]): M[Cofree[F, A]]

Kleisli variant of attributeTopDown

def cata[F[_], A](t: T[F])(f: (F[A]) ⇒ A)(implicit arg0: Functor[F]): A

def cataM[F[_], M[_], A](t: T[F])(f: (F[A]) ⇒ M[A])(implicit arg0: Traverse[F], arg1: Monad[M]): M[A]

def children[F[_]](t: T[F])(implicit arg0: Functor[F], arg1: Foldable[F]): List[T[F]]

def collect[F[_], B](t: T[F])(pf: PartialFunction[T[F], B])(implicit arg0: Functor[F], arg1: Foldable[F]): List[B]

def contains[F[_]](t: T[F], c: T[F])(implicit arg0: Functor[F], arg1: Foldable[F], T: Equal[T[F]]): Boolean

def convertTo[F[_], R[_[_]]](t: T[F])(implicit arg0: Functor[F], arg1: Corecursive[R]): R[F]

def equals(arg0: Any): Boolean

def foldMap[F[_], Z](t: T[F])(f: (T[F]) ⇒ Z)(implicit arg0: Functor[F], arg1: Foldable[F], arg2: Monoid[Z]): Z

def foldMapM[F[_], M[_], Z](t: T[F])(f: (T[F]) ⇒ M[Z])(implicit arg0: Functor[F], arg1: Foldable[F], arg2: Monad[M], arg3: Monoid[Z]): M[Z]

def gcata[F[_], W[_], A](t: T[F])(k: DistributiveLaw[F, W], g: (F[W[A]]) ⇒ A)(implicit arg0: Functor[F], arg1: Comonad[W]): A

def ghisto[F[_], H[_], A](t: T[F])(g: DistributiveLaw[F, H], f: (F[Cofree[H, A]]) ⇒ A)(implicit arg0: Functor[F], arg1: Functor[H]): A

def gpara[F[_], W[_], A](t: T[F])(e: DistributiveLaw[F, W], f: (F[EnvT[T[F], W, A]]) ⇒ A)(implicit arg0: Functor[F], arg1: Comonad[W], T: Corecursive[T]): A

def gzygo[F[_], W[_], A, B](t: T[F])(f: (F[B]) ⇒ B, w: DistributiveLaw[F, W], g: (F[EnvT[B, W, A]]) ⇒ A)(implicit arg0: Functor[F], arg1: Comonad[W]): A

def hashCode(): Int

def histo[F[_], A](t: T[F])(f: (F[Cofree[F, A]]) ⇒ A)(implicit arg0: Functor[F]): A

final def isInstanceOf[T0]: Boolean

def isLeaf[F[_]](t: T[F])(implicit arg0: Functor[F], arg1: Foldable[F]): Boolean

def mutu[F[_], A, B](t: T[F])(f: (F[(A, B)]) ⇒ B, g: (F[(B, A)]) ⇒ A)(implicit arg0: Functor[F]): A

Mutually-recursive fold.

def para[F[_], A](t: T[F])(f: (F[(T[F], A)]) ⇒ A)(implicit arg0: Functor[F]): A

def paraM[F[_], M[_], A](t: T[F])(f: (F[(T[F], A)]) ⇒ M[A])(implicit arg0: Traverse[F], arg1: Monad[M]): M[A]

def paraZygo[F[_], A, B](t: T[F])(f: (F[(T[F], B)]) ⇒ B, g: (F[(B, A)]) ⇒ A)(implicit arg0: Functor[F], arg1: Unzip[F]): A

def toString(): String

def topDownCataM[F[_], M[_], A](t: T[F], a: A)(f: (A, T[F]) ⇒ M[(A, T[F])])(implicit arg0: Traverse[F], arg1: Monad[M], T: Corecursive[T]): M[T[F]]

def universe[F[_]](t: T[F])(implicit arg0: Functor[F], arg1: Foldable[F]): List[T[F]]

def zygo[F[_], A, B](t: T[F])(f: (F[B]) ⇒ B, g: (F[(B, A)]) ⇒ A)(implicit arg0: Functor[F]): A