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 type of the immediately containing class or interface.

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 assignable to the type of this class or interface.

The keyword super refers to the current instance of the immediately containing class or interface. Its type is the intersection of the immediate superclass and all immediate superinterfaces of the class. 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.

The keyword super may occur as the first operand of an of operator, in which case the second operand is any supertype of the class. 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.

The keyword package is not an expression, and does not have a well-defined type. However, it may be used to qualify and disambiguate a value reference or callable reference. A value reference or callable reference qualified by the keyword package always refers to a toplevel member of the containing package, never to an imported declaration or nested declaration.

A base expression is an unqualified identifier, with an optional list of type arguments:

BaseExpression: (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.6 Realizations.

The type argument list, if any, must conform, as defined by §3.6.1 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, or member class 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.6 Realizations.

The type argument list, if any, must conform, as defined by §3.6.1 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 expresson 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 value reference is a base expression or member expression that references a value declaration.

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

A value 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 or member expression that references something—a function or class—that can be invoked or instantiated by specifying a list of arguments.

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

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

A callable reference may not appear 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.

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

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

A static 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.6 Realizations.

The type argument list, if any, must conform, as defined by §3.6.1 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.

A static value reference is a static expression that references an attribute declaration.

List<Anything>.size

The type of a static value reference expression for an attribute whose realization is of type X, and with qualifying type T, is X(T).

A value 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—that can be invoked or instantiated.

List<String>.filter

Iterable<Integer>.map<String>

The type of a static callable reference expression for a method or member class whose realization has callable type C, and with qualifying type T, is C(T).

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 or class to which the callable reference refers.

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.6 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 or class, the restriction above on the argument list type is equivalent to the following requirements. Given the parameter list of the realization of the function or class, 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.1 Type arguments and type constraints, to the type parameter list of the realization of the function or class.

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.1 Type arguments and type constraints, of the function or class 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: "* "Expression

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

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

An comprehension occurring in an extends clause may not contain a reference to a variable value.

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 }

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

ValueArgument | FunctionArgument | ObjectArgument

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

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.

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.

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

DynamicValue: "value" NamedArguments

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.

There are 18 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 principal: 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.

In the tables, the following pseudo-code is used, which is not legal Ceylon syntax:

First,

if (b) then x else y   //pseudocode

means the value of result after execution of the following:

X result; if (b) { result=x; } else { result=y; }

Second,

let t=x in y   //pseudocode

means the value of result after execution of the following:

X t = x; Y result=y;

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, and for joining and obtaining subranges of Sequences.

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

A class reference expression, interface reference expression, alias reference expression, or type parameter reference expression is a series of initial uppercase identifiers, with the keyword class, interface, alias, or given, respectively, surrounded by backticks.

TypeDec: "`" ("class" | "interface" | "alias" | "given") (TypeName ".")* TypeName "`"

A value reference expression or function reference expression is an initial lowercase identifier, qualified by a list of initial uppercase identifiers, with the keyword value or function, surrounded by backticks.

MemberDec: "`" ("value" | "function") (TypeName ".")* MemberName "`"

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.

ClassDeclaration personClass = `class Person`;

InterfaceDeclaration stringListInterface = `interface List`;

AliasDeclaration numberAlias = `alias Number`;

TypeParameter elementTypeParameter = `given Element`;

ValueDeclaration personNameAttribute = `value Person.name`;

FunctionDeclaration personSayMethod = `function Person.say`;

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.

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.12 Module descriptors.

Module languageModule = `module ceylon.language`;

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