CompiledSemantics

A semantics that can interpret complicated expressions by compiling the expressions. This semantics constructs actual working scala code (see the format below).

Notice from the code that is constructed that it calls a function in com.eharmony.aloha.semantics.func.GenFunc. The function that is called is based on the input arity. Aside from the f0 function, f_i has i arguments in the first argument list and two arguments in the second argument list. The first argument list represents the definition of the accessor functions. These are the functions created to extract data from the domain object. com.eharmony.aloha.semantics.compiled.CompiledSemanticsPlugin objects are responsible for constructing the function bodies. For instance, (_:Map[String, Long]).get("user.match.TaxBrackets") in the first example. The CompiledSemantics class is responsible for wrapping this code appropriately, constructing the aggregation function and finally putting everything together and compiling it.

Examples

E.g. 1: Two variables are both optional (not necessarily in the input type passed to the model): - user.match.TaxBrackets - cand.taxBracket

val spec1 = "Seq(${user.match.TaxBrackets}) contains ${cand.taxBracket}"
val f1 = s.createFunction[Boolean](spec1, Some(false)).right.get

// Equivalent to:
//    val f1a =
//      com.eharmony.aloha.semantics.compiled.GenFunc.f2(           // f2 b/c 2 variables.
//        com.eharmony.aloha.semantics.compiled.GeneratedAccessor(  // Optional Accessor:
//          "user.match.TaxBrackets",
//          (_:Map[String, Long]).get("user.match.TaxBrackets"),             // <-- get produces Option[Long]
//          Some("(_:Map[String, Long]).get(\"user.match.TaxBrackets\")")),
//        com.eharmony.aloha.semantics.compiled.GeneratedAccessor(  // Optional Accessor:
//          "cand.taxBracket",
//          (_:Map[String, Long]).get("cand.taxBracket"),                    // <-- get produces Option[Long]
//          Some("(_:Map[String, Long]).get(\"cand.taxBracket\")"))
//      )(
//        "Seq(${user.match.TaxBrackets}) contains ${cand.taxBracket}",
//        (o0, o1) => for {
//          _user__match__TaxBrackets <- o0                                  // Optional fields in for comprehension
//          _cand__taxBracket <- o1
//        } yield {
//          Seq(_user__match__TaxBrackets) contains _cand__taxBracket        // Transformed function spec
//        }
//      )
//
//    val f1 = com.eharmony.aloha.semantics.compiled.OptionalFunc(f1a, false)

E.g. 2: Two variables (one required, one optional): - user.inboundComm (required) - user.pageViews (optional)

val spec2 = "${user.inboundComm} / ${user.pageViews}.toDouble"
val f2 = s.createFunction[Double](spec2, Some(Double.NaN)).right.get

// Equivalent to:
//    val f2a =
//      com.eharmony.aloha.semantics.compiled.GenFunc.f2(           // f2 b/c 2 variables.
//        com.eharmony.aloha.semantics.compiled.GeneratedAccessor(  // Optional Accessor:
//          "user.pageViews",
//          (_:Map[String, Long]).get("user.pageViews"),                     // <-- get produces Option[Long]
//          Some("(_:Map[String, Long]).get(\"user.pageViews\")")),
//        com.eharmony.aloha.semantics.compiled.GeneratedAccessor(  // Required Accessor:
//          "user.inboundComm",
//          (_:Map[String, Long]).apply("user.inboundComm"),                 // <-- apply produces Long
//          Some("(_:Map[String, Long]).apply(\"user.inboundComm\")"))
//      )(
//        "${user.inboundComm} / ${user.pageViews}.toDouble",
//        (o0, _user__inboundComm) => for {
//          _user__pageViews <- o0                                           // Optional field in for comprehension
//        } yield {
//          _user__inboundComm / _user__pageViews.toDouble                   // Transformed function spec
//        }
//      )
//
//    val f2 = com.eharmony.aloha.semantics.compiled.OptionalFunc(f2a, Double.NaN)

E.g. 3: Three required variables (one, two, three):

val spec3 = "List(${one}, ${two}, ${three}).sum.toInt"
val f3 = s.createFunction[Int](spec3).right.get

// Equivalent to:
//    val f3 =
//      com.eharmony.aloha.semantics.compiled.GenFunc.f3(           // f3 b/c 3 variables.
//        com.eharmony.aloha.semantics.compiled.GeneratedAccessor(
//          "one",
//          (_:Map[String, Long]).apply("one"),
//          Some("(_:Map[String, Long]).apply(\"one\")")),
//        com.eharmony.aloha.semantics.compiled.GeneratedAccessor(
//          "two",
//          (_:Map[String, Long]).apply("two"),
//          Some("(_:Map[String, Long]).apply(\"two\")")),
//        com.eharmony.aloha.semantics.compiled.GeneratedAccessor(
//          "three",
//          (_:Map[String, Long]).apply("three"),
//          Some("(_:Map[String, Long]).apply(\"three\")"))
//      )(
//        "List(${one}, ${two}, ${three}).sum.toInt",
//        (_one, _two, _three) => {                  // Notice simplified expression when all params are required.
//          List(_one, _two, _three).sum.toInt       // Variable names are in the param list so no need for temp
//        }                                          // variables.
//      )

E.g. 4: Invariant function (not dependent on any input variables).

val spec4 = "new util.Random(System.nanoTime).nextLong"
val f = s.createFunction[Long](spec4).right.get         // f(null) is OK b/c not reliant on input value.

// Equivalent to:
//    val f4 =
//      com.eharmony.aloha.semantics.compiled.GenFunc.f0( // f0 b/c input arity is 0
//        "new util.Random(System.nanoTime).nextLong",
//        (_:Any) => new util.Random(System.nanoTime).nextLong     // Notice input is Any
//      )                                                          // OK b/c of Function1 1st arg contravariance.

A: the input type to the functions that are to be generated. Said another way, this is domain type of the models that will be generated by the ModelFactory to which this com.eharmony.aloha.semantics.Semantics will be passed.
compiler: a compiler capable of compiling real scala code and generating real instances that work at full speed.
plugin: a plugin that can make sense of the variable specifications and generate code to extract data from them.
imports: a list of imports.
provideSemanticsUdfException: whether we should provide com.eharmony.aloha.semantics.SemanticsUdfException instead of raw exceptions in the case that a feature produces an exception. The perceived benefit of this seems to drastically outweigh the performance hit, so this defaults to true (as this is suggested).
ec: an execution context in which to run the Futures that are used in the cache.

Linear Supertypes

Serializable, Serializable, Product, Equals, ErrorEnrichingSemantics[A], MorphableSemantics[CompiledSemantics, A], CompiledSemanticsLike[A], Logging, EitherHelpers, Semantics[A], Closeable, AutoCloseable, AnyRef, Any

Instance Constructors

new CompiledSemantics(compiler: ContainerReadable[Try], plugin: CompiledSemanticsPlugin[A], imports: Array[String], ec: ExecutionContext)

A java (Spring) friendly constructor.
A java (Spring) friendly constructor.
compiler
a compiler capable of compiling real scala code and generating real instances that work at full speed.
plugin
a plugin that can make sense of the variable specifications and generate code to extract data from them.
imports
an array of imports. Will be cloned before being stored to avoid caller changing array values.
ec
an execution context in which to run the Futures that are used in the cache.
new CompiledSemantics(compiler: ContainerReadable[Try], plugin: CompiledSemanticsPlugin[A], imports: Array[String], provideSemanticsUdfException: Boolean, ec: ExecutionContext)

A java (Spring) friendly constructor.
A java (Spring) friendly constructor.
compiler
a compiler capable of compiling real scala code and generating real instances that work at full speed.
plugin
a plugin that can make sense of the variable specifications and generate code to extract data from them.
imports
an array of imports. Will be cloned before being stored to avoid caller changing array values.
provideSemanticsUdfException
whether we should provide com.eharmony.aloha.semantics.SemanticsUdfException instead of raw exceptions in the case that a feature produces an exception. The perceived benefit of this seems to drastically outweigh the performance hit, so this defaults to true (as this is suggested).
ec
an execution context in which to run the Futures that are used in the cache.
new CompiledSemantics(compiler: ContainerReadable[Try], plugin: CompiledSemanticsPlugin[A], imports: Seq[String], provideSemanticsUdfException: Boolean = true)(implicit ec: ExecutionContext)

compiler
a compiler capable of compiling real scala code and generating real instances that work at full speed.
plugin
a plugin that can make sense of the variable specifications and generate code to extract data from them.
imports
a list of imports.
provideSemanticsUdfException
whether we should provide com.eharmony.aloha.semantics.SemanticsUdfException instead of raw exceptions in the case that a feature produces an exception. The perceived benefit of this seems to drastically outweigh the performance hit, so this defaults to true (as this is suggested).
ec
an execution context in which to run the Futures that are used in the cache.

Type Members

type ENS[+A] = Either[Seq[String], A]

Either of Non-empty Seq (Like poor man's version of ValidationNel from scalaz)
Either of Non-empty Seq (Like poor man's version of ValidationNel from scalaz)

Attributes
protected[this]
Definition Classes
EitherHelpers

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 accessorFunctionNames: Nothing

Returns the string representations of all of the data "variables" used by functions created from this Semantics object.
Returns the string representations of all of the data "variables" used by functions created from this Semantics object.

Definition Classes
CompiledSemanticsLike → Semantics
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def close(): Unit

Definition Classes
CompiledSemanticsLike → Closeable → AutoCloseable
val compiler: ContainerReadable[Try]

a compiler capable of compiling real scala code and generating real instances that work at full speed.
a compiler capable of compiling real scala code and generating real instances that work at full speed.

Definition Classes
CompiledSemantics → CompiledSemanticsLike
def createFunction[B](codeSpec: String, default: Option[B] = None)(implicit arg0: RefInfo[B]): Either[Seq[String], GenAggFunc[A, B]]

Create a function from A to B.
Create a function from A to B. If provideSemanticsUdfException is false or the generated function is is com.eharmony.aloha.semantics.func.EnrichedErrorGenAggFunc return the function; otherwise, return the function wrapped in an com.eharmony.aloha.semantics.func.EnrichedErrorGenAggFunc. com.eharmony.aloha.semantics.func.GenAggFunc produced by the underlying semantics.
B
The return type of the function.
codeSpec
specification for a function to be produced by this semantics.
default
a default value in the case that the function would produce an optional type.

Definition Classes
ErrorEnrichingSemantics → Semantics
final def debug(msg: ⇒ Any, t: ⇒ Throwable): Unit

Issue a debug logging message, with an exception.
Issue a debug logging message, with an exception.
msg
the message object. toString() is called to convert it to a loggable string.
t
the exception to include with the logged message.

Attributes
protected[this]
Definition Classes
Logging
final def debug(msg: ⇒ Any): Unit

Issue a debug logging message.
Issue a debug logging message.
msg
the message object. toString() is called to convert it to a loggable string.

Attributes
protected[this]
Definition Classes
Logging
implicit val ec: ExecutionContext

an execution context in which to run the Futures that are used in the cache.
an execution context in which to run the Futures that are used in the cache.

Attributes
protected
Definition Classes
CompiledSemantics → CompiledSemanticsLike
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def error(msg: ⇒ Any, t: ⇒ Throwable): Unit

Issue a error logging message, with an exception.
Issue a error logging message, with an exception.
msg
the message object. toString() is called to convert it to a loggable string.
t
the exception to include with the logged message.

Attributes
protected[this]
Definition Classes
Logging
final def error(msg: ⇒ Any): Unit

Issue a error logging message.
Issue a error logging message.
msg
the message object. toString() is called to convert it to a loggable string.

Attributes
protected[this]
Definition Classes
Logging
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def fromValidationNel[A](v: ValidationNel[String, A]): ENS[A]

Attributes
protected[this]
Definition Classes
EitherHelpers
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
val imports: Seq[String]

a list of imports.
a list of imports.

Definition Classes
CompiledSemantics → CompiledSemanticsLike
final def info(msg: ⇒ Any, t: ⇒ Throwable): Unit

Issue a info logging message, with an exception.
Issue a info logging message, with an exception.
msg
the message object. toString() is called to convert it to a loggable string.
t
the exception to include with the logged message.

Attributes
protected[this]
Definition Classes
Logging
final def info(msg: ⇒ Any): Unit

Issue a info logging message.
Issue a info logging message.
msg
the message object. toString() is called to convert it to a loggable string.

Attributes
protected[this]
Definition Classes
Logging
final def isDebugEnabled: Boolean

Determine whether debug logging is enabled.
Determine whether debug logging is enabled.

Attributes
protected[this]
Definition Classes
Logging
final def isErrorEnabled: Boolean

Determine whether error logging is enabled.
Determine whether error logging is enabled.

Attributes
protected[this]
Definition Classes
Logging
final def isInfoEnabled: Boolean

Determine whether info logging is enabled.
Determine whether info logging is enabled.

Attributes
protected[this]
Definition Classes
Logging
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isTraceEnabled: Boolean

Determine whether trace logging is enabled.
Determine whether trace logging is enabled.

Attributes
protected[this]
Definition Classes
Logging
final def isWarnEnabled: Boolean

Determine whether warn logging is enabled.
Determine whether warn logging is enabled.

Attributes
protected[this]
Definition Classes
Logging
final lazy val logger: Logger

The logger is a @transient lazy val to enable proper working with Spark.
The logger is a @transient lazy val to enable proper working with Spark. The logger will not be serialized with the rest of the class with which this trait is mixed-in.

Attributes
protected[this]
Definition Classes
Logging
def loggerInitName(): String

The name with which the logger is initialized.
The name with which the logger is initialized. This can be overridden in a derived class.

Attributes
protected
Definition Classes
Logging
final def loggerName: String

Get the name associated with this logger.
Get the name associated with this logger.
returns
the name.

Attributes
protected[this]
Definition Classes
Logging
def mapSeq[A, B](l: Seq[A])(f: (A) ⇒ ENS[B]): ENS[Seq[B]]

Like l.map(f).sequence[({type L[+A] = Either[Seq[String], A]})#L, C ] in scalaz except that it short circuits if it finds an error.
Like l.map(f).sequence[({type L[+A] = Either[Seq[String], A]})#L, C ] in scalaz except that it short circuits if it finds an error. (There must be some better way to do this w/ scalaz).
If we put a println("folding") at the top of the inner function h, we would get the following:
```
scala> mapSeq(Left(Seq("1")) +: (2 to 3).map(Right(_)))(identity)  // Only 1 "folding" instead of 3.
folding
res0: ENS[Seq[Int]] = Left(List(0))

scala> mapSeq((1 to 3).map(Right(_)))(identity)
folding
folding
folding
res1: ENS[Seq[Int]] = Right(List(1, 2, 3))
```
A
type of values in the input sequence in the first parameter list.
B
type of values in the output sequence if successful.
l
list of values to which f should be applied.
f
function to map over l

Attributes
protected[this]
Definition Classes
EitherHelpers
def morph[B](implicit ri: RefInfo[B]): Option[CompiledSemantics[B]]

Attempt to create a new CompiledSemantics with a different type parameter.
Attempt to create a new CompiledSemantics with a different type parameter.
B
input type for the new MorphableSemantics instance that might be created. A MorphableSemantics instance may choose not allow morphing to all B. In that case, a None will be returned.
ri
reflection information that may be necessary to determine whether to create the MorphableSemantics that was requested.

Definition Classes
CompiledSemantics → MorphableSemantics
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val plugin: CompiledSemanticsPlugin[A]

a plugin that can make sense of the variable specifications and generate code to extract data from them.
a plugin that can make sense of the variable specifications and generate code to extract data from them.

Definition Classes
CompiledSemantics → CompiledSemanticsLike
val provideSemanticsUdfException: Boolean

whether we should provide com.eharmony.aloha.semantics.SemanticsUdfException instead of raw exceptions in the case that a feature produces an exception.
whether we should provide com.eharmony.aloha.semantics.SemanticsUdfException instead of raw exceptions in the case that a feature produces an exception. The perceived benefit of this seems to drastically outweigh the performance hit, so this defaults to true (as this is suggested).

Definition Classes
CompiledSemantics → ErrorEnrichingSemantics
def refInfoA: RefInfo[A]

returns
a com.eharmony.aloha.reflect.RefInfo for input type A.

Definition Classes
CompiledSemanticsLike → Semantics
def retainGeneratedCode(): Boolean

Generated code will only be retained in the Generated code when debug logging is enabled.
Generated code will only be retained in the Generated code when debug logging is enabled.

Definition Classes
CompiledSemantics → CompiledSemanticsLike
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toValidationNel[A](e: ENS[A]): ValidationNel[String, A]

Attributes
protected[this]
Definition Classes
EitherHelpers
final def trace(msg: ⇒ Any, t: ⇒ Throwable): Unit

Issue a trace logging message, with an exception.
Issue a trace logging message, with an exception.
msg
the message object. toString() is called to convert it to a loggable string.
t
the exception to include with the logged message.

Attributes
protected[this]
Definition Classes
Logging
final def trace(msg: ⇒ Any): Unit

Issue a trace logging message.
Issue a trace logging message.
msg
the message object. toString() is called to convert it to a loggable string.

Attributes
protected[this]
Definition Classes
Logging
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( ... )
final def warn(msg: ⇒ Any, t: ⇒ Throwable): Unit

Issue a warn logging message, with an exception.
Issue a warn logging message, with an exception.
msg
the message object. toString() is called to convert it to a loggable string.
t
the exception to include with the logged message.

Attributes
protected[this]
Definition Classes
Logging
final def warn(msg: ⇒ Any): Unit

Issue a warn logging message.
Issue a warn logging message.
msg
the message object. toString() is called to convert it to a loggable string.

Attributes
protected[this]
Definition Classes
Logging

Related Docs: object CompiledSemantics | package compiled

Examples

Instance Constructors

new CompiledSemantics(compiler: ContainerReadable[Try], plugin: CompiledSemanticsPlugin[A], imports: Array[String], ec: ExecutionContext)

new CompiledSemantics(compiler: ContainerReadable[Try], plugin: CompiledSemanticsPlugin[A], imports: Array[String], provideSemanticsUdfException: Boolean, ec: ExecutionContext)

new CompiledSemantics(compiler: ContainerReadable[Try], plugin: CompiledSemanticsPlugin[A], imports: Seq[String], provideSemanticsUdfException: Boolean = true)(implicit ec: ExecutionContext)

Type Members

type ENS[+A] = Either[Seq[String], A]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def accessorFunctionNames: Nothing

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def close(): Unit

val compiler: ContainerReadable[Try]

def createFunction[B](codeSpec: String, default: Option[B] = None)(implicit arg0: RefInfo[B]): Either[Seq[String], GenAggFunc[A, B]]

final def debug(msg: ⇒ Any, t: ⇒ Throwable): Unit

final def debug(msg: ⇒ Any): Unit

implicit val ec: ExecutionContext

final def eq(arg0: AnyRef): Boolean

final def error(msg: ⇒ Any, t: ⇒ Throwable): Unit

final def error(msg: ⇒ Any): Unit

def finalize(): Unit

def fromValidationNel[A](v: ValidationNel[String, A]): ENS[A]

final def getClass(): Class[_]

val imports: Seq[String]

final def info(msg: ⇒ Any, t: ⇒ Throwable): Unit

final def info(msg: ⇒ Any): Unit

final def isDebugEnabled: Boolean

final def isErrorEnabled: Boolean

final def isInfoEnabled: Boolean

final def isInstanceOf[T0]: Boolean

final def isTraceEnabled: Boolean

final def isWarnEnabled: Boolean

final lazy val logger: Logger

def loggerInitName(): String

final def loggerName: String

def mapSeq[A, B](l: Seq[A])(f: (A) ⇒ ENS[B]): ENS[Seq[B]]

def morph[B](implicit ri: RefInfo[B]): Option[CompiledSemantics[B]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val plugin: CompiledSemanticsPlugin[A]

val provideSemanticsUdfException: Boolean

def refInfoA: RefInfo[A]

def retainGeneratedCode(): Boolean

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

def toValidationNel[A](e: ENS[A]): ValidationNel[String, A]

final def trace(msg: ⇒ Any, t: ⇒ Throwable): Unit

final def trace(msg: ⇒ Any): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def warn(msg: ⇒ Any, t: ⇒ Throwable): Unit

final def warn(msg: ⇒ Any): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from ErrorEnrichingSemantics[A]

Inherited from MorphableSemantics[CompiledSemantics, A]

Inherited from CompiledSemanticsLike[A]

Inherited from Logging

Inherited from EitherHelpers

Inherited from Semantics[A]

Inherited from Closeable

Inherited from AutoCloseable

Inherited from AnyRef

Inherited from Any

Ungrouped