LogicalPlan

Type Members

final case class ConstantF[A](data: Data) extends LogicalPlan[A] with Product with Serializable
final case class ConstrainedPlan(inferred: Type, constraints: Predef.List[NamedConstraint], plan: Fix[LogicalPlan]) extends Product with Serializable
final case class FreeF[A](name: Predef.Symbol) extends LogicalPlan[A] with Product with Serializable
final case class InvokeF[A, N <: Nat](func: GenericFunc[N], values: Input[A, N]) extends LogicalPlan[A] with Product with Serializable
final case class LetF[A](let: Predef.Symbol, form: A, in: A) extends LogicalPlan[A] with Product with Serializable
final case class NamedConstraint(name: Predef.Symbol, inferred: Type, term: Fix[LogicalPlan]) extends Product with Serializable
final case class ReadF[A](path: FPath) extends LogicalPlan[A] with Product with Serializable
type SemDisj[A] = \/[NonEmptyList[SemanticError], A]
type SemNames[A] = IndexedStateT[SemDisj, NameGen, NameGen, A]
type SemValidation[A] = Validation[NonEmptyList[SemanticError], A]
final case class TypecheckF[A](expr: A, typ: Type, cont: A, fallback: A) extends LogicalPlan[A] with Product with Serializable
type Typed[F[_]] = Cofree[F, Type]

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object Constant
implicit val EqualFLogicalPlan: EqualF[LogicalPlan]
object Free
object Invoke
object InvokeFUnapply
object Let
implicit val LogicalPlanBinder: Binder[LogicalPlan]
implicit val LogicalPlanTraverse: Traverse[LogicalPlan]
implicit val LogicalPlanUnzip: Unzip[LogicalPlan]
object Read
implicit val RenderTreeLogicalPlan: Delay[RenderTree, LogicalPlan]
object Typecheck
final def asInstanceOf[T0]: T0

Definition Classes
Any
val checkTypesƒ: ((Type, LogicalPlan[ConstrainedPlan])) ⇒ NameT[SemDisj, ConstrainedPlan]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def ensureCorrectTypes(term: Fix[LogicalPlan]): ValidationNel[SemanticError, Fix[LogicalPlan]]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def freshName(prefix: Predef.String): State[NameGen, Predef.Symbol]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def inferTypes(typ: Type, term: Fix[LogicalPlan]): SemValidation[Typed[LogicalPlan]]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def lpParaZygoHisto[A, B]: (Fix[LogicalPlan]) ⇒ ((LogicalPlan[(Fix[LogicalPlan], B)]) ⇒ B, (LogicalPlan[Cofree[LogicalPlan, (B, A)]]) ⇒ scalaz.Scalaz.Id[A]) ⇒ scalaz.Scalaz.Id[A]
def lpParaZygoHistoM[M[_], A, B](t: Fix[LogicalPlan])(f: (LogicalPlan[(Fix[LogicalPlan], B)]) ⇒ B, g: (LogicalPlan[Cofree[LogicalPlan, (B, A)]]) ⇒ M[A])(implicit arg0: Monad[M]): M[A]
def lpParaZygoHistoS[S, A, B]: (Fix[LogicalPlan]) ⇒ ((LogicalPlan[(Fix[LogicalPlan], B)]) ⇒ B, (LogicalPlan[Cofree[LogicalPlan, (B, A)]]) ⇒ IndexedStateT[[+X]X, S, S, A]) ⇒ IndexedStateT[[+X]X, S, S, A]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def normalizeLets(t: Fix[LogicalPlan]): Fix[LogicalPlan]
val normalizeLetsƒ: (LogicalPlan[Fix[LogicalPlan]]) ⇒ Predef.Option[LogicalPlan[Fix[LogicalPlan]]]

Per the following: 1.
Per the following: 1. Successive Lets are re-associated to the right: (let a = (let b = x1 in x2) in x3) becomes (let b = x1 in (let a = x2 in x3)) 2. Lets are "hoisted" outside of Invoke and Typecheck nodes: (add (let a = x1 in x2) (let b = x3 in x4)) becomes (let a = x1 in (let b = x3 in (add x2 x4)) Note that this is safe only if all bound names are unique; otherwise it could create spurious shadowing. normalizeTempNames is recommended. NB: at the moment, Lets are only hoisted one level.
def normalizeTempNames(t: Fix[LogicalPlan]): Fix[LogicalPlan]
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def paths(lp: Fix[LogicalPlan]): Predef.Set[FPath]

The set of paths referenced in the given plan.
def rename[M[_]](f: (Predef.Symbol) ⇒ M[Predef.Symbol])(t: Fix[LogicalPlan])(implicit arg0: Monad[M]): M[Fix[LogicalPlan]]
def renameƒ[M[_]](f: (Predef.Symbol) ⇒ M[Predef.Symbol])(implicit arg0: Monad[M]): ((Predef.Map[Predef.Symbol, Predef.Symbol], Fix[LogicalPlan])) ⇒ M[LogicalPlan[(Predef.Map[Predef.Symbol, Predef.Symbol], Fix[LogicalPlan])]]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: trait LogicalPlan | package quasar

object LogicalPlan extends Serializable

Type Members

final case class ConstantF[A](data: Data) extends LogicalPlan[A] with Product with Serializable

final case class ConstrainedPlan(inferred: Type, constraints: Predef.List[NamedConstraint], plan: Fix[LogicalPlan]) extends Product with Serializable

final case class FreeF[A](name: Predef.Symbol) extends LogicalPlan[A] with Product with Serializable

final case class InvokeF[A, N <: Nat](func: GenericFunc[N], values: Input[A, N]) extends LogicalPlan[A] with Product with Serializable

final case class LetF[A](let: Predef.Symbol, form: A, in: A) extends LogicalPlan[A] with Product with Serializable

final case class NamedConstraint(name: Predef.Symbol, inferred: Type, term: Fix[LogicalPlan]) extends Product with Serializable

final case class ReadF[A](path: FPath) extends LogicalPlan[A] with Product with Serializable

type SemDisj[A] = \/[NonEmptyList[SemanticError], A]

type SemNames[A] = IndexedStateT[SemDisj, NameGen, NameGen, A]

type SemValidation[A] = Validation[NonEmptyList[SemanticError], A]

final case class TypecheckF[A](expr: A, typ: Type, cont: A, fallback: A) extends LogicalPlan[A] with Product with Serializable

type Typed[F[_]] = Cofree[F, Type]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Constant

implicit val EqualFLogicalPlan: EqualF[LogicalPlan]

object Free

object Invoke

object InvokeFUnapply

object Let

implicit val LogicalPlanBinder: Binder[LogicalPlan]

implicit val LogicalPlanTraverse: Traverse[LogicalPlan]

implicit val LogicalPlanUnzip: Unzip[LogicalPlan]

object Read

implicit val RenderTreeLogicalPlan: Delay[RenderTree, LogicalPlan]

object Typecheck

final def asInstanceOf[T0]: T0

val checkTypesƒ: ((Type, LogicalPlan[ConstrainedPlan])) ⇒ NameT[SemDisj, ConstrainedPlan]

def clone(): AnyRef

def ensureCorrectTypes(term: Fix[LogicalPlan]): ValidationNel[SemanticError, Fix[LogicalPlan]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def freshName(prefix: Predef.String): State[NameGen, Predef.Symbol]

final def getClass(): Class[_]

def hashCode(): Int

def inferTypes(typ: Type, term: Fix[LogicalPlan]): SemValidation[Typed[LogicalPlan]]

final def isInstanceOf[T0]: Boolean

def lpParaZygoHisto[A, B]: (Fix[LogicalPlan]) ⇒ ((LogicalPlan[(Fix[LogicalPlan], B)]) ⇒ B, (LogicalPlan[Cofree[LogicalPlan, (B, A)]]) ⇒ scalaz.Scalaz.Id[A]) ⇒ scalaz.Scalaz.Id[A]

def lpParaZygoHistoM[M[_], A, B](t: Fix[LogicalPlan])(f: (LogicalPlan[(Fix[LogicalPlan], B)]) ⇒ B, g: (LogicalPlan[Cofree[LogicalPlan, (B, A)]]) ⇒ M[A])(implicit arg0: Monad[M]): M[A]

def lpParaZygoHistoS[S, A, B]: (Fix[LogicalPlan]) ⇒ ((LogicalPlan[(Fix[LogicalPlan], B)]) ⇒ B, (LogicalPlan[Cofree[LogicalPlan, (B, A)]]) ⇒ IndexedStateT[[+X]X, S, S, A]) ⇒ IndexedStateT[[+X]X, S, S, A]

final def ne(arg0: AnyRef): Boolean

def normalizeLets(t: Fix[LogicalPlan]): Fix[LogicalPlan]

val normalizeLetsƒ: (LogicalPlan[Fix[LogicalPlan]]) ⇒ Predef.Option[LogicalPlan[Fix[LogicalPlan]]]

def normalizeTempNames(t: Fix[LogicalPlan]): Fix[LogicalPlan]

final def notify(): Unit

final def notifyAll(): Unit

def paths(lp: Fix[LogicalPlan]): Predef.Set[FPath]

def rename[M[_]](f: (Predef.Symbol) ⇒ M[Predef.Symbol])(t: Fix[LogicalPlan])(implicit arg0: Monad[M]): M[Fix[LogicalPlan]]

def renameƒ[M[_]](f: (Predef.Symbol) ⇒ M[Predef.Symbol])(implicit arg0: Monad[M]): ((Predef.Map[Predef.Symbol, Predef.Symbol], Fix[LogicalPlan])) ⇒ M[LogicalPlan[(Predef.Map[Predef.Symbol, Predef.Symbol], Fix[LogicalPlan])]]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped