Molecule 1.1.0 - molecule.core.dsl.attributes.MapAttr

def !=(value: expression.AttrExpressions.qm): In with Attr

Mark molecule as input molecule awaiting attribute negation value(s).

for {
  _ <- Person.name.age.get.map(_ ==> List(("Ben", 42), ("Liz", 37)))

  // Create input molecule at compile time by applying `?` marker to attribute
  ageOfPersonsOtherThan = m(Person.name_.!=(?).age)

  // Apply `name` attribute value at runtime to get ages of all other than Ben
  _ <- ageOfPersonsOtherThan("Ben").get.map(_ ==> List(37)) // Liz' age
} yield ()

value: Input marker ? for negation value
returns: Input molecule

Definition Classes: ValueAttrExpr

def !=(values: Seq[T]): Ns with Attr

Match attribute values different from applied Iterable of values.

for {
  _ <- Person.name.get.map(_ ==> List("Ben", "Liz", "Joe"))

  // Negate Iterable of values
  _ <- Person.name.!=(List("Ben", "Joe")).get.map(_ ==> List("Liz"))

  // same as
  _ <- Person.name.not(List("Ben", "Joe")).get.map(_ ==> List("Liz"))
} yield ()

values: Iterable of negated attribute values
returns: Filtered molecule

Definition Classes: AttrExpr

def !=(value: T, moreValues: T*): Ns with Attr

Match attribute values different from one or more applied values.

for {
  _ <- Person.name.get.map(_ ==> List("Ben", "Liz", "Joe"))

  // Negate one value
  _ <- Person.name.!=("Ben").get.map(_ ==> List("Liz", "Joe"))

  // Negate multiple values
  _ <- Person.name.!=("Ben", "Liz").get.map(_ ==> List("Joe"))

  // same as
  _ <- Person.name.not("Ben", "Liz").get.map(_ ==> List("Joe"))
} yield ()

value: Negated attribute value
moreValues: Optional additional negated attribute values
returns: Filtered molecule

Definition Classes: AttrExpr

final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

def <(upper: expression.AttrExpressions.qm): In with Attr

Mark molecule as input molecule awaiting attribute upper value.

for {
  _ <- Person.name.age.get.map(_ ==> List(("Liz", 37), ("Ben", 42), ("Don", 71)))

  // Create input molecule at compile time by applying `?` marker to attribute
  personsUnder = m(Person.name.age_.<(?))

  // Apply upper value at runtime to get names of all under 42
  _ <- personsUnder(42).get.map(_ ==> List("Liz"))
} yield ()

upper: Input marker ? for upper value
returns: Input molecule

Definition Classes: ValueAttrExpr

def <(upper: T): Ns with Attr

Match attribute values less than upper value.

for {
  _ <- Person.age.get.map(_ ==> List(5, 12, 28))
  _ <- Person.age.<(12).get.map(_ ==> List(5))
} yield ()

upper: Upper value
returns: Molecule

Definition Classes: ValueAttrExpr

def <=(upper: expression.AttrExpressions.qm): In with Attr

Mark molecule as input molecule awaiting attribute upper value.

for {
  _ <- Person.name.age.get.map(_ ==> List(("Liz", 37), ("Ben", 42), ("Don", 71)))

  // Create input molecule at compile time by applying `?` marker to attribute
  personsUnderOrExactly = m(Person.name.age_.<=(?))

  // Apply upper value at runtime to get names of all under or exactly 42
  _ <- personsUnderOrExactly(42).get.map(_ ==> List("Liz", "Ben"))
} yield ()

upper: Input marker ? for upper value
returns: Input molecule

Definition Classes: ValueAttrExpr

def <=(upper: T): Ns with Attr

Match attribute values less than or equal to upper value.

for {
  _ <- Person.age.get.map(_ ==> List(5, 12, 28))
  _ <- Person.age.<=(12).get.map(_ ==> List(5, 12))
} yield ()

upper: Upper value
returns: Molecule

Definition Classes: ValueAttrExpr

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def >(lower: expression.AttrExpressions.qm): In with Attr

Mark molecule as input molecule awaiting attribute lower value.

for {
  _ <- Person.name.age.get.map(_ ==> List(("Liz", 37), ("Ben", 42), ("Don", 71)))

  // Create input molecule at compile time by applying `?` marker to attribute
  personsOver = m(Person.name.age_.>(?))

  // Apply lower value at runtime to get names of all over 42
  _ <- personsOver(42).get.map(_ ==> List("Don"))
} yield ()

lower: Input marker ? for lower value
returns: Input molecule

Definition Classes: ValueAttrExpr

def >(lower: T): Ns with Attr

Match attribute values bigger than lower value

for {
  _ <- Person.age.get.map(_ ==> List(5, 12, 28))
  _ <- Person.age.>(12).get.map(_ ==> List(28))
} yield ()

lower: Lower value
returns: Molecule

Definition Classes: ValueAttrExpr

def >=(lower: expression.AttrExpressions.qm): In with Attr

Mark molecule as input molecule awaiting attribute lower value.

for {
  _ <- Person.name.age.get.map(_ ==> List(("Liz", 37), ("Ben", 42), ("Don", 71)))

  // Create input molecule at compile time by applying `?` marker to attribute
  personsOverOrExactly = m(Person.name.age_.>=(?))

  // Apply lower value at runtime to get names of all over or exactly 42
  _ <- personsOverOrExactly(42).get.map(_ ==> List("Ben", "Don"))
} yield ()

lower: Input marker ? for lower value
returns: Input molecule

Definition Classes: ValueAttrExpr

def >=(lower: T): Ns with Attr

Match attribute values bigger than or equal to lower value.

for {
  _ <- Person.age.get.map(_ ==> List(5, 12, 28))
  _ <- Person.age.>=(12).get.map(_ ==> List(12, 28))
} yield ()

lower: Lower value
returns: Molecule

Definition Classes: ValueAttrExpr

def apply(map: Map[String, T]): Ns with Attr

Match Map of map attribute key/value pair(s).

for {
  _ <- Greeting.id.strMap insert List(
    (1, Map("en" -> "Hi there", "da" -> "Hejsa")),
    (2, Map("en" -> "Oh, Hi", "da" -> "Hilser", "fr" -> "Bonjour", "it" -> "Bon giorno")),
    (3, Map("en" -> "Hello", "da" -> "Hej")),
    (4, Map("da" -> "Hej"))
  )

  // Apply Map of key/value pairs (OR semantics)
  _ <- Greeting.id.strMap_(Map("da" -> "Hej", "en" -> "Hi there")).get.map(_ ==> List(1, 3, 4))
} yield ()

map: Map of key/value pairs
returns: Filtered molecule

Definition Classes: MapAttrExpr

def apply(keyValues: Or[(String, T)]): Ns with Attr

Match OR expression of map attribute key/value pairs.

for {
  _ <- Greeting.id.strMap insert List(
    (1, Map("en" -> "Hi there", "da" -> "Hejsa")),
    (2, Map("en" -> "Oh, Hi", "da" -> "Hilser", "fr" -> "Bonjour", "it" -> "Bon giorno")),
    (3, Map("en" -> "Hello", "da" -> "Hej")),
    (4, Map("da" -> "Hej"))
  )

  // Apply OR expression(s) of key/value pairs
  _ <- Greeting.id.strMap_("en" -> "Hi there" or "fr" -> "Bonjour").get.map(_ ==> List(1, 2))
  _ <- Greeting.id.strMap_("en" -> "Hi there" or "fr" -> "Bonjour" or "en" -> "Hello").get.map(_ ==> List(1, 2, 3))
} yield ()

keyValues: One or more OR expressions of key/value pairs
returns: Filtered molecule

Definition Classes: MapAttrExpr

def apply(keyValues: Iterable[(String, T)]): Ns with Attr

Match Iterable of map attribute key/value pair(s).

for {
  _ <- Greeting.id.strMap insert List(
    (1, Map("en" -> "Hi there", "da" -> "Hejsa")),
    (2, Map("en" -> "Oh, Hi", "da" -> "Hilser", "fr" -> "Bonjour", "it" -> "Bon giorno")),
    (3, Map("en" -> "Hello", "da" -> "Hej")),
    (4, Map("da" -> "Hej"))
  )

  // Apply Iterable of key/value pairs (OR semantics)
  _ <- Greeting.id.strMap_(List("da" -> "Hej", "en" -> "Hi there")).get.map(_ ==> List(1, 3, 4))
} yield ()

keyValues: Iterable of key/value pairs
returns: Filtered molecule

Definition Classes: MapAttrExpr

def apply(keyValue: (String, T), moreKeyValues: (String, T)*): Ns with Attr

Match map attribute key/value pair(s).

for {
  _ <- Greeting.id.strMap insert List(
    (1, Map("en" -> "Hi there", "da" -> "Hejsa")),
    (2, Map("en" -> "Oh, Hi", "da" -> "Hilser", "fr" -> "Bonjour", "it" -> "Bon giorno")),
    (3, Map("en" -> "Hello", "da" -> "Hej")),
    (4, Map("da" -> "Hej"))
  )

  // Apply key/value pair
  _ <- Greeting.id.strMap_("da" -> "Hej").get.map(_ ==> List(3, 4))

  // Apply multiple key/value pairs (OR semantics)
  _ <- Greeting.id.strMap_("da" -> "Hej", "en" -> "Hi there").get.map(_ ==> List(1, 3, 4))
} yield ()

keyValue: Key/value pair
moreKeyValues: Optional further key/value pairs
returns: Filtered molecule

Definition Classes: MapAttrExpr

def apply(expr3: Exp3[T, T, T]): Ns with Attr

Expression AST for building OR/AND expressions.

for {
  _ <- Person.name.age.hobbies.get.map(_ ==> List(
    ("Liz", 37, Set("golf", "diving")),
    ("Ben", 42, Set("golf", "diving", "reading")),
    ("Joe", 42, Set("golf", "reading"))
  ))

  // Apply two AND expression for card-many attributes
  _ <- Person.name.hobbies_("golf" and "diving" and "reading").get.map(_ ==> List("Ben"))
} yield ()

With input molecules we can apply logic to multiple attributes at once.

for {
  _ <- Person.name.age.noOfCars.noOfKids.get.map(_ ==> List(
    ("Joe", 42, 1, 2),
    ("Ben", 42, 1, 1),
    ("Liz", 37, 2, 3)
  ))
  // Apply AND-triples to OR expression:
  persons = m(Person.name.age_(?).noOfCars(?).noOfKids_(?))
  _ <- persons((42 and 1 and 1) or (37 and 2 and 3)).get.map(_ ==> List("Ben", "Liz"))
} yield ()

expr3: OR/AND expression
returns: Molecule

Definition Classes: ValueAttrExpr

def apply(expr2: Exp2[T, T]): Ns with Attr

Filter attribute values with logical expression.

for {
  _ <- Person.name.age.hobbies.get.map(_ ==> List(
    ("Joe", 42, Set("golf", "reading")),
    ("Ben", 42, Set("golf", "diving", "reading")),
    ("Liz", 37, Set("golf", "diving"))
  ))

  // Apply AND expression for card-many attributes
  _ <- Person.name.hobbies_("golf" and "diving").get.map(_ ==> List("Ben", "Liz"))

  // Given an input molecule awaiting 2 inputs, we can apply AND-pairs to OR expression:
  persons = m(Person.name_(?).age(?))
  _ <- persons(("Ben" and 42) or ("Liz" and 37)).get.map(_ ==> List(42, 37))
} yield ()

expr2: OR/AND expression
returns: Molecule

Definition Classes: ValueAttrExpr

def apply(expr1: Exp1[T]): Ns with Attr

Filter attribute values with logical expression.

for {
  _ <- Person.name.age.get.map(_ ==> List(
    ("Liz", 37),
    ("Ben", 42),
    ("Don", 71)
  ))

  // Apply OR expression
  // Match all entities with `name` attribute having value "Liz" or "Ben"
  _ <- Person.name_("Liz" or "Ben").age.get.map(_ ==> List(37, 42))
} yield ()

expr1: OR expression
returns: Molecule

Definition Classes: ValueAttrExpr

def apply(value: expression.AttrExpressions.qm): In with Attr

Mark molecule as input molecule awaiting attribute value(s) to be matched.

for {
  _ <- Person.name.age.get.map(_ ==> List(("Ben", 42), ("Liz", 37)))

  // Create input molecule at compile time by applying `?` marker to attribute
  ageOfPerson = m(Person.name_(?).age)

  // Apply `name` attribute value at runtime to get age
  _ <- ageOfPerson("Ben").get.map(_ ==> List(42))
} yield ()

value: Input marker ? for equality match
returns: Input molecule

Definition Classes: ValueAttrExpr

def apply(unifyer: expression.AttrExpressions.unify_stable): Ns with Attr

Mark tacit attribute to be unified in self-join.

Mark tacit attribute to be unified in self-join.

Attributes before Self are joined with attributes added after Self by values that can unify:

Find 23-year olds liking the same beverage as 25-year olds (unifying by beverage):

for {
  _ <- Person.name.age(23).Drinks.beverage._Person.Self // create self join
        .name.age(25).Drinks.beverage_(unify)           // unify by beverage
        .get.map(_ ==> List(
          ("Joe", 23, "Coffee", "Ben", 25),  // Joe (23) and Ben(25) both like coffee
          ("Liz", 23, "Coffee", "Ben", 25),  // Liz (23) and Ben(25) both like coffee
          ("Liz", 23, "Tea", "Ben", 25)      // Liz (23) and Ben(25) both like tea
        ))
} yield ()

unify marker can only be applied to tacit attribute (with underscore).

unifyer: unify marker to unify self-join by this attribute values
returns: Self-join molecule

Definition Classes: AttrExpr

def apply(values: Iterable[T], moreValues: Iterable[T]*): Ns with Attr

Match one or more Iterables of attribute values.

Match one or more Iterables of attribute values.

Multiple Iterables are concatenated into one Iterable of values to be matched.

Applying value(s) to an attribute has different semantics depending on what operation is performed:

for {
  // Querying with `get` - Ben is 42
  _ <- Person.name_(Set("Ben")).age.get.map(_ ==> List(42))

  members = List("Ben", "Liz")
  associates = List("Don", "Ann")

  // OR-semantics when multiple values are queried
  _ <- Person.name_(members).age.get.map(_ ==> List(42, 37))
  // Multiple Iterables concatenated
  _ <- Person.name_(members, associates).age.get.map(_ ==> List(42, 37, 71, 28))

  // Single value in Iterable can be added when saving
  // (although easier to apply the value directly)
  _ <- Person.name(List("Joe")).save

  // Saving multiple new card-many attribute values (all old values are retracted).
  // (Saving multiple new values not allowed for card-one attributes)
  sports = Set("golf", "diving")
  _ <- Person.hobbies(sports).save

  // Replacing value when updating (old value is retracted).
  _ <- Person(benId).age(List(43)).update

  // Replacing multiple values for card-many attributes (all old values are retracted).
  // (Replacing multiple values not allowed for card-one attributes)
  _ <- Person(benId).hobbies(Seq("reading", "walking")).update

  // Multiple Iterables can be applied
  _ <- Person(benId).hobbies(Seq("reading", "walking"), Set("stamps")).update
} yield ()

values: Iterable of attribute values to be matched
moreValues: Optional additional Iterables of attribute values to be matched
returns: Filtered molecule

Definition Classes: AttrExpr

def apply(value: T, moreValues: T*): Ns with Attr

Match one or more attribute values.

Match one or more attribute values.

Applying value(s) to an attribute has different semantics depending on what operation is performed:

for {
  // Querying with `get` - Ben is 42
  _ <- Person.name_("Ben").age.get.map(_ ==> List(42))

  // OR-semantics when multiple values are queried
  _ <- Person.name_("Ben", "Liz").age.get.map(_ ==> List(42, 37))

  // Saving new value (any old value is retracted)
  _ <- Person.name("Joe").save

  // Saving multiple new card-many attribute values (all old values are retracted).
  // (Saving multiple new values not allowed for card-one attributes)
  _ <- Person.hobbies("golf", "diving").save

  // Replacing value when updating (old value is retracted).
  _ <- Person(benId).age(43).update

  // Replacing multiple values for card-many attributes (all old values are retracted).
  // (Replacing multiple values not allowed for card-one attributes)
  _ <- Person(benId).hobbies("reading", "walking").update
} yield ()

value: Attribute values to be matched
moreValues: Optional additional attribute values to be matched
returns: Filtered molecule

Definition Classes: AttrExpr

def apply(): Ns with Attr

Apply empty value to retract datom in an update.

for {
  benId <- Person.name("Ben").age(42).save.map(_.eid)
  _ <- Person.name.age$.get.map(_ ==> List(("Ben", Some(42))))

  // Retract Ben's age
  _ <- Person(benId).age().update
  _ <- Person.name.age$.get.map(_ ==> List(("Ben", None)))
} yield ()

For cardinality-many attributes, all values of the attribute are retracted.

Definition Classes: AttrExpr

final def asInstanceOf[T0]: T0

Definition Classes: Any

def assert(values: Iterable[(String, T)]): Ns with Attr

Assert Iterable of card-many attribute values.

for {
  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving")))

  // Assert/add values of Iterable
  _ <- Person(benId).hobbies.assert(Seq("stamps", "walking", "theater")).update

  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving", "stamps", "walking", "theater")))
} yield ()

values: Iterable of attribute values
returns: Molecule to be updated

Definition Classes: ManyAttrExpr

def assert(value: (String, T), moreValues: (String, T)*): Ns with Attr

Assert one or more card-many attribute values.

for {
  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving")))

  // Assert/add value
  _ <- Person(benId).hobbies.assert("stamps").update

  // Assert multiple values
  _ <- Person(benId).hobbies.assert("walking", "theater").update

  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving", "stamps", "walking", "theater")))
} yield ()

value: New attribute value
moreValues: Optional additional new attribute values
returns: Molecule to be updated

Definition Classes: ManyAttrExpr

def clone(): AnyRef

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws( ... ) @native()

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def finalize(): Unit

Attributes: protected[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()

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

def k(or: Or[String]): Values with Ns with Attr

Match OR expression(s) of map attribute keys to retrieve corresponding key/value pairs.

for {
  _ <- Greeting.id.strMap insert List(
    (1, Map("en" -> "Hi there", "da" -> "Hejsa")),
    (2, Map("en" -> "Oh, Hi", "da" -> "Hilser", "fr" -> "Bonjour", "it" -> "Bon giorno")),
    (3, Map("en" -> "Hello", "da" -> "Hej")),
    (4, Map("da" -> "Hej"))
  )

  // Apply OR expression of keys
  _ <- Greeting.id.strMap_.k("en" or "fr").get.map(_ ==> List(1, 2, 3))
  _ <- Greeting.id.strMap.k("en" or "fr").get.map(_ ==> List(
    (1, Map("en" -> "Hi there")),
    (2, Map("en" -> "Oh, Hi", "fr" -> "Bonjour")),
    (3, Map("en" -> "Hello"))
  ))

  // Apply multiple OR expressions of keys
  _ <- Greeting.id.strMap_.k("en" or "fr" or "da").get.map(_ ==> List(1, 2, 3, 4))
} yield ()

or: OR expression(s) of attribute keys
returns: Filtered molecule

Definition Classes: MapAttrExpr

def k(keys: Iterable[String]): Values with Ns with Attr

Match Iterable of map attribute keys to retrieve corresponding key/value pairs.

for {
  _ <- Greeting.id.strMap insert List(
    (1, Map("en" -> "Hi there", "da" -> "Hejsa")),
    (2, Map("en" -> "Oh, Hi", "da" -> "Hilser", "fr" -> "Bonjour", "it" -> "Bon giorno")),
    (3, Map("en" -> "Hello", "da" -> "Hej")),
    (4, Map("da" -> "Hej"))
  )

  // Apply Iterable of keys
  _ <- Greeting.id.strMap_.k(List("en", "fr")).get.map(_ ==> List(1, 2, 3))
  _ <- Greeting.id.strMap.k(List("en", "fr")).get.map(_ ==> List(
    (1, Map("en" -> "Hi there")),
    (2, Map("en" -> "Oh, Hi", "fr" -> "Bonjour")),
    (3, Map("en" -> "Hello"))
  ))
} yield ()

keys: Iterable of attribute keys
returns: Filtered molecule

Definition Classes: MapAttrExpr

def k(key: String, moreKeys: String*): Values with Ns with Attr

Match map attribute keys to retrieve corresponding key/value pairs.

for {
  _ <- Greeting.id.strMap insert List(
    (1, Map("en" -> "Hi there", "da" -> "Hejsa")),
    (2, Map("en" -> "Oh, Hi", "da" -> "Hilser", "fr" -> "Bonjour", "it" -> "Bon giorno")),
    (3, Map("en" -> "Hello", "da" -> "Hej")),
    (4, Map("da" -> "Hej"))
  )

  // Apply keys
  _ <- Greeting.id.strMap_.k("en", "fr").get.map(_ ==> List(1, 2, 3))
  _ <- Greeting.id.strMap.k("en", "fr").get.map(_ ==> List(
    (1, Map("en" -> "Hi there")),
    (2, Map("en" -> "Oh, Hi", "fr" -> "Bonjour")),
    (3, Map("en" -> "Hello"))
  ))
} yield ()

key: Map attribute key (String)
moreKeys: Optional additional map attribute keys
returns: Filtered molecule

Definition Classes: MapAttrExpr

def k(key: String): Values with Ns with Attr

Match map attribute key to retrieve corresponding key/value pairs.

for {
  _ <- Greeting.id.strMap insert List(
    (1, Map("en" -> "Hi there", "da" -> "Hejsa")),
    (2, Map("en" -> "Oh, Hi", "da" -> "Hilser", "fr" -> "Bonjour", "it" -> "Bon giorno")),
    (3, Map("en" -> "Hello", "da" -> "Hej")),
    (4, Map("da" -> "Hej"))
  )

  // Apply key
  _ <- Greeting.id.strMap_.k("en").get.map(_ ==> List(1, 2, 3))
  _ <- Greeting.id.strMap.k("en").get.map(_ ==> List(
    (1, Map("en" -> "Hi there")),
    (2, Map("en" -> "Oh, Hi")),
    (3, Map("en" -> "Hello"))
  ))
} yield ()

key: Map attribute key (String)
returns: Filtered molecule

Definition Classes: MapAttrExpr

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def not(value: expression.AttrExpressions.qm): In with Attr

Mark molecule as input molecule awaiting attribute negation value(s).

for {
  _ <- Person.name.age.get.map(_ ==> List(("Ben", 42), ("Liz", 37)))

  // Create input molecule at compile time by applying `?` marker to attribute
  ageOfPersonsOtherThan = m(Person.name_.not(?).age)

  // Apply `name` attribute value at runtime to get ages of all other than Ben
  _ <- ageOfPersonsOtherThan("Ben").get.map(_ ==> List(37)) // Liz' age
} yield ()

value: Input marker ? for negation value
returns: Input molecule

Definition Classes: ValueAttrExpr

def not(values: Iterable[T]): Ns with Attr

Match attribute values different from applied Iterable of values.

for {
  _ <- Person.name.get.map(_ ==> List("Ben", "Liz", "Joe"))

  // Negate Iterable of values
  _ <- Person.name.not(List("Ben", "Joe")).get.map(_ ==> List("Liz"))

  // same as
  _ <- Person.name.!=(List("Ben", "Joe")).get.map(_ ==> List("Liz"))
} yield ()

values: Iterable of negated attribute values
returns: Filtered molecule

Definition Classes: AttrExpr

def not(value: T, moreValues: T*): Ns with Attr

Match attribute values different from one or more applied values.

for {
  _ <- Person.name.get.map(_ ==> List("Ben", "Liz", "Joe"))

  // Negate one value
  _ <- Person.name.not("Ben").get.map(_ ==> List("Liz", "Joe"))

  // Negate multiple values
  _ <- Person.name.not("Ben", "Liz").get.map(_ ==> List("Joe"))

  // same as
  _ <- Person.name.!=("Ben", "Liz").get.map(_ ==> List("Joe"))
} yield ()

value: Negated attribute value
moreValues: Optional additional negated attribute values
returns: Filtered molecule

Definition Classes: AttrExpr

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native()

def replace(oldNews: Iterable[(String, T)]): Ns with Attr

Replace Iterable of card-many attribute values.

Replace Iterable of card-many attribute values.

Retracts old value and asserts new value.

for {
  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving")))

  // Replace values by applying Iterable of old/new value pairs
  _ <- Person(benId).hobbies.replace("theater" -> "concerts", "diving" -> "football").update

  _ <- Person.hobbies.get.map(_ ==> List(Set("concerts", "football")))
} yield ()

oldNews: Iterable of old/new attribute values. For map attributes it's key/value pairs.
returns: Molecule to be updated

Definition Classes: ManyAttrExpr

def replace(oldNew: (String, T), oldNews: (String, T)*): Ns with Attr

Replace one or more card-many attribute values.

Replace one or more card-many attribute values.

Retracts old value and asserts new value.

for {
  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving")))

  // Replace value by applying old/new value pair
  _ <- Person(benId).hobbies.replace("golf" -> "theater").update

  // Replace multiple values by applying multiple old/new value pairs
  _ <- Person(benId).hobbies.replace("theater" -> "concerts", "diving" -> "football").update

  _ <- Person.hobbies.get.map(_ ==> List(Set("concerts", "football")))
} yield ()

oldNew: Pair of old/new value
oldNews: Optional additional pairs of old/new value
returns: Molecule to be updated

Definition Classes: ManyAttrExpr

def retract(values: Iterable[String]): Ns with Attr

Retract Iterable of card-many attribute values.

for {
  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving", "stamps", "walking", "theater")))

  // Retract multiple values
  _ <- Person(benId).hobbies.retract(List("walking", "theater")).update

  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving", "stamps")))
} yield ()

values: Iterable of attribute values to be retracted
returns: Molecule to be updated

Definition Classes: ManyAttrExpr

def retract(value: String, moreValues: String*): Ns with Attr

Retract one or more card-many attribute values.

for {
  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving", "stamps", "walking", "theater")))

  // Retract value
  _ <- Person(benId).hobbies.retract("theater").update

  // Retract multiple values
  _ <- Person(benId).hobbies.retract("stamps", "walking").update

  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving")))
} yield ()

value: Attribute value to be retracted
moreValues: Optional additional attribute values to be retracted
returns: Molecule to be updated

Definition Classes: ManyAttrExpr

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( ... ) @native()

Packages

MapAttr

trait MapAttr[Ns, In, TT, T] extends ValueAttr[Ns, In, TT, T] with expression.AttrExpressions.MapAttrExpr[Ns, In, T]

Type Members

Value Members

Inherited from expression.AttrExpressions.MapAttrExpr[Ns, In, T]

Inherited from expression.AttrExpressions.ManyAttrExpr[Ns, (String, T), (String, T), String]

Inherited from expression.AttrExpressions.ValueAttrExpr[Ns, In, T]

Inherited from expression.AttrExpressions.AttrExpr[Ns, T]

Inherited from ValueAttr[Ns, In, TT, T]

Inherited from Attr

Inherited from AnyRef

Inherited from Any

Ungrouped