As a special exception to the rules defined above, the compiler is permitted to emit bytecode or compiled JavaScript that produces a new instance of certain types in the module ceylon.language without execution of the initializer of the class, whenever any expression is evaluated. These types are: Integer, Float, Character, Range, Entry, String, Array, and Tuple. Furthermore, it is permitted to use such a newly-produced instance as the value of the expression, as long as the newly-produced instance is equal to the value expected according to the rules above, as determined using the == operator.

Therefore, the types listed above directly extend Object instead of Basic, and are not Identifiable.

Type arguments, as defined in §3.6 Generic type arguments, are reified in Ceylon. An instance of a generic type holds a reference to each of its type arguments. Therefore, the following are possible in Ceylon:

At runtime, all types are concrete types formed by:

in any type that appears in an expression or condition.

Therefore, every type parameter refers, at runtime, to a concrete type that involves no type aliases or type parameters. In particular, the type arguments held by an instance of a generic class are concrete types.

This program prints String[].

class Generic<out T>(T t) { string=>`T`.string; }
Generic<{S*}> gen<S>(S* ss) => Generic(ss);
void run() {
    print(gen("hello", "world"));
}

The runtime is generally permitted, as an optimization, to return a more precise type in place of a less precise type when a type parameter is evaluated. This program may print String instead of Object, even though Object is the type argument inferred at compile time.

class Generic<out T>(T t) { string=>`T`.string; }
Generic<Object> gen(Object o) => Generic(o);
void run() {
    print(gen("hello"));
}

When execution of a body begins, a frame is created. For each reference whose declaration directly occurs in the body, the frame has a value, which may or may not be initialized. The value may be initialized or assigned during execution of the body.

We can visualize a frame as a list of reference declarations with optional values. For example, a frame with an initialized reference named language and an uninitialized reference named count would be written like this:

{ String language = "ceylon"; Integer count; }

While a body is executing, all values held in the frame are considered accessible. An evaluation, assignment, invocation, or instantiation may result in a pause in execution of the body while the called getter, setter, function, or class is executed or instantiated. However, the frame associated with the calling body is retained and values held in the frame are still considered accessible. When execution of the body resumes, the frame is restored.

When execution of a body terminates, the frame may or may not become inaccessible. In the case of a class body, if the initializer terminates with no thrown exception, the frame and its values become a new instance of the class, are associated with the newly created unique identifier, and remain accessible while this object is itself accessible. In the case of any other kind of body, or in the case that an initializer throws an exception, the frame and its values may remain accessible if:

Otherwise, the frame becomes inaccessible and may be destroyed.

The principle of closure states that a nested body always has access to a frame for every containing body. The set of current instances of containing classes and current frames of containing blocks forms the closure of a nested declaration.

A frame may be the current frame for a body. When the body is executing, the created frame is the current frame. When execution of the body terminates, the created frame is no longer the current frame. Invocation or evaluation of a member of a class or interface, invocation of a callable reference or anonymous function, or evaluation of the values produced by a comprehension may result in the frame being restored as the current frame.

A class instance, callable reference, anonymous function reference, or comprehension instance packages a reference to a frame for each body containing the program element, as specified below. When a member of the class instance is invoked or evaluated, when the callable reference or anonymous function is invoked, or when the comprehension instance produces a value, these frames are restored as the current frames of the associated bodies. When the invocation or evaluation terminates, or when the comprehension value has been produced, these frames are no longer current frames.

The value associated with a value reference in the current frame of the body to which the value reference belongs is called the current value of the value reference.

If a frame is the current frame for a class or interface body, we call it the current instance of the class or interface.

If a statement is occurs directly or indirectly inside a class or interface body, then there is always a current instance of the class or interface when the statement is executed. The current instance is determined as follows:

Here, innerObject is the current instance of Inner when member() is executed, and outerObject is the current instance of Outer:

Outer outerObject = Outer();
Inner innerObject = outerObject.Inner();
innerObject.member();

If a statement occurs directly or indirectly inside a block, then there is always a current frame of the block when the statement is executed. The current frame is determined as follows:

In each of the following code fragments, result refers to the value "hello":

String()() outerMethod(String s) {
    String() middleMethod() {
        String innerMethod() => s;
        return innerMethod;
    }
    return middleMethod;
}

String middleMethod()() => outerMethod("hello");
String innerMethod() => middleMethod();
String result = innerMethod();

Object outerMethod(String s) {
    object middleObject {
        shared actual String string => s;
    }
    return middleObject;
}

Object middleObject = outerMethod("hello");
String result = middleObject.string;

When an instance is instantiated, its initializer is executed, and the initializer for every class it inherits is executed. If a class has constructors, one of its constructors is also executed. For a class C:

If any initializer or constructor in the class hierarchy terminates with a thrown exception, initialization terminates and the incompletely-initialized instance never becomes accessible.

Each initializer produces a frame containing initialized values for each reference declared by the corresponding class. These frames are aggregated together to form the new instance of the class C.

As an exception to the above, the compiler is permitted to destroy a persistent value associated with a class instance when the class initializer terminates, potentially rendering inaccessible the instance identified by the value, if it can determine that the persistent value will never be subsequently accessed by the program.

When an expression statement is executed, the expression is evaluated.

When a non-lazy specification statement is executed, the specified expression is evaluated, and the resulting value assigned to the specified reference within the current frame or current instance associated with the body to which the specified reference belongs.

When a lazy specification statement is executed, the specified expression is associated with the specified reference within the current frame or current instance associated with the body to which the specified reference belongs. Subsequent evaluation or invocation of the reference for this current frame or current instance may result in evaluation of the specified expression, in which case the expression is evaluated within this current frame or current instance.

Execution of a control directive, as specified in §5.3.2 Control directives, terminates execution of the body in which it occurs, and possibly of other containing bodies.

If execution of an evaluation, assignment, invocation, or instantiation terminates with an exception thrown, the exception propagates to the calling code, and terminates execution of the body of the function, getter, setter, or class initializer in which the expression involving the evaluation, assignment, invocation, or instantiation sequentially occurs, and of all intervening bodies, and, furthermore, the exception propagates to the caller unless there is an intervening try with a catch clause matching the thrown exception, in which case it terminates execution of the body of the try statement and all intervening bodies, and execution continues from the body of the catch clause.

A toplevel reference has no associated frame. Instead, the lifecycle of its persistent value is associated with the loading and unloading of a module by the module runtime. The first time a toplevel reference is accessed following the loading of its containing module, its initializer expression is evaluated, and the resulting value is associated with the reference. This association survives until the toplevel reference is reassigned, or until the module is unloaded by the module runtime.

Initialization of a toplevel reference may result in recursive initialization of other toplevel references. Therefore, it is possible that a cycle could occur where evaluation of a toplevel reference occurs while evaluating its initializer expression. When this occurs, an InitializationError is thrown.

A reference annotated late may be uninitialized in a given frame. The rules of the language do not guarantee that an uninitialized late reference is never evaluated at runtime. If a late reference which is uninitialized in the current frame or current instance is evaluated, an InitializationError is thrown.

Likewise, if a non-variable late reference which is already initialized in the current frame or current instance is assigned, an InitializationError is thrown.

Execution of an if, while, or assert requires evaluation of a condition list, as defined in §5.4 Conditions.

To determine if a condition list is satisfied, its constituent conditions are evaluated in the lexical order in which they occur in the condition list. If any condition is not satisfied, none of the subsequent conditions in the list are evaluated.

For any other kind of condition, the condition is satisfied if its value reference or expression evaluates to an instance of the required type when the condition is evaluated:

A condition list is satisfied if and only if all of its constituent conditions are satisfied.

When an assertion, as specified in §5.5.6 Assertions, is executed, its condition list is evaluated. If the condition list is not satisfied, an exception of type AssertionError in ceylon.language is thrown.

The information carried by the AssertionError includes:

The if/else and switch/case/else constructs control conditional execution.

When the if/else construct, specified in §5.5.1 if/else, is executed, its condition list is evaluated. If the condition list is satisfied, the if block is executed. Otherwise, the else block, if any, is executed, or, if the construct has an else if, the child if construct is executed.

When a switch/case/else construct, specified in §5.5.2 switch/case/else, is executed, its switch expression is evaluated to produce a value. The value is guaranteed to match at most one case of the switch. If it matches a certain case, then that case block is executed. Otherwise, switch is guaranteed to have an else, and so the else block is executed.

The value produced by the switch expression matches a case if either:

The for/else and while loops control repeated execution.

When a while construct, specified in §5.5.4 while, is executed, the loop condition list is evaluated repeatedly until the first time the condition list is not satisfied, or until a break, return, or throw directive that terminates the loop is executed. Each time the condition is satisfied, the while block is executed.

When a for/else construct, specified in §5.5.3 for/else, is executed:

Note that:

We say that the loop exits early if it ends via execution of a break, return, or throw directive. Otherwise, we say that the loop completes normally.

If the loop completes normally, the else block is executed. Otherwise, if the loop exits early, the else block is not executed.

When a try/catch/finally construct, specified in §5.5.5 try/catch/finally, is executed:

Inside a dynamic block, a situation might occur that requires dynamic type checking, as specified in §5.3.5 Dynamic blocks. It is possible that:

Whenever such a condition is encountered at runtime, an AssertionError is immediately thrown.

Dynamic dispatch is the process of determing at runtime a member declaration based upon the runtime type of an object, which, as a result of subtype polymorphism, may be different to its static type known at compile time.

Any concrete class is guaranteed to have exactly one declaration of a member, either declared or inherited by the class, which refines all other declarations of the member declared or inherited by the class. At runtime, this member is selected.

There is one exception to this rule: member expressions where the receiver expression is of form super or (super of Type), as defined in §6.3.3 super, are dispatched based on the static type of the receiver expression:

Evaluation of a value reference, as defined in §6.5.4 Value references, produces its current value. Evaluation of a callable reference, as defined in §6.5.5 Callable references, that does not occur as the primary of a direct invocation results in a new instance of Callable that packages the callable reference.

person.name

'/'.equals

When a value reference expression is executed:

The resulting value is the persistent value retrieved, or the return value of the getter, as specified by the return directive.

When a callable reference expression that does not occur as the primary of a direct invocation expression is executed:

The resulting value is the instance of Callable. The concrete class of this instance is not specified here.

Given a value reference, as defined in §6.5.4 Value references, to a variable, the assignment operator = assigns it a new value.

person.name = "Gavin"

When an assignment expression is executed:

Evaluation of an invocation expression, as defined in §6.6 Invocation expressions, results in invocation of a function or callable constructor, or instantiation of a class. Every invocation has a callable expression:

In either case, the callable expression determines the instance and member to be invoked.

print("Hello world!")

Entry(person.name, person)

When an invocation expression is executed:

A function invocation evaluates to the return value of the function, as specified by the return directive. The argument values are passed to the parameters of the method, and the body of the method is executed.

A class instantiation evaluates to a new instance of the class. The argument values are passed to the initializer parameters of the class, and the initializer is executed.

When an anonymous function expression, as defined in §6.4 Anonymous functions, is evaluated, a reference to the function and a reference to the current frame or instance of every containing body are packaged into an instance of Callable. The instance of Callable is the resulting value of the expression. The concrete class of this instance is not specified here.

Evaluation of an enumeration expression, as defined in §6.6.12 Iterable and tuple enumeration, results in creation of an iterable stream or tuple.

{ "hello", "world" }

[ new, *elements ]

When an iterable enumeration expression is executed, a reference to the enumeration expression, together with a reference to the current frame or instance of every containing body, together with a comprehension instance, as defined in §8.6 Evaluation of comprehensions, in the case that the enumeration expression has a comprehension, are packaged together into a stream. Evaluation of an expression occurring in the enumeration expression occurs in the context of the packaged framed associated with the stream. When the stream is iterated, it produces, in turn:

When a tuple enumeration expression is executed:

In the case of an iterable enumeration, the concrete class of the resulting value is not specified here. In the case of a tuple enumeration it is always Tuple, Empty, or Sequence.

A spread argument, as defined in §6.6.5 Spread arguments, produces multiple values by iterating the iterable object to which the spread operator is applied.

When a spread argument expression type is a subtype of Sequential, the behavior does not depend upon where the spread argument occurs:

On the other hand, when a spread argument expression type is not a subtype of Sequential, the behavior depends upon where the spread argument occurs:

Likewise, a comprehension, as defined in §6.6.6 Comprehensions, produces multiple values, as specified by §8.6 Evaluation of comprehensions. The behavior depends upon where the comprehension occurs:

As a special exception to the rules, the compiler is permitted to optimize certain operations upon certain types in the module ceylon.language. These types are: Integer, Float, Character, Range, Entry, String, Array, and Tuple.

Thus, the tables in the previous chapter define semantics only. The compiler may emit bytecode or compiled JavaScript that produces the same value at runtime as the pseudo-code that defines the operator, without actually executing any invocation, for the following operators:

In all operator expressions, the arguments of the operator must be evaluated from left to right when the expression is executed. In certain cases, depending upon the definition of the operator, evaluation of the leftmost argument expression results in a value that causes the final value of the operator expression to be produced immediately without evaluation of the remaining argument expressions. Optimizations performed by the Ceylon compiler must not alter these behaviours.

The arithmetic operations defined in §6.8.10 Arithmetic operators for values of type Integer and Float are defined in terms of methods of the interface Numeric. However, these methods themselves make use of the native operations of the underlying virtual machine. Likewise, values of type Integer and Float are actually represented in terms of a format native to the virtual machine.

It follows that the precise behavior of numeric operations depends upon the virtual machine upon which the program executes. However, certain behaviours are common to supported virtual machines:

Platform-dependent behavior of numeric operations is defined in the Java Language Specification, and the ECMAScript Language Specification.

The expression which produces the source stream for a child for clause may refer to an iteration variable of a parent for clause. In this case the child clause is considered correlated. Otherwise it is considered uncorrelated.

In either case, the child clause produces a stream of frames. For each frame produced by the parent clause, and for each value produced by the source stream of the child clause, the child clause produces a frame consisting of the parent clause frame extended by the iteration variable value defined by the child clause.

This comprehension has a correlated for clause. For each character c in each string w in words, the child for clause produces the frame { String word=w; Character char=c; }.

for (word in words) for (char in word) char

This comprehension has an uncorrelated for clause. For each string n in nouns, and each string a in adjectives, the child for clause produces the frame { String noun=n; String adj=a; }.

for (noun in nouns) for (adj in adjectives) adj + " " + noun

A child if clause filters its parent clause frames. For every frame produced by the parent clause which satisfies the condition list of the child clause, the child clause produces that frame, extended by any condition variable defined by the child clause.

This comprehension has an if clause. For each object o in objects that is a nonempty String, the if clause produces the frame { Object obj=o; String str=o; }.

for (obj in objects) if (is String str=obj, !str.empty) str

As specified in §6.6.6 Comprehensions, every comprehension ends in an expression clause. An expression clause produces a single value for each frame produced by its parent clause, by evaluating the expression in the frame. These resulting values are the values returned by the whole comprehension.