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

Attribute a tree via an algebra starting from the root.

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

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(t: T)(implicit BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.List[T]

def clone(): AnyRef

def collect[B](t: T)(pf: slamdata.Predef.PartialFunction[T, B])(implicit BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.List[B]

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[[β$21$]Cofree[Base, β$21$], Base, A])(implicit BF: Functor[Base]): A

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

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

def elgotZygoM[A, B, M[_]](t: T)(f: AlgebraM[M, Base, B], g: ElgotAlgebraM[[β$11$](B, β$11$), 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[[γ$15$]EnvT[B, W, γ$15$], 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]

final def getClass(): Class[_]

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

def gpara[W[_], A](t: T)(e: DistributiveLaw[Base, W], f: GAlgebra[[γ$29$]EnvT[T, W, γ$29$], Base, A])(implicit arg0: Comonad[W], T: Aux[T, Base], BF: Functor[Base]): A

def gprepro[W[_], A](t: T)(k: DistributiveLaw[Base, W], e: ~>[Base, Base], f: GAlgebra[W, Base, A])(implicit arg0: Comonad[W], T: Aux[T, Base], BF: Functor[Base]): A

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

def hashCode(): Int

def histo[A](t: T)(f: GAlgebra[[β$19$]Cofree[Base, β$19$], 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 T: Aux[T, Base], BF: Functor[Base]): Base[T]

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

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

def mutu[A, B](t: T)(f: GAlgebra[[β$17$](A, β$17$), Base, B], g: GAlgebra[[β$18$](B, β$18$), 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[[β$2$](T, β$2$), 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[[β$25$](T, β$25$), Base, B], g: GAlgebra[[β$26$](B, β$26$), Base, A])(implicit BF: Functor[Base], BU: Unzip[Base]): A

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

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

def toString(): String

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

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

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

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

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

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

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

def transApoT(t: T)(f: (T) ⇒ \/[T, T])(implicit T: Aux[T, Base], 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 T: Aux[T, Base], BF: Functor[Base]): T

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

def transHylo[G[_], U, H[_]](t: T)(φ: (G[U]) ⇒ H[U], ψ: (Base[T]) ⇒ G[T])(implicit arg0: Functor[G], arg1: Functor[H], U: Aux[U, H], BF: Functor[Base]): U

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

def transParaT(t: T)(f: ((T, T)) ⇒ T)(implicit T: Aux[T, Base], 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], UR: Aux[U, G], UC: 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], T: Aux[T, Base], U: Aux[U, G], BF: Functor[Base]): U

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

def universe(t: T)(implicit BF: Functor[Base], B: Foldable[Base]): NonEmptyList[T]

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[[β$3$](B, β$3$), Base, A])(implicit BF: Functor[Base]): A

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