Ad/2010-08-01 Concrete Syntax for a uml action Language for Foundational uml (Alf) Second Revised Submission

9.6Local Name Declaration Statements

let interest : CurrencyAmount = this.principal * this.rate * period;

In the second form, the type name precedes the local name:

CurrencyAmount interest = this.principal * this.rate * period;

The two forms are completely equivalent. In both cases, the local name is assigned the result of evaluating the expression.

NOTE. The first form of local name declaration is consistent with the usual UML notation for declaring the type of a name. The second form is consistent with the form of declarations in many common programming languages and also emphasizes the essential semantics of the statement as an assignment with an added type constraint.

Examples

let currentOffer : Offer = this.offers[1];

let origin : Point = new(0,0);

CurrencyAmount interest = this.principal * this.rate * period;

let inactiveMembers : Member[] = members -> select member (!member.active);

RealProperty[] realProperties = (RealProperty)assets;

IntegerList list = {1, 2, 3};

Set fixedAssets = new { land, home, condominium };

Figure 9 48 Abstract Syntax of Local Name Declaration Statements

1. 
   Name see Subclause 7.5
   
2. 
   Expression see Subclause 8.1
   
3. 
   QualifiedName see Subclause 8.2
   
4. 
   TypeName see Subclause 8.2
   
5. 
   SequenceInitializationExpression see Subclause 8.3.15
   
6. 
   MultiplicityIndicator see Subclause 8.3.15
   
7. 
   Statement see Subclause 9.1
   

The local name in a local name declaration statement must be unassigned before the statement and before the expression in the statement. It must remain unassigned after the expression. The assigned source for the name after the local name declaration statement is the statement itself.

Typing

The new local name has the type given by the type name in the statement (see Subclause 8.2 on type names). If the type name is a qualified name, it must resolve to a classifier that is not a template, though it may be the binding of a template. If the multiplicity indicator “[]” is specified with the type, then the multiplicity of the local name is [0..*]. Otherwise it is [0..1] and the multiplicity upper bound of the assigned expression must not be greater than 1.

For example, the following is legal:

let v: Vehicle = new Car();
v = new Truck();

presuming that Car and Truck are both subclasses of Vehicle. However, the following would not be legal:

v = new Car();
v = new Truck(); // Type error!

because the initial assignment would determine the type of v as being Car, which is not compatible with Truck.

A similar effect to the legal assignment above can be achieved using a type cast (see Subclause 8.5.5):

v = (Vehicle)new Car();

Even though the initial value assigned to v here is a Car, the type of the expression “(Vehicle)new Car()” is Vehicle, due to the cast. Therefore, the initial assignment determines the type of v as being Vehicle, so the second assignment is legal.

However, there is an important semantic difference. Type casts in Alf filter values that cannot be cast, so that

v = (Vehicle)new House();

is legal and will assign null to v. On the other hand, the following is not legal:

let v: Vehicle = new House(); // Type error!

since the class House does not statically conform to the declared type Vehicle.

Initialization Expressions

Since a local name declaration statement already includes an explicit declaration of the type of a new name, it is possible to use simplified forms for sequence construction expressions (see Subclause 8.3.15) and instance creation expressions (see Subclause 8.3.12) used as initialization expressions in local name declaration statements. In these simplified forms, the explicit type part usually included in the expressions may be omitted, with the type declared as part of the statement being used instead.

For example, in the statement

let fixedAssets: RealProperty[] = { land, home, condominium };

the type part normally required for a sequence construction expression has been omitted. The statement is equivalent to one in which the type part for the sequence construction expression is the same as the type declared for the new local name:

let fixedAssets: RealProperty[] = RealProperty[]{ land, home, condominium };

This simplified form may also be used when initializing collection objects. Thus, the statement

let fixedAssets: Set = { land, home, condominium };

is equivalent to

let fixedAssets: Set =
Set{ land, home, condominium };

Similarly, in the statement

let origin : Point = new(0,0);

the explicit constructor description has been omitted from the instance creation expression, leaving only the keyword new and the tuple. The statement is equivalent to one in which the instance creation expression is explicitly for the type declared for the new local name:

let origin : Point = new Point(0,0);

NOTE. The initialization expression short hands can also be used in Alf expressions representing default values, either as integrated with a non-Alf representation of a property or parameter (see Subclause 8.1) or as the initializer for the definition of an attribute in Alf (see Subclause 10.5.2).