matryoshka
Unfolds for corecursive data types.
To avoid diverging implicits with fixed-point types, we need to defer the lookup.
To avoid diverging implicits with fixed-point types, we need to defer the
lookup. We do this with a NaturalTransformation (although there
are more type class-y solutions available now).
A NaturalTransformation that sequences two types
This is the simplest fixpoint type, implemented with general recursion.
The operations here are very similar to those in Recursive and Corecursive.
The operations here are very similar to those in Recursive and Corecursive.
The usual names (cata, ana, etc.) are prefixed with trans and behave
generally the same, except
1. the A of the [un]fold is restricted to T[G], but
2. the [co]algebra shape is like F[A] => G[A] rather than F[A] => A.
In exchange, the [un]folds are available to more types (EG, folds available
to Free and unfolds available to Cofree).
There are two additional operations – transCataT and transAnaT. The
distinction between these and transCata/transAna is that this allows
the algebra to return the context (the outer T) to be used, whereas
transCata always uses the original context of the argument to f.
This is noticable when T is Cofree. In this function, the result may
have any head the algebra desires, whereas in transCata, it can only
have the head of the argument to f.
Docs for operations, since they seem to break scaladoc if put in the right place:
- map – very roughly like Uniplate’s descend
- transCataT – akin to Uniplate’s transform
- transAnaT – akin to Uniplate’s topDownTransform
- transCata – akin to Fixplate’s restructure
An algebra and its dual form an isomorphism.
Like Zip, but it can fail to merge, so it’s much more general.
This is for inductive (finite) recursive structures, models the concept of “data”, aka, the “least fixed point”.
This is for coinductive (potentially infinite) recursive structures, models the concept of “codata”, aka, the “greatest fixed point”.
Folds for recursive data types.
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.
Aligns “These” into a single structure, short-circuting when we hit a “This” or “That”.
Turns any F-algebra, into an identical one that attributes the tree with the results for each node.
A version of matryoshka.Corecursive.ana that annotates each node with
the A it was expanded from.
A version of matryoshka.Corecursive.ana that annotates each node with
the A it was expanded from. This is also the unfold from a decomposed
coelgot.
A Kleisli matryoshka.attributeAna.
A function to be called like attributeElgotM[M](myElgotAlgebraM).
NB: Since Cofree carries the functor, the resulting algebra is a cata, not a para.
Generates an infinite sequence from two seed values.
Similar to a hylomorphism, this composes a futumorphism and a histomorphism.
cata ⋘ futu
cataM ⋘ futuM
elgotZygo ⋘ ana
elgotZygoM ⋘ anaM
The fold of a decomposed coelgot, since the Cofree already has the
attribute for each node.
Count the instinces of form in the structure.
This implicit allows Delay implicits to be found when searching for a traditionally-defined instance.
See delayEqual.
histo ⋘ ana
cata ⋘ elgotGApo
There is a fold/unfold isomorphism for any AlgebraIso.
There is a fold prism for any AlgebraPrism.
The unfold from a decomposed elgot.
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)
A Kleisli ghylo (gcataM ⋘ ganaM)
The largest number of hops from a node to a leaf.
Composition of an anamorphism and a catamorphism that avoids building the intermediate recursive data structure.
A Kleisli hylomorphism.
This folds a Free that you may think of as “already partially-folded”.
This folds a Free that you may think of as “already partially-folded”.
It’s also the fold of a decomposed elgot.
Merges a tuple of functors, if possible.
Converts a failable fold into a non-failable, by returning the default upon failure.
Converts a failable fold into a non-failable, by simply returning the argument upon failure.
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).
The number of nodes in this structure.
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.
There is an unfold prism for any CoalgebraPrism.
Combines a tuple of zippable functors.
Generic algebras that operate over most functors.
Operations that modify algebras in various ways to make them easier to combine with others.
Natural transformations required for generalized folds and unfolds.
Traversals that apply an unfold and a fold in a single pass.
Generalized folds, unfolds, and refolds.