LogicalPlanR

Instance Constructors

new LogicalPlanR()(implicit TR: Aux[T, LogicalPlan], TC: Aux[T, LogicalPlan])

Type Members

type SemDisj[A] = \/[NonEmptyList[SemanticError], A]
type SemNames[A] = IndexedStateT[SemDisj, NameGen, NameGen, A]
type SemValidation[A] = Validation[NonEmptyList[SemanticError], A]
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
def absolutePaths(lp: T): ISet[APath]

The set of absolute paths referenced in the given plan.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bindFree(vars: slamdata.Predef.Map[CIName, T])(t: T): T
val checkTypesƒ: ((Type, LogicalPlan[ConstrainedPlan[T]])) ⇒ NameT[SemDisj, ConstrainedPlan[T]]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def constant(data: Data): T
def constrain(inf: Type, poss: Type): slamdata.Predef.Option[Type]
def ensureCorrectTypes(term: T): ValidationNel[SemanticError, T]
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 free(name: Symbol): T
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def inferTypes(typ: Type, term: T): SemValidation[Typed[LogicalPlan]]

Annotations
@SuppressWarnings()
def invoke[N <: Nat](func: GenericFunc[N], values: Input[T, N]): T
def invoke1(func: GenericFunc[shapeless.Nat._1], v1: T): T
def invoke2(func: GenericFunc[shapeless.Nat._2], v1: T, v2: T): T
def invoke3(func: GenericFunc[shapeless.Nat._3], v1: T, v2: T, v3: T): T
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def join(left: T, right: T, tpe: JoinType, cond: JoinCondition[T]): T
def joinSideName(name: Symbol): T
def let(name: Symbol, form: T, in: T): T
def lpParaZygoHisto[A, B]: (T) ⇒ ((LogicalPlan[(T, B)]) ⇒ B, (LogicalPlan[Cofree[LogicalPlan, (B, A)]]) ⇒ scalaz.Scalaz.Id[A]) ⇒ scalaz.Scalaz.Id[A]
def lpParaZygoHistoM[M[_], A, B](t: T)(f: (LogicalPlan[(T, B)]) ⇒ B, g: (LogicalPlan[Cofree[LogicalPlan, (B, A)]]) ⇒ M[A])(implicit arg0: Monad[M]): M[A]
def lpParaZygoHistoS[S, A, B]: (T) ⇒ ((LogicalPlan[(T, 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: T): T
val normalizeLetsƒ: (LogicalPlan[T]) ⇒ slamdata.Predef.Option[LogicalPlan[T]]

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: T): T
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def paths(lp: T): ISet[FPath]

The set of paths referenced in the given plan.
def read(path: FPath): T
def rename[M[_]](f: (Symbol) ⇒ M[Symbol])(t: T)(implicit arg0: Monad[M]): M[T]
def renameƒ[M[_]](f: (Symbol) ⇒ M[Symbol])(implicit arg0: Monad[M]): CoalgebraM[M, LogicalPlan, (slamdata.Predef.Map[Symbol, Symbol], T)]
def sort(src: T, order: NonEmptyList[(T, SortDir)]): T
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def temporalTrunc(part: TemporalPart, src: T): T
def toString(): String

Definition Classes
AnyRef → Any
def typecheck(expr: T, typ: Type, cont: T, fallback: T): T
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 Doc: package logicalplan

final class LogicalPlanR[T] extends AnyRef

Instance Constructors

new LogicalPlanR()(implicit TR: Aux[T, LogicalPlan], TC: Aux[T, LogicalPlan])

Type Members

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

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

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

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

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def absolutePaths(lp: T): ISet[APath]

final def asInstanceOf[T0]: T0

def bindFree(vars: slamdata.Predef.Map[CIName, T])(t: T): T

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

def clone(): AnyRef

def constant(data: Data): T

def constrain(inf: Type, poss: Type): slamdata.Predef.Option[Type]

def ensureCorrectTypes(term: T): ValidationNel[SemanticError, T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def free(name: Symbol): T

final def getClass(): Class[_]

def hashCode(): Int

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

def invoke[N <: Nat](func: GenericFunc[N], values: Input[T, N]): T

def invoke1(func: GenericFunc[shapeless.Nat._1], v1: T): T

def invoke2(func: GenericFunc[shapeless.Nat._2], v1: T, v2: T): T

def invoke3(func: GenericFunc[shapeless.Nat._3], v1: T, v2: T, v3: T): T

final def isInstanceOf[T0]: Boolean

def join(left: T, right: T, tpe: JoinType, cond: JoinCondition[T]): T

def joinSideName(name: Symbol): T

def let(name: Symbol, form: T, in: T): T

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

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

def lpParaZygoHistoS[S, A, B]: (T) ⇒ ((LogicalPlan[(T, 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: T): T

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

def normalizeTempNames(t: T): T

final def notify(): Unit

final def notifyAll(): Unit

def paths(lp: T): ISet[FPath]

def read(path: FPath): T

def rename[M[_]](f: (Symbol) ⇒ M[Symbol])(t: T)(implicit arg0: Monad[M]): M[T]

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

def sort(src: T, order: NonEmptyList[(T, SortDir)]): T

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

def temporalTrunc(part: TemporalPart, src: T): T

def toString(): String

def typecheck(expr: T, typ: Type, cont: T, fallback: T): T

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped