Difference between revisions of "EDT:EGL Language Statements"

Latest revision as of 16:31, 4 May 2012

Please see the parent of this page, EDT:EGL Language.

Statements (Table 5)

Notes on Table 5

1. EDT won't support every variation of RBD's move statement. There will be support for move byName, move for, and move for all. A move statement without one of the additional keywords is only allowed between two reference variables of the same type, and it results in the target being assigned a deep copy of the source's value. The deep copy is invalid for JavaObject and JavaScriptObject ExternalTypes. If/when we support structured records, we might not support move byName on them because of the complex (unclean) design.
2. EDT doesn't have called programs, but services and native programs can be called.
3. EDT's foreach statement will support iterating over an array.
4. New syntax will allow setting annotations on declarations without the use of curly braces. In RBD we usually do x int {myAnnotation = 3}; but another way to do the same thing is x int {@myAnnotation{3}};. In EDT we will allow that to be outside of curly braces and before the declaration, for example @myAnnotation{3} x int;.
5. EDT won't support exit stack.
6. See the discussion of nullability below.
   
7. See the discussion of array declarations below.
   

Nullability

Variable declarations, function parameters, and function return types may end with a question mark to indicate that they're nullable. Nullability means that a variable may really be null. It's not an "I'm null" flag like in RBD.  Even reference variables can be nullable.

A NullValueException will be thrown if you try to access a field or function of a null variable, even a record. A NullValueException will be thrown if a null variable is an operand to a math operator, an array access, a substring access, a comparison, or a bitwise operator. The string concatenation operators will work the same as in RBD with respect to nulls. :: treats null as the empty string, and ?: results in null if either operand is null. A question mark won't be allowed on the second operand of the AS and ISA operators (the name of the type).

A validation check will ensure that things which can't be instantiated (interfaces, and types with private default constructors) must be declared nullable. Constructors can be defined in ExternalTypes and handlers.

You can't assign null to something that's not nullable.  We'll give a validation error on notNullableVariable = null; and a runtime error on notNullableVariable = nullableVariable; when the nullableVariable is null.

Array Declarations

Arrays can't be declared with an initial size

Arrays can't be declared with an initial size. The size of an array isn't part of its type. That's why in RBD you can declare an int[5] and then assign [1,2,3] to it -- you change its length from 5 to 3. In EDT, all arrays must be declared without an initial size.

A size is still allowed on a new expression when you create an array.

Here are some example array declarations for EDT:

• a int[] = new int[3];

• a int[] = [1, 2, 3];

• a int[]; // This is an array of length zero.

• a int[]?; // Initially null.

• a int[]? {}; // This is an array of length zero.

Initializing arrays with literals

Array initializers must be efficient. "a int[] = [1, 2, 3];" means make an array of three elements, values 1 then 2 then 3. Do not make a zero-length array, then make an array from the literal, and throw away the original zero-length array.

Initializing arrays with set-values blocks

A set-values block on an array declaration causes the values within the block to be appended to the array. For example "a int[] { 1, 2, 3 };" results in [1, 2, 3]. The block has a different effect in RBD: it sets elements rather than appending them, so you'd get an index out of bounds exception on the declaration "a int[] { 1, 2, 3 };".