Packages

trait Recursive[T] extends Based[T]

Folds for recursive data types.

Linear Supertypes
Based[T], Serializable, Serializable, AnyRef, Any
Known Subclasses
Birecursive
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Recursive
  2. Based
  3. Serializable
  4. Serializable
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. abstract type Base[A]
    Definition Classes
    Based
  2. type BaseT[A] = Base[A]

Abstract Value Members

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

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def all(t: T)(p: (T) ⇒ slamdata.Predef.Boolean)(implicit BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.Boolean
  5. def any(t: T)(p: (T) ⇒ slamdata.Predef.Boolean)(implicit BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.Boolean
  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. 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.

  8. 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

  9. def cata[A](t: T)(f: Algebra[Base, A])(implicit BF: Functor[Base]): A
  10. def cataM[M[_], A](t: T)(f: AlgebraM[M, Base, A])(implicit arg0: Monad[M], BT: Traverse[Base]): M[A]

    A Kleisli catamorphism.

  11. def children(t: T)(implicit BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.List[T]
  12. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  13. def collect[B](t: T)(pf: slamdata.Predef.PartialFunction[T, B])(implicit BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.List[B]
  14. def contains(t: T, c: T)(implicit T: Equal[T], BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.Boolean
  15. def convertTo[R](t: T)(implicit R: Aux[R, Base], BF: Functor[Base]): R
  16. 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.

  17. def elgotHisto[A](t: T)(f: ElgotAlgebra[[β$15$]Cofree[Base, β$15$], Base, A])(implicit BF: Functor[Base]): A
  18. def elgotPara[A](t: T)(f: ElgotAlgebra[[β$1$](T, β$1$), Base, A])(implicit BF: Functor[Base]): A
  19. def elgotZygo[A, B](t: T)(f: Algebra[Base, B], g: ElgotAlgebra[[β$5$](B, β$5$), Base, A])(implicit BF: Functor[Base]): A
  20. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  21. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  22. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  23. def foldMap[Z](t: T)(f: (T) ⇒ Z)(implicit arg0: Monoid[Z], BF: Functor[Base], B: Foldable[Base]): Z
  24. 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]
  25. def gElgotZygo[W[_], A, B](t: T)(f: Algebra[Base, B], w: DistributiveLaw[Base, W], g: ElgotAlgebra[[γ$9$]EnvT[B, W, γ$9$], Base, A])(implicit arg0: Comonad[W], BF: Functor[Base]): A
  26. 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.

  27. def gcataM[W[_], M[_], A](t: T)(k: DistributiveLaw[Base, W], g: GAlgebraM[W, M, Base, A])(implicit arg0: Comonad[W], arg1: Traverse[W], arg2: Monad[M], BT: Traverse[Base]): M[A]
  28. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  29. def ghisto[H[_], A](t: T)(g: DistributiveLaw[Base, H], f: GAlgebra[[β$17$]Cofree[H, β$17$], Base, A])(implicit arg0: Functor[H], BF: Functor[Base]): A
  30. def gpara[W[_], A](t: T)(e: DistributiveLaw[Base, W], f: GAlgebra[[γ$23$]EnvT[T, W, γ$23$], Base, A])(implicit arg0: Comonad[W], T: Aux[T, Base], BF: Functor[Base]): A
  31. 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
  32. def gzygo[W[_], A, B](t: T)(f: Algebra[Base, B], w: DistributiveLaw[Base, W], g: GAlgebra[[γ$7$]EnvT[B, W, γ$7$], Base, A])(implicit arg0: Comonad[W], BF: Functor[Base]): A
  33. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  34. def histo[A](t: T)(f: GAlgebra[[β$13$]Cofree[Base, β$13$], Base, A])(implicit BF: Functor[Base]): A
  35. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  36. def isLeaf(t: T)(implicit BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.Boolean
  37. 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.

  38. def mapR[U, G[_]](t: T)(f: (Base[T]) ⇒ G[U])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[Base]): U
  39. def mutu[A, B](t: T)(f: GAlgebra[[β$11$](A, β$11$), Base, B], g: GAlgebra[[β$12$](B, β$12$), Base, A])(implicit BF: Functor[Base]): A

    Mutually-recursive fold.

  40. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  41. final def notify(): Unit
    Definition Classes
    AnyRef
  42. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  43. def para[A](t: T)(f: GAlgebra[[β$0$](T, β$0$), Base, A])(implicit BF: Functor[Base]): A
  44. def paraM[M[_], A](t: T)(f: GAlgebraM[[β$2$](T, β$2$), M, Base, A])(implicit arg0: Monad[M], BT: Traverse[Base]): M[A]
  45. 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.

    Combines two functors that may fail to merge, also providing access to the inputs at each level. This is akin to an Elgot, not generalized, fold.

  46. def paraZygo[A, B](t: T)(f: GAlgebra[[β$19$](T, β$19$), Base, B], g: GAlgebra[[β$20$](B, β$20$), Base, A])(implicit BF: Functor[Base], BU: Unzip[Base]): A
  47. def prepro[A](t: T)(e: ~>[Base, Base], f: Algebra[Base, A])(implicit T: Aux[T, Base], BF: Functor[Base]): A
  48. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  49. def toString(): String
    Definition Classes
    AnyRef → Any
  50. def topDownCata[A](t: T, a: A)(f: (A, T) ⇒ (A, T))(implicit T: Aux[T, Base], BF: Functor[Base]): T
  51. 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]
  52. def transAna[U, G[_]](t: T)(f: (Base[T]) ⇒ G[T])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[Base]): U
  53. 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]
  54. def transAnaT(t: T)(f: (T) ⇒ T)(implicit T: Aux[T, Base], BF: Functor[Base]): T
  55. def transAnaTM[M[_]](t: T)(f: (T) ⇒ M[T])(implicit arg0: Monad[M], T: Aux[T, Base], BF: Traverse[Base]): M[T]
  56. def transApo[U, G[_]](t: T)(f: CoalgebraicGTransform[[β$22$]\/[U, β$22$], T, Base, G])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[Base]): U
  57. 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.

  58. def transCata[U, G[_]](t: T)(f: (Base[U]) ⇒ G[U])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[Base]): U
  59. 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]
  60. def transCataT(t: T)(f: (T) ⇒ T)(implicit T: Aux[T, Base], BF: Functor[Base]): T
  61. def transCataTM[M[_]](t: T)(f: (T) ⇒ M[T])(implicit arg0: Monad[M], T: Aux[T, Base], BF: Traverse[Base]): M[T]
  62. 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
  63. def transPara[U, G[_]](t: T)(f: AlgebraicGTransform[[β$21$](T, β$21$), U, Base, G])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[Base]): U
  64. 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.

  65. 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
  66. 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
  67. 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]
  68. def universe(t: T)(implicit BF: Functor[Base], B: Foldable[Base]): slamdata.Predef.List[T]
  69. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  70. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  71. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  72. def zygo[A, B](t: T)(f: Algebra[Base, B], g: GAlgebra[[β$3$](B, β$3$), Base, A])(implicit BF: Functor[Base]): A

Inherited from Based[T]

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped