All values are members of this type.

The following binary operations take Any as a left operand.

The in operator returns true if some member of the right operand is equal (==) to the left operand.

All values that are not members of Entity or Collection (or null) are members of this type. It has no additional operators beyond those defined on Any.

Number is an abstract type with four abstract subtypes enumerated in the following table. Each of these subtypes is further refined to a concrete type with a precision. A concrete type of a smaller precision may always be converted to the same type of a larger precision. Converting from a larger precision to a smaller precision tests for overflow at runtime.

The arithmetic operations (+, -, *, /, %) defined above are specialized to return the most specific type of its operands (for example, Integer8 + Integer8 returns Integer8, Decimal9 + Decimal38 returns Decimal38).

type Person {
    Id : Integer32 = AutoNumber();
    Name : Text;
    Age : Integer32;
    Spouse : Person;
} where identity Id;

People : Person*;

The representation of text is implementation-dependent.

The following postfix operator takes Text as a left operand.

The postfix # operator returns the count of characters in a Text string.

The following binary operations take Text as a left operand.

The binary + operator concatenates two Text strings.

The relational operators perform a lexicographic comparison on the Text strings and return a Logical value.

Count() : Unsigned;
Like(pattern : Text) : Logical;
PatternIndex(pattern : Text) : Integer;

Text#N;

Text where value.Count <= N;

The following binary operations take Character as a left operand.

The relational operators perform a comparison and return a Logical value.

The following unary operator takes Logical as an operand.

The following binary operations take Logical as a left operand.

The following ternary operator takes Logical as a right operand.

The following unary operator takes Binary as a right operand.

The ~ operator computes the bitwise negation of its operand.

The following binary operations take Binary as a left operand.

The left shift operator << discards n high-order bits, shifts remaining bits left, and zeros the low-order empty bit positions. Similarly, the right shift operator >> discards n low-order bits, shifts remaining bits right, and zeros the high-order empty bit positions. The result of left shift and right shift has the same length as the left operand.

The bitwise and, bitwise exclusive or, and bitwise or operators implicitly convert their operands to the same length. The smaller operand is padded with zeros on the left.

The precedence of the bitwise and, or, and exclusive or is lower than it is in many other languages.

The following binary operations take Guid as a left operand.

Guids are created with the system-defined NewGuid computed value.

NewGuid() : Guid;

The following binary operations take Date as a left operand.

The following binary operations take DateTime as a left operand.

The following binary operations take Time as a left operand.

The following syntax defines a collection of all possible instances that satisfy the structure and constraint.

EntityTypeExpression:
  { EntityMemberDeclarations  }
EntityMemberDeclarations:
  EntityMemberDeclaration
  EntityMemberDeclarations  EntityMemberDeclaration
EntityMemberDeclaration:
  FieldDeclaration
  ComputedValueDeclaration

Entity declarations share FieldDeclaration and ComputedValueDeclaration with module. It is an error to declare two FieldDeclarations with different default values.

The identity constraint controls the representation of identity. If it is specified, the selected fields are used to represent the identity. If no identity constraint is specified, the entity cannot be referenced. Placing the identity constraint on a field makes that field initialize only. It cannot be updated.

The identity constraint may be specified either on entity declarations or on extent declarations, not both. The identity constraint requires that the elements in the constraint are unique within each extent (not across extents) as with the unique constraint. An identity declaration on a derived type supersedes that of any types it derives from. As a result, there can be only one identity constraint on an entity or an extent.

Consider the following example:

type Container {
    Id : Integer32;
    Capacity: Integer32;
} where identity Id;

CoffeeCups : Container* { {Id = 1, Capacity = 12} }
WaterBottles : Container* { {Id = 1, Capacity = 12} }

EqualityTest() {
    from c in CoffeeCups
    from w in WaterBottles
    where c == w
    select "Never"
}

It is legal for the two extents to contain instances whose Id fields are equal. Having the same Id field does not equate the instances. The computed value EqualityTest will always return the empty collection because identity is relative to an extent.

An implementation of M may restrict the types of fields used to form identity.

The following binary operations take Entity as a left operand.

The equality operations on entities compare identity (shallow equal). == returns true if both operands refer to an instance with the same identity in the same collection.

The following member is defined on all entities:

FieldNames() : Text*;

FieldNames returns the string names of each label in an instance. This member is not affected by ascription and does not return names of computed values or missing default values.

Entities have a default indexer that accepts field name as text and returns the value of the field if present or null:

{Name = "Bob"}("Name") == "Bob"
{Name = "Bob"}("Age")  == null

The indexer accesses the underlying instance data without interpretation by the type. This allows the indexer to access field values that may be hidden by a computed value. Consider

type Hider {
    Name() : Text { "Hides instance values" };
}

Given the preceding declaration, the following two expressions would evaluate to true.

({Name = "Underlying value"} : Hider).Name == "Hides instance values"
({Name = "Underlying value"} : Hider)("Name") == "Underlying value"

An entity defines a constraint over a set of values. An entity type can be ascribed to any value that satisfies its constraint. Ascribing an entity type allows the computed values defined in the entity to be applied to the value.

Consider the following two entities and two instances. (The square root [SQRT] and absolute value [ABS] functions must be provided by a library; they are not intrinsic.)

type PointOnPlane {
    X : Single;
    Y : Single;
    DistanceFromOrigin : Single { SQRT(X * X + Y * Y) }
}

type PointOnLine {
    X : Single;
    Y : Single;
    DistanceFromOrigin : Single { ABS(X) * SQRT(2) }
} where X == Y;

Point1 = {X=1, Y=1};
Point2 = {X=0, Y=1};

Both entities define fields X and Y and a computed value DistanceFromOrigin although the implementation of the computed value differs. The first entity, PointOnPlane, allows any X,Y combination—the entire X,Y plane. The second entity, PointOnLine, has a constraint that restricts the values that can be members of the type.

Point1 is a member of both PointOnPlane and PointOnLine. Both declarations of DistanceFromOrigin are valid and yield the same result.

Point2 can be ascribed PointOnPlane but not of PointOnLine since the constraint X == Y is not satisfied. This prevents the alternative declaration of DistanceFromOrigin from producing an incorrect result.

New collection types are defined by a type constructor and a multiplicity ( +, *, #m..n ).

The default value for a collection type is the empty collection, written {}. The one-to-many multiplicity constraint forbids an empty collection so must have at least one member on initialization.

The following postfix unary operator takes Collection as a left operand.

The following binary operations take Collection as a left operand.

For the operators that return a collection, the inferred element type of the resulting collection is the most specific type that the elements of both operands may be converted to.

The following members are defined on all collections:

Choose() : Any;
Count() : Unsigned;
Distinct() : Collection;

Choose picks an arbitrary element from a collection. The return type is the element type. Count returns the total number of elements in a collection. The return type is a Number. Distinct removes all duplicates in a collection. The return type is the same as the collection.

The following members are defined on collections of type Logical*:

All() : Logical;
Exists() : Logical;

All returns false if false is an element of the collection and true otherwise. Exists returns true if true is an element of the collection and false otherwise.

The following members are defined on collections that are subtypes of Number*:

Average() : Scientific;
Maximum() : Number;
Minimum() : Number;
Sum() : Number;

Maximum, Minimum, and Sum are specialized to return the element type of the collection.

A collection may be accessed using language generated indexers of two kinds, selectors and projectors. A selector extracts members of a collection with a member that matches a value. A projector extracts all values of a field from a collection. Both of these operations can be accomplished with query expressions; however, this notation is more compact.

type Person {
    Id : Integer64 = AutoNumber();
    Name : Text;
    HairColor : Text;
} where identity Id, unique Name;

People : Person* {
    {Name = "Mary", HairColor = "Brown"},
    {Name = "John", HairColor = "Brown"},
    {Name = "Fritz", HairColor = "Blue"}
};

People.Name("Mary")

{{Name = "Mary", HairColor = "Brown" }}

People.Name("Bill")

{}

People.HairColor("Brown")

{
    {Name = "Mary", HairColor = "Brown" },
    {Name = "John", HairColor = "Brown"}
}

// Assuming the Fritz record was assigned the Id 123
People.Id(123)

{{Name = "Fritz", HairColor = "Blue"}}

Collection.MemberField(Expression)

from c in Collection
where c.MemberField == Expression
select c

People(123) == {{Name = "Fritz", HairColor = "Blue"}}

type Person Scdt1
{
    Name : Text;
    HairColor : Text;
} where identity Name;

People("Mary") == {{Name = "Mary", HairColor = "Brown" }}

Collection (Expression)

from c in Collection
where c. Identity == Expression
select c

type Person {
    Id : Integer64 = AutoNumber();
    Name : Text;
    HairColor : Text;
} where identity Id, unique Name;

People : Person* {
    {Name = "Mary", HairColor = "Brown"},
    {Name = "John", HairColor = "Brown"},
    {Name = "Fritz", HairColor = "Blue"}
};

People.Name == {"Mary", "John", "Fritz"}
People.HairColor == {"Brown", "Brown", "Blue"}
People.HairColor.Distinct == {"Brown", "Blue"}

Collection.MemberField

from c in Collection
select c.MemberField

Collections in M may contain multiple copies of the same element. The constraint unique value limits the number of elements in a collection with that field or fields of the same value to 1. No two elements in the collection will return true for ==.

The unique constraint may also take an expression or a comma separated list of expressions. In this case, the constraint will ensure no two elements are equal on every expression in the list.