MapInt

trait MapInt[Ns, In] extends MapAttr[Ns, In, Map[String, Int], Int]

Source: attributes.scala

Linear Supertypes

MapAttr[Ns, In, Map[String, Int], Int], api.core.MapAttrExpr[Ns, In, Int], api.core.ManyAttrExpr[Ns, (String, Int), (String, Int), String], api.core.ValueAttrExpr[Ns, In, Int], api.core.AttrExpr[Ns, Int], ValueAttr[Ns, In, Map[String, Int], Int], Attr, AnyRef, Any

Type Hierarchy

Ordering

Alphabetic
By Inheritance

Inherited

MapInt
MapAttr
MapAttrExpr
ManyAttrExpr
ValueAttrExpr
AttrExpr
ValueAttr
Attr
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Type Members

trait Values extends AnyRef
Definition Classes
MapAttrExpr

Value Members

def !=(value: api.core.??): In with Attr

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

Person.name.age.get === List(("Ben", 42), ("Liz", 37))

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

// Apply `name` attribute value at runtime to get ages of all other than Ben
ageOfPersonsOtherThan("Ben").get === List(37) // Liz' age

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

Definition Classes: ValueAttrExpr

def !=(values: Seq[Int]): Ns with Attr
Match attribute values different from applied Iterable of values.
Match attribute values different from applied Iterable of values.
```
Person.name.get === List("Ben", "Liz", "Joe")

// Negate Iterable of values
Person.name.!=(List("Ben", "Joe")).get === List("Liz")

// same as
Person.name.not(List("Ben", "Joe")).get === List("Liz")
```
values
Iterable of negated attribute values
returns
Filtered molecule
Definition Classes
AttrExpr
def !=(value: Int, moreValues: Int*): Ns with Attr
Match attribute values different from one or more applied values.
Match attribute values different from one or more applied values.
```
Person.name.get === List("Ben", "Liz", "Joe")

// Negate one value
Person.name.!=("Ben").get === List("Liz", "Joe")

// Negate multiple values
Person.name.!=("Ben", "Liz").get === List("Joe")

// same as
Person.name.not("Ben", "Liz").get === List("Joe")
```
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: api.core.??): In with Attr

Mark molecule as input molecule awaiting attribute upper value.

Person.name.age.get === List(("Liz", 37), ("Ben", 42), ("Don", 71))

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

// Apply upper value at runtime to get names of all under 42
personsUnder(42).get === List("Liz")

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

Definition Classes: ValueAttrExpr

def <(upper: Int): Ns with Attr
Match attribute values less than upper value.
Match attribute values less than upper value.
```
Person.age.get === List(5, 12, 28)
Person.age.<(12).get === List(5)
```
upper
Upper value
returns
Molecule
Definition Classes
ValueAttrExpr

def <=(upper: api.core.??): In with Attr

Mark molecule as input molecule awaiting attribute upper value.

Person.name.age.get === List(("Liz", 37), ("Ben", 42), ("Don", 71))

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

// Apply upper value at runtime to get names of all under or exactly 42
personsUnderOrExactly(42).get === List("Liz", "Ben")

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

Definition Classes: ValueAttrExpr

def <=(upper: Int): Ns with Attr
Match attribute values less than or equal to upper value.
Match attribute values less than or equal to upper value.
```
Person.age.get === List(5, 12, 28)
Person.age.<=(12).get === List(5, 12)
```
upper
Upper value
returns
Molecule
Definition Classes
ValueAttrExpr
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any

def >(lower: api.core.??): In with Attr

Mark molecule as input molecule awaiting attribute lower value.

Person.name.age.get === List(("Liz", 37), ("Ben", 42), ("Don", 71))

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

// Apply lower value at runtime to get names of all over 42
personsOver(42).get === List("Don")

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

Definition Classes: ValueAttrExpr

def >(lower: Int): Ns with Attr
Match attribute values bigger than lower value
Match attribute values bigger than lower value
```
Person.age.get === List(5, 12, 28)
Person.age.>(12).get === List(28)
```
lower
Lower value
returns
Molecule
Definition Classes
ValueAttrExpr

def >=(lower: api.core.??): In with Attr

Mark molecule as input molecule awaiting attribute lower value.

Person.name.age.get === List(("Liz", 37), ("Ben", 42), ("Don", 71))

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

// Apply lower value at runtime to get names of all over or exactly 42
personsOverOrExactly(42).get === List("Ben", "Don")

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

Definition Classes: ValueAttrExpr

def >=(lower: Int): Ns with Attr
Match attribute values bigger than or equal to lower value.
Match attribute values bigger than or equal to lower value.
```
Person.age.get === List(5, 12, 28)
Person.age.>=(12).get === List(12, 28)
```
lower
Lower value
returns
Molecule
Definition Classes
ValueAttrExpr

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

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

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 === List(1, 3, 4)

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

Definition Classes: MapAttrExpr

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

Match OR expression of map attribute key/value pairs.

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 === List(1, 2)
Greeting.id.strMap_("en" -> "Hi there" or "fr" -> "Bonjour" or "en" -> "Hello").get === List(1, 2, 3)

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

Definition Classes: MapAttrExpr

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

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

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 === List(1, 3, 4)

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

Definition Classes: MapAttrExpr

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

Match map attribute key/value pair(s).

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 === List(3, 4)

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

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

Definition Classes: MapAttrExpr

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

Expression AST for building OR/AND expressions.

Person.name.age.hobbies.get === 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 === List("Ben")

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

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

expr3: OR/AND expression
returns: Molecule

Definition Classes: ValueAttrExpr

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

Filter attribute values with logical expression.

Person.name.age.hobbies.get === 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 === List("Ben", "Liz")

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

expr2: OR/AND expression
returns: Molecule

Definition Classes: ValueAttrExpr

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

Filter attribute values with logical expression.

Person.name.age.get === 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 === List(37, 42)

expr1: OR expression
returns: Molecule

Definition Classes: ValueAttrExpr

def apply(value: api.core.??): In with Attr
Mark molecule as input molecule awaiting attribute value(s) to be matched.
Mark molecule as input molecule awaiting attribute value(s) to be matched.
```
Person.name.age.get === List(("Ben", 42), ("Liz", 37))

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

// Apply `name` attribute value at runtime to get age
ageOfPerson("Ben").get === List(42)
```
value
Input marker ? for equality match
returns
Input molecule
Definition Classes
ValueAttrExpr
def apply(unifyer: api.core.unify): 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):
```
Person.name.age(23).Drinks.beverage._Person.Self // create self join
      .name.age(25).Drinks.beverage_(unify)      // unify by beverage
      .get === 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
      )
```
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: Seq[Int], moreValues: Seq[Int]*): 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:

// Querying with `get` - Ben is 42
Person.name_(Set("Ben")).age.get === List(42)

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

// OR-semantics when multiple values are queried
Person.name_(members).age.get === List(42, 37)
// Multiple Iterables concatenated
Person.name_(members, associates).age.get === 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)
val 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

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: Int, moreValues: Int*): 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:

// Querying with `get` - Ben is 42
Person.name_("Ben").age.get === List(42)

// OR-semantics when multiple values are queried
Person.name_("Ben", "Liz").age.get === 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

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.
Apply empty value to retract datom in an update.
```
val benId = Person.name("Ben").age(42).save.eid
Person.name.age$ === List(("Ben", Some(42)))

// Retract Ben's age
Person(benId).age().update
Person.name.age$ === List(("Ben", None))
```
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, Int)]): Ns with Attr

Assert Iterable of card-many attribute values.

Person.hobbies.get === List(Set("golf", "diving"))

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

Person.hobbies.get === List(Set("golf", "diving", "stamps", "walking", "theater"))

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

Definition Classes: ManyAttrExpr

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

Assert one or more card-many attribute values.

Person.hobbies.get === 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 === List(Set("golf", "diving", "stamps", "walking", "theater"))

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(classOf[java.lang.CloneNotSupportedException]) @native()
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
final def getClass(): Class[_ <: AnyRef]
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.

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 === List(1, 2, 3)
Greeting.id.strMap.k("en" or "fr").get === 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 === List(1, 2, 3, 4)

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.

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 === List(1, 2, 3)
Greeting.id.strMap.k(List("en", "fr")).get === List(
  (1, Map("en" -> "Hi there")),
  (2, Map("en" -> "Oh, Hi", "fr" -> "Bonjour")),
  (3, Map("en" -> "Hello"))
)

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.

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 === List(1, 2, 3)
Greeting.id.strMap.k("en", "fr").get === List(
  (1, Map("en" -> "Hi there")),
  (2, Map("en" -> "Oh, Hi", "fr" -> "Bonjour")),
  (3, Map("en" -> "Hello"))
)

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.

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 === List(1, 2, 3)
Greeting.id.strMap.k("en").get === List(
  (1, Map("en" -> "Hi there")),
  (2, Map("en" -> "Oh, Hi")),
  (3, Map("en" -> "Hello"))
)

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

Definition Classes: MapAttrExpr

final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef

def not(value: api.core.??): In with Attr

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

Person.name.age.get === List(("Ben", 42), ("Liz", 37))

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

// Apply `name` attribute value at runtime to get ages of all other than Ben
ageOfPersonsOtherThan("Ben").get === List(37) // Liz' age

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

Definition Classes: ValueAttrExpr

def not(values: Seq[Int]): Ns with Attr
Match attribute values different from applied Iterable of values.
Match attribute values different from applied Iterable of values.
```
Person.name.get === List("Ben", "Liz", "Joe")

// Negate Iterable of values
Person.name.not(List("Ben", "Joe")).get === List("Liz")

// same as
Person.name.!=(List("Ben", "Joe")).get === List("Liz")
```
values
Iterable of negated attribute values
returns
Filtered molecule
Definition Classes
AttrExpr
def not(value: Int, moreValues: Int*): Ns with Attr
Match attribute values different from one or more applied values.
Match attribute values different from one or more applied values.
```
Person.name.get === List("Ben", "Liz", "Joe")

// Negate one value
Person.name.not("Ben").get === List("Liz", "Joe")

// Negate multiple values
Person.name.not("Ben", "Liz").get === List("Joe")

// same as
Person.name.!=("Ben", "Liz").get === List("Joe")
```
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, Int)]): Ns with Attr
Replace Iterable of card-many attribute values.
Replace Iterable of card-many attribute values.

Retracts old value and asserts new value.
```
Person.hobbies.get === 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 === List(Set("concerts", "football"))
```
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, Int), oldNews: (String, Int)*): 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.

Person.hobbies.get === 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 === List(Set("concerts", "football"))

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.
Retract Iterable of card-many attribute values.
```
Person.hobbies.get === List(Set("golf", "diving", "stamps", "walking", "theater"))

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

Person.hobbies.get === List(Set("golf", "diving", "stamps"))
```
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.
Retract one or more card-many attribute values.
```
Person.hobbies.get === 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 === List(Set("golf", "diving"))
```
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(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()

api		Molecule API.
ast		Internal Molecule ASTs.
boilerplate		Internal interfaces for auto-generated DSL boilerplate code.
composition		Builder methods to compose molecules.
exceptions		Exceptions thrown by Molecule.
expression		Attribute expressions and operations.
facade		Molecule facades to Datomic.
factory		Implicit macro methods `m` to instantiate molecules from custom DSL molecule constructs.
input		Input molecules awaiting input.
macros		Internal macros generating molecule code from custom DSL molecule constructs.
generic		Interfaces to generic information about datoms and Datomic database.
ops		Internal operational helpers for transforming DSL to molecule.
schema		Schema definition DSL.
transform		Internal transformers from DSL to Model/Query/Transaction.
util		Internal Java database functions for Datomic.

Packages

Sub-packages

MapInt

trait MapInt[Ns, In] extends MapAttr[Ns, In, Map[String, Int], Int]

Type Members

Value Members

Inherited from MapAttr[Ns, In, Map[String, Int], Int]

Inherited from api.core.MapAttrExpr[Ns, In, Int]

Inherited from api.core.ManyAttrExpr[Ns, (String, Int), (String, Int), String]

Inherited from api.core.ValueAttrExpr[Ns, In, Int]

Inherited from api.core.AttrExpr[Ns, Int]

Inherited from ValueAttr[Ns, In, Map[String, Int], Int]

Inherited from Attr

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Sub-packages

MapInt

trait MapInt[Ns, In] extends MapAttr[Ns, In, Map[String, Int], Int]

Type Members

Value Members

Inherited from MapAttr[Ns, In, Map[String, Int], Int]

Inherited from api.core.MapAttrExpr[Ns, In, Int]

Inherited from api.core.ManyAttrExpr[Ns, (String, Int), (String, Int), String]

Inherited from api.core.ValueAttrExpr[Ns, In, Int]

Inherited from api.core.AttrExpr[Ns, Int]

Inherited from ValueAttr[Ns, In, Map[String, Int], Int]

Inherited from Attr

Inherited from AnyRef

Inherited from Any

Ungrouped

MapInt