Datalog query.

Molecule transforms custom boilerplate DSL constructs to Datomic queries in 3 steps:

Custom DSL molecule --> Model --> Query --> Datalog query

Internal Model representation of a molecule.

Molecule transforms custom boilerplate DSL constructs to Datomic queries in 3 steps:

Custom DSL molecule --> Model --> Query --> Datalog query

Internal Query representation of molecule.

Molecule transforms custom boilerplate DSL constructs to Datomic queries in 3 steps:

Custom DSL molecule --> Model --> Query --> Datalog query

Resolve input molecule by applying 2 Seq of values, one for each input attribute

// Input molecule awaiting 2 inputs for profession and age
val profAge = m(Person.name.profession_(?).age_(?))
for {
  // Sample data set
  Person.name.profession.age insert List(
    ("Ann", "doctor", 37),
    ("Ben", "teacher", 37),
    ("Joe", "teacher", 32),
    ("Liz", "teacher", 28)
  )

  // Apply 2 Seq of values, each matching one of the input attributes
  _ <- profAge(Seq("doctor"), Seq(37)).get.map(_ ==> List("Ann"))
  _ <- profAge(Seq("doctor", "teacher"), Seq(37, 32)).get.map(_.sorted ==> List("Ann", "Ben", "Joe"))

  // Number of arguments in each Seq don't have to match but can be asymmetric
  _ <- profAge(Seq("doctor", "teacher"), Seq(37)).get.map(_.sorted ==> List("Ann", "Ben"))
  _ <- profAge(Seq("teacher"), Seq(37, 32)).get.map(_.sorted ==> List("Ben", "Joe"))
} yield ()

Resolve input molecule by applying 2 expressions, one for each input attribute

// Input molecule awaiting 2 inputs for `profession` and `age`
val profAge = m(Person.name.profession_(?).age_(?))
for {
  // Sample data set
  Person.name.profession.age insert List(
    ("Ann", "doctor", 37),
    ("Ben", "teacher", 37),
    ("Joe", "teacher", 32),
    ("Liz", "teacher", 28)
  )

  // Apply 2 expressions, one for each input attribute
  // [profession-expression] and [age-expression]
  _ <- profAge("doctor" and 37).get.map(_ ==> List("Ann"))
  _ <- profAge(("doctor" or "teacher") and 37).get.map(_.sorted ==> List("Ann", "Ben"))
  _ <- profAge(("doctor" or "teacher") and (32 or 28)).get.map(_.sorted ==> List("Joe", "Liz"))
} yield ()

Resolve input molecule by applying Seq of value pairs

// Input molecule awaiting 2 inputs for `profession` and `age`
val profAge = m(Person.name.profession_(?).age_(?))
for {
  // Sample data set
  Person.name.profession.age insert List(
    ("Ann", "doctor", 37),
    ("Ben", "teacher", 37),
    ("Joe", "teacher", 32),
    ("Liz", "teacher", 28)
  )

  // Apply Seq of one or more value pairs, each matching both input attributes
  _ <- profAge(Seq(("doctor", 37))).get.map(_ ==> List("Ann"))
  _ <- profAge(Seq(("doctor", 37), ("teacher", 37))).get.map(_.sorted ==> List("Ann", "Ben"))
} yield ()

Resolve input molecule by applying one or more pairs of expressions, each matching both input attributes

// Input molecule awaiting 2 inputs for `profession` and `age`
val profAge = m(Person.name.profession_(?).age_(?))
for {
  // Sample data set
  Person.name.profession.age insert List(
    ("Ann", "doctor", 37),
    ("Ben", "teacher", 37),
    ("Joe", "teacher", 32),
    ("Liz", "teacher", 28)
  )

  // Apply two or more pair expressions, each matching both input attributes
  // [profession/age-expression] or [profession/age-expression] or ...
  _ <- profAge("doctor" and 37).get.map(_.sorted ==> List("Ann"))
  _ <- profAge(("doctor" and 37) or ("teacher" and 32)).get.map(_.sorted ==> List("Ann", "Joe"))
} yield ()

Resolve input molecule by applying one or more value pairs

// Input molecule awaiting 2 inputs for `profession` and `age`
val profAge = m(Person.name.profession_(?).age_(?))
for {
  // Sample data set
  Person.name.profession.age insert List(
    ("Ann", "doctor", 37),
    ("Ben", "teacher", 37),
    ("Joe", "teacher", 32),
    ("Liz", "teacher", 28)
  )

  // Apply one or more value pairs, each matching both input attributes
  _ <- profAge(("doctor", 37)).get.map(_ ==> List("Ann"))
  _ <- profAge(("doctor", 37), ("teacher", 37)).get.map(_.sorted ==> List("Ann", "Ben"))
} yield ()

Resolve input molecule by applying 2 input values as individual args

// Input molecule awaiting 2 inputs for `profession` and `age`
val profAge = m(Person.name.profession_(?).age_(?))
for {
  // Sample data set
  Person.name.profession.age insert List(
    ("Ann", "doctor", 37),
    ("Ben", "teacher", 37),
    ("Joe", "teacher", 32),
    ("Liz", "teacher", 28)
  )

  // Apply 2 input values
  _ <- profAge("doctor", 37).get.map(_ ==> List("Ann"))
} yield ()