Expressions
Primary Expressions

Primary expressions are the most basic kind of expression. First of all, there are various literals:

"String literal" 'String literal' 34 12.5 nil true false

Next there are identifiers:

some-identifier SomeClass

An identifier might refer to a local variable, to a field of the current object, to a class object, or to a namespace. Identifiers start with a letter, and may contain letters, numbers, and hyphens. An identifier may not end with a hyphen. By convention, almost all identifiers are all lowercase and use hyphens to separate words. The exceptions are class names and namespace names, which are capitalized and use intercaps to separate words.

this super

"this" and "super" both refer to the current object. The difference is that if a function call is made on "super", it will use the method defined in the superclass, not the one in the current object's class that overrides it.

There are expressions to create a new object:

new SomeClass new SomeClass(argument-1, argument-2)

Creating a new object (almost) always includes calling a create() function on the new object, so you can pass the arguments for that function call.

Dot Expressions

Once you've got a reference to an object, you can access its fields or call its functions using the dot operator:

some-object.some-field some-object.some-function(argument-1, argument-2) "A string".length (3).string

Note the last two examples; they show that literals are objects just like any other, and that you don't need an argument list -- not even the parentheses -- to call a function that has no arguments. (A function with no arguments is called a "nullary" function.) But you can include the parentheses if you want:

"Hello world.\n".write()

There is a convention about when to use the parentheses when calling a nullary function: If you're calling the function just to find out something about the object, don't use the parentheses. If you're calling the function because it's going to do something, use the parentheses.

The name of the function can also be given as a string literal instead of as an identifier:

some-object."some-function"() some-object."+"(some-other-object)

Class fields and functions can be accessed without having an object of the class. Just give the class name, a dot, and the field or function:

System.system
Operators

Most of the operators available in C and C++ are also available in Cleet, and result in function calls. So the following pairs of expressions are equivalent:

3 + 4 (3)."+"(4) some-object[some-index-1, some-index-2] some-object."[]"(some-index-1, some-index-2)

The exceptions are the "short-circuit" logical operators: &&, ||, and !. These are not function calls. Neither is the "=" operator; see below for the explanation of how that is handled.

Precedence is the same as in C/C++:

= || && | ^ & == != < > <= >= << >> + - * / % ! unary+ unary- ~ []

(Note that unlike C/C++, Cleet has no pre-/post- increment/decrement operators, conditional expressions, or comma operator.)

Assignment and the "=" operator

Most of the time, the "=" operator is used to assign to a local variable or a field:

some-local = some-value some-field-of-current-object = some-value some-object.some-field = some-value

But it can also be used with functions, in which case the function name has "-set" appended to it and the value is the last argument. So the following pairs of expressions are equivalent:

some-object.some-function(some-argument) = some-value some-object.some-function-set(some-argument, some-value) some-object[some-index] = some-value some-object."[]-set"(some-index, some-value)

Most of the binary operators have an associated operator that makes the function call and assigns the result in one step:

x += 1

(These have the same precedence as the "=" operator.)