core/higherkindness.droste/scheme

scheme

object scheme
class Object
trait Matchable
class Any
scheme.type

Type members

Classlikes

object zoo

A petting zoo for wild and exotic animals we keep separate from the regulars in scheme. For their safety and yours.

A petting zoo for wild and exotic animals we keep separate from the regulars in scheme. For their safety and yours.

Inherited classlikes

final class SchemePartialBasis[PatR[_[_]], PatF[_[_], _]]

Value members

Inherited methods

def ana[F[_] : Functor, A, R](coalgebra: Coalgebra[F, A])(implicit evidence$4: Functor[F], embed: Embed[F, R]): A => R
Inherited from:
SchemeConvenientPorcelain
def anaM[M[_] : Monad, F[_] : Traverse, A, R](coalgebraM: CoalgebraM[M, F, A])(implicit evidence$5: Monad[M], evidence$6: Traverse[F], embed: Embed[F, R]): A => M[R]
Inherited from:
SchemeConvenientPorcelain
def apply[PatR[_[_]]](implicit ev: Solve[PatR]): SchemePartialBasis[PatR, PatF]

Convenience to specify the base constructor "shape" (such as Fix or Cofree[*[_], Int]) for recursion.

Convenience to specify the base constructor "shape" (such as Fix or Cofree[*[_], Int]) for recursion.

This helps to guide Scala's type inference so all of the type parameters for the various recursion scheme methods don't have to be provided.

Inherited from:
SchemeConvenientPorcelain
def cata[F[_] : Functor, R, B](algebra: Algebra[F, B])(implicit evidence$7: Functor[F], project: Project[F, R]): R => B
Inherited from:
SchemeConvenientPorcelain
def cataM[M[_] : Monad, F[_] : Traverse, R, B](algebraM: AlgebraM[M, F, B])(implicit evidence$8: Monad[M], evidence$9: Traverse[F], project: Project[F, R]): R => M[B]
Inherited from:
SchemeConvenientPorcelain
def gana[F[_] : Functor, A, S, R](scattered: Scattered[F, A, S])(implicit evidence$16: Functor[F], embed: Embed[F, R]): A => R
Inherited from:
SchemeGeneralizedPorcelain
def gana[F[_] : Functor, A, S, R](coalgebra: GCoalgebra[F, A, S])(scatter: (F, A) => S)(implicit evidence$25: Functor[F], embed: Embed[F, R]): A => R
Inherited from:
SchemeGeneralizedPlumbing
def ganaM[M[_] : Monad, F[_] : Traverse, A, S, R](scattered: Scattered[M, F, A, S])(implicit evidence$17: Monad[M], evidence$18: Traverse[F], embed: Embed[F, R]): A => M[R]
Inherited from:
SchemeGeneralizedPorcelain
def ganaM[M[_] : Monad, F[_] : Traverse, A, S, R](coalgebra: GCoalgebraM[M, F, A, S])(scatter: (F, A) => S)(implicit evidence$26: Monad[M], evidence$27: Traverse[F], embed: Embed[F, R]): A => M[R]
Inherited from:
SchemeGeneralizedPlumbing
def gcata[F[_] : Functor, R, S, B](gathered: Gathered[F, S, B])(implicit evidence$13: Functor[F], project: Project[F, R]): R => B
Inherited from:
SchemeGeneralizedPorcelain
def gcata[F[_] : Functor, R, S, B](galgebra: GAlgebra[F, S, B])(gather: (F, S) => B)(implicit evidence$22: Functor[F], project: Project[F, R]): R => B
Inherited from:
SchemeGeneralizedPlumbing
def gcataM[M[_] : Monad, F[_] : Traverse, R, S, B](gathered: Gathered[M, F, S, B])(implicit evidence$14: Monad[M], evidence$15: Traverse[F], project: Project[F, R]): R => M[B]
Inherited from:
SchemeGeneralizedPorcelain
def gcataM[M[_] : Monad, F[_] : Traverse, R, S, B](algebra: GAlgebraM[M, F, S, B])(gather: (F, S) => B)(implicit evidence$23: Monad[M], evidence$24: Traverse[F], project: Project[F, R]): R => M[B]
Inherited from:
SchemeGeneralizedPlumbing
def ghylo[F[_] : Functor, A, SA, SB, B](gathered: Gathered[F, SB, B], scattered: Scattered[F, A, SA]): A => B
Inherited from:
SchemeGeneralizedPorcelain
def ghylo[F[_] : Functor, A, SA, SB, B](algebra: GAlgebra[F, SB, B], coalgebra: GCoalgebra[F, A, SA])(gather: (F, SB) => B, scatter: (F, A) => SA): A => B
Inherited from:
SchemeGeneralizedPlumbing
def ghyloM[M[_] : Monad, F[_] : Traverse, A, SA, SB, B](gathered: Gathered[M, F, SB, B], scattered: Scattered[M, F, A, SA]): A => M[B]
Inherited from:
SchemeGeneralizedPorcelain
def ghyloM[M[_] : Monad, F[_] : Traverse, A, SA, SB, B](algebra: GAlgebraM[M, F, SB, B], coalgebra: GCoalgebraM[M, F, A, SA])(gather: (F, SB) => B, scatter: (F, A) => SA): A => M[B]
Inherited from:
SchemeGeneralizedPlumbing
def hylo[F[_] : Functor, A, B](algebra: Algebra[F, B], coalgebra: Coalgebra[F, A]): A => B

Build a hylomorphism by recursively unfolding with coalgebra and refolding with algebra.

Build a hylomorphism by recursively unfolding with coalgebra and refolding with algebra.

 hylo A ---------------> B
| ^ co- | | algebra | | algebra
| | v | F[A] ------------> F[B] map hylo
Inherited from:
SchemeHyloPorcelain
def hyloM[M[_] : Monad, F[_] : Traverse, A, B](algebra: AlgebraM[M, F, B], coalgebra: CoalgebraM[M, F, A]): A => M[B]

Build a monadic hylomorphism

Build a monadic hylomorphism

 hyloM A ---------------> M[B]
| ^ co- | | algebraM | | flatMap f
| | v | M[F[A]] ---------> M[F[M[B]]] map hyloM

with f:

F[M[B]] -----> M[F[B]] ----------> M[B] sequence flatMap algebraM
Inherited from:
SchemeHyloPorcelain