A list of statements and declarations, surrounded by braces.

Logically, a class body is divided into two sections:

  • An initializer section, mixing statements and declarations, and
  • a declaration section, containing only statements.

There is, however, no syntactical separation between these, so syntactically a class body looks exactly like a Block.

Examples (multi-line):

{
    shared formal Float x;
    shared formal Float y;
    shared actual default Float distance(Point other) => ((x-other.x)^2 + (y-other.y)^2)^0.5;
}
{
    if (token != secret) {
        throw AssertionError("You may not instantiate this class!");
    }
    shared void hack(Anything victim) {
        ████ ███████ ██ █;
    }
}

no subtypes hierarchy

Initializer
ClassBody(<Declaration|Statement>[] content)
Parameters:
  • content

    The content of the body.

Attributes
childrenSource Codeshared actual <Declaration|Statement>[] children

The child nodes of this node.

Refines Body.children ultimately refines Node.children
contentSource Codeshared actual <Declaration|Statement>[] content

The content of the body.

Refines Body.content
hashSource Codeshared actual Integer hash

The hash value of the value, which allows the value to be an element of a hash-based set or key of a hash-based map. Implementations must respect the constraint that:

  • if x==y then x.hash==y.hash.

Therefore, a class which refines equals must also refine hash.

Refines Object.hash
Inherited Attributes
Attributes inherited from: Node
Attributes inherited from: Object
Methods
copySource Codeshared ClassBody copy(<Declaration|Statement>[] content = ...)
Parameters:
  • content = this.content
equalsSource Codeshared actual Boolean equals(Object that)

Determine if two values are equal. Implementations should respect the constraints that:

  • if x===y then x==y (reflexivity),
  • if x==y then y==x (symmetry),
  • if x==y and y==z then x==z (transitivity).

Furthermore it is recommended that implementations ensure that if x==y then x and y have the same concrete class.

A class which explicitly refines equals() is said to support value equality, and the equality operator == is considered much more meaningful for such classes than for a class which simply inherits the default implementation of identity equality from Identifiable.

transformSource Codeshared actual Result transform<out Result>(Transformer<Result> transformer)

Transform this node with the given transformer by calling the appropriate transformX method on the transformer.

If you have a Node node that’s actually an LIdentifier instance, then the runtime will call LIdentifier.transform; therefore, this method is by nature narrowing. This means that if transformer is a NarrowingTransformer, calling node.transform(transformer) is equivalent to calling transformer.transformNode(node). On the other hand, if transformer is a WideningTransformer, then the two operations are very different.

Inherited Methods
Methods inherited from: Node