Field Access

Fields of a Class or Record can be accessed simply by specifying their name.

For fields of the current type (i.e. the class or record that the current code is also a part of), simply the name of the field on its own suffices to access it. To access fields of a different type (or a different instance of the same type), a Member Access Expression is used, appending a . or : to the expression that represents the instance, followed by the field name:

  Foo = public class
    var fValue: String;
    method CopyFrom(aBar: Foo);
      fValue := aBar.fValue;


In the above example, fValue can be accessed directly, to get its value in the current instance of the class. A Member Access Expression is used to access the same field on aBar – a different object.

Note that non-private fields are discouraged, so accessing fields (opposed to, say, Properties) on other instances is a rare (but not entirely uncommon) situation. In the example above, you notice that a class can access private fields of other instances of the same class

Using self to Avoid Ambiguity

The self expression can be used to explicitly access a field on the current instance, in cases where the name of the field is hidden by a different identifier in scope:

var Value: String;
method UpdateValue(Value: String);
  self.Value := Value;

Although in general it is advised to avoid such issues by having a consistent naming schema — such as f prefix for fields, and a prefix for parameter names:

var fValue: String;
method UpdateValue(aValue: String);
  fValue := aValue;

Writing to Fields

Unless a field is marked as readonly, field access expressions are assignable, allowing code to to update the value of the field (as already seen in the code snippet above).

fValue := 'Hello';

See Also