Statements

Basic Statements

The most common type of statement is an expression followed by a semicolon:

some-object.do-something();

Statements can be grouped together using braces:

{
  some-object.do-something();
  x = y + 1;
}

The "if" statement works like in C:

if (a-string.is-empty) {
  a-string = "<empty>";
  }

Declarations

Local variables are declared by following the name of the new variable with a colon and the type of the variable. The statement ends with a semicolon:

name: String;

You can initialize the variable to a value:

name: String = "Fred";

The declaration can also create a new object. You can give the arguments to a create() function. These two statements are equivalent:

node: Node(value);
node: Node = new Node(value);

Let's return to the first example:

name: String;

What is the value of name? If the class of the new variable has a create() function with no arguments (as String does), a new object is created and that create() function is called. If not, it is set to nil. So, assuming there's a Node class that doesn't have a nullary create() function, the following pairs of statements are equivalent:

name: String;
name: String();

node: Node;
node: Node = nil;

Looping Statements

The most basic kind of loop is the "loop" statement. It repeats forever:

loop {
  do-something();
  }

This wouldn't be very useful, except you can use the "break" statement to break out of the loop. You can also use the "continue" statement to skip to the top of the loop.

The "while" and "do/while" statements are also available:

while (y < bottom) {
  draw-line(x, y);
  y = y + line-height;
  }

do {
  line: String = stream.read-line();
  (line + "\n").write();
} while (!stream.is-done);

The most complex looping statement is the "for" statement. The Cleet "for" statement is completely different from the one in C/C++. It's used for iterating over collections:

sum: Int = 0;
for (value: Int in array)
  sum += value;

for (line: String in file.contents.lines) {
  if (line.is-empty)
    continue;
  parse-line(line);
  }

As you can see, the "for" statement declares a new local variable (whose scope is the loop), and sets it to each value in the collection in turn. How does this work? The collection will have a function called iterator that returns an iterator object. So the first example is the same as this:

{
  sum: Int = 0;
  iterator: IntArrayIterator = array.iterator;
  while (!iterator.is-done) {
    value: Int = iterator.current-item;
    sum += value;
    iterator.go-forward();
    }
}

And for the more detail-oriented among you, here's the equivalent of the second example:

{
  iterator: LinesIterator = file.contents.lines.iterator;
  while (!iterator.is-done) {
    line: String = iterator.current-item;
    try {
      if (line.is-empty)
        throw ContinueException;
      parse-line(line);
      }
    catch (ContinueException) {
      // just keep going
      }
    iterator.go-forward();
    }
}

Exceptions

As that last example shows, Cleet supports throwing and catching exceptions with the "throw" and "try"/"catch" statements. "throw" can either take an existing object or it can create a new object. The following two statements are equivalent:

throw MessageException("Something is terribly wrong!");
throw new MessageException("Something is terribly wrong!");

The "catch" statement shown above doesn't actually do anything with the object it caught, but you can:

try {
  do-something();
  }
catch (exception: Exception) {
  ("Error!: " + exception.message + "\n").write();
  }

Any type of object can be thrown or caught, but there is a standard Exception class that most exceptions will be subclasses of. There is also a simple MessageException class that is easy to throw.

Returning from a Method

Finally, there is a "return" statement to return from a function:

return;
return some-value;