trait InputMolecule_3[I1, I2, I3] extends InputMolecule
Shared interfaces of input molecules awaiting 3 inputs.
// Sample data set Person.name.profession.age.score insert List( ("Ann", "doctor", 37, 1.0), ("Ben", "teacher", 37, 1.0), ("Joe", "teacher", 32, 1.0), ("Liz", "teacher", 28, 2.0) ) // Input molecule awaiting 3 inputs for `profession`, `age` and `score` val profAgeScore = m(Person.name.profession_(?).age_(?).score_(?)) // A. Triples of input ................................. // One triple as params profAgeScore.apply("doctor", 37, 1.0).get === List("Ann") // One or more triples profAgeScore.apply(("doctor", 37, 1.0)).get === List("Ann") profAgeScore.apply(("doctor", 37, 1.0), ("teacher", 37, 1.0)).get.sorted === List("Ann", "Ben") // One or more logical triples // [triple-expression] or [triple-expression] or ... profAgeScore.apply(("doctor" and 37 and 1.0) or ("teacher" and 32 and 1.0)).get.sorted === List("Ann", "Joe") // List of triples profAgeScore.apply(Seq(("doctor", 37, 1.0))).get === List("Ann") profAgeScore.apply(Seq(("doctor", 37, 1.0), ("teacher", 37, 1.0))).get.sorted === List("Ann", "Ben") // B. 3 groups of input, one for each input attribute ................................. // Three expressions // [profession-expression] and [age-expression] and [score-expression] profAgeScore.apply("doctor" and 37 and 1.0).get === List("Ann") profAgeScore.apply(("doctor" or "teacher") and 37 and 1.0).get.sorted === List("Ann", "Ben") profAgeScore.apply(("doctor" or "teacher") and (37 or 32) and 1.0).get.sorted === List("Ann", "Ben", "Joe") profAgeScore.apply(("doctor" or "teacher") and (37 or 32) and (1.0 or 2.0)).get.sorted === List("Ann", "Ben", "Joe") // Three lists profAgeScore.apply(Seq("doctor"), Seq(37), Seq(1.0)).get === List("Ann") profAgeScore.apply(Seq("doctor", "teacher"), Seq(37), Seq(1.0)).get.sorted === List("Ann", "Ben")
- I1
Type of input matching first attribute with
?
marker (profession: String)- I2
Type of input matching second attribute with
?
marker (age: Int)- I3
Type of input matching third attribute with
?
marker (score: Double)
- Source
- InputMolecule_3.scala
- See also
- Grouped
- Alphabetic
- By Inheritance
- InputMolecule_3
- InputMolecule
- MoleculeBase
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Abstract Value Members
-
abstract
val
_model: Model
Internal Model representation of molecule.
Internal Model representation of molecule.
Molecule transforms custom boilerplate DSL constructs to Datomic queries in 3 steps:
Custom DSL molecule --> Model --> Query --> Datomic query string- Definition Classes
- MoleculeBase
-
abstract
val
_nestedQuery: Option[Query]
Internal optional Query representation of nested molecule with added entity search for each level.
Internal optional Query representation of nested molecule with added entity search for each level.
Molecule transforms custom boilerplate DSL constructs to Datomic queries in 3 steps:
Custom DSL molecule --> Model --> Query --> Datomic query string- Definition Classes
- MoleculeBase
-
abstract
val
_query: Query
Internal Query representation of molecule.
Internal Query representation of molecule.
Molecule transforms custom boilerplate DSL constructs to Datomic queries in 3 steps:
Custom DSL molecule --> Model --> Query --> Datomic query string- Definition Classes
- MoleculeBase
-
abstract
def
apply(in1: Seq[I1], in2: Seq[I2], in3: Seq[I3])(implicit conn: Conn): MoleculeBase
Resolve input molecule by applying 3 groups of values, one for each of the 3 input attributes
Resolve input molecule by applying 3 groups of values, one for each of the 3 input attributes
// Sample data set Person.name.profession.age.score insert List( ("Ann", "doctor", 37, 1.0), ("Ben", "teacher", 37, 1.0), ("Joe", "teacher", 32, 1.0), ("Liz", "teacher", 28, 2.0) ) // Input molecule awaiting 3 inputs for `profession`, `age` and `score` val profAgeScore = m(Person.name.profession_(?).age_(?).score_(?)) // Apply 3 Seq of values, each matching one of the input attributes proOfAge(Seq("doctor"), Seq(37)).get === List("Ann") proOfAge(Seq("doctor", "teacher"), Seq(37, 32)).get.sorted === List("Ann", "Ben", "Joe") // Number of arguments in each Seq don't have to match but can be asymmetric profAgeScore.apply(Seq("doctor"), Seq(37), Seq(1.0)).get === List("Ann") profAgeScore.apply(Seq("doctor", "teacher"), Seq(37), Seq(1.0)).get.sorted === List("Ann", "Ben")
- in1
Seq of values matching first input attribute (professions: Seq[String])
- in2
Seq of values matching second input attribute (ages: Seq[Int])
- in3
Seq of values matching third input attribute (scores: Seq[Double])
- conn
Implicit Conn in scope
- returns
Resolved molecule that can be queried
-
abstract
def
apply(and: And3[I1, I2, I3])(implicit conn: Conn): MoleculeBase
Resolve input molecule by applying 3 groups of expressions, one for each of the 3 input attributes
Resolve input molecule by applying 3 groups of expressions, one for each of the 3 input attributes
// Sample data set Person.name.profession.age.score insert List( ("Ann", "doctor", 37, 1.0), ("Ben", "teacher", 37, 1.0), ("Joe", "teacher", 32, 1.0), ("Liz", "teacher", 28, 2.0) ) // Input molecule awaiting 3 inputs for `profession`, `age` and `score` val profAgeScore = m(Person.name.profession_(?).age_(?).score_(?)) // Apply 3 expressions, one for each input attribute // [profession-expression] and [age-expression] and [score-expression] profAgeScore.apply("doctor" and 37 and 1.0).get === List("Ann") profAgeScore.apply(("doctor" or "teacher") and 37 and 1.0).get.sorted === List("Ann", "Ben") profAgeScore.apply(("doctor" or "teacher") and (37 or 32) and 1.0).get.sorted === List("Ann", "Ben", "Joe") profAgeScore.apply(("doctor" or "teacher") and (37 or 32) and (1.0 or 2.0)).get.sorted === List("Ann", "Ben", "Joe")
- and
First input expr
and
second input exprand
third input expr- conn
Implicit Conn in scope
- returns
Resolved molecule that can be queried
-
abstract
def
apply(ins: Seq[(I1, I2, I3)])(implicit conn: Conn): MoleculeBase
Resolve input molecule by applying Seq of value triples
Resolve input molecule by applying Seq of value triples
// Sample data set Person.name.profession.age.score insert List( ("Ann", "doctor", 37, 1.0), ("Ben", "teacher", 37, 1.0), ("Joe", "teacher", 32, 1.0), ("Liz", "teacher", 28, 2.0) ) // Input molecule awaiting 3 inputs for `profession`, `age` and `score` val profAgeScore = m(Person.name.profession_(?).age_(?).score_(?)) // Apply Seq of one or more value triples, each matching all 3 input attributes profAgeScore.apply(Seq(("doctor", 37, 1.0))).get === List("Ann") profAgeScore.apply(Seq(("doctor", 37, 1.0), ("teacher", 37, 1.0))).get.sorted === List("Ann", "Ben")
- ins
Seq of value triples, each matching the 3 input attributes
- conn
Implicit Conn in scope
- returns
Resolved molecule that can be queried
-
abstract
def
apply(or: Or3[I1, I2, I3])(implicit conn: Conn): MoleculeBase
Resolve input molecule by applying one or more triples of expressions, each matching the 3 input attributes
Resolve input molecule by applying one or more triples of expressions, each matching the 3 input attributes
// Sample data set Person.name.profession.age.score insert List( ("Ann", "doctor", 37, 1.0), ("Ben", "teacher", 37, 1.0), ("Joe", "teacher", 32, 1.0), ("Liz", "teacher", 28, 2.0) ) // Input molecule awaiting 3 inputs for `profession`, `age` and `score` val profAgeScore = m(Person.name.profession_(?).age_(?).score_(?)) // Apply two or more triple expressions, each matching all 3 input attributes // [profession/age/score-expression] or [profession/age/score-expression] or ... profAgeScore.apply(("doctor" and 37 and 1.0) or ("teacher" and 32 and 1.0)).get.sorted === List("Ann", "Joe")
- or
Two or more tuple3 expressions separated by
or
- conn
Implicit Conn in scope
- returns
Resolved molecule that can be queried
-
abstract
def
apply(tpl: (I1, I2, I3), tpls: (I1, I2, I3)*)(implicit conn: Conn): MoleculeBase
Resolve input molecule by applying one or more value triples
Resolve input molecule by applying one or more value triples
// Sample data set Person.name.profession.age.score insert List( ("Ann", "doctor", 37, 1.0), ("Ben", "teacher", 37, 1.0), ("Joe", "teacher", 32, 1.0), ("Liz", "teacher", 28, 2.0) ) // Input molecule awaiting 3 inputs for `profession`, `age` and `score` val profAgeScore = m(Person.name.profession_(?).age_(?).score_(?)) // Apply one or more value triples, each matching all 3 input attributes profAgeScore.apply(("doctor", 37, 1.0)).get === List("Ann") profAgeScore.apply(("doctor", 37, 1.0), ("teacher", 37, 1.0)).get.sorted === List("Ann", "Ben")
- tpl
First triple of values matching the 3 input attributes
- tpls
Optional more triples of values matching both input attributes
- conn
Implicit Conn in scope
- returns
Resolved molecule that can be queried
-
abstract
def
apply(i1: I1, i2: I2, i3: I3)(implicit conn: Conn): MoleculeBase
Resolve input molecule by applying 3 input values as individual args
Resolve input molecule by applying 3 input values as individual args
// Sample data set Person.name.profession.age.score insert List( ("Ann", "doctor", 37, 1.0), ("Ben", "teacher", 37, 1.0), ("Joe", "teacher", 32, 1.0), ("Liz", "teacher", 28, 2.0) ) // Input molecule awaiting 3 inputs for `profession`, `age` and `score` val profAgeScore = m(Person.name.profession_(?).age_(?).score_(?)) // Apply 3 input values (1 triple) profAgeScore.apply("doctor", 37, 1.0).get === List("Ann")
- i1
Input value matching first input attribute (profession: String)
- i2
Input value matching second input attribute (age: Int)
- i3
Input value matching third input attribute (score: Double)
- conn
Implicit Conn in scope
- returns
Resolved molecule that can be queried
Concrete 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
addNilClause(clauses: Seq[Clause], e: Var, kw: KW, v0: Var): Seq[Clause]
- Attributes
- protected
- Definition Classes
- InputMolecule
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
bindSeqs(query: Query, inputRaw1: Seq[I1], inputRaw2: Seq[I2], inputRaw3: Seq[I3]): Query
- Attributes
- protected
-
def
bindValues(query: Query, inputTuples: Seq[(I1, I2, I3)]): Query
- Attributes
- protected
-
def
cardinality(ns: String, attr: String): Int
- Attributes
- protected
- Definition Classes
- InputMolecule
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
dataClause(e: String, kw: KW, enumPrefix: Option[String], arg: Any, i: Int): Seq[Clause]
- Attributes
- protected
- Definition Classes
- InputMolecule
-
def
deepNil(args: Seq[Any]): Boolean
- Attributes
- protected
- Definition Classes
- InputMolecule
-
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] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
isExpression(ns: String, attr: String): Boolean
- Attributes
- protected
- Definition Classes
- InputMolecule
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
isTacit(ns: String, attr: String): Boolean
- Attributes
- protected
- Definition Classes
- InputMolecule
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
pre[T](enumPrefix: Option[String], arg: T): Any
- Attributes
- protected
- Definition Classes
- InputMolecule
-
def
resolveAnd3(and3: And3[I1, I2, I3])(implicit conn: Conn): (Seq[I1], Seq[I2], Seq[I3])
- Attributes
- protected
-
def
resolveInput[T](query: Query, ph: Placeholder, inputs: Seq[T], ruleName: String = "rule1", unifyRule: Boolean = false): Query
- Attributes
- protected
- Definition Classes
- InputMolecule
-
def
resolveOr[I1](or: Or[I1]): Seq[I1]
- Attributes
- protected
- Definition Classes
- InputMolecule
-
def
resolveOr3(or: Or3[I1, I2, I3])(implicit conn: Conn): Seq[(I1, I2, I3)]
- Attributes
- protected
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
valueClauses[TT](e: String, kw: KW, enumPrefix: Option[String], args: TT): Seq[Clause]
- Attributes
- protected
- Definition Classes
- InputMolecule
-
def
varsAndPrefixes(query: Query): Seq[(Var, String)]
- Attributes
- protected
- Definition Classes
- InputMolecule
-
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
- @native() @throws( ... )
Documentation/API for the Molecule library - a meta DSL for the Datomic database.
Manual | scalamolecule.org | Github | Forum