Packages

p

matryoshka

package matryoshka

Generalized folds, unfolds, and refolds.

Linear Supertypes
AnyRef, Any
Ordering
  1. Grouped
  2. Alphabetic
  3. By Inheritance
Inherited
  1. matryoshka
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type Algebra[F[_], A] = (F[A]) ⇒ A

    Fold a structure F to a value A.

  2. type AlgebraIso[F[_], A] = PIso[F[scalaz.Scalaz.Id[A]], F[scalaz.Scalaz.Id[A]], A, A]
  3. type AlgebraM[M[_], F[_], A] = (F[A]) ⇒ M[A]

    Fold a structure F to a value A, accumulating effects in the monad M.

  4. type AlgebraPrism[F[_], A] = PPrism[F[A], F[A], A, A]
  5. type AlgebraicGTransform[W[_], T, F[_], G[_]] = (F[W[T]]) ⇒ G[T]

    Transform a structure F containing values in W, to a structure G, in bottom-up fashion.

  6. type AlgebraicGTransformM[W[_], M[_], T, F[_], G[_]] = (F[W[T]]) ⇒ M[G[T]]

    Transform a structure F containing values in W, to a structure G, in bottom-up fashion.

  7. trait Based [T] extends Serializable

    Provides a type describing the pattern functor of some {co}recursive type T.

    Provides a type describing the pattern functor of some {co}recursive type T. For standard fixed-point types like matryoshka.data.Fix, Based[Fix[F]]#Base is simply F. However, directly recursive types generally have a less obvious pattern functor. E.g., Based[Cofree[F, A]]#Base is EnvT[A, F, ?].

  8. trait Birecursive [T] extends Recursive[T] with Corecursive[T]

    A type that is both Recursive and Corecursive.

    A type that is both Recursive and Corecursive.

    NB: Do not define instances of this or use it as a constraint until issue #44 is resolved. Define an instance of BirecursiveT if possible, otherwise define separate Recursive and Corecursive instances.

  9. trait BirecursiveT [T[_[_]]] extends RecursiveT[T] with CorecursiveT[T]

    This is a workaround for a certain use case (e.g., matryoshka.patterns.Diff and matryoshka.patterns.PotentialFailure).

    This is a workaround for a certain use case (e.g., matryoshka.patterns.Diff and matryoshka.patterns.PotentialFailure). Define an instance of this rather than Recursive and Corecursive when possible.

  10. type Coalgebra[F[_], A] = (A) ⇒ F[A]

    Unfold a value A to a structure F.

  11. type CoalgebraM[M[_], F[_], A] = (A) ⇒ M[F[A]]

    Unfold a value A to a structure F, accumulating effects in the monad M.

  12. type CoalgebraPrism[F[_], A] = PPrism[A, A, F[A], F[A]]
  13. type CoalgebraicElgotTransform[N[_], T, F[_], G[_]] = (F[T]) ⇒ N[G[T]]

    Transform a structure F to a structure G, in top-down fashion, accumulating effects in the monad M.

  14. type CoalgebraicGTransform[N[_], T, F[_], G[_]] = (F[T]) ⇒ G[N[T]]

    Transform a structure F to a structure G, in top-down fashion, accumulating effects in the monad M.

  15. type CoalgebraicGTransformM[N[_], M[_], T, F[_], G[_]] = (F[T]) ⇒ M[G[N[T]]]

    Transform a structure F to a structure G containing values in N, in top-down fashion, accumulating effects in the monad M.

  16. trait Corecursive [T] extends Based[T]

    Unfolds for corecursive data types.

  17. trait CorecursiveT [T[_[_]]] extends AnyRef

    This is a workaround for a certain use case (e.g., matryoshka.patterns.Diff and matryoshka.patterns.PotentialFailure).

    This is a workaround for a certain use case (e.g., matryoshka.patterns.Diff and matryoshka.patterns.PotentialFailure). Define an instance of this rather than Corecursive when possible.

  18. trait Delay [F[_], G[_]] extends AnyRef

    To avoid diverging implicits with fixed-point types, we need to defer the lookup.

  19. type DistributiveLaw[F[_], G[_]] = NaturalTransformation[[A]F[G[A]], [A]G[F[A]]]

    A NaturalTransformation that sequences two types

  20. type ElgotAlgebra[W[_], F[_], A] = (W[F[A]]) ⇒ scalaz.Scalaz.Id[A]

    Fold a structure F (usually a Functor) contained in W (usually a Comonad), to a value A.

  21. type ElgotAlgebraIso[W[_], N[_], F[_], A] = PIso[W[F[A]], N[F[A]], A, A]
  22. type ElgotAlgebraM[W[_], M[_], F[_], A] = (W[F[A]]) ⇒ M[A]

    Fold a structure F (usually a Functor) contained in W (usually a Comonad), to a value A, accumulating effects in the monad M.

  23. type ElgotCoalgebra[E[_], F[_], A] = (A) ⇒ E[F[A]]

    Unfold a value A to a structure F (usually a Functor), contained in E.

  24. type ElgotCoalgebraM[E[_], M[_], F[_], A] = (A) ⇒ M[E[F[A]]]

    Unfold a value A to a structure F (usually a Functor), contained in E, accumulating effects in the monad M.

  25. type EndoTransform[T, F[_]] = (F[T]) ⇒ F[T]
  26. trait EqualT [T[_[_]]] extends Serializable
  27. type GAlgebra[W[_], F[_], A] = (F[W[A]]) ⇒ A

    Fold a structure F containing values in W, to a value A.

  28. type GAlgebraIso[W[_], N[_], F[_], A] = PIso[F[W[A]], F[N[A]], A, A]

    An algebra and its dual form an isomorphism.

  29. type GAlgebraM[W[_], M[_], F[_], A] = (F[W[A]]) ⇒ M[A]

    Fold a structure F containing values in W, to a value A, accumulating effects in the monad M.

  30. type GCoalgebra[N[_], F[_], A] = (A) ⇒ F[N[A]]

    Unfold a value A to a structure F containing values in N.

  31. type GCoalgebraM[N[_], M[_], F[_], A] = (A) ⇒ M[F[N[A]]]

    Unfold a value A to a structure F containing values in N, accumulating effects in the monad M.

  32. sealed abstract class Hole extends AnyRef
  33. trait Merge [F[_]] extends Serializable

    Like Zip, but it can fail to merge, so it’s much more general.

  34. trait Recursive [T] extends Based[T]

    Folds for recursive data types.

  35. trait RecursiveT [T[_[_]]] extends slamdata.Predef.Serializable

    This is a workaround for a certain use case (e.g., matryoshka.patterns.Diff and matryoshka.patterns.PotentialFailure).

    This is a workaround for a certain use case (e.g., matryoshka.patterns.Diff and matryoshka.patterns.PotentialFailure). Define an instance of this rather than Recursive when possible.

  36. trait ShowT [T[_[_]]] extends Serializable
  37. type Transform[T, F[_], G[_]] = (F[T]) ⇒ G[T]

    Transform a structure F to a structure G.

    Transform a structure F to a structure G. For a top-down transformation, T#Base must be F, and for a bottom-up transformation, T#Base must be G.

  38. type TransformM[M[_], T, F[_], G[_]] = (F[T]) ⇒ M[G[T]]

    Transform a structure F to a structure G, accumulating effects in the monad M.

    Transform a structure F to a structure G, accumulating effects in the monad M. For a top-down transformation, T#Base must be F, and for a bottom-up transformation, T#Base must be G.

  39. sealed abstract class ∘ [F[_], G[_]] extends AnyRef

Value Members

  1. implicit def AlgebraZip[F[_]](implicit arg0: Functor[F]): Zip[[γ$44$](F[scalaz.Scalaz.Id[γ$44$]]) ⇒ γ$44$]

  2. implicit def ElgotAlgebraMZip[W[_], M[_], F[_]](implicit arg0: Functor[W], arg1: Applicative[M], arg2: Functor[F]): Zip[[δ$46$](W[F[δ$46$]]) ⇒ M[δ$46$]]

  3. implicit def ElgotAlgebraZip[W[_], F[_]](implicit arg0: Functor[W], arg1: Functor[F]): Zip[[δ$46$](W[F[δ$46$]]) ⇒ scalaz.Scalaz.Id[δ$46$]]

  4. implicit def GAlgebraZip[W[_], F[_]](implicit arg0: Functor[W], arg1: Functor[F]): Zip[[γ$44$](F[W[γ$44$]]) ⇒ γ$44$]

  5. def alignThese[T, F[_]](implicit arg0: Align[F], T: Aux[T, F]): ElgotCoalgebra[[β$51$]\/[T, β$51$], F, \&/[T, T]]

    Aligns “These” into a single structure, short-circuting when we hit a “This” or “That”.

  6. def attrK[F[_], A](k: A)(implicit arg0: Functor[F]): Algebra[F, Cofree[F, A]]

  7. def attrSelf[T, F[_]](implicit arg0: Functor[F], T: Aux[T, F]): Algebra[F, Cofree[F, T]]

  8. def attributeAlgebra[F[_], A](f: Algebra[F, A])(implicit arg0: Functor[F]): Algebra[F, Cofree[F, A]]

  9. def attributeAlgebraM[F[_], M[_], A](f: AlgebraM[M, F, A])(implicit arg0: Functor[F], arg1: Functor[M]): AlgebraM[M, F, Cofree[F, A]]

    Turns any F-algebra, into an identical one that attributes the tree with the results for each node.

  10. def attributeCoalgebra[F[_], B](ψ: Coalgebra[F, B]): Coalgebra[[γ$35$]EnvT[B, F, γ$35$], B]

  11. def bilambekIso[T, F[_]](implicit arg0: Functor[F], TR: Aux[T, F], TC: Aux[T, F]): AlgebraIso[F, T]
  12. def binarySequence[A](relation: (A, A) ⇒ A): Coalgebra[[β$52$](A, β$52$), (A, A)]

    Generates an infinite sequence from two seed values.

  13. def birecursiveIso[T, F[_]](implicit arg0: Functor[F], TR: Aux[T, F], TC: Aux[T, F]): AlgebraIso[F, T]
  14. implicit def birecursiveTBirecursive[T[_[_]], F[_]](implicit arg0: BirecursiveT[T]): Aux[T[F], F]
  15. implicit def birecursiveTFunctor[T[_[_]], F[_, _]](implicit arg0: BirecursiveT[T], F: Bifunctor[F]): Functor[[α]T[[β$53$]F[α, β$53$]]]
  16. def builder[F[_], A, B](fa: F[A], children: slamdata.Predef.List[B])(implicit arg0: Traverse[F]): F[B]
  17. def chrono[F[_], A, B](a: A)(g: GAlgebra[[β$6$]Cofree[F, β$6$], F, B], f: GCoalgebra[[β$7$]Free[F, β$7$], F, A])(implicit arg0: Functor[F]): B

    Similar to a hylomorphism, this composes a futumorphism and a histomorphism.

  18. def codyna[F[_], A, B](a: A)(φ: Algebra[F, B], ψ: GCoalgebra[[β$1$]Free[F, β$1$], F, A])(implicit arg0: Functor[F]): B

    cata ⋘ futu

  19. def codynaM[M[_], F[_], A, B](a: A)(φ: AlgebraM[M, F, B], ψ: GCoalgebraM[[β$3$]Free[F, β$3$], M, F, A])(implicit arg0: Monad[M], arg1: Traverse[F]): M[B]

    cataM ⋘ futuM

  20. def coelgot[F[_], A, B](a: A)(φ: ElgotAlgebra[[β$16$](A, β$16$), F, B], ψ: Coalgebra[F, A])(implicit F: Functor[F]): B

    elgotZygo ⋘ ana

  21. implicit def corecursiveTCorecursive[T[_[_]], F[_]](implicit arg0: CorecursiveT[T]): Aux[T[F], F]
  22. def count[T, F[_]](form: T)(implicit arg0: Equal[T], arg1: Functor[F], arg2: Foldable[F], T: Aux[T, F]): ElgotAlgebra[[β$50$](T, β$50$), F, slamdata.Predef.Int]

    Count the instances of form in the structure.

  23. def deattribute[F[_], A, B](φ: Algebra[F, B]): Algebra[[γ$36$]EnvT[A, F, γ$36$], B]

    Useful for ignoring the annotation when folding a cofree.

  24. implicit def delayEqual[F[_], A](implicit A: Equal[A], F: Delay[Equal, F]): Equal[F[A]]

    This implicit allows Delay implicits to be found when searching for a traditionally-defined instance.

  25. implicit def delayShow[F[_], A](implicit A: Show[A], F: Delay[Show, F]): Show[F[A]]

    See delayEqual.

  26. def distAna[F[_]]: DistributiveLaw[scalaz.Scalaz.Id, F]

  27. def distApo[T, F[_]](implicit arg0: Functor[F], T: Aux[T, F]): DistributiveLaw[[β$29$]\/[T, β$29$], F]

  28. def distApplicative[F[_], G[_]](implicit arg0: Traverse[F], arg1: Applicative[G]): DistributiveLaw[F, G]

    A general DistributiveLaw for the case where the scalaz.Comonad is also scalaz.Applicative.

  29. def distCata[F[_]]: DistributiveLaw[F, scalaz.Scalaz.Id]

  30. def distDistributive[F[_], G[_]](implicit arg0: Functor[F], arg1: Distributive[G]): DistributiveLaw[F, G]

    A general DistributiveLaw for the case where the scalaz.Comonad is also scalaz.Distributive.

  31. def distFutu[F[_]](implicit arg0: Functor[F]): DistributiveLaw[[β$32$]Free[F, β$32$], F]

  32. def distGApo[F[_], B](g: Coalgebra[F, B])(implicit arg0: Functor[F]): DistributiveLaw[[β$30$]\/[B, β$30$], F]

  33. def distGApoT[F[_], M[_], B](g: Coalgebra[F, B], k: DistributiveLaw[M, F])(implicit arg0: Functor[F], arg1: Functor[M]): DistributiveLaw[[γ$31$]EitherT[M, B, γ$31$], F]

    Allows for more complex unfolds, like futuGApo(φ0: Coalgebra[F, B], φ: GCoalgebra[λ[α => EitherT[Free[F, ?], B, α]], F, A])

  34. def distGFutu[H[_], F[_]](k: DistributiveLaw[H, F])(implicit arg0: Functor[H], F: Functor[F]): DistributiveLaw[[β$33$]Free[H, β$33$], F]

  35. def distGHisto[F[_], H[_]](k: DistributiveLaw[F, H])(implicit arg0: Functor[F], arg1: Functor[H]): DistributiveLaw[F, [β$28$]Cofree[H, β$28$]]

  36. def distHisto[F[_]](implicit arg0: Functor[F]): DistributiveLaw[F, [β$27$]Cofree[F, β$27$]]

  37. def distPara[T, F[_]](implicit arg0: Functor[F], T: Aux[T, F]): DistributiveLaw[F, [β$22$](T, β$22$)]

  38. def distParaT[T, W[_], F[_]](t: DistributiveLaw[F, W])(implicit arg0: Comonad[W], arg1: Functor[F], T: Aux[T, F]): DistributiveLaw[F, [γ$23$]EnvT[T, W, γ$23$]]

  39. def distZygo[F[_], B](g: Algebra[F, B])(implicit arg0: Functor[F]): DistributiveLaw[F, [β$24$](B, β$24$)]

  40. def distZygoM[F[_], M[_], B](g: AlgebraM[M, F, B], k: DistributiveLaw[F, M])(implicit arg0: Functor[F], arg1: Monad[M]): DistributiveLaw[F, [A]M[(B, A)]]

  41. def distZygoT[F[_], W[_], B](g: Algebra[F, B], k: DistributiveLaw[F, W])(implicit arg0: Functor[F], arg1: Comonad[W]): DistributiveLaw[F, [γ$26$]EnvT[B, W, γ$26$]]

  42. def dyna[F[_], A, B](a: A)(φ: (F[Cofree[F, B]]) ⇒ B, ψ: Coalgebra[F, A])(implicit arg0: Functor[F]): B

    histo ⋘ ana

  43. def elgot[F[_], A, B](a: A)(φ: Algebra[F, B], ψ: ElgotCoalgebra[[β$10$]\/[B, β$10$], F, A])(implicit F: Functor[F]): B

    cata ⋘ elgotGApo

  44. def elgotHylo[W[_], N[_], F[_], A, B](a: A)(kφ: DistributiveLaw[F, W], kψ: DistributiveLaw[N, F], φ: ElgotAlgebra[W, F, B], ψ: ElgotCoalgebra[N, F, A])(implicit arg0: Comonad[W], arg1: Monad[N], arg2: Functor[F]): B

    Composition of an elgot-anamorphism and an elgot-catamorphism that avoids building the intermediate recursive data structure.

    Composition of an elgot-anamorphism and an elgot-catamorphism that avoids building the intermediate recursive data structure.

    elgotCata ⋘ elgotAna

  45. def elgotM[M[_], F[_], A, B](a: A)(φ: AlgebraM[M, F, B], ψ: ElgotCoalgebraM[[β$13$]\/[B, β$13$], M, F, A])(implicit M: Monad[M], F: Traverse[F]): M[B]

    cataM ⋘ elgotGApoM

  46. implicit def equalTEqual[T[_[_]], F[_]](implicit arg0: Functor[F], T: EqualT[T], F: Delay[Equal, F]): Equal[T[F]]
  47. def find[T](f: (T) ⇒ slamdata.Predef.Boolean): (T) ⇒ \/[T, T]

    Returns (on the left) the first element that passes f.

  48. def foldIso[T, F[_], A](alg: AlgebraIso[F, A])(implicit arg0: Functor[F], TR: Aux[T, F], TC: Aux[T, F]): Iso[T, A]

    There is a fold/unfold isomorphism for any AlgebraIso.

  49. def foldPrism[T, F[_], A](alg: AlgebraPrism[F, A])(implicit arg0: Traverse[F], TR: Aux[T, F], TC: Aux[T, F]): Prism[T, A]

    There is a fold prism for any AlgebraPrism.

  50. def forgetAnnotation[T, R, F[_], A](t: T)(implicit arg0: Functor[F], T: Aux[T, [γ$37$]EnvT[A, F, γ$37$]], R: Aux[R, F]): R
  51. def ghylo[W[_], N[_], F[_], A, B](a: A)(w: DistributiveLaw[F, W], n: DistributiveLaw[N, F], f: GAlgebra[W, F, B], g: GCoalgebra[N, F, A])(implicit arg0: Comonad[W], arg1: Monad[N], arg2: Functor[F]): B

    A generalized version of a hylomorphism that composes any coalgebra and algebra.

    A generalized version of a hylomorphism that composes any coalgebra and algebra. (gcata ⋘ gana)

  52. def ghyloM[W[_], N[_], M[_], F[_], A, B](a: A)(w: DistributiveLaw[F, W], n: DistributiveLaw[N, F], f: GAlgebraM[W, M, F, B], g: GCoalgebraM[N, M, F, A])(implicit arg0: Comonad[W], arg1: Traverse[W], arg2: Monad[N], arg3: Traverse[N], arg4: Monad[M], arg5: Traverse[F]): M[B]

    A Kleisli ghylo (gcataM ⋘ ganaM)

  53. def height[F[_]](implicit arg0: Foldable[F]): Algebra[F, slamdata.Predef.Int]

    The largest number of hops from a node to a leaf.

  54. def holes[F[_], A](fa: F[A])(implicit arg0: Traverse[F]): F[(A, Coalgebra[F, A])]
  55. def holesList[F[_], A](fa: F[A])(implicit arg0: Traverse[F]): slamdata.Predef.List[(A, Coalgebra[F, A])]
  56. def hylo[F[_], A, B](a: A)(φ: Algebra[F, B], ψ: Coalgebra[F, A])(implicit arg0: Functor[F]): B

    The hylomorphism is the fundamental operation of recursion schemes.

    The hylomorphism is the fundamental operation of recursion schemes. It first applies ψ, recursively breaking an A into layers of F, then applies φ, combining the Fs into a B. It can also be seen as the (fused) composition of an anamorphism and a catamorphism that avoids building the intermediate recursive data structure.

  57. def hyloM[M[_], F[_], A, B](a: A)(f: AlgebraM[M, F, B], g: CoalgebraM[M, F, A])(implicit M: Monad[M], F: Traverse[F]): M[B]

    A Kleisli hylomorphism.

  58. def join[A]: Algebra[[α]Option[(A, (α, α))], slamdata.Predef.List[A]]
  59. def liftT[F[_], A, B](φ: ElgotAlgebra[[β$38$](A, β$38$), F, B]): Algebra[[γ$39$]EnvT[A, F, γ$39$], B]

    Makes it possible to use ElgotAlgebras on EnvT.

  60. def liftTM[M[_], F[_], A, B](φ: ElgotAlgebraM[[β$40$](A, β$40$), M, F, B]): AlgebraM[M, [γ$41$]EnvT[A, F, γ$41$], B]

    Makes it possible to use ElgotAlgebras on EnvT.

  61. def mergeTuple[T, F[_]](implicit arg0: Functor[F], arg1: Merge[F], T: Aux[T, F]): CoalgebraM[slamdata.Predef.Option, F, (T, T)]

    Merges a tuple of functors, if possible.

  62. def orDefault[A, B](default: B)(f: (A) ⇒ slamdata.Predef.Option[B]): (A) ⇒ B

    Converts a failable fold into a non-failable, by returning the default upon failure.

  63. def orOriginal[A](f: (A) ⇒ slamdata.Predef.Option[A]): (A) ⇒ A

    Converts a failable fold into a non-failable, by simply returning the argument upon failure.

  64. def partition[A](implicit arg0: Order[A]): Coalgebra[[α]Option[(A, (α, α))], slamdata.Predef.List[A]]
  65. def project[F[_], A](index: slamdata.Predef.Int, fa: F[A])(implicit arg0: Foldable[F]): slamdata.Predef.Option[A]
  66. def quicksort[A](as: slamdata.Predef.List[A])(implicit arg0: Order[A]): slamdata.Predef.List[A]
  67. implicit def recursiveTFoldable[T[_[_]], F[_, _]](implicit arg0: RecursiveT[T], FB: Bifoldable[F], FF: Bifunctor[F]): Foldable[[α]T[[β$58$]F[α, β$58$]]]
  68. implicit def recursiveTRecursive[T[_[_]], F[_]](implicit arg0: RecursiveT[T]): Aux[T[F], F]
  69. final def repeatedly[A](f: (A) ⇒ slamdata.Predef.Option[A])(expr: A): A

    Repeatedly applies the function to the result as long as it returns Some.

    Repeatedly applies the function to the result as long as it returns Some. Finally returns the last non-None value (which may be the initial input).

    Annotations
    @tailrec()
  70. def runT[F[_], A, B](ψ: ElgotCoalgebra[[β$42$]\/[A, β$42$], F, B]): Coalgebra[[γ$43$]CoEnv[A, F, γ$43$], B]
  71. implicit def showTShow[T[_[_]], F[_]](implicit arg0: Functor[F], T: ShowT[T], F: Delay[Show, F]): Show[T[F]]
  72. def size[F[_]](implicit arg0: Foldable[F]): Algebra[F, slamdata.Predef.Int]

    The number of nodes in this structure.

  73. def substitute[T](original: T, replacement: T)(implicit arg0: Equal[T]): (T) ⇒ \/[T, T]

    Replaces all instances of original in the structure with replacement.

  74. def toTree[F[_]](implicit arg0: Functor[F], arg1: Foldable[F]): Algebra[F, Tree[F[slamdata.Predef.Unit]]]

    Converts a fixed-point structure into a generic Tree.

    Converts a fixed-point structure into a generic Tree. One use of this is using .cata(toTree).drawTree rather than .show to get a pretty-printed tree.

  75. def unfoldPrism[T, F[_], A](coalg: CoalgebraPrism[F, A])(implicit arg0: Traverse[F], TR: Aux[T, F], TC: Aux[T, F]): Prism[A, T]

    There is an unfold prism for any CoalgebraPrism.

  76. def zipTuple[T, F[_]](implicit arg0: Functor[F], arg1: Zip[F], T: Aux[T, F]): Coalgebra[F, (T, T)]

    Combines a tuple of zippable functors.

  77. object AlgebraIso extends Serializable
  78. object AlgebraPrism extends Serializable
  79. object Based extends Serializable
  80. object Birecursive extends Serializable
  81. object BirecursiveT extends Serializable
  82. object CoalgebraPrism extends Serializable
  83. object Corecursive extends Serializable
  84. object CorecursiveT
  85. object Delay
  86. object ElgotAlgebraIso extends Serializable
  87. object Embed

    An extractor to make it easier to pattern-match on arbitrary Recursive structures.

    An extractor to make it easier to pattern-match on arbitrary Recursive structures.

    NB: This extractor is irrufutable and doesn’t break exhaustiveness checking.

  88. object EqualT extends Serializable
  89. object GAlgebraIso extends Serializable
  90. object Hole extends Hole with Product with Serializable
  91. object Merge extends Serializable
  92. object Recursive extends Serializable
  93. object RecursiveT extends Serializable
  94. object ShowT extends Serializable
  95. object attributeElgotM

    A function to be called like attributeElgotM[M](myElgotAlgebraM).

  96. object coelgotM

    elgotZygoM ⋘ anaM

Inherited from AnyRef

Inherited from Any

Algebras & Coalgebras

Generic algebras that operate over most functors.

Algebra Transformations

Operations that modify algebras in various ways to make them easier to combine with others.

Distributive Laws

Natural transformations required for generalized folds and unfolds.

Refolds

Traversals that apply an unfold and a fold in a single pass.

Ungrouped