Packages

p

matryoshka

patterns

package patterns

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

Type Members

  1. final case class Added [T[_[_]], F[_], A](right: T[F]) extends Diff[T, F, A] with Product with Serializable
  2. sealed abstract class AndMaybe [A, B] extends AnyRef
  3. sealed abstract class AndMaybeInstances extends AnyRef
  4. final case class CoEnv [E, F[_], A](run: \/[E, F[A]]) extends Product with Serializable

    The pattern functor for Free.

  5. sealed abstract class CoEnvInstances extends CoEnvInstances0
  6. sealed abstract class CoEnvInstances0 extends AnyRef
  7. final case class ConsF [A, B](car: A, cdr: B) extends ListF[A, B] with Product with Serializable
  8. final case class Deleted [T[_[_]], F[_], A](left: F[A]) extends Diff[T, F, A] with Product with Serializable
  9. sealed abstract class Diff [T[_[_]], F[_], A] extends AnyRef

    Represents diffs of recursive data structures.

  10. sealed abstract class DiffInstances extends DiffInstances0
  11. sealed abstract class DiffInstances0 extends AnyRef
  12. type DiffT[T[_[_]], F[_]] = T[[γ$0$]Diff[T, F, γ$0$]]
  13. trait Diffable [F[_]] extends Serializable
  14. final case class Different [T[_[_]], F[_], A](left: T[F], right: T[F]) extends Diff[T, F, A] with Product with Serializable
  15. final case class EnvT [E, W[_], A](run: (E, W[A])) extends Product with Serializable

    This is the transformer for the (,) comonad.

  16. trait EnvTFunctions extends AnyRef
  17. sealed abstract class EnvTInstances extends EnvTInstances0
  18. sealed abstract class EnvTInstances0 extends EnvTInstances1
  19. sealed abstract class EnvTInstances1 extends AnyRef
  20. final case class Failure [T[_[_]], F[_], E, A] extends PotentialFailure[T, F, E, A] with Product with Serializable

    Akin to Free.point

  21. final case class Indeed [A, B](h: A, t: B) extends AndMaybe[A, B] with Product with Serializable
  22. final case class Inserted [T[_[_]], F[_], A](right: F[A]) extends Diff[T, F, A] with Product with Serializable
  23. sealed abstract class ListF [A, B] extends AnyRef
  24. final case class LocallyDifferent [T[_[_]], F[_], A](left: F[A], right: F[slamdata.Predef.Unit]) extends Diff[T, F, A] with Product with Serializable
  25. final case class NilF [A, B]() extends ListF[A, B] with Product with Serializable
  26. final case class Only [A, B](a: A) extends AndMaybe[A, B] with Product with Serializable
  27. final case class PartialFailure [T[_[_]], F[_], E, A] extends PotentialFailure[T, F, E, A] with Product with Serializable

    Akin to Free.roll

  28. sealed abstract class PotentialFailure [T[_[_]], F[_], E, A] extends AnyRef

    Generally similar to CoEnv (Free), this has an additional success case that indicates there’s no failure down to the leaves.

  29. type PotentialFailureT[T[_[_]], F[_], E] = T[[δ$1$]PotentialFailure[T, F, E, δ$1$]]
  30. final case class Removed [T[_[_]], F[_], A](left: T[F]) extends Diff[T, F, A] with Product with Serializable
  31. final case class Same [T[_[_]], F[_], A](ident: T[F]) extends Diff[T, F, A] with Product with Serializable
  32. final case class Similar [T[_[_]], F[_], A](ident: F[A]) extends Diff[T, F, A] with Product with Serializable
  33. final case class Success [T[_[_]], F[_], E, A] extends PotentialFailure[T, F, E, A] with Product with Serializable

Value Members

  1. def diff[T[_[_]], F[_]](implicit arg0: BirecursiveT[T], arg1: Diffable[F], arg2: Functor[F], arg3: Foldable[F]): (T[F], T[F], slamdata.Predef.Option[F[DiffT[T, F]]]) ⇒ DiffT[T, F]
  2. def ginterpretM[W[_], M[_], F[_], A, B](f: (A) ⇒ M[B], φ: GAlgebraM[W, M, F, B]): GAlgebraM[W, M, [γ$7$]CoEnv[A, F, γ$7$], B]
  3. def interpret[F[_], A, B](f: (A) ⇒ B, φ: Algebra[F, B]): Algebra[[γ$5$]CoEnv[A, F, γ$5$], B]

    Algebra transformation that allows a standard algebra to be used on a CoEnv structure (given a function that converts the leaves to the result type).

  4. def interpretM[M[_], F[_], A, B](f: (A) ⇒ M[B], φ: AlgebraM[M, F, B]): AlgebraM[M, [γ$6$]CoEnv[A, F, γ$6$], B]
  5. def recover[F[_], A](φ: Algebra[F, A]): Algebra[[γ$8$]CoEnv[A, F, γ$8$], A]

    A specialization of interpret where the leaves are of the result type.

    A specialization of interpret where the leaves are of the result type. This folds a Free that you may think of as “already partially-folded”. It’s also the fold of a decomposed elgot.

  6. object AndMaybe extends AndMaybeInstances
  7. object CoEnv extends CoEnvInstances with Serializable
  8. object Diff extends DiffInstances
  9. object Diffable extends Serializable
  10. object EnvT extends EnvTInstances with EnvTFunctions with Serializable
  11. object ListF
  12. object PotentialFailure

Inherited from AnyRef

Inherited from Any

Ungrouped