Recursive

abstract def project(t: T)(implicit BF: Functor[Base]): BaseT[T]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def all(t: T)(p: (T) ⇒ slamdata.Predef.Boolean)(implicit BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.Boolean

def any(t: T)(p: (T) ⇒ slamdata.Predef.Boolean)(implicit BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.Boolean

final def asInstanceOf[T0]: T0

def attributeTopDown[U, A](t: T, z: A)(f: (A, Base[T]) ⇒ A)(implicit U: Aux[U, [γ$33$]EnvT[A, Base, γ$33$]], BF: Functor[Base]): U

Attribute a tree via an algebra starting from the root.

def attributeTopDownM[M[_], U, A](t: T, z: A)(f: (A, Base[T]) ⇒ M[A])(implicit arg0: Monad[M], U: Aux[U, [γ$34$]EnvT[A, Base, γ$34$]], BT: Traverse[Base]): M[U]

Kleisli variant of attributeTopDown

def cata[A](t: T)(f: Algebra[Base, A])(implicit BF: Functor[Base]): A

def cataM[M[_], A](t: T)(f: AlgebraM[M, Base, A])(implicit arg0: Monad[M], BT: Traverse[Base]): M[A]

A Kleisli catamorphism.

def children[U](t: T)(implicit U: Aux[U, [β$32$]ListF[T, β$32$]], BF: Functor[Base], B: Foldable[Base]): U

def clone(): AnyRef

def collect[U, B](t: T)(pf: slamdata.Predef.PartialFunction[T, B])(implicit arg0: Monoid[U], U: Aux[U, [β$35$]ListF[B, β$35$]], BF: Functor[Base], B: Foldable[Base]): U

def contains(t: T, c: T)(implicit T: Equal[T], BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.Boolean

def convertTo[R](t: T)(implicit R: Aux[R, Base], BF: Functor[Base]): R

def elgotCata[W[_], A](t: T)(k: DistributiveLaw[Base, W], g: ElgotAlgebra[W, Base, A])(implicit arg0: Comonad[W], BF: Functor[Base]): A

A catamorphism generalized with a comonad outside the functor.

def elgotCataM[W[_], M[_], A](t: T)(k: DistributiveLaw[Base, [A]M[W[A]]], g: ElgotAlgebraM[W, M, Base, A])(implicit arg0: Comonad[W], arg1: Traverse[W], arg2: Monad[M], BT: Traverse[Base]): M[A]

def elgotHisto[A](t: T)(f: ElgotAlgebra[[β$22$]Cofree[Base, β$22$], Base, A])(implicit BF: Functor[Base]): A

def elgotPara[A](t: T)(f: ElgotAlgebra[[β$2$](T, β$2$), Base, A])(implicit BF: Functor[Base]): A

def elgotZygo[A, B](t: T)(f: Algebra[Base, B], g: ElgotAlgebra[[β$10$](B, β$10$), Base, A])(implicit BF: Functor[Base]): A

def elgotZygoM[A, B, M[_]](t: T)(f: AlgebraM[M, Base, B], g: ElgotAlgebraM[[β$12$](B, β$12$), M, Base, A])(implicit arg0: Monad[M], BT: Traverse[Base]): M[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def foldMap[Z](t: T)(f: (T) ⇒ Z)(implicit arg0: Monoid[Z], BF: Functor[Base], B: Foldable[Base]): Z

def foldMapM[M[_], Z](t: T)(f: (T) ⇒ M[Z])(implicit arg0: Monad[M], arg1: Monoid[Z], BF: Functor[Base], B: Foldable[Base]): M[Z]

def gElgotZygo[W[_], A, B](t: T)(f: Algebra[Base, B], w: DistributiveLaw[Base, W], g: ElgotAlgebra[[γ$16$]EnvT[B, W, γ$16$], Base, A])(implicit arg0: Comonad[W], BF: Functor[Base]): A

def gcata[W[_], A](t: T)(k: DistributiveLaw[Base, W], g: GAlgebra[W, Base, A])(implicit arg0: Comonad[W], BF: Functor[Base]): A

A catamorphism generalized with a comonad inside the functor.

def gcataM[W[_], M[_], A](t: T)(w: DistributiveLaw[Base, W], g: GAlgebraM[W, M, Base, A])(implicit arg0: Comonad[W], arg1: Traverse[W], arg2: Monad[M], BT: Traverse[Base]): M[A]

def gcataZygo[W[_], A, B](t: T)(k: DistributiveLaw[Base, W], f: GAlgebra[W, Base, B], g: GAlgebra[[β$26$](B, β$26$), Base, A])(implicit arg0: Comonad[W], BF: Functor[Base], BU: Unzip[Base]): A

final def getClass(): Class[_]

def ghisto[H[_], A](t: T)(g: DistributiveLaw[Base, H], f: GAlgebra[[β$24$]Cofree[H, β$24$], Base, A])(implicit arg0: Functor[H], BF: Functor[Base]): A

def gzygo[W[_], A, B](t: T)(f: Algebra[Base, B], w: DistributiveLaw[Base, W], g: GAlgebra[[γ$14$]EnvT[B, W, γ$14$], Base, A])(implicit arg0: Comonad[W], BF: Functor[Base]): A

def hashCode(): Int

def histo[A](t: T)(f: GAlgebra[[β$20$]Cofree[Base, β$20$], Base, A])(implicit BF: Functor[Base]): A

final def isInstanceOf[T0]: Boolean

def isLeaf(t: T)(implicit BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.Boolean

def mutu[A, B](t: T)(f: GAlgebra[[β$18$](A, β$18$), Base, B], g: GAlgebra[[β$19$](B, β$19$), Base, A])(implicit BF: Functor[Base]): A

Mutually-recursive fold.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def para[A](t: T)(f: GAlgebra[[β$0$](T, β$0$), Base, A])(implicit BF: Functor[Base]): A

def paraM[M[_], A](t: T)(f: GAlgebraM[[β$3$](T, β$3$), M, Base, A])(implicit arg0: Monad[M], BT: Traverse[Base]): M[A]

def paraMerga[A](t: T, that: T)(f: (T, T, slamdata.Predef.Option[Base[A]]) ⇒ A)(implicit BF: Functor[Base], BM: Merge[Base]): A

Combines two functors that may fail to merge, also providing access to the inputs at each level.

def paraZygo[A, B](t: T)(f: GAlgebra[[β$28$](T, β$28$), Base, B], g: GAlgebra[[β$29$](B, β$29$), Base, A])(implicit BF: Functor[Base], BU: Unzip[Base]): A

implicit val rec: Aux[T, Base]

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

def toString(): String

def transCata[U, G[_]](t: T)(f: (Base[U]) ⇒ G[U])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[Base]): U

def transCataM[M[_], U, G[_]](t: T)(f: TransformM[M, U, Base, G])(implicit arg0: Monad[M], arg1: Functor[G], U: Aux[U, G], BT: Traverse[Base]): M[U]

def transGcata[W[_], U, G[_]](t: T)(k: DistributiveLaw[Base, W], f: AlgebraicGTransform[W, U, Base, G])(implicit arg0: Comonad[W], arg1: Functor[G], U: Aux[U, G], BF: Functor[Base]): U

def transPara[U, G[_]](t: T)(f: AlgebraicGTransform[[β$36$](T, β$36$), U, Base, G])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[Base]): U

def transPostpro[U, G[_]](t: T)(e: ~>[G, G], f: Transform[T, Base, G])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[Base]): U

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zygo[A, B](t: T)(f: Algebra[Base, B], g: GAlgebra[[β$4$](B, β$4$), Base, A])(implicit BF: Functor[Base]): A

def zygoM[A, B, M[_]](t: T)(f: AlgebraM[M, Base, B], g: GAlgebraM[[β$6$](B, β$6$), M, Base, A])(implicit arg0: Monad[M], BT: Traverse[Base]): M[A]