core/higherkindness.droste

higherkindness.droste

package higherkindness.droste

Type members

Classlikes

object Algebra
object AlgebraM
sealed trait Basis[F[_], R] extends Embed[F, R] with Project[F, R]
Companion:
object
object Basis
Companion:
class
object CVAlgebra
object CVCoalgebra
object Coalgebra
object CoalgebraM
trait Embed[F[_], R]
Companion:
object
object Embed
Companion:
class
final class GAlgebra[F[_], S, A](val run: F[S] => A) extends AnyVal
Companion:
object
object GAlgebra
Companion:
class
final class GAlgebraM[M[_], F[_], S, A](val run: F[S] => M[A]) extends AnyVal
Companion:
object
object GAlgebraM
Companion:
class
final class GCoalgebra[F[_], A, S](val run: A => F[S]) extends AnyVal
Companion:
object
object GCoalgebra
Companion:
class
final class GCoalgebraM[M[_], F[_], A, S](val run: A => M[F[S]]) extends AnyVal
Companion:
object
object GCoalgebraM
Companion:
class
final class GTrans[F[_], G[_], A, B](val run: F[A] => G[B]) extends AnyVal
Companion:
object
object GTrans
Companion:
class
final class GTransM[M[_], F[_], G[_], A, B](val run: F[A] => M[G[B]]) extends AnyVal
Companion:
object
object GTransM
Companion:
class
object Gather
trait Project[F[_], R]
Companion:
object
object Project
Companion:
class
object RAlgebra
object RAlgebraM
object RCoalgebra
object RCoalgebraM
object Scatter
object Trans
object TransM
object kernel

Fundamental recursion schemes implemented in terms of functions and nothing else.

Fundamental recursion schemes implemented in terms of functions and nothing else.

object prelude
object scheme

Types

type Algebra[F[_], A] = GAlgebra[F, A, A]
type AlgebraM[M[_], F[_], A] = GAlgebraM[M, F, A, A]
type CVAlgebra[F[_], A] = GAlgebra[F, Attr[F, A], A]
type CVCoalgebra[F[_], A] = GCoalgebra[F, A, Coattr[F, A]]
type Coalgebra[F[_], A] = GCoalgebra[F, A, A]
type CoalgebraM[M[_], F[_], A] = GCoalgebraM[M, F, A, A]
type Delay[F[_], G[_]] = FunctionK[F, <none>]
type Gather[F[_], S, A] = (A, F[S]) => S
type RAlgebra[R, F[_], A] = GAlgebra[F, (R, A), A]
type RAlgebraM[R, M[_], F[_], A] = GAlgebraM[M, F, (R, A), A]
type RCoalgebra[R, F[_], A] = GCoalgebra[F, A, Either[R, A]]
type RCoalgebraM[R, M[_], F[_], A] = GCoalgebraM[M, F, A, Either[R, A]]
type Scatter[F[_], A, S] = S => Either[A, F[S]]
type Trans[F[_], G[_], A] = GTrans[F, G, A, A]
type TransM[M[_], F[_], G[_], A] = GTransM[M, F, G, A, A]