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.

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.

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 that 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:

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 that 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 item.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.

The following example initializes the extent SmallNumbers to the collection of values 1, 2, 3, 4:

SmallNumbers { 1, 2, 3, 4 }

The following example initializes three extents: Colors, Makes, and Cars. Although there is no intrinsic enumeration type in the M language, the first two extents are used as enumerations.

Colors { Red = "Red", Blue = "Blue", Yellow = "Yellow" }
Makes { Ford = "Ford", Chevy = "Chevrolet" }
Cars {
    { Make = Makes.Ford, Color = Colors.Blue }
    { Make = Makes.Chevy, Color = Colors.Red }
}

M provides labeled collections to construct instances that reference each other. Consider the following type Person and extent People:

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

People : Person* where item.Spouse in People;

The Spouse field references another Person. One way to initialize this structure is to explicitly assign the identity of each instance:

People {
    { Id = 0, Name = "Jack", Age = 23, Spouse = 1 },
    { Id = 1, Name = "Jill", Age = 25, Spouse = 0 },
}

This assumes that the values 0 and 1 are not already used in the Person extent and exposes unnecessary implementation details. M provides label values to initialize references without explicit manipulation of identity values. Consider the following example, which initializes the same preceding structure:

People {
    Jack { Name = "Jack", Age = 23, Spouse = Jill },
    Jill { Name = "Jill", Age = 25, Spouse = Jack },
}

The label Jack introduces an identifier that can be used to reference the instance. This allows the first instance, Jack, to reference the second instance, Jill, as a spouse and vice versa.

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 item.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 {
     { Kind = "Graphics", Computer = Computers.MyPC },
     { Kind = "Sound", Computer = Computers.MyPC },
     { Kind = "Network", Computer = Computers.MyPC },
}

Using non-local initialization, this same structure can be initialized “top down” as follows:

Computers {
    MyPC { Processor = "x86",
            .Boards {
                 { Kind = "Graphics", Computer = MyPC },
                 { Kind = "Sound", Computer = MyPC },
                 { Kind = "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.

A SimpleName consists of a single identifier.

In the expression:

Person.Age

Both Person and Age are SimpleNames.

A ParenthesizedExpression consists of an Expression enclosed in parentheses:

A ParenthesizedExpression is evaluated by evaluating the Expression within the parentheses.

The ?? operator is called the null coalescing operator:

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.

The ?: operator is called the conditional operator. It is at times also called the ternary operator.

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 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.

The infix where operation filters elements from a collection that match a predicate:

WhereExpression:
  QueryExpression
  QueryExpression  where WhereExpressions
WhereExpressions:
  WhereExpression
  WhereExpressions  , WhereExpression

The WhereExpression introduces the identifier value into the scope of the right side to refer to an element of the collection on the left. The right side may also use any other identifiers that are in lexical scope.

If the QueryExpression returns a collection of collections (e.g. Number*); then the right side also introduces the identifier item into scope to refer to elements of the base domain.

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;

The keyword item constrains the values of elements of elements. The following declaration is equivalent to the previous:

SmallCollectionOneToTen : Number* where value.Count < 10 &&
    item > 0 &&
    item <= 10;

Formalizing this convention:

QueryExpression where Expression

is a compact syntax for one of the two following expressions:

from value in QueryExpression
where Expression
select value

from value in QueryExpression
where (from item in value select Expression).All
select value

The choice between the first and second expansions is made based on the type of the left operand to the where clause. If it is a collection of collections the second expansion is used; otherwise, if it is a collection, the first expansion is used; otherwise it is a type error.

The select operator applies an expression to every element in a collection and returns the results in a new collection:

SelectExpression:
  WhereExpression
  WhereExpression  select Expression

The SelectExpression introduces the identifier value into the scope of the right side to refer to an element of the collection on the left. The right 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 value.Name
{{}, {1}, {1,1}} select value#