An integer literal, as defined in §2.4.1 Numeric literals, is an expression of type Integer, representing a numeric integer.

Integer five = 5;

Integer mask = $1111_0000;

Integer white = #FFFF;

A floating point literal, as defined in §2.4.1 Numeric literals, is an expression of type Float, a floating-point representation of a numeric value.

shared Float pi = 3.14159;

A single character literal, as defined in §2.4.2 Character literals, is an expression of type Character, representing a single 32-bit Unicode character.

if (exists ch=string[i], ch == '+') { ... }

A character string literal or verbatim string, as defined in §2.4.3 String literals, is an expression of type String, representing a sequence of Unicode characters.

person.name = "Gavin King";

print("Melbourne\tVic\tAustralia\nAtlanta\tGA\tUSA\nGuanajuato\tGto\tMexico\n");

String verbatim = """A verbatim string can have \ or a " in it."""";

The keyword this refers to the current instance, as defined in §8.2.3 Current instance of a class or interface, of the immediately containing class or interface (the class or interface in which the expression appears). Its type is the applied type formed by the immediately containing class or interface with its own type parameters as type arguments.

The keyword outer refers to the current instance, as defined in §8.2.3 Current instance of a class or interface, of the class or interface which immediately contains the immediately containing class or interface. Its type is the applied type formed by this class or interface with its own type parameters as type arguments.

The keyword super refers to the current instance of the immediately containing class or interface. Its type is the intersection of the principal instantiation of the immediate superclass for the immediately containing class or interface, as defined in §3.7.4 Principal instantiation of a supertype, with all principal instantiations of immediate superinterfaces of the immediately containing class or interface. A member reference such as super.x may not resolve to a formal declaration, nor to any member inherited from more than one supertype of the intersection type.

As an exception to this, when the keyword super occurs in an extends clause, as specified in §3.3.2 Extension, it refers to the current instance of the class or interface which immediately contains the declaration to which the extends clause belongs. Its type is the intersection of the principal instantiation of the immediate superclass of this containing class or interface, with all principal instantiations of immediate superinterfaces of this containing class or interface.

The keyword super may occur as the first operand of an of operator, in which case the second operand is the principal instantiation of some supertype of the class for the immediately containing class or interface. The expression (super of Type) has type Type. A member reference such as (super of Type).x may not resolve to a formal member, nor to any member inherited from more than one supertype of Type, nor to any member that is refined by the class or any intermediate supertype of the class.

If the type of a parameter of an anonymous function is not declared explicitly, then the type of the parameter may in certain cases be inferred if the anonymous function occurs:

Suppose the type of the ith parameter p of an anonymous function is not declared explicitly, and further suppose that the anonymous function occurs as the argument to a parameter x of some function or class in a direct invocation expression, as defined in §6.6.1 Direct invocations.

Then the type of p may be inferred if either:

Then the type of p is inferred to be the type of q in the realization of the function or class, as defined in §3.7.7 Realizations.

Otherwise, suppose the type of the ith parameter p of an anonymous function is not declared explicitly, and further suppose that the anonymous function occurs as the nth argument in the positional argument list of an indirect invocation expression.

Then if the callable type of the invoked expression represents a function whose nth parameter is a callable parameter with the same number of parameters as the anonymous function, according to §4.7.1 Callable type of a function, then the type of p is inferred to be the type of the corresponding ith parameter of this callable parameter.

That is, if the type of the invoked expression is R(*T) where T is a tuple type whose nth element type is P(*S) and S is in turn a tuple type whose ith element type is Q, then Q is the inferred type of p.

A base expression is an identifier, optionally qualified by the keyword package, with an optional list of type arguments:

BaseExpression: PackageQualifier? (MemberName | TypeName) TypeArguments?

A base expression is either:

The referenced declaration is determined by resolving the unqualified reference as defined by §5.1.7 Unqualified reference resolution. The unqualified realization for the unqualified reference is determined according to §3.7.7 Realizations.

The type argument list, if any, must conform, as defined by §3.6.3 Type arguments and type constraints, to the type parameter list of the unqualified realization.

If a base expression is a reference to an attribute, method, member class, or member class constructor of a class, the receiving instance is the current instance of that class, as defined by §8.2.3 Current instance of a class or interface. Otherwise, there is no receiving instance.

A member expression is a receiver expression, followed by an identifier, with an optional list of type arguments.

MemberExpression: (Primary ".") (MemberName | TypeName) TypeArguments?

A member expression is a reference to a member of a type: an attribute, method, or member class.

The referenced member is determined by resolving the qualified reference as defined by §5.1.8 Qualified reference resolution. The qualified realization for the qualified reference is determined according to §3.7.7 Realizations.

The type argument list, if any, must conform, as defined by §3.6.3 Type arguments and type constraints, to the type parameter list of the qualified realization.

The receiver expression produces the instance upon which the member is invoked or evaluated. When a member expression is executed, the receiver expression is evaluated to produce the receiving instance which is held until the member is invoked or evaluated, as defined in §8.4 Evaluation, invocation, and assignment.

A constructor expression is a base or member expression that references a class with constructors, followed by an identifier, with an optional list of type arguments.

ConstructorExpression: (BaseExpression | MemberExpression) "." MemberName TypeArguments?

A constructor expression is a reference to a constructor of a class.

The referenced member is determined by resolving the qualified reference as defined by §5.1.8 Qualified reference resolution. The qualified realization for the qualified reference is determined according to §3.7.7 Realizations.

The type argument list, if any, must conform, as defined by §3.6.3 Type arguments and type constraints, to the type parameter list of the qualified realization.

If the constructor expression is qualified by a member expression, its receiver expression produces the instance upon which the constructor is invoked. When a constructor expression is executed, the receiver expression is evaluated to produce the receiving instance which is held until the constructor is invoked or evaluated, as defined in §8.4 Evaluation, invocation, and assignment.

A value reference is a base expression or member expression that references a value declaration or value constructor declaration.

The type of a value reference expression is the type of the realization of the referenced value or value constructor.

A value or value constructor declaration is never generic, so a value reference never has a type argument list.

A value reference that does not occur within any dynamic block may not refer to a value declaration or value parameter with no type.

A value reference which occurs within a dynamic block and which does not reference any statically typed declaration, or which references a value declaration or value parameter with no type, has no type.

If a base expression or member expression does not reference any statically typed declaration, and occurs within a dynamic block, then it is considered a value reference.

A callable reference is a base expression, member expression, or constructor expression that references something—a function, class, or callable constructor—that can be invoked or instantiated by specifying a list of arguments.

If a callable reference refers to a class with a default constructor, the callable reference is considered a reference to the default constructor.

A callable reference may be invoked immediately, or it may be passed to other code which may invoke the reference. A callable reference captures the return type and parameter list types of the function or class it refers to, allowing compile-time validation of argument types when the callable reference is invoked.

The type of a callable reference expression is the callable type of the realization of the referenced function, class, or callable constructor.

If a callable reference expression refers to a generic declaration, it must either:

A callable reference may not occur as the receiver expression of a member expression.

A callable reference that does not occur within any dynamic block may not refer to a function declaration with no return type.

A callable reference which occurs within a dynamic block and which references a function declaration with no return type, has no type.

If a callable reference f with no explicit type argument list occurs as the argument to a callable parameter p of a function or class in a direct invocation expression, as defined below in §6.6.1 Direct invocations, then the type arguments of f are inferred according to the rules defined in §3.6.5 Type argument inference as if the types of the parameters of p were the types of listed arguments of f in a positional argument list, unless the invoked function or class is generic, and the invocation expression does not itself specify explicit type arguments, in which case any parameter whose type involves a type argument of the invoked function or class is ignored.

If a callable reference f with no explicit type argument list occurs as the argument to a value parameter p of type Return(*Args) in a direct or indirect invocation expression, then the type arguments of f are inferred according to the rules defined in §3.6.5 Type argument inference as if Args were the type of a positional argument list, unless the invocation is a direct invocation expression, and the invoked function or class is generic, and Args involves type parameters of the invoked function or class.

A static expression is a type, optionally qualifier by the keyword package, followed by an identifier, with an optional list of type arguments.

StaticExpression: PackageQualifier? (TypeName TypeArguments? ".")+ (MemberName | TypeName) TypeArguments?

A static expression is a reference to a member of a type: an attribute, method, or member class, or to a constructor of a member class of the type.

The referenced member is determined by resolving the qualified reference as defined by §5.1.8 Qualified reference resolution. The qualified realization for the qualified reference is determined according to §3.7.7 Realizations.

The type argument list, if any, must conform, as defined by §3.6.3 Type arguments and type constraints, to the type parameter list of the qualified realization.

Unlike member expressions, a static expression does not have a receiver expression. All static expressions are callable expressions which accept an argument of the specified type.

A static expression must reference a statically typed declaration with no missing types, even within a dynamic block.

If the qualifying type in a static expression refers to a generic declaration, then either:

If a static expression T.m for a generic type T with no explicit type argument list occurs as the argument to a parameter p of type Return(*Arg) in a direct or indirect invocation expression, then the type arguments of T are inferred according to the rules defined in §3.6.5 Type argument inference as if Arg were the type of a positional argument list, and [T] were the type of a parameter list, unless the invocation is a direct invocation expression, and the invoked function or class is generic, and Arg involves type parameters of the invoked function or class.

A static value reference is a static expression that references an attribute declaration or member class value constructor declaration.

List<Anything>.size

The type of a static value reference expression is:

A value or value constructor declaration is never generic, so a static value reference never ends in a type argument list.

A static callable reference is a static expression that references something—a method or member class, or a callable constructor of a member class—that can be invoked or instantiated.

List<String>.filter

Iterable<Integer>.map<String>

The type of a static callable reference expression is:

If a callable reference expression refers to a generic declaration, it must end in an explicit type argument list.

Any invocation expression where the invoked expression is a callable reference expression is called a direct invocation expression of the function, class, or callable constructor to which the callable reference refers.

A direct invocation expression of a callable reference expression that refers to a class or constructor is called a (direct) instantiation expression.

In a direct invocation expression:

If an invocation expression has a named argument list, it must be a direct invocation.

The type of a direct invocation expression is the return type of the realization of the function, or the type of the realization of the class, as defined in §3.7.7 Realizations.

If the function has no return type, and occurs within a dynamic block, then the whole direct invocation expression has no type.

In a direct invocation expression of a function, class, or callable constructor, the restriction above on the argument list type is equivalent to the following requirements. Given the parameter list of the realization of the function, class, or callable constructor, and the arguments of the direct invocation:

Furthermore, if type argument are inferred, then the inferred type arguments must conform, as defined by §3.6.3 Type arguments and type constraints, to the type parameter list of the realization of the function or class, or class to which the callable constructor belongs.

If an argument expression has no type, or if its parameter has no type, and the invocation occurs within a dynamic block, then the argument is not type-checked at compile time.

An invocation expression that does not occur within any dynamic block may not assign an argument to a value parameter with no type.

When no argument is assigned to a defaulted parameter by the caller, the default argument defined by the parameter declaration of the realization, as defined by §3.6.3 Type arguments and type constraints, of the function, class, or callable constructor is used. The default argument expression is evaluated every time the method is invoked with no argument specified for the defaulted parameter.

This class:

shared class Counter(Integer initialCount=0) { ... }

May be instantiated using any of the following invocations:

Counter()

Counter(1)

Counter {}

Counter { initialCount=10; }

A list of arguments may be formed from:

ArgumentList: ((ListedArgument ",")* (ListedArgument | SpreadArgument | Comprehension))?

Every such list of arguments has a type, which captures the types of the individual arguments in the list. This type is always a subtype of Anything[]. The type of an empty list of arguments is [].

A listed argument is an expression.

ListedArgument: Expression

If a listed argument is an expression of type T, and a list of arguments has type P with principal instantiation Sequential<Y>, then the type of a new argument list formed by prepending the expression to the first parameter list is Tuple<T|Y,T,P>.

A spread argument is an expression prefixed by the spread operator *.

SpreadArgument: "*" ValueExpression

The spread operator is parsed with a precedence just lower than the multiplication operator * and just higher than the set union and complement operators | and ~, and is not associative.

The expression type T must have the principal instantiation {X*} for some type X. We form the sequential type of a spread argument as follows:

When a spread argument with an expression type not assignable to Anything[] is evaluated, the elements of the iterable automatically are packaged into a sequence.

The type of a list of arguments containing only a spread argument of sequential type S is simply S.

A comprehension accepts one or more streams of values and produces a new stream of values. Any instance of Iterable is considered a stream of values. The comprehension has two or more clauses:

Every comprehension begins with a for or if clause, and ends with an expression clause. There may be any number of intervening for or if clauses. Each clause in the comprehension is considered a child of the clause that immediately precedes it.

Comprehension: ForComprehensionClause | IfComprehensionClause

ForComprehensionClause: "for" ForIterator ComprehensionClause

IfComprehensionClause: "if" ConditionList ComprehensionClause

ComprehensionClause: ForComprehensionClause | IfComprehensionClause | Expression

An expression that occurs in a child clause may refer to iteration variables and condition variables declared by parent clauses. The types of such variables are specified in §5.5 Control structures and assertions.

The type of a list of arguments containing only a comprehension is [T*] where T is the type of the expression which terminates the comprehension, or [T+] if there are no if clauses, and if every for clause has an iterated expression of nonempty type.

When invocation arguments are listed positionally, the argument list is enclosed in parentheses.

PositionalArguments: "(" ArgumentList ")"

The type of the positional argument list is the type of the list of arguments it contains.

When invocation arguments are listed by name, the argument list is enclosed in braces.

NamedArguments: "{" NamedArgument* ArgumentList "}"

Named arguments may be listed in a different order to the corresponding parameters.

Each named argument in a named argument list is either:

NamedArgument: AnonymousArgument | SpecifiedArgument | InlineDeclarationArgument

Additionally, a named argument list has an ordinary list of arguments, which may be empty. This argument list is interpreted as a single argument to a parameter of type Iterable.

{ initialCapacity=2; "hello", "world" }

{ initialCapacity=people.size; loadFactor=0.8; for (p in people) p.name->p }

An inline declaration argument or an ordinary list of arguments occurring in an extends clause of a class may not contain a reference to a variable attribute of the class.

Given a parameter list, and a named argument list, we may attempt to construct an equivalent positional argument list as follows:

The resulting equivalent positional argument list is formed by ordering the arguments according to the position of their corresponding parameters in the parameter list, and then replacing any inline value, function, or object declarations with a reference to the declaration.

The type of a named argument list is the type of the equivalent positional argument list.

An anonymous argument is just an expression followed by a semicolon.

AnonymousArgument: Expression ";"

The type of the argument is the type of the expression.

{
    Head { title="Hello"; };
    Body {
        Div { "Hello ``name``!" };
    };
}

A specified argument is a value specification statement or lazy specification statement, as defined in §5.3.3 Specification statements, where the value reference or callable reference is treated as the name of a parameter of the invoked function or class instead of using the usual rules for resolving unqualified names.

SpecifiedArgument: Specification

{ 
    product = getProduct(id); 
    quantity = 1; 
}

{ 
    by(Value x, Value y) => x<=>y;
}

An inline declaration argument defines a getter, function, or anonymous class, and assigns it to a parameter.

InlineDeclarationArgument: ValueArgument | FunctionArgument | ObjectArgument

An inline getter argument is a streamlined value declaration, as defined in §4.8 Values. The type of the argument is the declared or inferred type of the value.

ValueArgument: ValueHeader (Block | (Specifier | LazySpecifier) ";")

An inline function argument is a streamlined function declaration, as defined in §4.7 Functions. The type of the argument is the callable type of the function, as defined by §4.7.1 Callable type of a function.

FunctionArgument: FunctionHeader (Block | LazySpecifier ";")

An inline anonymous class argument is a streamlined anonymous class declaration, as defined in §4.5.7 Anonymous classes. The type of the argument is the anonymous class type.

ObjectArgument: ObjectHeader ClassBody

A named argument may not have type parameters or annotations.

{
    description = "Total";
    value amount { 
        variable Float total = 0.0;
        for (Item item in items) {
            sum += item.amount;
        }
        return total;
    }
}

{ 
    label = "Say Hello"; 
    void onClick() { 
        say("Hello!"); 
    } 
}

{ 
    function by(Value x, Value y) => x<=>y;
}

{
    object iterator 
            satisfies Iterator<Order> {
        variable value done = false;
        shared actual Order|Finished next() {
            if (done) {
                return finished;
            }
            else {
                done=true;
                return order; 
            }
        }
    }   
}

An enumeration expression is an abbreviation for tuple and iterable object instantiation. Iterable enumerations are delimited using braces. Tuple enumerations are delimited by brackets.

Enumeration: Iterable | Tuple | DynamicValue

Iterable: "{" ArgumentList "}"

Tuple: "[" ArgumentList "]"

The type of an iterable enumeration expression is:

The type of a tuple enumeration expression is the type of the list of arguments it contains.

{String+} = { "hello", "world" };

[] none = [];

[Float,Float] xy = [x, y];

[Float,Float, String*] xy = [x, y, *labels];

Every argument expression must have a type, even if the enumeration expression occurs in a dynamic block.

An iterable enumeration expression occurring in an extends clause of a class may not contain a reference to a variable attribute of the class.

A dynamic enumeration expression creates a new object with no class by enumerating its members, allowing interoperation with dynamically typed native code.

DynamicValue: "dynamic" "[" NamedArgument* ArgumentList "]"

A dynamic enumeration expression has no type.

Any argument names may be specified in the named argument list.

A dynamic enumeration expression must occur inside a dynamic block.

An if/then/else expression has a condition list, as defined in §5.4 Conditions, a then expression, and an else expression. The else expression is not optional.

IfElseExpression: "if" ConditionList ThenExpression ElseExpression

The type of an if/then/else expression with then expression of type X and else or else if expression of type Y is X|Y.

ThenExpression: "then" Expression

ElseExpression: "else" Expression

The expression following then or else is parsed with precedence just higher than the || operator, and just lower than the then and else operators, that is, between the layers 3 and 4 defined in §6.8.1 Operator precedence.

Alternatively, the expression following then or else may be an if/then/else expression or a let expression.

if (exists lang) then lang.name else "Ceylon"

A switch/case/else expression has a switch expression or inline variable, a list of case expressions, and, optionally, an else expression.

SwitchCaseElseExpression: Switch CaseExpression+ ElseExpression

The type of a switch/case/else expression with case expressions of type X1, X2, ..., Xn and else expression of type Y is X1|X2|...|Xn|Y.

CaseExpression: "case" CaseCondition Expression

The expression following case or else is parsed with precedence just higher than the || operator, and just lower than the then and else operators, that is, between the layers 3 and 4 defined in §6.8.1 Operator precedence.

Alternatively, the expression following then or else may be an if/then/else expression or a let expression.

Each case expression includes a value case or type case, as defined in §5.4.4 Case conditions. Just like in a switch/case/else conditional statement:

switch (seq) case (null) "null" case (is []) "empty" else "nonempty"

A let expression comprises a pattern list, followed by an expression involving the pattern variables that occur in the listed patterns.

LetExpression: "let" PatternList Expression

The expression is parsed with precedence just higher than the || operator, and just lower than the then and else operators, that is, between the layers 3 and 4 defined in §6.8.1 Operator precedence.

Alternatively, the expression may be an if/then/else expression or another let expression.

A pattern list is enclosed in parentheses.

PatternList: "(" PatternListElement ("," PatternListElement)* ")"

Each element of the pattern list is a pattern, as defined in §5.2.2 Patterns, followed by a specified expression. The patterned type is the type of the specified expression.

PatternListElement: Pattern Specifier

The pattern variables that occur in the pattern list are considered in scope in the expression that follows the pattern list. Furthermore, a specified expression in the pattern list may refer to a pattern variable declared by an earlier element in the pattern list.

let ([x,y] = loc, d = sqrt(x^2+y^2)) [x/d, y/d]

An inline anonymous class expression resembles an anonymous class declaration as defined in §4.5.7 Anonymous classes. The expression defines the schema, supertypes, and implementation of a class. It does not specify a type name. Instead, the type has a name assigned internally by the compiler that is not available at compilation time.

ObjectExpression: "object" ObjectInheritance ClassBody

The class:

The type of an inline anonymous class expression is the intersection of the class type it extends with all interface types it satisfies. The type of the inline anonymous class itself is not accessible outside the body of the inline anonymous class expression.

object 
        satisfies {Integer+} {
    iterator() => object 
            satisfies Iterator<Integer> {
        variable value current = 0;
        next() => current++;
    };
}

An inline anonymous class expression occurring in an extends clause of a class may not contain a reference to a variable attribute of the class.

There are 19 distinct operator precedence levels, but these levels are arranged into layers in order to make them easier to predict.

Within each layer, postfix operators have a higher precedence than prefix operators, and prefix operators have a higher precedence than binary operators.

There is a single exception to this principle: the binary exponentiation operator ^ has a higher precedence than the prefix operators + and -. The reason for this is that the following expressions should be equivalent:

-x^2       //means -(x^2)

0 - x^2    //means 0 - (x^2)

This table defines the relative precedence of the various operators, from highest to lowest, along with associativity rules:

It's important to be aware that in Ceylon, compared to other C-like languages, the logical not operator ! has a very low precedence. The following expressions are equivalent:

!x.y == 0.0  //means !(x.y == 0.0)

x.y != 0.0

The following tables define the semantics of the Ceylon operators. There are six basic operators which do not have a definition in terms of other operators or invocations:

All other operators are defined below in terms of other operators and/or invocations.

These operators support method invocation and attribute evaluation and assignment.

These operators compare values for equality, order, magnitude, or membership, producing boolean values.

A bounded comparison is an abbreviation for two binary comparisons:

for expressions l, u, and x.

These abbreviations have the same precedence as the binary < and <= operators, and, like the binary forms, are not associative.

These are the usual logical operations for boolean values.

These operators make it easy to work with optional expressions.

These operators provide a simplified syntax for accessing values of a Correspondence, for obtaining subranges of Ranged objects, and for spreading member access over a stream.

Operands within brackets in any subrange operator are parsed as if they were operands of the .. or : operators.

There are two special cases related to sequences. A type X is a sequence type if X is a subtype of Sequential<Anything>.

For any sequence type X with principal instantiation [E*] and integer n, we can form the nth tail type, Xn, of X as follows:

For any sequence type X and integer n, we can form the nth element type, En, of X as follows:

Then the two special cases are:

These operators simplify the syntax for instantiating certain commonly used built-in types.

Two special operators allow emulation of the famous ternary operator of C-like languages.

These are the usual mathematical operations for all kinds of numeric values.

Arithmetic operators automatically widen from Integer to Float when necessary. If one operand expression is of static type Integer, and the other is of type Float, the operand of type Integer is widened to a Float in order to make the operator expression well-typed. Widening is performed by evaluating the attribute float defined by Integer.

These operators provide traditional mathematical operations for sets.

The type of a metamodel expression depends upon the kind of declaration referenced:

Furthermore, given a member of a type T:

Finally:

If a type alias occurs inside a typed metamodel expression, it is replaced by its definition, after substituting type arguments, before determining the type of the metamodel expression.

Declaration reference expressions may be qualified by a member declaration qualifier, a sequence of identifiers identifying a class or interface declaration or an anonymous class declaration:

MemberDecQualifier: ( (TypeName | MemberName) "." )+

Each identifier in the member declaration qualifier is the name of a class, interface, or anonymous class.

A class reference expression, interface reference expression, alias reference expression, or type parameter reference expression is an optional member declaration qualifier, followed by the name of a class or anonymous class, interface, alias, or type parameter, with the keyword class, interface, alias, or given, respectively, surrounded by backticks.

TypeKeyword: "class" | "interface" | "alias" | "given"

TypeDec: "`" TypeKeyword ( PackageQualifier? MemberDecQualifier? (TypeName | MemberName) )? "`"

For a class or interface reference expression, the name of the class or interface is optional. In this case, the class or interface reference is to the immediately containing class or interface, if any, as defined in §6.3 Self references. For alias or type parameter reference expressions, the name of the alias or type parameter is required.

ClassDeclaration thisClass = `class`;

ClassDeclaration personClass = `class Person`;

ClassDeclaration thisInterface = `interface`;

InterfaceDeclaration stringListInterface = `interface List`;

AliasDeclaration numberAlias = `alias Number`;

TypeParameter elementTypeParameter = `given Element`;

CallableConstructorDeclaration arrayOfSizeConstructor = `new Array.ofSize`;

A value reference expression or function reference expression is an optional member declaration qualifier, followed by the name of a function, value, value constructor, or anonymous class, with the keyword value or function, surrounded by backticks.

MemberKeyword: "value" | "function"

MemberDec: "`" MemberKeyword PackageQualifier? MemberDecQualifier? MemberName "`"

A constructor reference expression is a member declaration qualifier, followed by the name of a callable constructor, with the keyword new, surrounded by backticks.

ConstructorKeyword: "new"

ConstructorDec: "`" ConstructorKeyword PackageQualifier? MemberDecQualifier TypeName "`"

A reference expression is a reference to a declaration. The referenced declaration is determined according to §5.1.7 Unqualified reference resolution and §5.1.8 Qualified reference resolution. The kind of the referenced declaration must match the kind of reference indicated by the keyword.

ValueDeclaration personNameAttribute = `value Person.name`;

FunctionDeclaration personSayMethod = `function Person.say`;

FunctionDeclaration processWriteMethod = `function process.write`;

ClassDeclaration processClass = `class process`;

A package reference expression is a package name, as defined by §4.1.2 Packages, with the keyword package, surrounded by backticks.

PackageDec: "`" "package" FullPackageName? "`"

The package name must refer to a package from which an import statement in the same compilation unit may import declarations, as defined by §4.2 Imports.

If there is no explicit package name, the package reference is to the package in which the package reference expression occurs.

Package currentPackage = `package`;
Package modelPackage = `package ceylon.language.meta.model`;

A module reference expression is a module name, as defined by §9.3.1 Module names and version identifiers, with the keyword module, surrounded by backticks.

ModuleDec: "`" "module" FullPackageName? "`"

The module name must refer to the module to which the compilation unit belongs, as specified by §9.2 Source layout, or to a module imported by the module to which the compilation unit belongs, as defined by §9.3.10 Module descriptors.

If there is no explicit module name, the module reference is to the package in which the module reference expression occurs.

Module currentModule = `module`;
Module languageModule = `module ceylon.language`;

The type of a reference expression depends upon the kind of program element referenced:

For a reference to an anonymous class, the type depends upon the keyword, class, or value, specified in the reference expression: