Note: information on this page refers to Ceylon 1.1, not to the current release.

Attributes and variables, control structures

This is the third part of the Tour of Ceylon. In the previous leg we learned about classes and met the concept of an attribute. What really makes a class special is that is can hold state—references to other objects. So it's time to learn more about attributes and variables.

Then we're going to skim over some material about control structures (if, switch, for, while and try).

Attributes and local values

In Java, a field of a class is quite easily distinguished from a local variable or parameter of a constructor. Fields are declared directly in the body of a Java class, whereas local variables are declared within the body of the constructor. And they're different kinds of things. A local variable in a constructor doesn't outlive the invocation of the constructor. But a field lives until the object it belongs to is garbage collected.

This distinction is much less meaningful in Ceylon, and often irrelevant. An attribute is really just a value declared in the parameter list or body of the class that happens to be captured by some shared declaration.

Here, count is a block-local variable of the initializer of Counter:

class Counter() {
    variable Integer count = 0;
}

But in this example, count is a shared attribute, visible to clients of the class:

class Counter() {
    shared variable Integer count = 0;
}

The distinction starts to melt away when we consider the next example:

class Counter() {
    variable Integer count = 0;
    shared Integer inc() => ++count;
}

Here, even though count is not shared, it still has a lifecycle that extends beyond the execution of the class initializer. We say that count is captured by the method inc().

This might seem a bit strange at first, but it's really just how the principle of closure works. The same behavior applies to block-local values declared in the body of a function. Functions can't declare shared members, of course, but they can return an object that captures a local variable:

interface Counter {
    shared formal Integer inc();
}

Counter createCounter() {
    variable Integer count = 0;
    object counter satisfies Counter {
        inc() => ++count;
    }
    return counter;
}

Or, as we'll see later, a function can even return a nested function that captures the local variable:

Integer() counter() {
    variable Integer count = 0;
    Integer inc() => ++count;
    return inc;
}

(Don't worry too much about the syntax here—for now all we're interested in is that counter() returns a reference to a function inc() that captures the variable count.)

So even though we'll continue to use the terms "local value" and "attribute" throughout this tutorial, keep in mind that there's no really strong distinction between the things these terms refer to. Any named value might be captured by some other declaration in the same containing scope. A local value is just an attribute that happens to not be captured by anything.

Variables

Ceylon encourages you to use immutable references as much as possible. Therefore, immutability is the default! An immutable reference has its value specified when the object is initialized, and is never reassigned.

class Box<Value>(val) {
    shared Value val;
}

Box<String> ref = Box("hello");
print(ref.val);
ref.val = "bar";    //compile error: value is not variable

Note that, just like in Java, we don't have to declare and initialize a reference in one line of code. We can write:

Box<String> ref;
if (leaving) {
    ref = Box("goodbye");
}
else {
    ref = Box("hello");    //ok
}

That's perfectly OK, as long as the compiler can verify that ref only gets assigned once in each conditional path through the code.

But if we want to be able to reassign a new value to a reference that has already been initialized, we need to annotate it variable:

class Box<Value>(val) {
    shared variable Value val;
}

Box<String> ref = Box("hello");
print(ref.val);
ref.val = "goodbye";    //ok
print(ref.val);

Idiomatic Ceylon code uses mutable references relatively less often than in most other languages.

Setters

We've already met the concept of a getter.

If we want to make an attribute defined as a getter mutable, we need to define a matching setter. Usually this is only useful if you have some other internal attribute you're trying to set the value of indirectly.

Suppose our class has the following attributes, intended for internal consumption only, so un-shared:

variable String? firstName = null;
variable String? lastName = null;

(Remember, Ceylon never automatically initializes attributes to null.)

Then we can abstract the attributes using a third attribute defined as a getter/setter pair:

shared String fullName
        => " ".join({ firstName, lastName }.coalesced);

assign fullName {
    value tokens = fullName.split().iterator();
    if (is String first = tokens.next()) {
        firstName = first;
    }
    if (is String last = tokens.next()) {
        lastName = last;
    }
}

A setter is identified by the keyword assign in place of a type declaration. (The type of the matching getter determines the type of the attribute.) Within the body of the setter, the attribute name evaluates to the value being set.

Yes, this is a lot like a Java get/set method pair, though the syntax is significantly streamlined. But since Ceylon attributes are polymorphic, and since you can redefine a reference as a getter or getter/setter pair without affecting clients that call the attribute, you don't need to write getters and setters unless you're doing something special with the value you're getting or setting.

Don't ever write code like this in Ceylon:

variable String _name = "";
shared String name => _name;  //pointless getter
assign name => _name=name;    //pointless setter

It's not necessary, and there's never any benefit to it.

Control structures

Ceylon has six built-in control structures. There's nothing much new here for Java or C# developers, so a few quick examples without much additional commentary should suffice.

Gotcha!

First, one "gotcha" for folks coming from other C-like languages: Ceylon doesn't allow you to omit the braces in a control structure. The following doesn't even parse:

if (x > 100) print("big");  //error

You are required to write:

if (x > 100) { print("big"); }

(The reason braces aren't optional in Ceylon is that an expression can begin with an opening brace, for example, {"hello", "world"}, so optional braces in control structures would make the whole grammar ambiguous.)

OK, so here we go with the examples.

If conditionals

The if/else statement is totally traditional:

if (x > 1000) {
    print("really big");
}
else if (x > 100) {
    print("big");
}
else {
    print("small");
}

Later we will learn how if can narrow the type of references in its block. We've already seen an example of that, back when we talked about optional types.

We often use the operators then and else instead of if.

Switch conditionals

The switch/case statement eliminates C's much-criticized "fall through" behavior and irregular syntax:

switch (x <=> 100)
case (smaller) { print("smaller"); }
case (equal) { print("one hundred"); }
case (larger) { print("larger"); }

The type of the switched expression may be an enumerated type, String, Character, or Integer.

We'll have much more to say about switch when we discuss enumerated types.

Assertions

Ceylon also has an assert statement:

assert (length < 10);

Such assertions are good for making statements which you know have to be true, but are not apparent to other readers of the code (including the type checker!). Common uses of assert include things like preconditions, postconditions and class invariants.

If the condition is false at runtime an exception is thrown. The exception message helpfully includes details of the condition which was violated, which is extra important when the assert has more than one condition.

assert (exists arg, !arg.empty);

To customize the assertion message, add a doc annotation:

"length must be less than 10"
assert (length < 10);

Where applicable, the typechecker uses asserted type information when checking statements which follow the assertion, for example:

Integer? x = parseInteger("1");
assert (exists x);
// after the assert, x has type Integer instead of Integer?
value y = x + 10;

This is really just the same behavior we saw earlier, only this time it's happening in the middle of a block rather than at the start of an if block. (Don't worry, there's more on this later.)

Note that, unlike Java's assert, which can be disabled at runtime, Ceylon's assertions are always enabled.

For loops

The for loop has an optional else block, which is executed when the loop completes normally, rather than via a return or break statement.

variable Boolean minors;
for (p in people) {
    if (p.age < 18) {
        minors = true;
        break;
    }
}
else {
    minors = false;
}

There is no C-style for. Instead, you can use the lengthwise range operator : to produce a sequence of Integers given a starting point and a length:

for (i in min:len) { ... }

Alternatively, you can use the ordinary range operator .. to produce a sequence of Integers given two endpoints:

for (i in min..max) { ... }

There are a couple of other tricks with for that we'll come back to later.

We often use comprehensions or even higher order functions instead of for.

While loops

The while loop is traditional.

value it = names.iterator();
while (is String next = it.next()) {
    print(next);
}

There is no do/while statement.

Try statements

The try/catch/finally statement works just like Java's:

try {
    message.send();
}
catch (ConnectionException|MessageException e) {
    tx.setRollbackOnly();
}

To handle all Ceylon exceptions, together with all JavaScript exceptions, or all Java exceptions that are subclasses of java.lang.Exception, we can catch the type Exception defined in ceylon.language. If we don't explicitly specify a type, Exception is inferred:

try {
    message.send();
}
catch (e) {  //equivalent to "catch (Exception e)"
    tx.setRollbackOnly();
}

To handle all exceptions, including subtypes of java.lang.Error, we can catch the root exception class Throwable.

The try statement may optionally specify a "resource" expression, just like in Java. The resource is a Destroyable or an Obtainable.

try (Transaction()) {
    try (s = Session()) {
        s.persist(person);
    }
}

There are no Java-style checked exceptions in Ceylon.

Condition lists

Constructs like if, while, and assert accept a condition list. A condition list is simply an ordered list of multiple boolean, exists, nonempty, and is conditions. The condition list is satisfied if (and only if) every one of the conditions is satisfied.

With plain Boolean conditions you could achieve the same thing with the && operator of course. But a condition list lets you use the "structured typecasting" of exists, is, and friends in conditions appearing later in the same list.

Let's see an example using assert:

value url = parserUri("http://ceylon-lang.org/download");
assert(exists authority = url.authority,
       exists host = authority.hostname);
// do something with host

Here you can see two exists conditions in the assert statement, separated with a comma. The first one declares authority (which is inferred to be a String, rather than a String? because of the exists). The second condition then uses this in its own exists condition.

The important thing to note is that the compiler lets us use authority in the second condition and knows that it's a String, not a String?. You can't do that by &&-ing multiple conditions together. You could do it by nesting several ifs, but that tends to lead to much less readable code, and doesn't work well in while statements or comprehensions.

There's more...

Now that we know enough about classes and their members, we're ready to explore inheritance and refinement (overriding).

Ceylon

Quick introduction

Tour of Ceylon

Ceylon Walkthrough

Language specification

Reference

Language module API

FAQs

Roadmap

Ceylon IDE