A package may not contain two toplevel declarations with the same name.

A program element is contained within the namespace of a declaration if either:

The namespace of a declaration may not contain a second declaration with the same name. (A parameter or type parameter is considered to be a declaration that is directly contained by the body of the declaration it parameterizes.)

A class or interface may not inherit a declaration with the same name as a declaration it contains unless either:

A class or interface may not inherit two declarations with the same name unless either:

The scope of a declaration is governed by the body or package in which it occurs. A declaration is in scope at a program element if and only if either:

Where:

Furthermore:

If two declarations with the same name are both in scope at a certain program element, then one declaration may hide the other declaration.

For example, the following code is legal:

class Person(name) {
    String name;
    shared String lowerCaseName {
        String name = this.name.lowercased;
        return name;
    }
}

As is this code:

class Point(x, y) {
    shared Float x; 
    shared Float y;
}

class Complex(Float x, Float y=0.0) 
        extends Point(x, y) {}

A declaration may be in scope at a program element, but not referenceable at the program element. A declaration is referenceable at a program element if the declaration is in scope at the program element and either:

Note that these rules have very different consequences for:

Declarations that occurs in a block or class initializer section are interspersed with procedural code that initializes references. Therefore, a program element in a block or initializer may not refer to a declaration that occurs later in the block or class body. This restriction does not apply to declarations that occur in an interface body or class declaration section.

The following toplevel function declarations, belonging to the same package, are legal:

Float x => y;

Float y => x;

This code is not legal, since the body of a function is an ordinary block:

Float->Float xy() {
    Float x => y;  //compiler error: y is not referenceable
    Float y => x;
    return x->y;
}

This code is not legal, since all three statements occur in the initializer section of the class body:

class Point() {
    Float x => y;  //compiler error: y is not referenceable
    Float y => x;
    Float->Float xy = x->y;
}

However, this code is legal, since the statements occur in the declaration section of the class body:

class Point() {
    Float x => y;
    Float y => x;
}

Likewise, this code is legal, since the statements occur in an interface body:

interface Point {
    Float x => y;
    Float y => x;
}

A value declared using the keyword value or a function declared using the keyword function may be in scope at a program element, but its type may not be inferrable from the point of view of that program element.

The type of a value or function declared using the keyword value or function is inferrable to a program element if the declaration is in scope at the program element and the program element occurs within the lexical scope of the declaration.

For any other declaration, that is, for declarations which explicitly specify a type, the type is considered inferrable to a program element if the declaration is in scope at the program element.

The following code is not legal:

interface Point {
    value x => y;  //compiler error: type of y is not inferrable
    value y => x;
}

However, this code is legal:

interface Point {
    value x => y;
    Float y => x;
}

An unqualified reference is:

If a program element contains an unqualified reference:

Then the given name refers to this unique unhidden declaration, and:

As a special exception to the above, if there is no declaration with the given name in scope at the program element and the program element occurs inside a dynamic block, then the unqualified reference does not refer to any statically typed declaration.

A qualified reference is:

Every qualified reference has a qualifying type:

If a program element contains a qualified reference:

Then the given name refers to this unique member. If the program element is contained in the body of a class or interface, and the member declaration directly occurs in the body of the class or interface, and the qualified reference is a value reference or callable reference, and the receiver expression is a self reference to the instance being initialized, then:

As a special exception to the above, if the program element occurs inside a dynamic block, and the the receiver expression has no type, then the qualified reference does not refer to any statically typed declaration.

The initializer of a class, or the body of a member of a class may instantiate, invoke, evaluate or assign members of the current instance of the class which defines the initializer or member—the instance being instantiated or invoked—without explicitly specifying the receiver, or by specifying a self reference this as the receiver.

The initializer of a nested class, or the body of a member of a nested class or nested interface may invoke, evaluate or assign members of the current instance of the containing class or interface—the parent instance of the instance being instantiated or invoked—without explicitly specifying the receiver, or by specifying an outer instance reference outer as the receiver.

A toplevel function or value body may not refer to a self reference, since there is no current instance.

The body of a value, function, or class nested inside the body of another function or value may invoke or evaluate any block local value or block local method whose declaration indirectly occurs earlier within the containing scope.

When a member of a class is hidden by a block local declaration, the member may be accessed via the self reference this or via the outer instance reference outer:

shared class Item(name) {
    variable String name;
    shared void changeName(String name) {
        this.name = name;
    }
}

class Catalog(name) {
    shared String name;
    class Schema(name) {
        shared String name;
        Catalog catalog => outer;
        String catalogName => outer.name;
        class Table(name) {
            shared String name;
            Schema schema => outer;
            String schemaName => outer.name;
            String catalogName => catalog.name;
        }
    }
}

When a toplevel declaration of a package is hidden by another declaration, the toplevel declaration may be accessed via the containing package reference package:

Integer n => 0;
Integer f(Integer n) => n+package.n;

Only certain expressions are valid statements:

ExpressionStatement: ( Assignment | IncrementOrDecrement | Invocation ) ";"

For example:

x += 1;

x++;

print("Hello");

Main(process.arguments);

A control directive statement ends execution of the current block and forces the flow of execution to resume in some outer scope. They may only occur as the lexically last statement of a block.

DirectiveStatement: Directive ";"

There are four control directives:

Directive: Return | Throw | Break | Continue

For example:

throw Exception();

return x+y;

break;

continue;

The return directive must sequentially occur in the body of a function, getter, setter, or class initializer. In the case of a setter, class initializer, or void function, no expression may be specified. In the case of a getter or non-void function, an expression must be specified. The expression type must be assignable to the return type of the function or the type of the value. When the directive is executed, the expression is evaluated to determine the return value of the function or getter.

Return: "return" Expression?

The break directive must sequentially occur in the body of a loop.

Break: "break"

The continue directive must sequentially occur in the body of a loop.

Continue: "continue"

A throw directive may appear anywhere and may specify an expression, whose type must be a subtype of type Exception defined in ceylon.language. When the directive is executed, the expression is evaluated and the resulting exception is thrown. If no expression is specified, the directive is equivalent to throw Exception().

Throw: "throw" Expression?

A specification statement may specify or initialize the persistent value of a forward-declared reference, or specify the implementation of a forward-declared getter or function.

Specification: ValueSpecification | LazySpecification

The persistent value of a forward-declared reference or the implementation of a forward-declared function may be specified using =. The specification statement consists of an unqualified value reference and a specifier. The value reference must refer to a declaration which sequentially occurs earlier in the body in which the specification statement occurs.

ValueSpecification: MemberName Specifier ";"

The type of the specified expression must be assignable to the type of the reference, or to the callable type of the function.

String greeting;
if (exists name) {
    greeting = "hello ``name``";
}
else {
    greeting = "hello world";
}

String process(String input);
if (normalize) {
    process = String.normalized;
}
else {
    process = (String s) => s;
}

The implementation of forward-declared getter or function may be specified using =>. The specification statement consists of either:

The value reference or callable reference must refer to a declaration which sequentially occurs earlier in the body in which the specification statement occurs.

A callable reference followed by a parameter list is itself considered a callable reference, called a parameterized reference. If the parameter list has type P then the callable reference must have the exact type Callable<R,P> for some type R. Then the type of the parameterized reference is R.

ParameterizedReference: MemberName Parameters+

Thus, the specification statement consists of a parameterized reference followed by a lazy specifier.

LazySpecification: (MemberName | ParameterizedReference) LazySpecifier ";"

The type of the specified expression must be assignable to the type of the parameterized reference, or to the type of the value reference.

String greeting;
if (exists name) {
    greeting => "hello ``name``";
}
else {
    greeting => "hello world";
}

String process(String input);
if (normalize) {
    process(String input) => input.normalized;
}
else {
    process(String s) => s;
}

A sequence of statements may definitely return.

The body of a non-void method or getter must definitely return.

A body may not contain an additional statement, control structure, or declaration following a sequence of statements that definitely returns. Such a statement, control structure, or declaration is considered unreachable.

A sequence of statements may definitely initialize a forward-declared declaration.

A forward-declared declaration is considered definitely initialized at a certain statement or declaration if its declaration has a specifier or initializer, if it is referenced by a parameter, or if it is definitely initialized by the sequence of statements from its declaration to the given statement or declaration.

A forward-declared declaration must be definitely initialized wherever any value reference or callable reference to it occurs as an expression within the body in which it is declared.

A shared forward-declared declaration belonging to a class and not annotated late must be definitely initialized:

A specification statement for a method or non-variable reference, getter, or function may not (indirectly) occur in a for or while block unless the declaration itself occurs within the same for or while block.

A sequence of statements may possibly initialize a forward-declared declaration.

A forward-declared declaration is considered definitely uninitialized at a certain statement or declaration if:

A method or non-variable local or simple attribute must be definitely uninitialized wherever any value reference or callable reference to it occurs as a specification statement within the body in which it is declared.

Some control structures allow inline declaration of a variable, a reference that is scoped to the control structure body.

TypedVariable: Type MemberName

In most cases, the explicit type be omitted.

Variable: Type? MemberName

If the type is missing from the declaration, the type of the variables is inferred from the type of the expression that follows.

A for loop requires an iteration variable declaration. An iteration variable declaration must specify an iteration variable.

IteratorVariable: Variable | CallableVariable | EntryVariablePair

An iteration variable of type Entry may be specified in destructured form.

EntryVariablePair: Variable "->" Variable

An iteration variable may be callable.

CallableVariable: (Type | "void")? MemberName Parameters+

If the return type is missing from the declaration, the return type of the callable variable is inferred.

Some control structures expect conditions. There are four kinds of condition:

Condition: BooleanCondition | IsCondition | ExistsOrNonemptyCondition

A condition list has one or more conditions.

ConditionList: "(" Condition ("," Condition) ")"

A condition in the list may refer to a condition variable defined earlier in the list.

A boolean condition is just an expression.

BooleanCondition: Expression

The expression must be of type Boolean.

An assignability, existence, or nonemptiness condition may contain either:

In the case of an assignability or existence condition, the type of the variable may be inferred.

IsCondition: "!"? "is" (TypedVariable Specifier | Type MemberName)

ExistsOrNonemptyCondition: ("exists" | "nonempty") (Variable Specifier | MemberName)

The type of the value reference or expression must be:

if (is Printable&Identifiable obj) { ... }

if (is Integer|Float num) { ... }

Every existence or nonemptiness condition is equivalent to—and may be considered an abbreviation of—an assignability condition:

For an is condition:

If you prefer, you can think of the following:

Transaction tx = ...
    if (is Usable tx) { ... }

As an abbreviation of:

if (is Transaction&Usable tx = tx) { ... }

Where the tx declared by the condition hides the outer declaration of tx inside the block that follows.

For an exists condition:

For a nonempty condition:

If you prefer, you can think of the following:

if (exists name) { ... }

As an abbreviation of:

if (exists String name = name) { ... }

Where the name declared by the condition hides the outer declaration of name inside the block that follows.

The if/else conditional has the following form:

IfElse: If Else?

If: "if" ConditionList Block

Else: "else" (Block | IfElse)

The construct may include a chain of an arbitrary number of child else if clauses.

For example:

if (payment.amount <= account.balance) {
    account.balance -= payment.amount;
    payment.paid = true;
}
else {
    throw NotEnoughMoneyException();
}

shared void welcome(User? user) {
    if (exists user) {
        print("Welcome back, ``user.name``!");
    }
    else {
        print("Welcome to Ceylon!");
    }
}

if (is CardPayment p = order.payment, 
        !p.paid) {
    p.card.charge(total);
}

The switch/case/else conditional has the following form:

SwitchCaseElse: Switch Cases

Switch: "switch" "(" Expression ")"

Cases: CaseItem+ DefaultCaseItem?

CaseItem: "case" "(" Case ")" Block

DefaultCaseItem: "else" Block

For a switch statement whose switch expression is of type U, each case must be either:

Case: Expression ("," Expression)* | "is" Type

Two cases are said to be disjoint if the intersection of their types is exactly Nothing. In every switch statement, all cases must be mutually disjoint.

A switch is exhaustive if the union type formed from by the types of the cases of the switch covers the switch expression type.

If no else block is specified, the switch must be exhaustive.

case (is Format & IdentifiableObject) { ... }

case (is Integer | Float) { ... }

If a switch has an assignability condition case, then the switch expression must be an unqualified value reference to a non-variable, non-default reference.

For an assignability condition case, the value referred by the switch expression will be treated by the compiler as having the intersection type of its declared type with the specified type inside the case block. This intersection type must not be exactly Nothing.

For example:

Boolean? maybe = ... ;
switch (maybe) 
case (null, false) {
    return false;
}
case (true) { 
    return true;
}

Integer|Float number = ... ;
switch (number)
case (is Integer) { 
    return sqrt(number.float);
} 
case (is Float) { 
    return sqrt(number);
}

A Java-style overloaded method may be emulated as follows:

shared void print<Printable>(Printable printable) 
        given Value of String | Integer | Float {
    switch (printable)
    case (is String) { 
        print("\"``printable``\""); 
    }
    case (is Integer) { 
        print(printable + ".00"); 
    }
    case (is Float) { 
        print(formatFloat(printable, 2)); 
    }
}

The for/else loop has the following form:

ForFail: For Fail?

For: "for" ForIterator Block

Fail: "else" Block

The for iterator consists of an iteration variable declaration and an iterated expression that contains the range of values to be iterated.

ForIterator: "(" IteratorVariable "in" Expression ")"

The type of the iterated expression depends upon the iteration variable declarations:

For example:

for (p in people) { 
    print(p.name);
}

variable Float sum = 0.0;
for (i in -10..10) {
    sum += x[i] else 0.0;
}

for (word -> freq in wordFrequencyMap) { 
    print("The frequency of ``word`` is ``freq``."); 
}

for (p in group) {
    if (p.age >= 18) {
        log.info("Found an adult: ``p.name``.");
        break;
    }
}
else {
    log.info("No adult in group.");
}

The while loop has the form:

While: LoopCondition Block

The loop condition list determines when the loop terminates.

LoopCondition: "while" ConditionList

For example:

variable Integer n=0;
variable [Integer*] seq = [];
while (n<=max) {
    seq=seq.withTrailing(n);
    n+=step(n);
}

The try/catch/finally exception manager has the form:

TryCatchFinally: Try Catch* Finally?

Try: "try" ("(" Resource ")")? Block

Catch: "catch" "(" Variable ")" Block

Finally: "finally" Block

Each catch block defines a variable. The type of the variable must be assignable to Exception in ceylon.language. If no type is explicitly specified, the type is inferred to be Exception.

catch (NotFoundException|DeletedException e) { ... }

If there are multiple catch blocks in a certain control structure, then:

The try block may declare a resource expression, which may be either:

A resource expresson produces a heavyweight object that must be released when execution of the try terminates. Each resource expression must be of type assignable to Closeable in ceylon.language.

Resource: MemberName | InitializerReference Arguments | Variable Specifier 

For example:

try (file = File(path)) {
    file.open(readOnly);
    ...
}
catch (FileNotFoundException fnfe) {
    print("file not found: ``path``");
}
catch (FileReadException fre) {
    print("could not read from file: ``path``");
}
finally {
    assert (file.closed);
}

try (Transaction()) {
    try (s = Session()) {
        return s.get(Person, id);
    }
    catch (NotFoundException|DeletedException e) {
        return null;
    }
}

An assertion has an asserted condition list and, optionally, an annotation list.

Assertion: Annotations "assert" ConditionList ";"

The message carried by the assertion failure may be specified using a doc annotation.

"total must be less than well-defined bound"
assert (exists bound, total<bound);

If the assertion contains an assignability, existence, or nonemptiness condition containing a value reference then the compiler treats the referenced value as having a narrowed type at program elements that occur in the lexical scope of the assertion.

{Element*} elements = ... ;
assert (nonempty elements);
Element first = elements.first;

assert (total<bound) 
else "total must be less than ``bound``";

A dynamic block allows interoperation with dynamically typed native code.

Dynamic: "dynamic" Block

Inside a dynamic block, a value reference or qualified or unqualified reference occurring in an expression that does not resolve to any statically typed program element is assumed to be a reference to something defined in dynamically typed native code. Then the qualified or unqualified reference is not assigned a type, but does not result in a compile-time error.