patterns

Type Members

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

The pattern functor for Free.
sealed abstract class CoEnvInstances extends CoEnvInstances0
sealed abstract class CoEnvInstances0 extends AnyRef
final case class ConsF[A, B](car: A, cdr: B) extends ListF[A, B] with Product with Serializable
final case class Deleted[T[_[_]], F[_], A](left: F[A]) extends Diff[T, F, A] with Product with Serializable
sealed abstract class Diff[T[_[_]], F[_], A] extends AnyRef

Represents diffs of recursive data structures.
sealed abstract class DiffInstances extends DiffInstances0
sealed abstract class DiffInstances0 extends AnyRef
type DiffT[T[_[_]], F[_]] = T[[γ$0$]Diff[T, F, γ$0$]]
trait Diffable[F[_]] extends Serializable
final case class Different[T[_[_]], F[_], A](left: T[F], right: T[F]) extends Diff[T, F, A] with Product with Serializable
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 EnvTInstances1
sealed abstract class EnvTInstances1 extends AnyRef
final case class Failure[T[_[_]], F[_], E, A] extends PotentialFailure[T, F, E, A] with Product with Serializable

Akin to Free.point
final case class Indeed[A, B](h: A, t: B) extends AndMaybe[A, B] with Product with Serializable
final case class Inserted[T[_[_]], F[_], A](right: F[A]) extends Diff[T, F, A] with Product with Serializable
sealed abstract class ListF[A, B] extends AnyRef
final case class LocallyDifferent[T[_[_]], F[_], A](left: F[A], right: F[slamdata.Predef.Unit]) extends Diff[T, F, A] with Product with Serializable
final case class NilF[A, B]() extends ListF[A, B] with Product with Serializable
final case class Only[A, B](a: A) extends AndMaybe[A, B] with Product with Serializable
final case class PartialFailure[T[_[_]], F[_], E, A] extends PotentialFailure[T, F, E, A] with Product with Serializable

Akin to Free.roll
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.
type PotentialFailureT[T[_[_]], F[_], E] = T[[δ$1$]PotentialFailure[T, F, E, δ$1$]]
final case class Removed[T[_[_]], F[_], A](left: T[F]) extends Diff[T, F, A] with Product with Serializable
final case class Same[T[_[_]], F[_], A](ident: T[F]) extends Diff[T, F, A] with Product with Serializable
final case class Similar[T[_[_]], F[_], A](ident: F[A]) extends Diff[T, F, A] with Product with Serializable
final case class Success[T[_[_]], F[_], E, A] extends PotentialFailure[T, F, E, A] with Product with Serializable

Value Members

object AndMaybe extends AndMaybeInstances
object CoEnv extends CoEnvInstances with Serializable
object Diff extends DiffInstances
object Diffable extends Serializable
object EnvT extends EnvTInstances with EnvTFunctions with Serializable
object ListF
object PotentialFailure
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]
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]
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).
def interpretM[M[_], F[_], A, B](f: (A) ⇒ M[B], φ: AlgebraM[M, F, B]): AlgebraM[M, [γ$6$]CoEnv[A, F, γ$6$], B]
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.

package patterns

Type Members

final case class Added[T[_[_]], F[_], A](right: T[F]) extends Diff[T, F, A] with Product with Serializable

sealed abstract class AndMaybe[A, B] extends AnyRef

sealed abstract class AndMaybeInstances extends AnyRef

final case class CoEnv[E, F[_], A](run: \/[E, F[A]]) extends Product with Serializable

sealed abstract class CoEnvInstances extends CoEnvInstances0

sealed abstract class CoEnvInstances0 extends AnyRef

final case class ConsF[A, B](car: A, cdr: B) extends ListF[A, B] with Product with Serializable

final case class Deleted[T[_[_]], F[_], A](left: F[A]) extends Diff[T, F, A] with Product with Serializable

sealed abstract class Diff[T[_[_]], F[_], A] extends AnyRef

sealed abstract class DiffInstances extends DiffInstances0

sealed abstract class DiffInstances0 extends AnyRef

type DiffT[T[_[_]], F[_]] = T[[γ$0$]Diff[T, F, γ$0$]]

trait Diffable[F[_]] extends Serializable

final case class Different[T[_[_]], F[_], A](left: T[F], right: T[F]) extends Diff[T, F, A] with Product with Serializable

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 EnvTInstances1

sealed abstract class EnvTInstances1 extends AnyRef

final case class Failure[T[_[_]], F[_], E, A] extends PotentialFailure[T, F, E, A] with Product with Serializable

final case class Indeed[A, B](h: A, t: B) extends AndMaybe[A, B] with Product with Serializable

final case class Inserted[T[_[_]], F[_], A](right: F[A]) extends Diff[T, F, A] with Product with Serializable

sealed abstract class ListF[A, B] extends AnyRef

final case class LocallyDifferent[T[_[_]], F[_], A](left: F[A], right: F[slamdata.Predef.Unit]) extends Diff[T, F, A] with Product with Serializable

final case class NilF[A, B]() extends ListF[A, B] with Product with Serializable

final case class Only[A, B](a: A) extends AndMaybe[A, B] with Product with Serializable

final case class PartialFailure[T[_[_]], F[_], E, A] extends PotentialFailure[T, F, E, A] with Product with Serializable

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

type PotentialFailureT[T[_[_]], F[_], E] = T[[δ$1$]PotentialFailure[T, F, E, δ$1$]]

final case class Removed[T[_[_]], F[_], A](left: T[F]) extends Diff[T, F, A] with Product with Serializable

final case class Same[T[_[_]], F[_], A](ident: T[F]) extends Diff[T, F, A] with Product with Serializable

final case class Similar[T[_[_]], F[_], A](ident: F[A]) extends Diff[T, F, A] with Product with Serializable

final case class Success[T[_[_]], F[_], E, A] extends PotentialFailure[T, F, E, A] with Product with Serializable

Value Members

object AndMaybe extends AndMaybeInstances

object CoEnv extends CoEnvInstances with Serializable

object Diff extends DiffInstances

object Diffable extends Serializable

object EnvT extends EnvTInstances with EnvTFunctions with Serializable

object ListF

object PotentialFailure

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]

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]

def interpret[F[_], A, B](f: (A) ⇒ B, φ: Algebra[F, B]): Algebra[[γ$5$]CoEnv[A, F, γ$5$], B]

def interpretM[M[_], F[_], A, B](f: (A) ⇒ M[B], φ: AlgebraM[M, F, B]): AlgebraM[M, [γ$6$]CoEnv[A, F, γ$6$], B]

def recover[F[_], A](φ: Algebra[F, A]): Algebra[[γ$8$]CoEnv[A, F, γ$8$], A]

Inherited from AnyRef

Inherited from Any

Ungrouped