A toplevel declaration defines a type—a class or interface—or a type alias, or a function or value.

Declaration: FunctionValueDeclaration | TypeDeclaration | ParameterDeclaration

FunctionValueDeclaration: FunctionDeclaration | ValueDeclaration | SetterDeclaration

TypeDeclaration: ClassDeclaration | ObjectDeclaration | InterfaceDeclaration | TypeAliasDeclaration

A toplevel declaration is not polymorphic and so may not be annotated formal, default, or actual.

Most toplevel declarations contain nested declarations.

Nested declarations are often mixed together with executable statements.

Each compilation unit belongs to exactly one package. Every toplevel declaration of the compilation unit also belongs directly to this package. The package is identified by the location of the text file on the file system, relative to a root source directory, as defined in §9.2 Source layout.

A package is a namespace. A full package name is a period-separated list of identifiers.

FullPackageName: PackageName ("." PackageName)*

There is also a default package whose name is empty. It is impossible to import declarations from this package.

Every package belongs to exactly one module, as specified in §9.3 Module architecture. The default package belongs to the default module.

An import element that specifies a type name imports the toplevel type with that name from the imported package or type.

ImportTypeElement: TypeAlias? TypeName ImportElements?

The specified name must be the name of a type declaration belonging to the imported package or type.

import ceylon.collection { MutableSet, MutableList, MutableMap }

The import element may be followed by a list of nested import elements:

An import element that specifies the name of an anonymous class, as defined in §4.5.7 Anonymous classes, imports the anonymous class with that name from the imported package or type.

ImportObjectElement: FunctionValueAlias? MemberName ImportElements?

The specified name must be the name of an anonymous class declaration belonging to the imported package or type.

import ceylon.file { home, current }

The import element may be followed by a list of nested import elements:

An import element that specifies a function or value name imports the toplevel function or value with that name from the imported package or type.

ImportFunctionValueElement: FunctionValueAlias? MemberName

The specified name must be the name of a function or value declaration belonging to the imported package or type.

import ceylon.math.float { sqrt, e, pi }

The optional alias clause in a fully-explicit import allows resolution of cross-namespace declaration name collisions.

TypeAlias: TypeName "="

FunctionValueAlias: MemberName "="

An alias assigns a different name to the imported declaration, or to a member of the imported declaration. This name is visible within the compilation unit, block, class body, or interface body in which the import statement occurs.

import java.util { JavaMap = Map }

import my.math { fib = fibonnacciNumber }

import java.lang { 
    Math { sin, cos, ln=log }, 
    System { sysprops=properties },
    Char=Character { upper=toUpperCase, lower=toLowerCase, char=charValue } 
}

The elipsis ... acts as a wildcard in import statements. An import statement that specifies a wildcard imports every toplevel declaration of the imported package, except for any declaration whose name collides with the name of a declaration contained directly in the compilation unit, block, class body, or interface body in which the import statement occurs.

ImportWildcard: "..."

An import statement may specify a list of alias imports followed by a wildcard. In this case, the alias imports are imported with the specified names, and all other toplevel declarations are imported with their declared names.

import ceylon.collection { ... }

import my.math { fib = fibonnacciNumber, ... }

Inside a compilation unit which imports a declaration, the declaration may be referred to, as specified in §5.1.7 Unqualified reference resolution and §5.1.8 Qualified reference resolution, by its imported name:

An import element may not result in an imported name that is the same as the name of a declaration directly contained in the compilation unit, block, class body, or interface body in which the import element occurs.

Two import elements occurring in the same compilation unit, block, class body, or interface body, which import into the toplevel namespace of the compilation unit, or into a local scope, may not result in the same imported name.

Two nested import elements belonging to the same import element may not result in the same imported name.

A parameter list is a list of parameter declarations and of names of parameters declared in the body of the class or function to which the parameter list belongs. A parameter list may include, optionally:

In a parameter list, defaulted parameters, if any, must occur after required parameters, if any. The variadic parameter, if any, must occur last.

Parameters: "(" ( (Required ",")* ( Required | (Defaulted ",")* (Defaulted | Variadic) ) )? ")"

Every parameter list has a type, which captures the types of the individual parameters in the list, whether they are defaulted, and whether the last parameter is variadic. This type is always an subtype of Anything[]. The type of an empty parameter list with no parameters is [].

A parameter may not be annotated formal, but it may be annotated default.

A required parameter is a value or callable parameter without a default argument.

A required parameter in a parameter list may be a parameter declaration, or the name of a non-variadic parameter declared in the body of the function or class.

Required: ValueParameter | CallableParameter | MemberName

Required parameters must occur before any other parameters in the parameter list.

A defaulted parameter is a value or callable parameter that specifies an expression that produces a default argument. A defaulted parameter may be either:

Defaulted: ValueParameter Specifier | CallableParameter LazySpecifier | MemberName Specifier

The = and => specifiers are used throughout the language. In a parameter list they are used to specify a default argument.

Specifier: "=" Expression

LazySpecifier: "=>" Expression

The default argument expression may involve other non-variable parameters declared earlier in the parameter list or lists. It may not involve parameters declared later in the parameter list or lists. It may not involve variable parameters of the parameter list.

The default argument expression may not involve an assignment, compound assignment, increment, or decrement operator.

Defaulted parameters must occur after required parameters in the parameter list.

(Product product, Integer quantity=1, Price pricing(Product p) => p.price)

A parameter of a method or class annotated actual may not specify a default argument. Instead, it inherits the default argument, if any, of the corresponding parameter of the method it refines.

If two parameter lists are almost identical, differing only in that the first parameter of one list is defaulted, and the first parameter of the second list is required, and P is the the type of the second parameter list, then the type of the first parameter list is []|P.

A value parameter is a reference, as specified in §4.8.1 References, that is named or defined in a parameter list. Like any other value declaration, it has a name, type, and, optionally, annotations.

ValueParameter: Annotations ValueParameterPrefix MemberName

ValueParameterPrefix: Type | "value" | "dynamic"

A value parameter may be declared using the keyword dynamic in place of the parameter type, indicating that it is a partially typed declaration. Such a parameter has no type.

In general, a value parameter must have an explicit type declaration, and may not be declared with the keyword value.

As a special exception, if a parameter of an anonymous function is declared with the keyword value, then the type of the parameter must be inferable, according to §6.4.1 Anonymous function parameter type inference.

If a value parameter x has type X, and a parameter list has type P with the principal instantiation Sequential<Y>, then the type of a new parameter list formed by prepending x to the first parameter list is:

The default argument expression, if any, for a callable parameter is specified using an ordinary = specifier. The type of the default argument expression must be assignable to the declared type of the value parameter.

(String label, Anything() onClick)

({Value*} values, Comparison(Value,Value) by)

A callable parameter is a function, as specified in §4.7 Functions, named or defined in a parameter list. Like any other function declaration, it has a name, type, one or more parameter lists, and, optionally, annotations.

CallableParameter: Annotations CallableParameterPrefix MemberName Parameters+

CallableParameterPrefix: Type | "void" | "dynamic"

A callable parameter may be declared using the keyword dynamic in place of the return type, indicating that it is a partially typed declaration. Such a parameter has no return type.

If a callable parameter f has callable type X(*A), as specified below in §4.7.1 Callable type of a function, and a parameter list has type P with the principal instantiation Sequential<Y>, then the type of a new parameter list formed by prepending f to the first parameter list is:

The default argument expression, if any, for a callable parameter is specified using a lazy => specifier. The type of the default argument expression must be assignable to the return type of the callable parameter.

(String label, void onClick())

({Value*} values, Comparison by(Value x, Value y))

A variadic parameter is a value parameter that accepts multiple arguments:

VariadicParameter: Annotations VariadicParameterPrefix MemberName

VariadicParameterPrefix: UnionType ("*" | "+")

A variadic parameter in a parameter list may be a variadic parameter declaration, or the name of a variadic parameter declared in the body of the function or class.

Variadic: VariadicParameter | MemberName

The variadic parameter must be the last parameter in a parameter list. A variadic parameter may not have a default argument. A variadic parameter declared T+ may not occur in a parameter list with defaulted parameters.

(Name name, Organization? org=null, Address* addresses)

(Float+ floats)

The type of a parameter list containing just a variadic parameter of type T* is [T*] The type of a parameter list containing just a variadic parameter of type T+ is [T+].

The body of an interface consists purely of declarations. The following constructs may not occur sequentially in the body of an interface:

Within an interface body, a super reference is any occurrence of the expression super, unless it also occurs in the body of a nested class or interface declaration. A statement or declaration contained in the interface body may not:

An interface may satisfy any number of other interfaces, as defined in §3.3.3 Satisfaction.

shared interface List<Element>
        satisfies Collection<Element> & Correspondence<Integer,Element>
        given Element satisfies Object {
    ...
}

Every type listed in the satisfies clause must be an interface. An interface may not satisfy the same interface twice (not even with distinct type arguments).

The interface is a subtype of every type listed in the satisfies clause. The interface is also a subtype of the type Object defined in ceylon.language.

An interface inherits all members (methods, attributes and member types) of every supertype. That is, every member of every supertype of the interface is also a member of the interface. Furthermore, the interface inherits all nested types (interfaces and abstract classes) of every supertype.

The schema of the inherited members is formed by substituting type arguments specified in the satisfies clause.

An interface that satisfies a nested interface must be a member of the type that declares the nested interface or of a subtype of the type that declares the nested interface.

A user-defined interface may not satisfy the interface Callable defined in ceylon.language nor directly satisfy the interface ConstrainedAnnotation defined in ceylon.language.

A toplevel or nested interface may be annotated sealed and is called a sealed interface.

An interface annotated sealed may not be satisfied by a class or interface outside the module in which it is defined.

An interface declaration may enumerate a list of cases of the interface, as defined in §3.4.2 Cases.

shared interface Node<Element> 
            of Root<Element> | Branch<Element> | Leaf<Element> { ... }

The cases may be interfaces, classes, or toplevel anonymous classes. A case may be an abstract class. Each case must be a direct subtype of the interface type. An interface may not be a case of itself. An interface declaration may not list the same case twice.

If an interface has an of clause, then every interface or class which directly inherits the interface must occur as exactly one of the enumerated cases of the interface. Furthermore, any interface or class which indirectly inherits the interface must inherit exactly one of the enumerated cases of the interface.

An interface alias is an interface declaration which specifies another type.

TypeSpecifier: "=>" Type

The specified type must be an interface type, that is, a reference to an interface with no type parameters or an instantiation of a generic interface, and is called the aliased type.

An interface alias simply assigns an alternative name to the aliased type. A reference to the alias may occur anywhere a reference to an interface may occur.

shared interface PeopleByName => Map<String,Person>;

interface Compare<Value> => Comparison(Value,Value);

If the aliased interface is a parameterized type, the aliased type must explicitly specify type arguments.

A class or interface may satisfy an interface alias, in which case, the class or interface inherits the aliased interface type.

Interface aliases are not reified types. The metamodel reference for an interface alias type—for example, PeopleByName—returns the metamodel object for the aliased interface—in this case, Map<String,Person>, as specified in §8.1.2 Type argument reification.

A dynamic interface is an interface declared with the keyword dynamic. Dynamic interfaces may be used to model the type of objects defined in dynamically typed native code.

Every declaration nested inside a dynamic interface must be declared formal. A dynamic interface may not satisfy any interface that is not also a dynamic interface.

Within a dynamic block, defined in §5.3.5 Dynamic blocks, assignment of a value with no Ceylon type to a dynamic interface type does not result in an AssertionError, as defined in §8.3.6 Dynamic type checking. Instead, the value is coerced to the dynamic interface type.

The callable type of a class with an initializer parameter list captures the type and initializer parameter types of the class. The callable type is T(*P), where T is the applied type formed by the class with its own type parameters as type arguments, and P is the type of the initializer parameter list of the class.

The callable type of a class with a default constructor is the callable type of the default constructor.

A class with no initializer parameter list and no default constructor does not have a callable type.

An abstract class is not callable, except from the extends clause of a subclass, or the class specifier of a class alias.

The initial part of the body of a class is called the initializer of the class and contains a mix of declarations, statements, and control structures. The initializer is executed every time the class is instantiated. If the class does not have an initializer parameter list, the initializer section may include one or more constructor declarations, as defined in §4.9 Constructors.

A class initializer is responsible for initializing the state of the new instance of the class, before a reference to the new instance is available to clients.

shared abstract class Point() {
    shared formal Float x;
    shared formal Float y;
}

shared class DiagonalPoint(Float distance) 
        extends Point() {
    
    value d = distance / 2^0.5;
    x => d;
    y => d;
    
    "must have correct distance from origin" 
    assert (x^2 + y^2 == distance^2);
    
}

shared object origin 
        extends Point() {
    x => 0.0;
    y => 0.0;
}

Within a class initializer, a self reference to the instance being initialized is:

A statement or declaration contained in the initializer of a class may not evaluate an attribute, invoke a method, or instantiate a member class upon the instance being initialized, including upon a self reference to the instance being initialized, if the attribute, method, or member class:

A member class contained in the initializer of a class may not extend a member or nested class of an interface or superclass of the class.

Furthermore, a statement or declaration contained in the initializer of a class may not:

Nor may the class pass a self reference to the instance being initialized as an argument of its own extends clause expression, if any.

As a special exception to these rules, a statement contained in an initializer may assign a self-reference to the instance being initialized to a reference annotated late.

For example, the following code fragments are not legal:

class Graph() {
    OpenList<Node> nodes = ArrayList<Node>();
    class Node() {
        nodes.add(this);    //error: self reference in initializer
    }
}

class Graph() {
    class Node() {}
    Node createNode() {
        Node node = Node();
        nodes.add(node);    //error: forward reference in initializer
        return node;
    }
    OpenList<Node> nodes = ArrayList<Node>();
}

But this code fragment is legal:

class Graph() {
    OpenList<Node> nodes = ArrayList<Node>();
    Node createNode() {
        Node node = Node();
        nodes.add(node);
        return node;
    }
    class Node() {}
}

The remainder of the body of the class consists purely of declarations, similar to the body of an interface. The following constructs may not occur sequentially in the declaration section:

However, the declarations in this second section may freely use this and super, and may invoke any method, evaluate any attribute, or instantiate any member class of the class or its superclasses.

Within the declaration section of a class body, a super reference is any occurrence of the expression super, unless it also occurs in the body of a nested class or interface declaration. A statement or declaration contained in the declaration section of a class body may not:

A class may extend another class, as defined in §3.3.2 Extension.

shared class Customer(Name name, Organization? org = null) 
        extends Person(name, org) { 
    ... 
}

The class is a subtype of the type specified by the extends clause. If a class does not explicitly specify a superclass using extends, its superclass is the class Basic defined in ceylon.language.

A class may satisfy any number of interfaces, as defined in §3.3.3 Satisfaction.

class Token() 
        extends Datetime()
        satisfies Comparable<Token> & Identifier {
    ... 
}

The class is a subtype of every type listed in the satisfies clause. A class may not satisfy the same interface twice (not even with distinct type arguments).

A class inherits all members (methods, attributes, and member types) of every supertype. That is, every member of every supertype of the class is also a member of the class. Furthermore, the class inherits all nested types (interfaces and abstract classes) of every supertype.

Unless the class is declared abstract or formal, the class:

The schema of the inherited members is formed by substituting type arguments specified in the extends or satisfies clause.

A subclass with an initializer parameter list must pass arguments to each superclass initialization parameter or callable constructor parameter in the extends clause. A subclass with no initializer parameter list may not pass arguments in the extends clause.

shared class SpecialKey1()
        extends Key( SpecialLock() ) {
    ...
}

shared class SpecialKey2(Lock lock) 
        extends Key(lock) {
    ...
}

A subclass of a nested class must be a member of the type that declares the nested class or of a subtype of the type that declares the nested class. A class that satisfies a nested interface must be a member of the type that declares the nested interface or of a subtype of the type that declares the nested interface.

A user-defined class may not satisfy the interface Callable defined in ceylon.language nor directly satisfy the interface ConstrainedAnnotation defined in ceylon.language.

A toplevel or nested class may be annotated abstract and is called an abstract class.

A toplevel or nested class may be annotated final and is called a final class.

A toplevel or nested class may be annotated sealed and is called a sealed class.

If a class annotated shared is a member of a containing class or interface, then the class may be annotated formal and is called a formal member class, or, sometimes, an abstract member class.

An abstract class or formal member class may have formal members.

An abstract class may not be instantiated.

A formal member class may be instantiated.

A class which is not annotated formal or abstract is called a concrete class.

A concrete class may not have formal members.

A class annotated final must be a concrete class.

A class annotated final may not have default members.

If a concrete class annotated shared is a member of a containing class or interface, then the class may be annotated default and is called a default member class.

A toplevel class may not be annotated formal or default.

An un-shared class may not be annotated formal or default.

A class annotated sealed may not be instantiated or extended outside the module in which it is defined.

A class with no parameter list may not be annotated sealed.

A member class annotated sealed formal must belong to a sealed class or interface.

shared formal class Buffer(Character...) 
        satisfies Sequence<Character>;

Member class refinement is a unique feature of Ceylon, akin to the "factory method" pattern of many other languages.

A member class of a subtype refines a member class of a supertype if the member class of the supertype is shared and the two classes have the same name. The first class is called the refining class, and the second class is called the refined class.

Then, given the refined realization of the class it refines, as defined in §3.7.7 Realizations, and, after substituting the type parameters of the refined class for the type parameters of the refining class in the schema of the refining class, the refining class must:

Furthermore:

If a member class is annotated actual, it must refine some member class of a supertype.

A member class may not, directly or indirectly, refine two different member classes not themselves annotated actual.

Then instantiation of the member class is polymorphic, and the actual subtype instantiated depends upon the concrete type of the containing class instance.

shared abstract class Reader() {
    shared formal class Buffer(Character* chars) 
            satisfies Character[] {}
    ...
}

shared class FileReader(File file) 
        extends Reader() {
    shared actual class Buffer(Character* chars) 
            extends super.Buffer(chars) {
        ...
    }
    ...
}

All of the above rules apply equally to member classes which are aliases.

shared abstract class Reader() {
    shared formal class Buffer(Character* chars) => AbstractBuffer(*chars);
    ...
}

shared class FileReader(File file) 
        extends Reader() {
    shared actual class Buffer(Character* chars) => FileBuffer(*chars);
    ...
}

An object or anonymous class declaration is a compact way to define a class with a single value constructor, together with a getter aliasing this value constructor.

ObjectDeclaration: Annotations ObjectHeader ClassBody

An object has an initial lowercase identifier. An object declaration does not specify parameters or type parameters.

ObjectHeader: "object" MemberName ObjectInheritance

ObjectInheritance: ExtendedType? SatisfiedTypes?

An object declaration specifies the name of the value and the schema, supertypes, and implementation of the class. It does not explicitly specify a type name. Instead, the type name is formed by prefixing the value name with \I, turning it into an initial uppercase identifier, as specified by §2.3 Identifiers and keywords.

An object class:

Therefore, members of an object may not be declared formal nor default.

The body of the object declaration is the body of the class.

This class never appears in types inferred by local declaration type inference or generic type argument inference. Instead, occurrences of the class are replaced with the intersection of the extended type with all satisfied types.

An object value is a getter, as defined in §4.8.2 Getters, that simply returns a reference to the value constructor of the class. The value:

Therefore, the object may not be annotated default nor formal.

Annotations applying to an object declaration are considered annotations of the object value, and are accessible via its ValueDeclaration, as defined in §6.10 Reference expressions.

The following declaration:

shared my object red extends Color('FF0000') {
     string => "Red";
}

Is exactly equivalent to:

shared final class \Ired of red extends Color {
     shared new red extends Color('FF0000') {}
     string => "Red";
}

shared my \Ired red => \Ired.red;

Where \Ired is the type name assigned by the compiler.

shared object sql {
    shared String escape(String string) { ... }
}

...

String escapedSearchString = sql.escape(searchString);

A class declaration may enumerate a list of cases of the class, as defined in §3.4.2 Cases.

The cases listed in the of clause must exhaust every means by which an instance of the class may be instantiated:

shared abstract class Boolean() 
        of true | false {}
        
shared object true extends Boolean() { string => "true"; }
shared object false extends Boolean() { string => "false"; }

shared abstract class Node<Element>(String name) 
        of Branch<Element> | Leaf<Element> { ... }
        
shared class Leaf<Element>(String name, Element element) 
        extends Node<Element>(name) { ... }
        
shared class Branch<Element>(String name, Node<Element> left, Node<Element> right) 
        extends Node<Element>(name) { ... }

shared class Status of enabled | disabled {
    shared actual String string;
    shared new enabled { string => "enabled"; }
    shared new disabled { string => "disabled"; }
}

A non-abstract class with an initializer parameter list or a callable constructor may not specify an of clause.

A non-abstract, non-toplevel class may not specify an of clause.

A class declaration may not list the same case twice.

shared abstract class Boolean(shared actual String string) 
        of object true ("true") | 
           object false ("false") {}

A class alias is a class declaration which specifies a reference to a class or callable constructor of a class, followed by a positional argument list, as defined in §6.6.7 Positional argument lists.

ClassSpecifier: "=>" (Extension | Construction)

The specification of the class or callable constructor is treated as a value expression, as in §3.3.2 Extension. The type of this value expression must be a class type, that is, a reference to a class with no type parameters or an instantiation of a generic class, and is called the aliased type.

A class alias simply assigns an alternative name to the aliased type. A reference to the alias may occur anywhere a reference to a class may occur.

shared class People(Person* people) => ArrayList<Person>(*people);

class Named<Value>(String name, Value val) 
        given Value satisfies Object
        => Entry<String,Value>(name, val);

Arguments to the initializer parameters of the aliased class must be specified.

If the aliased class is a parameterized type, the aliased type must explicitly specify type arguments.

The type arguments may not be inferred from the initializer arguments.

If a toplevel class alias or un-shared class alias aliases an abstract class, the alias must be annotated abstract, and it may not be directly instantiated.

If a shared class alias nested inside the body of a class or interface aliases an abstract class, the alias must be annotated abstract or formal. If it is annotated formal, it is considered a member class of the containing class or interface. If it is annotated abstract, it is considered an abstract nested class of the containing class or interface.

A class alias may not alias a partial constructor. A shared class alias may not alias an un-shared constructor.

A class may extend a class alias, in which case, the class inherits the aliased class type.

Class aliases are not reified types. The metamodel reference for a class alias type—for example, People—returns the metamodel object for the aliased class—in this case, ArrayList<Person>, as specified in §8.1.2 Type argument reification.

The callable type of a function captures the return type and parameter types of the function.

A function implementation may be a block.

shared Integer add(Integer x, Integer y) {
    return x + y;
}

shared void printAll(Object* objects) {
    for (obj in objects) {
        print(obj);
    }
}

shared void addEntry(Key->Item entry) {
    map.put(entry.key,entry.item);
}

shared Set<Element> singleton<Element>(Element element) 
        given Element satisfies Comparable<Element> {
    return TreeSet { element };
}

Alternatively, a function implementation may be a lazy specifier, that is, an expression specified using =>. The type of the specified expression must be assignable to the return type of the function. In the case of a function declared void, the expression must be a legal statement, as defined by §5.3.1 Expression statements.

shared Integer add(Integer x, Integer y) => x + y;

shared void addEntry(Key->Item entry) => map.put(entry.key,entry.item);

shared Set<Element> singleton<Element>(Element element) 
            given Element satisfies Comparable<Element>
        => TreeSet { element };

A non-void, un-shared function with a block or lazy specifier may be declared using the keyword function in place of the explicit return type declaration. Then the function return type is inferred:

This function has inferred return type Integer.

function add(Integer x, Integer y) => x + y;

This function has inferred return type Float|Integer.

function unit(Boolean floating) {
    if (floating) {
        return 1.0;
    }
    else {
        return 1;
    }
}

This function has inferred return type Nothing.

function die() {
    throw;
}

The declaration of a function may be separated from the specification of its implementation. If a function declaration does not have a lazy specifier, or a block, and is not annotated formal, and is not a parameter, it is a forward-declared function.

A forward-declared function may later be specified using a specification statement, as defined in §5.3.3 Specification statements. The specification statement for a forward-declared function may be:

Comparison order(String x, String y);
if (reverseOrder) {
    order(String x, String y) => y<=>x;
}
else {
    order(String x, String y) => x<=>y;
}

Comparison format(Integer x);
switch (base)
case (decimal) {
    format = (Integer i) => i.string; 
}
case (binary) {
    format = formatBin;
}
case (hexadecimal) {
    format = formatHex;
}

Every forward-declared function must explicitly specify a type. It may not be declared using the keyword function.

A toplevel function may not be forward-declared. A method of an interface may not be forward-declared. A method annotated default may not be forward-declared.

If a shared method is forward-declared, its implementation must be definitely specified by all conditional paths in the class initializer.

A function may declare multiple lists of parameters. A function with more than one parameter list returns instances of Callable in ceylon.language when invoked. Every function with multiple parameter lists is exactly equivalent to a function with a single parameter list that returns an anonymous function.

This function declaration:

Boolean greaterThan<Element>(Element val)(Element element)
        given Element satisfies Comparable<Element> => 
                element>val;

is equivalent to the following:

Boolean(Element) greaterThan<Element>(Element val)
        given Element satisfies Comparable<Element> => 
                (Element element) => element>val;

For a function with n parameter lists, there are n-1 inferred anonymous functions. The ith inferred function:

Then the original function returns the first inferred anonymous function.

This method declaration:

function fullName(String firstName)(String middleName)(String lastName)
        => firstName + " " + middleName + " " + lastName;

Is equivalent to:

function fullName(String firstName) =>
        (String middleName) =>
                (String lastName) =>
                        firstName + " " + middleName + " " + lastName;

If a function declaration does not have a lazy specifier, or a block, and is annotated shared, and is a method of either:

then the function declaration may be annotated formal, and is called a formal method, or, sometimes, an abstract method.

shared formal Item? get(Key key);

A method which is not annotated formal is called a concrete method.

If a concrete method is annotated shared, and is a member of a class or interface, then it may be annotated default and is called a default method.

shared default void writeLine(String line) {
    write(line);
    write("\n");
}

A method annotated formal may not specify an implementation (a lazy specifier, or a block).

A method annotated default must specify an implementation (a lazy specifier, or a block), and may not be forward-declared.

Every formal method must explicitly specify a type. It may not be declared using the keyword function.

A toplevel method may not be annotated formal or default.

An un-shared method may not be annotated formal or default.

Methods may be refined, just like in other object-oriented languages.

A method of a subtype refines a method of a supertype if the method of the supertype is shared and the two methods have the same name. The first method is called the refining method, and the second method is called the refined method.

Then, given the refined realization of the method it refines, as defined in §3.7.7 Realizations, and, after substituting the type parameters of the refined method for the type parameters of the refining method in the schema of the refining method, the refining method must:

Furthermore:

If a method is annotated actual, it must refine some method defined by a supertype.

A method may not, directly or indirectly, refine two different methods not themselves annotated actual.

Then invocation of the method is polymorphic, and the actual method invoked depends upon the concrete type of the class instance.

shared abstract class AbstractSquareRooter() {
    shared formal Float squareRoot(Float x);
}

class ConcreteSquareRooter()
        extends AbstractSquareRooter() {
    shared actual Float squareRoot(Float x) => x^0.5;
}

Alternatively, a subtype may refine a method using a specification statement, as defined in §5.3.3 Specification statements. The specification statement must satisfy the requirements of §4.7.5 Forward declaration of functions above for specification of a forward-declared function.

class ConcreteSquareRooter()
        extends AbstractSquareRooter() {
    squareRoot(Float x) => x^0.5;
}

The lifecycle and scope of the persistent value of a reference depends upon where the reference declaration occurs:

The persistent value of a reference may be specified or initialized as part of the declaration of the reference, or via a later specification statement, as defined in §5.3.3 Specification statements, or assignment expression, as defined in §6.8 Operators, or, if it is a parameter, by an argument to an invocation expression, as defined in §6.6 Invocation expressions.

A reference annotated variable has a persistent value that can be assigned multiple times. A reference not annotated variable has a persistent value that can be specified exactly once and not subsequently modified.

variable Integer count = 0;

shared Decimal pi = calculatePi();

shared Integer[] evenDigits = [0,2,4,6,8];

A reference declaration may have a specifier which specifies its persistent value or, in the case of a variable reference, its initial persistent value. The type of the specified expression must be assignable to the type of the reference.

If the specified expression has no type, and the declaration occurs within a dynamic block, then the specification is not type-checked at compile time.

If a reference is a parameter, it must not specify a persistent value.

A reference belonging to a class may be annotated late, in which case the initializer of the class is not required to initialize its persistent value. Furthermore, a self-reference to an instance being initialized may be assigned to the reference.

A reference annotated late may not be initialized or assigned a value by the class initializer. A parameter may not be annotated late. A reference not belonging to a class may not be annotated late.

If a class declares or inherits a variable reference, it must (directly or indirectly) extend the class Basic defined in ceylon.language.

A getter implementation may be a block.

shared Float total {
    variable Float sum = 0.0;
    for (li in lineItems) {
        sum += li.amount;
    }
    return sum;
}

Every conditional execution path of the block must end in a return directive that specifies an expression assignable to the type of the value, or in a throw directive, as specified in §5.3.6 Definite return.

Alternatively, a getter implementation may be a lazy specifier, that is, an expression specified using =>. The type of the specified expression must be assignable to the type of the value.

Name name => Name(firstName, initial, lastName);

A setter defines how the value of a getter is assigned.

SetterDeclaration: Annotations "assign" MemberName (Block | LazySpecifier)

The name specified in a setter declaration must be the name of a matching getter that directly occurs earlier in the body containing the setter declaration. If a getter has a setter, we say that the value is variable.

Within the body of the setter, a value reference to the getter evaluates to the value being assigned.

A setter implementation may be a block. The block may not contain a return directive that specifies an expression.

shared String name { return join(firstName, lastName); }
assign name { firstName=first(name); lastName=last(name); }

Alternatively, a setter implementation may be a lazy specifier. The specified expression must be a legal statement.

shared String name => join(n[0], n[1]);
assign name => n = [first(name), last(name)];

A setter may not be annotated shared, default or actual. The visibility and refinement modifiers of an attribute with a setter are specified by annotating the matching getter.

An un-shared value with a block, specifier, or lazy specifier may be declared using the keyword value in place of the explicit type declaration. Then the value's type is inferred:

value names = List<String>();

variable value count = 0;

value name => Name(firstName, initial, lastName);

The declaration of a reference may be separated from the specification or initialization of its persistent value. The declaration of a getter may be separated from the specification of its implementation. If a value declaration does not have a specifier, lazy specifier, or a block, and is not annotated formal, it is a forward-declared value.

A forward-declared value may later be specified using a specification statement, as defined in §5.3.3 Specification statements.

String greeting;
switch (language)
case (en) {
    greeting = "Hello";
}
case (es) {
    greeting = "Hola";
}
else {
    throw LanguageNotSupported();
}
print(greeting);

Every forward-declared value must explicitly specify a type. It may not be declared using the keyword value.

A toplevel value may not be forward-declared. An attribute of an interface may not be forward-declared. An attribute annotated default may not be forward-declared.

A forward-declared getter may not have a setter.

If a shared value is forward-declared, its implementation must be definitely specified by all conditional paths in the class initializer.

If a value declaration does not have a specifier, lazy specifier, or a block, and is annotated shared, and is a member of either:

then the value declaration may be annotated formal, and is called a formal attribute, or, sometimes, an abstract attribute.

shared formal variable String firstName;

An attribute which is not annotated formal is called a concrete attribute.

If a concrete attribute is annotated shared, and is a member of a class or interface, then it may be annotated default and is called a default attribute.

shared default String greeting = "Hello";

An attribute annotated formal may not specify an implementation (a specifier, lazy specifier, or a block). Nor may there be a setter for a formal attribute.

An attribute annotated default must specify an implementation (a specifier, lazy specifier, or a block), and may not be forward-declared.

Every formal attribute must explicitly specify a type. It may not be declared using the keyword function.

A toplevel attribute may not be annotated formal or default.

An un-shared attribute may not be annotated formal or default.

Ceylon allows attributes to be refined, just like methods. This helps eliminate the need for Java-style getter and setter methods.

Any non-variable attribute may be refined by a reference or getter. A variable attribute may be refined by a variable refernce or by a getter and setter pair.

An attribute of a subtype refines an attribute of a supertype if the attribute of the supertype is shared and the two attributes have the same name. The first attribute is called the refining attribute, and the second attribute is called the refined attribute.

Then, given the refined realization of the attribute it refines, as defined in §3.7.7 Realizations, the refining attribute must:

Furthermore:

If an attribute is annotated actual, it must refine some attribute defined by a supertype.

An attribute may not, directly or indirectly, refine two different attributes not themselves annotated actual.

A non-variable attribute may be refined by a variable attribute.

Then evaluation and assignment of the attribute is polymorphic, and the actual attribute evaluated or assigned depends upon the concrete type of the class instance.

shared abstract class AbstractPi() {
    shared formal Float pi;
}

class ConcretePi() 
        extends AbstractPi() {
    shared actual Float pi = calculatePi();
}

Alternatively, a subtype may refine an attribute using a specification statement, as defined in §5.3.3 Specification statements. The specification statement must satisfy the requirements of §4.8.5 Forward declaration of values above for specification of a forward-declared attribute.

class ConcretePi() 
        extends AbstractPi() {
    pi = calculatePi();
}

For a callable constructor, the callable type of the constructor captures the type of the class, and parameter types of the constructor. The callable type is T(*P), where T is the applied type formed by the class with its own type parameters as type arguments, and P is the type of the parameter list of the constructor.

A constructor of an abstract class is not callable, except from the extends clause of a subclass, or the class specifier of a class alias.

A partial constructor is not callable, except from the extends clause of another constructor of the same class.

The type of a value constructor is simply T, where T is the class to which it belongs.

A callable constructor annotated abstract is called a partial constructor.

A partial constructor may not be annotated shared.

A default constructor may not be annotated abstract.

A value constructor may not be annotated abstract.

Every constructor of any class which does not directly extend Basic defined in ceylon.language must explicitly delegate, as defined in §3.3.2 Extension, to either:

If the constructor of a class which directly extends Basic does not have an extends clause, the constructor implicitly delegates to the initializer of Basic.