CS2130 Programming Language Concepts Unit 9 Values, Types and Variables

The term value refers to anything that results when an expression is evaluated, or an entity that may be stored in a memory cell within the computer, or which forms part of a larger composite data structure such as an array or record, or which may be passed as a parameter to a procedure or function, or returned as a function value.

A program variable is an abstraction of a computer memory cell (or a collection of memory cells). Programmers often think of variables as names for memory cells, but this is an over-simplification. A variable can be characterised by six attributes:

type lifetime scope

type checking strong typing type coercion

scope rules referencing environments
The name of a variable was discussed extensively in unit 2. The address or reference to a variable specifies the location of the storage associated with that variable, that is the place where its value will be stored. The relation of the name, reference and value can be visualised as schematically as

The address or reference associated with a variable is often referred to as its l-value or left-value, and then for clarity its normal value is referred to as its r-value or right-value. The motivation for this terminology is that in an assignment of the form:
A = B; (C, Java etc.) A := B; (Ada, Modula-2, Pascal etc.)
The reference associated with A is used to specify the target of the assignment, that it specifies the location of the memory cell in which the right-value of the variable associated with B is to be stored. Thus it is really only the l-value of A and the r-value of B which are relevant for the assignment. Of course the reference associated with B is used to access its right-value and the right-value (if any) associated with A before the assignment is irrelevant.
Types

In many languages we find different types of values. A type is defined as a set of values. When we say a value n is of type T, we mean simply that n  T. The type of a variable specifies the sort of values that can be associated with the variable and is used among other things to determine range of valid operations that can be performed on these values and the amount of storage that needs to be allocated to store such values. Not every collection of values is suitable to be regarded as a type; we expect that the values of a type exhibit some sort of uniformity and behave in a consistent way under the operations associated with the type.

A value of a composite type can be thought of as being composed of several values of a simpler type.

values of such types are references to (that is addresses of) values of some other type

Above we have described value semantics, that is the value of the variable is stored directly in the value cell. However many object-oriented languages use what is known as reference semantics where a reference cell contains a reference to the value rather than the value itself. The situation can be envisaged diagramatically as

Ptr : T_Ref := NEW T’(Value);

However in Ada two distinct types are involved; the reference in the value cell is directly accessible as the value of Ptr (of type T_Ref) and this must be de-referenced explicitly (using Ptr.ALL) to access the value of type T. In a language using reference semantics only the type T is involved, the reference in the reference cell is not directly accessible by the programmer; the reference is de-referenced automatically to access the current value of the variable Name (of type T).

Note the important difference between the behaviour of the following Ada and Java fragments:

TYPE IntArray IS ARRAY(1..100) OF Integer;

-- declare 2 array variables and allocate storage for their elements

A, B : IntArray;

.....

A := B; -- copies all 100 elements of B to A

int[] b = new int[100];

.....

a = b; // copies reference only

All operations should be checked for type consistency as this helps prevent programs performing meaningless operations, for example:

operators should only be applied to operands of appropriate types

subprograms should only be called with parameters of the appropriate types.
Rigorous type checking ensures the program is logically consistent and helps promote program correctness.
Static Typing

In a statically typed language every variable and parameter has a fixed type specified by the programmer. Thus the type of every expression can be deduced at compile time and so operations can be checked for type consistency during compilation. Most high-level compiled languages are statically typed.

In a dynamically typed language, only values have fixed types. Variables and parameters have no specified type, and may take on values of different types at different times during program execution. This implies that an operation must be checked for type consistency at run-time immediately before the operation is performed. Prolog, SmallTalk, Lisp (usually) and most scripting languages are dynamically typed. Dynamic typing is more flexible as it allows the same variable to store different values and allows (for example) lists whose elements are of different types. There are however disadvantages:

Storage for the current value must be allocated dynamically as in general different types of value will occupy different amounts of storage. When a value of a different type is assigned to a variable, the value of the tag is changed and (in general) new storage is allocated to hold the current value and the reference to the current value is updated.

RLisp is a dialect of Lisp: one can either use classical Lisp bracketed prefix notation or a syntax similar to a standard imperative language such as Pascal or Ada. In RLisp we could write the fragment

% and initialise them

C := A + B; % run-time check that operands of + are numbers

% declare (global) variable C implicitly

% A, B and C now all hold integer values
A := {1.2, "Alan", 2}; % A now holds a list of 3 values

B := First(A); % run-time check that A is a list

C := Second(A); % B now holds a real value and C a string

A := B + C; % run-time check detects a type error as we

% can't add a real value 1.2 to a string
Tags in Objected-oriented Languages

In object-oriented languages such as Java there is a (hidden) tag associated with objects of each class. This tag is inspected at run-time to enable dynamic dispatching in method calls:

public int f() { public int f() { // override f

...... ......

} }

} }
Parent a;

if(some-condition)

a = new Parent();

else

a = new Child();

In some languages (for example C and C++) types are considered equivalent if their construction from primitive types is the same. We say that the language uses structural equivalence of types. For example in C and C++

char name[20]; char name[20];

int age; int age;

float salary; float salary;

} person; } individual;
person a; individual b;
defines person and individual to be structure (or record) types. These clearly have the same structure and regarded as equivalent. We could pass b (of type individual) as a parameter to a function which expected a parameter of type person. Also the assignment a = b is valid. In fact the names individual and person are regarded as referring to the same underlying type.
Ada and Pascal use name equivalence: types are equivalent if and only if they have the same name. Each use of the type constructor produces a new type. Thus in Ada the types Heights and Weights below are regarded as distinct:
TYPE Heights IS ARRAY(1 .. 10) OF Float;

TYPE Weights IS ARRAY(1 .. 10) OF Float;

A : Weights;

B : Heights;

.........

B := A; -- !? illegal (type error)

.......

public char[] name; public char[] name;

public int age; public int age;

public float salary; public float salary;

} }
Person a = new Person(); Individual b = new Individual();
then object a of class Person and object b of class Individual though structurally the same are of different types and the assignment a = b; would cause a compilation error.
Java uses structural equivalence for arrays:
int[] a; // 1-D array

int [] b;

int [][] c; // 2-D array

int [][] d;

.......
a = b; // OK -- reference copied

c = d; // OK -- reference copied

a = c; // illegal

c = a; // illegal

In languages using name equivalence new types can be created based on existing types. For example in Ada this is done by using NEW:

I : Integer;

FD : File_Descriptor;

............

FD := I; --!? illegal incompatible types in assignment
Such types are called derived types. The new type File_Descriptor inherits the operations of the parent type (Integer in this case), but has a set of values which is regarded as distinct from the parent type (though the sets are structurally equivalent). Using such derived types enables the compiler to detect some logical errors. In UNIX and other POSIX-compliant operating systems the open files of a process are identified by an integer file descriptor; such integers are logically distinct from normal integer values and type checking protects us from accidental confusion of the two.
Subtypes

Some languages notably Ada and Modula-2 support the notion of subtypes whereas others C, C++ and Java do not. A subtype is a base type together with a constraint; a value of the base type belongs to the subtype if it satisfies the constraint. For example in Ada

Mark : Percent;

I : Integer;

.........

I := Mark; -- always OK

........

Get(Mark); -- run-time constraint check necessary

........

SUBTYPE LongStr IS String(1 .. 100);

A : ShortStr;

B : LongStr;

C : String(1 .. 20); -- anonymous string subtype

.......

Ada.Text_IO.Put(B);

Values of certain types can be converted to values of a related type; the most common example is conversion between numerical types where numerical values are preserved as far as possible³. For example in Ada:

X, Av : Float;

.........

X := Float(N) + X;

N := Integer(X);

Av := Float(Total)/Float(N);

float x, av;

......

x = n + x; /* OK in C or Java */

av = total/n; /* valid in C or Java, but logically incorrect */

av = (float)total/n; /* OK in C or Java */
Note that in the first command the integer value n is implicitly converted to float before the addition is performed. In arithmetic expressions with operands of mixed type the operand of the less general type is converted to the more general type.
least general ------> most general

byte⁴ short int long float double

FD : File_Descriptor;

.......... -- so we can use Put from Ada.Integer_Text_IO;

Put(Integer(FD)); -- we convert FD to type Integer

Type conversions (which convert a value in one type to a logically related value in another type) should be distinguished from casts which merely reinterpret the internal bit pattern of a value of one type as the value in another type. For example in Ada this is done by instantiating a suitable instance of the generic library function Unchecked_Conversion:

N : Integer := 1;

..........

Put(Cast_To_Float(N));

-- output bit pattern in N interpreted as a Float
Note in C the same effect can be achieved more simply as the arguments of printf are not type-checked:
int n = 1;

.....

/* output bit pattern of n using float format %f */

In virtually all languages values of a primitive type can be evaluated, assigned, passed to subprograms as parameters, returned as function values and compared for equality and inequality. In addition numerical values can be combined in arithmetic expressions and compared with operators such as ≤. Similarly boolean values can be combined with logical operators such as &&, || and !. Such values are referred to as first class values as all logically meaningful operations on values of these types are supported by the language. Records and arrays in Ada (and arrays and class instances in Java) can passed as parameters to procedures (methods in Java) and can be returned as function values and so are first class values.

The type completeness principle states that no logically meaningful operation should be arbitrarily restricted in the types of the values involved. Thus C, C++ and Pascal can be seen to violate this principle in their treatment of arrays and records, but Ada and Java conform to the principle in this respect. However Ada, C and Java violate the principle in respect of function values whereas Haskell and Miranda do not