The Microsoft code name "M" Modeling Language Specification - Expressions
November 2009
[This content is no longer valid. For the latest information on "M", "Quadrant", SQL Server Modeling Services, and the Repository, see the Model Citizen blog.]
[This documentation targets the Microsoft SQL Server Modeling CTP (November 2009) and is subject to change in future releases. Blank topics are included as placeholders.]
Sections:
1: Introduction to "M"
2: Lexical Structure
3: Text Pattern Expressions
4: Productions
5: Rules
6: Languages
7: Types
8: Computed and Stored Values
9: Expressions
10: Module
11: Attributes
12: Catalog
13: Standard Library
14: Glossary
9 Expressions
An expression is a sequence of operators and operands. This chapter defines the syntax, order of evaluation of operands and operators, and meaning of expressions.
9.1 Operators
Expressions are constructed from operands and operators. The operators of an expression indicate which operations to apply to the operands. Examples of operators include +, -, *, and /. Examples of operands include literals, fields, and expressions.
There are the following kinds of operators:
- Unary operators take one operand and use prefix notation such as –x.
- Binary operators take two operands and use infix notation such as x + y.
- Ternary operator. Only one ternary operator, ?:, exists; it takes three operands and uses infix notation (c? x: y).
- Query comprehensions
Precedence determines how operators are grouped with operands. Unless otherwise specified, the order of evaluation of operands is undefined.
A single syntactic operator may have different meanings depending on the type of its operands. That is, an operator may be overloaded. In this case, the meaning and the return type is determined by selecting the most specific super type for both operands for which a meaning and return type are specified in §2.
9.1.1 Operator precedence and associativity
Precedence and associativity determine how operators and operands are grouped together. For example, the expression x + y * z is evaluated as x + (y * z) because the * operator has higher precedence than +. The following table summarizes all operators in order of precedence from highest to lowest:
| Category | Operators |
|---|---|
Primary |
x.y f(x) |
Unary |
+ - ! # identity unique |
Multiplicity (unary postfix) |
? + * # |
Multiplicative |
* / % |
Additive |
+ - |
Relational and type testing |
< > <= >= in !in x:T |
Equality |
== != |
Logical And (conjunction) |
&& |
Logical Or (disjunction) |
|| |
Null Coalescing |
?? |
Conditional |
?: |
Query Comprehension |
from join let where select group by accumulate |
Where |
where |
Select |
select |
Bitwise And, Intersection |
& |
Bitwise Exclusive Or |
^ |
Bitwise Or, Union |
| |
When an operand occurs between two operators with the same precedence, the associativity of the operators controls the order in which the operations are performed. All binary operators are left associative, that is, operations are performed left to right. For example, x + y + z is evaluated as (x + y) + z.
Precedence and associativity can be controlled using parentheses. For example, x + y * z first multiplies y by z and then adds the result to x, but (x + y) * z first adds x and y and then multiplies the result by z.
9.2 Member access
A MemberAccessExpression takes an expression which resolves to a scope as the left operand and a symbol as the right operand. Evaluating the expression returns the value bound to the symbol in the scope.
syntax MemberAccessExpression
= PrimaryExpression "." MemberName;
syntax MemberName
= Identifier;
A MemberAccessExpression consists of a PrimaryExpression, followed by a "." token, followed by a member selector. Consider the following MemberAccessExpression:
{Name => "Bill", Age => 23}.Age
The member access operator looks up the symbol Age in the scope defined by the instance:
{Name => "Bill", Age => 23}
9.2.1 Symbol lookup
A symbol lookup is the process whereby the meaning of a name in a context is determined. A symbol lookup may occur as part of evaluating a SimpleName or a MemberAccess in an expression.
M is a lexically scoped language. Scopes introduce symbols and may nest and an inner scope may introduce a symbol which hides a symbol in an outer scope. Initially a symbol is resolved against the lexically innermost scope. If no matching symbol is found in the innermost scope, lookup proceeds in the containing scope. This process continues until the outermost scope is reached which is always a module.
The following are examples of scopes:
- An entity definition.
- A module.
- A field definition.
- The left hand side of a where expression.
- A query expression.
A member lookup of a name N in a type T is processed as follows: The set of all accessible members named N declared in T and the base types of T is constructed. If no members named N exist and are accessible, then the lookup produces no match.
Field declarations override lexical scoping to prevent the type of a declaration binding to the declaration itself. The ascribed type of a field declaration must not be the declaration itself; however, the declaration may be used in a constraint. Consider the following example:
type A;
type B {
A : A;
}
The lexically enclosing scope for the type ascription of the field declaration A is the entity declaration B. With no exception, the type ascription A would bind to the field declaration in a circular reference which is an error. The exception allows lexical lookup to skip the field declaration in this case.
A declaration may be used within a constraint on the ascribed type as in the following example:
type Node {
Label : Text;
Parent : Node;
}
Nodes : {(Node where value.Parent in Nodes)*};
The right operand of the in clause stipulates that the Parent field of a node must be within the collection being defined, Nodes.
9.3 Initializers
This needs to be cleaned up to make entities, collections, and lists primitive.
Entity types and collections use a common initialization syntax.
An InitializationExpression constructs a new instance of a collection or entity.
syntax InitializationExpression
= "{" Elements? "}"
| "[" Elements? "]"
| Kind? "{" Properties "}";
syntax Elements
= Expression ","?
| Elements "," Expression;
syntax Properties
= Property ","?
| Properties "," Property;
syntax Kind
= Identifier;
9.3.1 Collection Initializer
The following are three examples of unordered collections:
{ 1, 2, 3, 4 }
{ 1, 1, 1, 1, }
{ [], "Hello", 24 }
9.3.2 List Initializer
The following are three examples of lists:
[ "Red", "Blue", "Green"]
[]
[{}, 3, [], ]
9.3.3 Record Initializer
The following are three examples of records:
{ Name => "John", Age => 24 }
{ Title => "Specifying Systems", Author => "Leslie Lamport", }
{ Colors => {"Red", "Blue", "Green"} }
9.3.4 Kind Pattern
The kind pattern allows records to have a discriminator. It is a syntactic transformation that transforms the following pattern Identifier { . . . } into { Kind => "Identifier", . . .}.
Consider the following examples:
Person { Name => "John", Age => 24 }
Cat { Name => "Fluffy", Age => 2 }
Dog { Name => "Rover", Age => 8 }
These are equivalent to:
{ Kind => "Person", Name => "John", Age => 24 }
{ Kind => "Cat", Name => "Fluffy", Age => 2 }
{ Kind => "Dog", Name => "Rover", Age => 8 }
9.3.5 Non Local Initialization
This section needs to be updated to new structures design and we should look at whether the feature is needed any longer.
It is frequently useful to initialize a value in another structure. In the following example computers have zero to many boards. This relationship is implemented as a reference from Board to Computer.
type Computer {
Id : Integer32 => AutoNumber();
Processor : Text;
} where identity Id;
type Board {
Id : Integer32 => AutoNumber();
Kind : Text;
Computer : Computer;
} where identity Id;
Boards : {(Board where value.Computer in Computers)*};
Computers : {Computer*};
Creating an instance of a computer requires initializing both the computer and the boards. This can be initialized "bottom up" as follows:
Computers {
MyPC { Processor => "x86"}
}
Boards {
Graphics { Computer => Computers.MyPC },
Sound { Computer => Computers.MyPC },
Network { Computer => Computers.MyPC },
}
Using non local initialization, this same structure can be initialized "top down" as follows:
Computers {
MyPC { Processor => "x86",
.Boards {
Graphics { Computer => MyPC },
Sound { Computer => MyPC },
Network { Computer => MyPC },
}
}
}
The dot prefix to the Boards label (.Boards) does not introduce a new label into the current scope. Rather, it looks up the symbol at the extent scope and adds the content to that extent.
9.4 Invocation Expression
The Identifier in an InvocationExpression resolves to a computed value declaration of the same name and arity. Evaluating an invocation expression causes each argument to be evaluated. The result of each argument is bound to the formal parameter in the corresponding position. The result of evaluating the body of the computed value declaration is the value of the invocation expression.
syntax InvocationExpression
= Identifier "(" Arguments? ")";
syntax Arguments
= Argument
| Arguments "," Argument;
syntax Argument
= Expression;
9.5 Primary expressions
The following rules define the grammar for primary expressions.
syntax PrimaryExpression
= Literal
| SimpleName
| ParenthesizedExpression
| MemberAccessExpression
| InvocationExpression
| InitializationExpression
| EntityTypeExpression
| ContextVariable
| AboutExpression;
Literal is defined in §2.5. EntityTypeExpression is defined in §7.5. The remaining non terminals are defined in this section, §8.3.
9.5.1 Simple names
A SimpleName consists of a single identifier.
syntax SimpleName
= Identifier;
In the expression:
Person.Age
Both Person and Age are SimpleNames.
9.5.2 Parenthesized expressions
A ParenthesizedExpression consists of an Expression enclosed in parentheses.
syntax ParenthesizedExpression
= "(" Expression ")";
A ParenthesizedExpression is evaluated by evaluating the Expression within the parentheses.
9.5.3 Context variable
The following rules define the grammar for context variables.
syntax ContextVariable
= "value";
Value is defined in §9.14.1.
9.5.4 About operator
The about is used to obtain the entry in Language.Catalog (§12) for a symbol. About is a special form, not a computed value. The symbol must be visible in the current scope and is resolved using normal symbol resolution rules. On evaluation, rather than returning the value the symbol represents, about returns a reference to the metadata for the symbol itself.
syntax AboutOperator
= "about" "(" DottedIdentifer ")";
Examples:
module Test {
import Language.Catalog;
type Person {
Name : Text;
Age : Integer;
}
People : {Person*};
Children() { People where Age < 18 }
Documentation : {{
About : Language.Catalog.Declaration,
Description : Text
}*};
Documentation {
{
About => about(Person).Declaration,
Description => "Describes people"
},
{
About => about(People).Declaration,
Description => "Contains people"
},
{
About => about(Children).Declaration,
Description => "Extracts young people"
},
}
}
The following table defines the classes of symbols that are resolved with about and the resulting entry in Language.Catalog.
| Symbol | Language.Catalog |
|---|---|
Computed Value |
ComputedValueGroup |
Extent |
Extents |
Module |
Modules |
Type |
Types |
9.6 Unary operators
The following rules define the grammar for unary operators.
syntax UnaryExpression
= PrimaryExpression
| "+" PrimaryExpression
| "-" PrimaryExpression
| "!" PrimaryExpression
| PrimaryExpression "#"
| IdentityExpression
| UniqueExpression;
syntax IdentityExpression
= identity Identifier
| identity "(" Identifiers ")";
syntax UniqueExpression
= unique Identifier
| unique "(" Identifiers ")";
The identity constraint is discussed in §7.5.2.
The type rules for unary operators are defined in Number §7.4.3.1, Logical §7.4.5, and Collection §7.6.2.
Examples of unary operators follow:
+1
-2
!true
!0x00
{1,2,3}#
identity Id
unique Name
9.7 Multiplicity
The following rules define the grammar for multiplicity operators.
syntax MultiplicityExpression
= UnaryExpression
| UnaryExpression "?"
| CollectionTypeExpression
| ListTypeExpression;
The type rules for multiplicity operators are defined in type operators §7.3.
Examples of multiplicity expressions follow:
Integer32?
[Text#2..4]
{{Name : Text; Age : Integer32}*}
9.8 Arithmetic operators
The following rules define the grammar for arithmetic operators.
syntax AdditiveExpression
= MultiplicativeExpression
| AdditiveExpression "+" MultiplicativeExpression
| AdditiveExpression "-" MultiplicativeExpression;
syntax MultiplicativeExpression
= UnaryExpression
| MultiplicativeExpression "*" MultiplicityExpression
| MultiplicativeExpression "/" MultiplicityExpression
| MultiplicativeExpression "%" MultiplicityExpression ;
The type rules on arithmetic operators are defined in Number §7.4.3, Text §7.4.4, Date §7.4.7, Time §7.4.8.
Examples of arithmetic operators follow:
1 + 1
2 * 3
"Hello " + "World"
9.9 Relational and type-testing operators
The following rules define the grammar for relational and type testing operators.
syntax RelationalExpression
= AdditiveExpression
| RelationalExpression "<" ShiftExpression
| RelationalExpression ">" ShiftExpression
| RelationalExpression "<=" ShiftExpression
| RelationalExpression ">=" ShiftExpression
| RelationalExpression "in" ShiftExpression
| RelationalExpression ":" ShiftExpression;
The type rules on relational and type-testing operators are throughout §2.
9.10 Equality operators
The following rules define the grammar for equality operators.
syntax EqualityExpression
= RelationalExpression
| EqualityExpression "==" RelationalExpression
| EqualityExpression "!=" RelationalExpression;
The type rules on equality operators are throughout §2.
9.11 Logical operators
The following rules define the grammar for logical operators.
syntax LogicalAndExpression
= EqualityExpression
| LogicalAndExpression "&&" EqualityExpression;
syntax LogicalOrExpression:
= LogicalAndExpression
| LogicalOrExpression "||" LogicalAndExpression;
The type rules on logical operators are defined in Logical §7.4.5.
9.12 Conditional operators
There are two conditional operators coalesce and conditional.
9.12.1 Coalescing operator
The ?? operator is called the null coalescing operator.
syntax NullCoalescingExpression
= LogicalOrExpression
| LogicalOrExpression "??" NullCoalescingExpression;
A null coalescing expression of the form a ?? b requires a to be nullable. If a is not null, the result of a ?? b is a; otherwise, the result is b. The operation evaluates b only if a is null.
b must be of the same type as a without the value null.
9.12.2 Conditional operator
The ?: operator is called the conditional operator. It is at times also called the ternary operator.
syntax ConditionalExpression:
= NullCoalescingExpression
| NullCoalescingExpression "?" Expression ":" Expression;
A conditional expression of the form b ? x : y first evaluates the condition b. Then, if b is true, x is evaluated and becomes the result of the operation. Otherwise, y is evaluated and becomes the result of the operation. A conditional expression never evaluates both x and y.
The conditional operator is right-associative, meaning that operations are grouped from right to left. For example, an expression of the form a ? b : c ? d : e is evaluated as a ? b : (c ? d : e).
The first operand of the ?: operator must be an expression of a type that can be implicitly converted to Logical otherwise a compile-time error occurs. The middle and left operands must be of compatible types. The result of the conditional is the least specific type.
9.13 Query expressions
Query expressions provide a language integrated syntax for queries that is similar to relational and hierarchical query languages such as Transact SQL and XQuery.
A query expression begins with a from clause and ends with either a select, group or accumulate clause. The initial from clause can be followed by zero or more from, let, or where clauses. Each from, let and join clause introduces a scope that adds one iteration identifier that is in scope for the remainder of the query expression.
syntax QueryExpression
= ConditionalExpression
| QueryFromClause QueryBody;
syntax QueryBody
= QueryBodyClauses? QueryConstructor;
syntax QueryBodyClauses
= QueryBodyClause
| QueryBodyClauses QueryBodyClause;
syntax QueryBodyClause
= QueryFromClause
| QueryLetClause
| QueryWhereClause
| QueryJoinClause;
syntax QueryConstructor
= QuerySelectClause
| QueryGroupClause
| QueryAccumulateClause;
syntax QueryFromClause
= "from" Identifier "in" ConditionalExpression;
syntax QueryLetClause
= "let" Identifier "=" ConditionalExpression;
syntax QueryJoinClause
= "join" Identifier "in" Expression "on" Expression "equals"
ConditionalExpression;
syntax QueryWhereClause
= "where" ConditionalExpression;
syntax QuerySelectClause
= "select" ConditionalExpression;
QueryGroupClause
= "group" Expression "by" ConditionalExpression;
QueryAccumulateClause
= QueryLetClause "accumulate" ConditionalExpression;
9.13.1 From clause
The from clause introduces an identifier that ranges over a collection. The following query body is interpreted once for each element in the collection with the identifier bound to that element. Thus if there are two from clauses in sequence, the query body following the second will be interpreted for the first element of the first collection and every element of the second collection, then for the second element of the first collection and every element of the second collection, etc. This ordering will be respected for ordered collections (lists). For unordered collections the elements may be processed in any order.
The following are examples of the from clause:
from n in {1,2,3,4,5}
select n
from n1 in {1,2,3,4,5}
from n2 in {1,2,3,4,5}
select n1*n2
from p in People
select { Name => p.Name, Age => p.Age }
9.13.2 Where clause
A where clause contains a predicate that filters further interpretation within a query expression. The expression
where true
has no effect.
The expression
where false
blocks further interpretation. The query expression will always return the empty set.
The following are examples of the where clause:
from n in {1, 2, 3, 4, 5}
where n%2 == 0
select n
from p in People
where p.Age > 17
select p
from n1 in {1,2,3,4,5}
from n2 in {1,2,3,4,5}
where n1 != n2
select n1*n2
9.13.3 Select clause
The select clause is a query constructor and determines results of the query expression. Consider a select clause of the following form:
select Expression
Where expression has type T. The type of the query expression will be [T*] if all collections in the from and join expressions are ordered and will be {T*} otherwise.
The following are examples of the select clause:
from n in {1,2,3,4,5}
select n%2
from p in People
select p.Name
from p in People
select {Name => p.Name, Age => p.Age}
9.13.4 Join clause
The join clause is a compact syntax for a common pattern. The expression
join x in Collection on Expression1 equals Expression2
is equivalent to
from x in Collection
where Expression1 == Expression2
The following are examples of the join clause:
from n1 in {1,2,3,4,5}
join n2 in {1,2,3,4,5} on n1 equals n2
select n1*n2
from c in Customers
join o in Orders on c.Id equals o.CustomerId
select { Customer => c.Name, OrderedOn => o.Submitted }
from a in Actors
join r in Roles on a.Id equals r.ActorId
join m in Moves on m.Id equals r.MovieId
select { Actor => a.FirstName + " " + a.LastName, Movie => m.Title }
9.13.5 Let clause
The let clause is a compact syntax for a common pattern. The expression
let x = Expression
is equivalent to
from x in {Expression}
The following are examples of the let clause:
from n in {1,2,3,4,5}
let pi = 3.1415
select { Radius => n, Area => n*n*pi }
from p in People
let FullName = p.First + " " + p.Last
select { Name => FullName, Age => p.Age }
from a in Actors
let FullName = a.FirstName + " " + a.LastName
join r in Roles on a.Id equals r.ActorId
join m in Moves on m.Id equals r.MovieId
select { Actor => FullName, Movie => m.Title }
9.13.6 Group By clause
The group by clause is a compact syntax for a common pattern. The expression:
from c in Collection
group c by F(c)
is equivalent to
from key in (Collection select F(value)).Distinct
select { Key => key, Value => (Collection where key == F(value)) }
The following are examples of the group by clause:
from n in {1,2,3,4,5}
group n by n%2
from p in People
group p by p.Age
from c in Cars
group c by c.Color
9.13.7 Accumulate clause
The accumulate keyword generalizes Sum, Min, Max et cetera. Its purpose is to repeatedly apply an expression to each element in a collection and accumulate the result.
The type of the expression in the let clause and the expression in the accumulate clause must be compatible. This type is the type of the expression.
Consider the following fragment:
from c in Collection
let a = Expression1
accumulate Expression2
Expression1 is evaluated and the result is bound to the identifier a. Expression2 is evaluated once for every element of Collection. Upon each evaluation the result is bound to the identifier a.
As an example, the following M code sums the elements in the collection Numbers:
from n in Numbers
let i = 0
accumulate i + n
The following computes minimum of a collection of {Integer32*}:
from n in Integers
let i = MaxInteger32
accumulate i < n ? i : n
The following computes the maximum of a collection of {Integer32*}:
from n in Integers
let i = MinInteger32
accumulate i > n ? i : n
The following returns false if a collection contains false and true otherwise:
from b in TruthValues
let r = true
accumulate b && r
The following returns true if a collection contains true and false otherwise:
from b in TruthValues
let r = false
accumulate b || r
9.14 Compact query expressions
There are two compact forms for query expressions the binary infix where and select.
9.14.1 Where operator
The infix where operation filters elements from a collection that match a predicate.
syntax WhereExpression
= QueryExpression
| QueryExpression "where" WhereExpressions;
syntax WhereExpressions
= WhereExpression
| WhereExpressions "," WhereExpression;
The WhereExpression introduces the identifier value into the scope of the right hand side to refer to an element of the collection on the left. The right hand side may also use any other identifiers that are in lexical scope.
The following example uses value to filter the Numbers collection:
OneToTen : Number where value > 0 && value <= 10;
When used over a collection type, value refers to the collection:
SmallCollection : {Number*} where value.Count == 2;
SmallCollectionOneToTen : {(Number where value > 0 && value <=10)*}
where value.Count < 10;
Formalizing this convention:
QueryExpression where Expression
Is a compact syntax for the following expression:
from value in QueryExpression
where Expression
select value
9.14.2 Select operator
The select operator applies an expression to every element in a collection and returns the results in a new collection.
syntax SelectExpression
= WhereExpression
| WhereExpression "select" Expression;
The SelectExpression introduces the identifier value into the scope of the right hand side to refer to an element of the collection on the left. The right hand side may also use any other identifiers that are in lexical scope.
Examples of the select operator follow:
{1, 2, 3} select value * 2
People select { Name => value.Name, Age => value.Age }
{{}, {1}, {1,1}} select value#
The select operator can be rewritten to a full query expression:
Collection select Expression
Is equivalent to:
from value in Collection
select Expression
9.15 Binary and Collection operators
The following rules define the grammar for binary and collection operators.
syntax InclusiveOrExpression
= ExclusiveOrExpression
| InclusiveOrExpression "|" ExclusiveOrExpression;
syntax ExclusiveOrExpression
= AndExpression
| ExclusiveOrExpression "^" AndExpression;
syntax AndExpression
= SelectExpression
| AndExpression "&" SelectExpression;
The type rules on binary and collection operators are defined in Number §7.4.3, and Collection §7.6.2.
9.16 Expressions
An expression is a sequence of operands and operators. Applying the operator to the operand yields a value.
syntax Expression
= InclusiveOrExpression;