Syntax differences between compiler and interpreter

Class definition and declaration

In the interpreter, the class includes only the member declarations, not their definitions; in the compiler, these are defined inside the class, just as in Java. Attribute change triggers have been moved into the class as well, using the "on change { block }" syntax.

Nonprivate class members must have explicit types; this means attributes must have an explicit type, and function signatures must have explicit types for return value and argument types.

Attribute values specified in a class are considered defaults only. If the object literal specifies a value, the defaults are not evaluated.

Interpreter:

 class Foo { 
   attribute foo;
   function moo(x);
 }
 
 attribute Foo.foo = 3;
 
 function Foo.moo(x) = { x + 1 }
 
 trigger on Foo.foo = newValue { code }


Compiler:

 class Foo { 
   attribute foo = 3
     on change { code };
   
   function moo(x) { x + 1 }
 }

Functions vs Operations

Currently, operations and functions have been folded together. Bind semantics are still up in the air.


Initialization

Any code that must be run after the instance is created via the object literal can be placed in an optional init { } block within the class definition. This can be used to reject invalid arguments, perform additional initialization steps, etc.

Compiler:

 class Foo { 
   attribute foo = 3
     on change { code };
   
   function moo(x) { x + 1 }

   init { 
     initialization code here
   }
 }

Modifiers

The compiler currently recognizes public, private, protected, abstract, and readonly as member modifiers.


Block Expressions

  • to be filled in*


Use of extends instead of supertype on class definition

  • to be filled in*


Import

  • to be filled in*


Cardinality

The only cardinality specifiers are nothing (instance) and [] (sequence).

Community content is available under CC-BY-SA unless otherwise noted.