Birecursive

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

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 ana[A](a: A)(f: Coalgebra[Base, A])(implicit BF: Functor[Base]): T

def anaM[M[_], A](a: A)(f: CoalgebraM[M, Base, A])(implicit arg0: Monad[M], BT: Traverse[Base]): M[T]

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

def apo[A](a: A)(f: GCoalgebra[[β$8$]\/[T, β$8$], Base, A])(implicit BF: Functor[Base]): T

An unfold that can short-circuit certain sections.

def apoM[M[_], A](a: A)(f: GCoalgebraM[[β$5$]\/[T, β$5$], M, Base, A])(implicit arg0: Monad[M], BT: Traverse[Base]): M[T]

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 colambek(ft: Base[T])(implicit BF: Functor[Base]): T

Roughly a default impl of embed, given a matryoshka.Recursive instance and an overridden ana.

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

implicit val corec: Aux[T, Base]

def elgotAna[N[_], A](a: A)(k: DistributiveLaw[N, Base], ψ: ElgotCoalgebra[N, Base, A])(implicit arg0: Monad[N], BF: Functor[Base]): T

def elgotApo[A](a: A)(f: ElgotCoalgebra[[β$10$]\/[T, β$10$], Base, A])(implicit BF: Functor[Base]): T

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 elgotFutu[A](a: A)(f: ElgotCoalgebra[[β$9$]Free[Base, β$9$], Base, A])(implicit BF: Functor[Base]): T

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[[β$3$](T, β$3$), 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 futu[A](a: A)(f: GCoalgebra[[β$7$]Free[Base, β$7$], Base, A])(implicit BF: Functor[Base]): T

def futuM[M[_], A](a: A)(f: GCoalgebraM[[β$11$]Free[Base, β$11$], M, Base, A])(implicit arg0: Monad[M], BT: Traverse[Base]): M[T]

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 gana[N[_], A](a: A)(k: DistributiveLaw[N, Base], f: GCoalgebra[N, Base, A])(implicit arg0: Monad[N], BF: Functor[Base]): T

def ganaM[N[_], M[_], A](a: A)(k: DistributiveLaw[N, Base], f: GCoalgebraM[N, M, Base, A])(implicit arg0: Monad[N], arg1: Traverse[N], arg2: Monad[M], BT: Traverse[Base]): M[T]

def gapo[A, B](a: A)(ψ0: Coalgebra[Base, B], ψ: GCoalgebra[[β$3$]\/[B, β$3$], Base, A])(implicit BF: Functor[Base]): T

An unfold that can handle sections with a secondary unfold.

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 gpara[W[_], A](t: T)(e: DistributiveLaw[Base, W], f: GAlgebra[[γ$12$]EnvT[T, W, γ$12$], Base, A])(implicit arg0: Comonad[W], BF: Functor[Base]): A

def gpostpro[N[_], A](a: A)(k: DistributiveLaw[N, Base], e: ~>[Base, Base], ψ: GCoalgebra[N, Base, A])(implicit BF: Functor[Base], N: Monad[N]): T

def gprepro[W[_], A](t: T)(k: DistributiveLaw[Base, W], e: ~>[Base, Base], f: GAlgebra[W, Base, A])(implicit arg0: Comonad[W], 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 lambek(tf: T)(implicit BF: Functor[Base]): Base[T]

Roughly a default impl of project, given a matryoshka.Corecursive instance and an overridden cata.

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[[β$1$](T, β$1$), 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[[β$5$](T, β$5$), Base, B], g: GAlgebra[[β$6$](B, β$6$), Base, A])(implicit BF: Functor[Base], BU: Unzip[Base]): A

def postpro[A](a: A)(e: ~>[Base, Base], g: Coalgebra[Base, A])(implicit BF: Functor[Base]): T

def prepro[A](t: T)(e: ~>[Base, Base], f: Algebra[Base, A])(implicit BF: Functor[Base]): A

implicit val rec: Aux[T, Base]

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

def toString(): String

def topDownCata[A](t: T, a: A)(f: (A, T) ⇒ (A, T))(implicit BF: Functor[Base]): T

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

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

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

def transAnaT(t: T)(f: (T) ⇒ T)(implicit BF: Functor[Base]): T

def transAnaTM[M[_]](t: T)(f: (T) ⇒ M[T])(implicit arg0: Monad[M], BF: Traverse[Base]): M[T]

def transApo[U, G[_]](u: U)(f: CoalgebraicGTransform[[β$15$]\/[T, β$15$], U, G, Base])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[Base]): T

def transApoT(t: T)(f: (T) ⇒ \/[T, T])(implicit BF: Functor[Base]): T

This behaves like matryoshka.Corecursive.elgotApo, but it’s harder to see from the types that in the disjunction, -\/ is the final result for this node, while \/- means to keep processing the children.

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 transCataT(t: T)(f: (T) ⇒ T)(implicit BF: Functor[Base]): T

def transCataTM[M[_]](t: T)(f: (T) ⇒ M[T])(implicit arg0: Monad[M], BF: Traverse[Base]): M[T]

def transFutu[U, G[_]](u: U)(f: CoalgebraicGTransform[[β$15$]Free[Base, β$15$], U, G, Base])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[Base]): T

def transGana[M[_], U, G[_]](u: U)(k: DistributiveLaw[M, Base], f: CoalgebraicGTransform[M, U, G, Base])(implicit arg0: Monad[M], arg1: Functor[G], U: Aux[U, G], BF: Functor[Base]): T

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[[β$14$](T, β$14$), U, Base, G])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[Base]): U

def transParaT(t: T)(f: ((T, T)) ⇒ T)(implicit BF: Functor[Base]): T

This behaves like matryoshka.Recursive.elgotPara, but it’s harder to see from the types that in the tuple, _2 is the result so far and _1 is the original structure.

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

def transPrepro[U, G[_]](t: T)(e: ~>[Base, Base], f: Transform[U, 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]