matryoshka

Type Members

type Algebra[F[_], A] = (F[scalaz.Scalaz.Id[A]]) ⇒ scalaz.Scalaz.Id[A]
type AlgebraM[M[_], F[_], A] = (F[scalaz.Scalaz.Id[A]]) ⇒ M[A]
sealed class AlgebraOps[F[_], A] extends AnyRef
final class AttributeCoelgotMPartiallyApplied[M[_]] extends AnyRef
type Coalgebra[F[_], A] = (A) ⇒ scalaz.Scalaz.Id[F[scalaz.Scalaz.Id[A]]]
type CoalgebraM[M[_], F[_], A] = (A) ⇒ M[F[scalaz.Scalaz.Id[A]]]
sealed class CoalgebraOps[F[_], A] extends AnyRef
final class CoelgotMPartiallyApplied[M[_]] extends AnyRef
final class CofParaMPartiallyApplied[M[_]] extends AnyRef
trait CofreeInstances extends AnyRef
trait Corecursive[T[_[_]]] extends Serializable

Unfolds for corecursive data types.
sealed class CorecursiveOps[T[_[_]], F[_]] extends AnyRef
type DistributiveLaw[F[_], G[_]] = NaturalTransformation[[α]F[G[α]], [α]G[F[α]]]

A NaturalTransformation that sequences two types
type ElgotAlgebra[F[_], A, B] = (A, F[B]) ⇒ scalaz.Scalaz.Id[B]
type ElgotAlgebraM[M[_], F[_], A, B] = (A, F[B]) ⇒ M[B]
type ElgotCoalgebra[F[_], A, B] = (A) ⇒ scalaz.Scalaz.Id[\/[B, F[A]]]
type ElgotCoalgebraM[M[_], F[_], A, B] = (A) ⇒ M[\/[B, F[A]]]
final case class EnvT[E, W[_], A](run: (E, W[A])) extends Product with Serializable

This is the transformer for the (,) comonad.
trait EnvTFunctions extends AnyRef
sealed abstract class EnvTInstances extends EnvTInstances0
sealed abstract class EnvTInstances0 extends AnyRef
final case class Fix[F[_]](unFix: F[Fix[F]]) extends Product with Serializable
trait FreeInstances extends AnyRef
trait FunctorT[T[_[_]]] extends Serializable

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
type GAlgebra[W[_], F[_], A] = (F[W[A]]) ⇒ scalaz.Scalaz.Id[A]
type GAlgebraM[W[_], M[_], F[_], A] = (F[W[A]]) ⇒ M[A]
type GCoalgebra[N[_], F[_], A] = (A) ⇒ scalaz.Scalaz.Id[F[N[A]]]
type GCoalgebraM[N[_], M[_], F[_], A] = (A) ⇒ M[F[N[A]]]
sealed trait Hole extends AnyRef
sealed class IdOps[A] extends AnyRef
final case class Mu[F[_]](unMu: ~>[[A](F[A]) ⇒ A, scalaz.Scalaz.Id]) extends Product with Serializable
final case class Nu[F[_]](unNu: ~>[scalaz.Scalaz.Id, F], a: scalaz.Scalaz.Id[_]) extends Product with Serializable
trait Recursive[T[_[_]]] extends Serializable

Folds for recursive data types.
trait TraverseT[T[_[_]]] extends FunctorT[T] with Serializable

Value Members

implicit def AlgebraZip[F[_]](implicit arg0: Functor[F]): Zip[[γ](F[scalaz.Scalaz.Id[γ]]) ⇒ γ]
object Corecursive extends Serializable
implicit def ElgotAlgebraMZip[M[_], F[_], C](implicit arg0: Applicative[M], arg1: Functor[F]): Zip[[δ](C, F[δ]) ⇒ M[δ]]
implicit def ElgotAlgebraZip[F[_], C](implicit arg0: Functor[F]): Zip[[δ](C, F[δ]) ⇒ scalaz.Scalaz.Id[δ]]
object EnvT extends EnvTInstances with EnvTFunctions with Serializable
object Fix extends Serializable
implicit def FreeCorecursive[A]: Corecursive[[α[_$3]]Free[α, A]]

Definition Classes
FreeInstances
implicit def FreeTraverseT[A]: TraverseT[[α[_$1]]Free[α, A]]

Definition Classes
FreeInstances
object FunctorT extends Serializable
implicit def GAlgebraZip[W[_], F[_]](implicit arg0: Functor[W], arg1: Functor[F]): Zip[[γ](F[W[γ]]) ⇒ γ]
val Hole: Hole
object Mu extends Serializable
object Nu extends Serializable
object Recursive extends Serializable
implicit def ToAlgebraOps[F[_], A](a: Algebra[F, A]): AlgebraOps[F, A]
implicit def ToCoalgebraOps[F[_], A](a: Coalgebra[F, A]): CoalgebraOps[F, A]
implicit def ToCorecursiveOps[T[_[_]], F[_]](f: F[T[F]])(implicit arg0: Corecursive[T]): CorecursiveOps[T, F]
implicit def ToIdOps[A](a: A): IdOps[A]
object TraverseT extends Serializable
def attrK[F[_], A](k: A)(implicit arg0: Functor[F]): (F[Cofree[F, A]]) ⇒ scalaz.Scalaz.Id[Cofree[F, A]]
def attrSelf[T[_[_]], F[_]](implicit arg0: Corecursive[T], arg1: Functor[F]): (F[Cofree[F, T[F]]]) ⇒ scalaz.Scalaz.Id[Cofree[F, T[F]]]
def attribute[F[_], A](f: (F[A]) ⇒ A)(implicit arg0: Functor[F]): (F[Cofree[F, A]]) ⇒ scalaz.Scalaz.Id[Cofree[F, A]]
def attributeCoelgotM[M[_]]: AttributeCoelgotMPartiallyApplied[M]
def attributeM[F[_], M[_], A](f: (F[A]) ⇒ M[A])(implicit arg0: Functor[F], arg1: Functor[M]): (F[Cofree[F, A]]) ⇒ M[Cofree[F, A]]

Turns any F-algebra, into an identical one that attributes the tree with the results for each node.
def attributePara[T[_[_]], F[_], A](f: (F[(T[F], A)]) ⇒ A)(implicit arg0: Corecursive[T], arg1: Functor[F]): (F[Cofree[F, A]]) ⇒ Cofree[F, A]

NB: Since Cofree carries the functor, the resulting algebra is a cata, not a para.
def builder[F[_], A, B](fa: F[A], children: List[B])(implicit arg0: Traverse[F]): F[B]
def chrono[F[_], A, B](a: A)(g: (F[Cofree[F, B]]) ⇒ B, f: (A) ⇒ F[Free[F, A]])(implicit arg0: Functor[F]): B

Similar to a hylomorphism, this composes a futumorphism and a histomorphism.
def coelgot[F[_], A, B](a: A)(φ: (A, F[B]) ⇒ B, ψ: (A) ⇒ F[A])(implicit arg0: Functor[F]): B
def coelgotM[M[_]]: CoelgotMPartiallyApplied[M]
def cofCataM[S[_], M[_], A, B](t: Cofree[S, A])(f: (A, S[B]) ⇒ M[B])(implicit arg0: Traverse[S], arg1: Monad[M]): M[B]
def cofParaM[M[_]]: CofParaMPartiallyApplied[M]
object cofree extends CofreeInstances
implicit def cofreeRecursive[A]: Recursive[[α[_$1]]Cofree[α, A]]

Definition Classes
CofreeInstances
implicit def cofreeShow[F[_], A](implicit arg0: Show[A], F: ~>[Show, [α]Show[F[α]]]): Show[Cofree[F, A]]

Definition Classes
CofreeInstances
implicit def cofreeTraverseT[A]: TraverseT[[α[_$3]]Cofree[α, A]]

Definition Classes
CofreeInstances
def colambek[T[_[_]], F[_]](ft: F[T[F]])(implicit arg0: Corecursive[T], arg1: Recursive[T], arg2: Functor[F]): T[F]
def count[T[_[_]], F[_]](form: T[F])(implicit arg0: Recursive[T], arg1: Functor[F], arg2: Foldable[F]): (F[(T[F], Int)]) ⇒ Int

Count the instinces of form in the structure.
def distAna[F[_]]: DistributiveLaw[scalaz.Scalaz.Id, F]
def distCata[F[_]]: DistributiveLaw[F, scalaz.Scalaz.Id]
def distFutu[F[_]](implicit arg0: Functor[F]): DistributiveLaw[[β]Free[F, β], F]
def distGFutu[H[_], F[_]](k: DistributiveLaw[H, F])(implicit H: Functor[H], F: Functor[F]): DistributiveLaw[[β]Free[H, β], F]
def distGHisto[F[_], H[_]](k: DistributiveLaw[F, H])(implicit F: Functor[F], H: Functor[H]): DistributiveLaw[F, [β]Cofree[H, β]]
def distHisto[F[_]](implicit arg0: Functor[F]): DistributiveLaw[F, [β]Cofree[F, β]]
def distPara[T[_[_]], F[_]](implicit arg0: Functor[F], T: Corecursive[T]): DistributiveLaw[F, [β](T[F], β)]
def distParaT[T[_[_]], F[_], W[_]](t: DistributiveLaw[F, W])(implicit arg0: Functor[F], arg1: Comonad[W], T: Corecursive[T]): DistributiveLaw[F, [γ]EnvT[T[F], W, γ]]
def distZygo[F[_], B](g: (F[B]) ⇒ B)(implicit arg0: Functor[F]): DistributiveLaw[F, [β](B, β)]
def distZygoT[F[_], W[_], B](g: (F[B]) ⇒ B, k: DistributiveLaw[F, W])(implicit arg0: Comonad[W], F: Functor[F]): DistributiveLaw[F, [γ]EnvT[B, W, γ]]
def elgot[F[_], A, B](a: A)(φ: (F[B]) ⇒ B, ψ: (A) ⇒ \/[B, F[A]])(implicit arg0: Functor[F]): B
object free extends FreeInstances
def ghylo[F[_], W[_], M[_], A, B](a: A)(w: DistributiveLaw[F, W], m: DistributiveLaw[M, F], f: (F[W[B]]) ⇒ B, g: (A) ⇒ F[M[A]])(implicit arg0: Functor[F], arg1: Comonad[W], M: Monad[M]): B

A generalized version of a hylomorphism that composes any coalgebra and algebra.
def holes[F[_], A](fa: F[A])(implicit arg0: Traverse[F]): F[(A, (A) ⇒ F[A])]
def holesList[F[_], A](fa: F[A])(implicit arg0: Traverse[F]): List[(A, (A) ⇒ F[A])]
def hylo[F[_], A, B](a: A)(f: (F[B]) ⇒ B, g: (A) ⇒ F[A])(implicit arg0: Functor[F]): B

Composition of an anamorphism and a catamorphism that avoids building the intermediate recursive data structure.
def hyloM[M[_], F[_], A, B](a: A)(f: (F[B]) ⇒ M[B], g: (A) ⇒ M[F[A]])(implicit arg0: Monad[M], arg1: Traverse[F]): M[B]

A Kleisli hylomorphism.
def lambek[T[_[_]], F[_]](tf: T[F])(implicit arg0: Corecursive[T], arg1: Recursive[T], arg2: Functor[F]): F[T[F]]
def once[A](f: (A) ⇒ Option[A]): (A) ⇒ A

Converts a failable fold into a non-failable, by simply returning the argument upon failure.
def project[F[_], A](index: Int, fa: F[A])(implicit arg0: Foldable[F]): Option[A]
def repeatedly[A](f: (A) ⇒ Option[A]): (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).

package matryoshka

Type Members

type Algebra[F[_], A] = (F[scalaz.Scalaz.Id[A]]) ⇒ scalaz.Scalaz.Id[A]

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

sealed class AlgebraOps[F[_], A] extends AnyRef

final class AttributeCoelgotMPartiallyApplied[M[_]] extends AnyRef

type Coalgebra[F[_], A] = (A) ⇒ scalaz.Scalaz.Id[F[scalaz.Scalaz.Id[A]]]

type CoalgebraM[M[_], F[_], A] = (A) ⇒ M[F[scalaz.Scalaz.Id[A]]]

sealed class CoalgebraOps[F[_], A] extends AnyRef

final class CoelgotMPartiallyApplied[M[_]] extends AnyRef

final class CofParaMPartiallyApplied[M[_]] extends AnyRef

trait CofreeInstances extends AnyRef

trait Corecursive[T[_[_]]] extends Serializable

sealed class CorecursiveOps[T[_[_]], F[_]] extends AnyRef

type DistributiveLaw[F[_], G[_]] = NaturalTransformation[[α]F[G[α]], [α]G[F[α]]]

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

type ElgotAlgebraM[M[_], F[_], A, B] = (A, F[B]) ⇒ M[B]

type ElgotCoalgebra[F[_], A, B] = (A) ⇒ scalaz.Scalaz.Id[\/[B, F[A]]]

type ElgotCoalgebraM[M[_], F[_], A, B] = (A) ⇒ M[\/[B, F[A]]]

final case class EnvT[E, W[_], A](run: (E, W[A])) extends Product with Serializable

trait EnvTFunctions extends AnyRef

sealed abstract class EnvTInstances extends EnvTInstances0

sealed abstract class EnvTInstances0 extends AnyRef

final case class Fix[F[_]](unFix: F[Fix[F]]) extends Product with Serializable

trait FreeInstances extends AnyRef

trait FunctorT[T[_[_]]] extends Serializable

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

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

type GCoalgebra[N[_], F[_], A] = (A) ⇒ scalaz.Scalaz.Id[F[N[A]]]

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

sealed trait Hole extends AnyRef

sealed class IdOps[A] extends AnyRef

final case class Mu[F[_]](unMu: ~>[[A](F[A]) ⇒ A, scalaz.Scalaz.Id]) extends Product with Serializable

final case class Nu[F[_]](unNu: ~>[scalaz.Scalaz.Id, F], a: scalaz.Scalaz.Id[_]) extends Product with Serializable

trait Recursive[T[_[_]]] extends Serializable

trait TraverseT[T[_[_]]] extends FunctorT[T] with Serializable

Value Members

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

object Corecursive extends Serializable

implicit def ElgotAlgebraMZip[M[_], F[_], C](implicit arg0: Applicative[M], arg1: Functor[F]): Zip[[δ](C, F[δ]) ⇒ M[δ]]

implicit def ElgotAlgebraZip[F[_], C](implicit arg0: Functor[F]): Zip[[δ](C, F[δ]) ⇒ scalaz.Scalaz.Id[δ]]

object EnvT extends EnvTInstances with EnvTFunctions with Serializable

object Fix extends Serializable

implicit def FreeCorecursive[A]: Corecursive[[α[_$3]]Free[α, A]]

implicit def FreeTraverseT[A]: TraverseT[[α[_$1]]Free[α, A]]

object FunctorT extends Serializable

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

val Hole: Hole

object Mu extends Serializable

object Nu extends Serializable

object Recursive extends Serializable

implicit def ToAlgebraOps[F[_], A](a: Algebra[F, A]): AlgebraOps[F, A]

implicit def ToCoalgebraOps[F[_], A](a: Coalgebra[F, A]): CoalgebraOps[F, A]

implicit def ToCorecursiveOps[T[_[_]], F[_]](f: F[T[F]])(implicit arg0: Corecursive[T]): CorecursiveOps[T, F]

implicit def ToIdOps[A](a: A): IdOps[A]

object TraverseT extends Serializable

def attrK[F[_], A](k: A)(implicit arg0: Functor[F]): (F[Cofree[F, A]]) ⇒ scalaz.Scalaz.Id[Cofree[F, A]]

def attrSelf[T[_[_]], F[_]](implicit arg0: Corecursive[T], arg1: Functor[F]): (F[Cofree[F, T[F]]]) ⇒ scalaz.Scalaz.Id[Cofree[F, T[F]]]

def attribute[F[_], A](f: (F[A]) ⇒ A)(implicit arg0: Functor[F]): (F[Cofree[F, A]]) ⇒ scalaz.Scalaz.Id[Cofree[F, A]]

def attributeCoelgotM[M[_]]: AttributeCoelgotMPartiallyApplied[M]

def attributeM[F[_], M[_], A](f: (F[A]) ⇒ M[A])(implicit arg0: Functor[F], arg1: Functor[M]): (F[Cofree[F, A]]) ⇒ M[Cofree[F, A]]

def attributePara[T[_[_]], F[_], A](f: (F[(T[F], A)]) ⇒ A)(implicit arg0: Corecursive[T], arg1: Functor[F]): (F[Cofree[F, A]]) ⇒ Cofree[F, A]

def builder[F[_], A, B](fa: F[A], children: List[B])(implicit arg0: Traverse[F]): F[B]

def chrono[F[_], A, B](a: A)(g: (F[Cofree[F, B]]) ⇒ B, f: (A) ⇒ F[Free[F, A]])(implicit arg0: Functor[F]): B

def coelgot[F[_], A, B](a: A)(φ: (A, F[B]) ⇒ B, ψ: (A) ⇒ F[A])(implicit arg0: Functor[F]): B

def coelgotM[M[_]]: CoelgotMPartiallyApplied[M]

def cofCataM[S[_], M[_], A, B](t: Cofree[S, A])(f: (A, S[B]) ⇒ M[B])(implicit arg0: Traverse[S], arg1: Monad[M]): M[B]

def cofParaM[M[_]]: CofParaMPartiallyApplied[M]

object cofree extends CofreeInstances

implicit def cofreeRecursive[A]: Recursive[[α[_$1]]Cofree[α, A]]

implicit def cofreeShow[F[_], A](implicit arg0: Show[A], F: ~>[Show, [α]Show[F[α]]]): Show[Cofree[F, A]]

implicit def cofreeTraverseT[A]: TraverseT[[α[_$3]]Cofree[α, A]]

def colambek[T[_[_]], F[_]](ft: F[T[F]])(implicit arg0: Corecursive[T], arg1: Recursive[T], arg2: Functor[F]): T[F]

def count[T[_[_]], F[_]](form: T[F])(implicit arg0: Recursive[T], arg1: Functor[F], arg2: Foldable[F]): (F[(T[F], Int)]) ⇒ Int

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

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

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

def distGFutu[H[_], F[_]](k: DistributiveLaw[H, F])(implicit H: Functor[H], F: Functor[F]): DistributiveLaw[[β]Free[H, β], F]

def distGHisto[F[_], H[_]](k: DistributiveLaw[F, H])(implicit F: Functor[F], H: Functor[H]): DistributiveLaw[F, [β]Cofree[H, β]]