Classes and Objects

Each Sather object has an associated type which indicates the class that was used to create the object. A variable in Sather also has a type, which indicates the kinds of objects it can be assigned to.

This chapter will focus on the most common kind of classes, reference classes, and the standard constructs used to create classes. Though iterators are an essential component of Sather code, their discussion has been deferred to the next chapter, since they are a relatively novel language feature.

2.1 Preliminaries

2.1.1 Some basic classes - INT, FLT and STR

a:FLT := 3.0;
b:INT := 5;
c:STR := "foo";

a:STR := "foo";
b:STR := "bar";       -- + concatentates strings
c:STR := a + b;       -- c is "foobar". 
e:INT := 5;
f:INT := 7;
g:INT := e+f;         -- g is 12
compare:BOOL := e > f;-- compare is false
#OUT + compare;       -- Prints out 'false'

2.1.2 Printing output

a:INT := 10;
#OUT+"hello world "+a;  -- Prints out "hello world 10"

2.1.3 Sather source files

Execution of a Sather program begins with a routine named 'main' in a specified class, (a class called 'MAIN' is used by default). If main is declared to have a return value of type INT, this will specify the exit code of the program when it finishes execution.

2.1.4 Hello World

class HELLO_WORLD is
 main is 
  #OUT+"Hello World\n"; 
 end; 
end;

If the above code is stored in the file hw.sa, it can be compiled (using the ICSI Sather compiler) by:

cs -main HELLO_WORLD -o hw hw.sa

prompt> hw
Hello World
prompt>

2.2 Defining Classes and Creating Objects

We will start by describing the data elements and then move on to the operations. In subsequent sections, we will describe the definition of object behavior in the form of routines. We will then point out that Sather provides a level of abstraction, which permits the state and behavior of the object to be treated in a uniform manner. Finally, we will describe the somewhat unusual meaning of assignment in Sather that makes this uniformity possible.

2.2.1 Defining Simple Classes

class POINT is
 attr x:INT;
 attr y:INT;
end;

The POINT class above defines an 'x' and a 'y' attribute both of which are integers. This class is useless, as it stands, since it provides no way to create instances of itself.

Object Creation: create and new

class POINT is
 attr x, y:INT;
 
 create(xvalue,yvalue:INT):POINT is
  res:POINT := new;
  res.x := xvalue;    res.y := yvalue;
  return res;
 end;
 
end; 

p:POINT := POINT::create(3,5);

point:POINT := #POINT(3,5);

Attribute access

a:POINT := #POINT(3,5);    
 -- Create a new point
#OUT + a.x ; 
-- Prints out the value of 'x', which is 3
a.x := 5;   
 -- Sets the value of the 'x' attribute to 5

Points to note

• The semantics of a class is independent of the textual order of its class elements. In particular, the actual attribute layout used by a Sather implementation is invisible to a programmer.

• The scope of feature names is the class body

• Feature names may be either lower or upper case.

• Class names must be all upper case letters (underscores and digits are permitted except as the first character).

• The feature namespace is separate from the class namespace.

• The scope of class names is the entire program; no two classes can have the same name (unless they have different number of parameters, which will be explained in the chapter on class parametrization).

• You have to explicitly call 'new' in the create routine. The following code exhibits a common error:

  class POINT is attr x,y:INT; create(xval, yval:INT):POINT is x := xval; -- Run time error! We have no object as yet! y := yval; end; ....

2.2.2 Checking whether an object has been created

a:POINT;
if void(a) then #OUT+"a is void!" end;

a:POINT := #POINT(3,5);
if void(a) then  #OUT+"a is void!" else #OUT+"a is not void!" end;

Note that the above test will not work in the same way for some of the built-in classes such as integers and booleans[2].

2.2.3 Types Introduced

a:POINT := #POINT(2,3);
b:POINT := #POINT(4,5);

When we introduce abstract classes in the chapter on Abstract Classes and Subtyping on page 79, we will see that some Sather variables can hold objects of many different types. In this case, it is useful to distinguish between the type of the variable (called the declared type) and the type of the object that it holds (called the actual type or the concrete type).

2.2.4 Hiding features: private and readonly

class POINT2 is
 private attr x:INT;      
  -- x cannot be seen from outside
 readonly attr y:INT;      
  -- y cannot be changed from outside
 create(xvalue,yvalue:INT):POINT is  
  res:POINT := new;
  res.x := xvalue;
  res.y := yvalue;
  return res
 end; 
end;

foo is ...
 -- some other piece of code
 a:POINT2 := #POINT2(3,5);     -- Create a new POINT2
 #OUT+ a.y; 
                  -- Prints out '5'
   -- Illegal: #OUT+ a.x  
   -- Illegal a.y := 10;

Points to note

• Privacy is on a per-class basis, rather than on a per-object basis. Thus, an object can access the private features of other objects of the same class. We actually use this fact in the create routine of the class POINT2 above. Assignments to the attributes of res are being done outside the object being returned.

2.3 Class Data: shared and const

2.3.1 Shared Attributes - Restricted global variables

private shared i,j:INT;
readonly shared c:CHAR := 'x' 

shared s:STR := "name";
-- ILLEGAL shared s,p:STR := "name";  
-- cannot use initializing expression if two shareds are
-- declared at the same time

2.3.2 Class Constants

• a character, boolean, string, integer or floating point literal

• a void or void test expression

• an and or or expression, each of whose components is a constant expression

• an array literal, each of whose components is a constant expression

• a routine call applied to a constant expression, each of whose arguments is a constant expression other than void. This caveat is imporant, since create routines are called on void. Thus the following is illegal

  -- ILLEGAL const a:POINT := #POINT(3,3); const a:POINT := void; -- The only legal kind of constant POINT is void

  :[3]

• a reference to another constant in the same class or in another class using the '::' notation.

  const r:FLT:=45.6; -- Reader routine is private r:FLT; private const a,b,c; private const d:=4,e,f const bar:BOOL := r > 10; -- Function call on constants const foo:ARRAY{INT} := |1,2,4,5,6|; -- Sather arrays are explained later const baz ::= BAR::foz ; -- foz must be a constant expression in foz

Integer constants and Enumerated Types

const a;          
-- a is of type INT and gets the value 0
const c,d;      
  -- c gets 0 and d gets 1
const e := 3;  
   -- e is also of type INT

Points to note

• There must not be cyclic dependencies among constant initializers.

  class FOO is const b:INT := BAR::c; class BAR is const c:INT := BAZ::d; class BAZ is -- ILLEGAL! const d:INT := FOO::b; -- Introduces a cycle between b, c and d

• Since constant initialization involves permits operations on the built-in types, the operations on the built-in types are designed so that no observable side-effects can occur during constant initialization.

• The prefix readonly cannot be applied to constants, since constants cannot be modified in any case.

• Due to their definition, constants are only useful for the basic classes such as numbers, booleans and characters. All other constants can only be assigned to be void!

  class FOO is const a:BAR := void; -- only legal value

2.3.3 Accessing Class Data - the :: notation

class FOO is
 const a:INT := 3;
 private const b:INT := 5;
 readonly shared c:INT := 6;
 shared d:INT := 7;
   attr f:INT;
 
   create(i:INT):SAME is res:SAME := new; res.f := i; return res; end;
 
   method1:INT is return d+a; end;
 
   method2:INT is return f+a; end;
 
end; 

#OUT+ FOO::a+"\n";
FOO::d := 3;

#OUT+FOO::method1;
 -- Prints out d+a = 10
#OUT+FOO::method2; 
-- Tries to print out self.f+a
   -- However, self (the object) is void, so trying to access 'f' 
   -- results in a run-time error - Attribute access of void

• The usual privacy and modification restrictions are maintained

  a_copy:INT := FOO::a; -- ILLEGAL FOO::c :=3; -- c is readonly -- FOO::a := 7; -- a is a constant

2.4 Routine definitions

class CALCULATOR is
 attr running_sum:INT;
 
 create:CALCULATOR is
  res:CALCULATOR := new;
  res.running_sum := 0;
  return res;
 end;
 
 add(x:INT):INT is
  res:INT := running_sum + x;
  return res;
 end; 
end; 

The body of a routine is a list of statements, separated by semicolons. In a routine with a return value, the final statement along each execution path must be a return statement . Thus, the following is not legal

scale_x(x:INT):INT is -- Illegal routine - the else clause has no return value if x > 0 then return 15; else #OUT+"Error!"; -- last statement on this branch is not return end; end;

A raise statement raises an exception, and can be used wherever a return statement might be required. Raise statements will be described in more detail in the chapter on Exceptions on page 131. For now, we merely note that the following version of the routine 'scale_x' does not return a value in the second branch of the if statement, but raises an exception instead, which is perfectly legal.

scale_x(x:INT):INT is if x > 0 then return 15; else raise "An error occurred!"; end; end;

Using the return value

new_x:INT := scale_x(15);
 -- Legal, the return value used
scale_x(15);              
 -- ILLEGAL! Return value unused

a := scale_x(15) + 3;

2.4.1 Routine Arguments and Modes

create(x,y:INT):POINT ...

class POINT is
  attr x,y:INT;
  add_x(x:INT) is
     self.x := self.x + x;
  end;

Multiple return values and out arguments

divide(x,y, out dividend, out remainder:INT) is
    -- Note that the 'INT' type specifier applies to  multiple  
    -- arguments while the mode qualifiers apply to only one
    -- argument.
 dividend := x/y;          
-- Integer division result
 remainder := x - y*(x/y);
  -- Remainder after the division. 
                                -- Could also use x.mod(y)
end;

a:INT := 15;  b:INT := 10;
div, rem:INT;                   
-- These are defined but not assigned 
divide(a,b,out div, out rem);
#OUT+"Divident="+div+" Remainder="+rem+"\n"; 
  -- Prints out Divident=1 Remainder=5

inout arguments

swap(inout x, inout y:INT) is
 tmp:INT := x;
 x := y;
 y := tmp;
end;
 
a:INT := 5;  b:INT := 10;   
-- a and b have an initial value
swap(inout a,inout b);      
#OUT+"a="+a+" b="+b;  
        -- Prints a=10 b=5

2.4.2 Local Variables - Scoping and Shadowing

... in the POINT class ...
swap_x_y is
 temp:INT;
 temp := x;
 x := y;
 y := temp;
end;

Points to note

• Local variables are initialized to void when the containing method is called.

• Local variables are not re-initialized when the declaration is encountered in the flow of control. This is particularly relevant in loop statements, which are discussed in the next chapter. The integer 'a' is initialized to zero when the function 'compute' is entered. It is not initialized every time through the loop.

  compute is loop 3.times!; a:INT; a := a + 3; #OUT+a+"\n"; -- Prints out successively 3, 6, 9 end; end;

• Note that explicit initialization (in this case 'a:=15' ) is performed every time it is encountered

  compute is loop 3.times!; a:INT := 15 a := a + 3; #OUT+a+"\n"; -- Prints out successively 18, 18, 18 end; end;

2.4.3 Routine calls

class POINT is
 
  
  attr x,y:INT;
   
  create(x,y:INT):POINT is
  res:POINT := new; res.x := x;  res.y := y;  return res;
 end;
 
  add(xval,yval:INT):POINT is
     xsum:INT := x + xval;  
     ysum:INT := y+yval;
     res:POINT := #POINT(xsum, ysum); 
     return res; 
 end; 
 
 offset_by(val:INT):POINT is  
  return add(val,val);    -- short for 'return self.add(val,val);'
   end;
end;

• If nothing precedes the method name, then the form is syntactic sugar for a call on self If the method name is preceded by an expression and a dot '.', then the method is called on the object returned by the expression. In the following example, pair (3,7) is first added to p1 and the pair (4,9) is added to that result. Note that the intermediate point that is created after the first 3,7 is added is not accessible from any variable and will be garbage collected.

  p1:POINT := #POINT(3,5); p2:POINT := p1.add(3,7).add(4,9);

• If the method name is preceded by a type specifier and a double colon '::' it is presumed to be a call on a void object of the specified class (POINT in the case below)

  a:POINT := POINT::create(3,5);

res:POINT := POINT::add(4,7); 
-- Runtime Error!

Since xsum := x + xval; is actually equivalent to saying xsum := self.x + xval; the routine accesses self, which is void and cannot be accessed.

2.4.4 Simple Overloading - Selecting a routine to call

Two routines in a class may have the same name provided they differ in at least one of the following aspect:

• the number of arguments

• the presence or absence of a return value

• the type of one of the arguments (provided the types are not abstract).

foo(a:INT, b:INT);
foo(a:INT);                 -- Different number of arguments
foo(a:INT,b:INT):INT;       -- Has a return value 

foo(a:INT,b:INT):INT; 
-- foo(a:INT,b:INT):BOOL 
-- differs only in return type, cannot overload 'foo'

2.5 Conditional Execution

2.5.1 if statements

i:INT :=-15
if i < 0 then i:=-i end
#OUT + i;                  -- Prints out 15
j:INT :=15
if j < 0 then j:=-j end     
#OUT + j;                  -- Prints out 15

 if x < 0 then y:=0
 else 
   if x < 100 then y := x
   else 
     if x < 200 then y := 200 - x else y := 0 end;
   end
 end;

if x < 0 then y := 0 
elsif x < 100 then y := x
elsif x < 200 then y := 200 - x
else y := 0 end

2.5.2 case statements

i:INT := 7;
switch i
when 1,2,3 then j := 3
when 4,5,6 then j := 4
when 7,8,9 then j := 5
else j := 10 end
#OUT+j;           -- Prints out 5

class POINT is
 attr x,y:INT;
 
 create(x,y:INT):POINT is 
  res:POINT := new;  res.x := x; res.y := y; return res; 
 end;
 
 is_eq(point2:POINT):BOOL is
     -- In Sather,= is short hand for a call on 'is_eq'
   return x = point2.x and y = point2.y;
 end; 
 
 str:STR is return "X="+x+" Y="+y;  end
 
end; 

p:POINT := #POINT(3,4);
zero_point:POINT := #POINT(0,0);
 
case p
when zero_point then  
      #OUT+"Zero point\n"; 
when #POINT(1,1), #POINT(1,-1),#POINT(-1,-1), #POINT(-1,1) then 
  #OUT+"Unit point:"+p.str+"\n":
else 
    #OUT+" Some other point\n" 
end;

if p = zero_point then #OUT+ "Zero point\n";
elsif p = #POINT(1,1) or p = #POINT(1,-1) or ... etc. then 
 #OUT+ "Unit point:"+p.str+"\n";
else 
 #OUT+" Some other point\n";
end;

There is one difference between the case statement and the equivalent if statement. If none of the branches of an if statement match and no else clause is present, then execution just continues onto the next statement after the if statement. However, if none of the branches of the case statement matches and there is no else clause, then a fatal run-time error will result.

Points to note

• It is a fatal error if no branch matches and there is no else clause for case statements but not for if statements.

2.5.3 Short circuit boolean expressions: and and or

Consider the code

p:POINT; if p.x > 3 then #OUT+p.x; end; -- Runtime error if p is void

The above block of code will work if p is not void. If it is void, however, the test p.x >3 will result in a runtime error, since it is attempting to dot into a void reference type. We can catch this problem by using the following piece of code, and the semantics of the short-circuit and

if ~void(p) and p.x > 3 then -- The ~ symbol indicates logical negation #OUT+p.x; end;

The above piece of code will not generate an error, even if p is void. The first part of the and expression tests for whether p is void. If it is void, then the void test returns true and the not turns this into a false. The and therefore fails before trying to evaluate the dotted expression p.x.

A similar behavior can be seen with the short-circuit or statement, where the second expression is not examine if the first expression evaluates to true

a:INT := 15; p:POINT; if a>10 or p.x < 10 then -- Since a>10 is true, the second expression is not evaluated

• Note that booleans also define an and_rout routine, which does not have the same short-circuit behavior:

  if ~void(p).and_rout(p.x > 3) then -- May generate a run-time error, when 'p' is void -- The argument to the 'and_rout' routine (p.x) is evaluated -- even when the first condition, ~void(p) fails. -- Hence, if 'p' is void, p.x is still evaluated and generates a -- run-time error (attribute access of void)

2.6 Attribute Accessor Routines

Each attribute definition adds a field to the object's state and causes the definition of a reader routine and a writer routine, both with the same name. The reader routine takes no arguments and returns the value of the attribute. Its return type is the attribute's type. The reader routine is private if the attribute is declared 'private'. The writer routine sets the value of the attribute, taking a single argument whose type is the attribute's type, and has no return value. The writer routine is private if the attribute is declared either private or readonly.

class INTERVAL is attr start:FLT; -- Defines the public reader start:FLT -- and the public writer start(FLT) attr finish; INT; create(st,fin:INT):SAME is -- Create a new interval res:SAME := new; res.start(st); -- Equivalent to res.start := st; res.finish(fin); -- Equivalent to res.finish := fin; end; end;

Thus, the levels of privacy are defined by whether the reader and writer routines are public or private

private attr a:FLT; -- Defines the reader, private a:FLT -- and the writer private a(FLT); readonly attr b:FLT; --Defines the public reader, b:FLT -- and the private writer b(FLT)

The same holds true for shared attribubtes. Each shared definition causes the definition of a reader routine and a writer routine, both with the same name. The reader routine takes no arguments and returns the value of the shared. Its return type is the shared's type.

class FOO is shared a:INT := 3; -- Defines a:INT and a(arg:INT); readonly shared b:INT; -- Defines a:INT and private a(arg:INT); ... #OUT + FOO::a; -- Prints out 3 FOO::a(4); -- 'a' is set to 4, same as FOO::a := 4; #OUT+ FOO::a; -- Prints out 4; FOO::a := 7; -- 'a' is set to '7' , equivalent to FOO::a(7); FOO::b(3); -- ILLEGAL! The writer routine is private

Constants do not define a writer routine. Each constant definition causes the implicit definition of a reader routine with the same name. It takes no arguments and returns the value of the constant. Its return type is the constant's type. The routine is private if and only if the constant is declared 'private'.

const r:FLT:=45.6; -- Reader routine is r:FLT; private const a,b,c; -- Reader routine is private a:INT; private const d:=4,e,f const bar:BOOL := r > 10; -- Function call on constants

2.6.1 Attribute assignment

By default, the assignment is syntactic sugar for a call of the routine with the same name as the attribute with the right hand side of the assignment as the only argument

p:POINT := #POINT(3,5); p.x := 3; -- Is syntactic sugar for p.x(3);

In the above example, the assignment to 'x' is the same as calling the routine 'x' with a single argument.

Replacing an attribute by a routine

class I_INTERVAL is
    -- Integer intervals
 attr start:INT;     -- Defines start:INT and start(INT) 
 attr finish:INT;    -- Defines finish:INT and finish(INT) 
 
 create(start,finish:INT):SAME is
  res:SAME := new;   
  res.start := start;       -- Equivalent to res.start(start);
  res.finish := finish;     -- Equivalent to res.finish(finish);
  return res; 
 end;
  
 size:INT is return finish - start + 1; end;  
        -- Returns the number of integers in the interval
end; 

i:I_INTERVAL := #I_INTERVAL(3,10);   
i.finish := 11;  
-- Equivalent to a call i.finish(11);
#OUT+ i.finish;  
-- Prints out 11
i.start := 15;   
-- Equivalent to the call i.start(15);

class I_INTERVAL is
 -- Integer intervals
 attr start:INT;          -- Defines start:INT and start(INT) 
 readonly attr size:INT;  -- Defines  size:INT and private size(INT)
   -- size is readonly, since we only need size:INT in the interface
 
 create(start,finish:INT):SAME is
  res:SAME := new;   
  res.start := start;          -- Equivalent to res.start(start);
  res.size :=  finish-start+1; -- Store the result in res.size
  return res; 
 end;
 
 finish:INT is return start+size-1 end;  
       -- Replacement for the reader routine for 'finish'
      -- Compute finish using 'start' and 'size'
 
 finish(new_finish:INT) is  size:=new_finish-start+1  end;
       -- Replacement for the writer routine for 'finish'
 
end; 

2.7 Static Type Inference

2.7.1 Creation Expressions

a:POINT;
a := #(3,4); 
 -- Equivalent to a := #POINT(3,4);

2.7.2 Assignments and ::=

a ::= 3;                     -- Equivalent to a:INT := 3;
p1:POINT := #POINT(3,5);
p2:POINT := #POINT(4,5);
p3 ::= p1.add(p2);           -- 'p3' is of type POINT. 
-- Assumes the function 'add'  in POINT i.e. POINT::add(POINT,POINT);

a ::= #POINT(3,4);  -- Equivalent to a:POINT := #POINT(3,4);
a:POINT := #(3,4);  -- Means the same

2.7.3 Arguments to a function call

foo(a:POINT) is  ... 
 
foo(#(3,5));    
 -- The create expression infers its type 
 -- from the type of the argument that 'foo' is expecting

apply(arg:ROUT{INT}:INT) is ....
apply(bind(3.plus(_));  

r:ROUT{INT}:INT := bind(3.plus(_));
apply(r);

2.8 Class Parameters

A Sather class may have various type parameters, which are basically place holders for types which are specified when the class is actually used. This allows us to write code that is generic and can be used with a different types. By convention, these type parameters are given names like T or TP. We show below a class TUP, which holds pairs of objects. Since we would like to be able to hold objects of any types, we just specify type parameters, T1 and T2. These parameters are place-holders, which must be set to actual honest-to-goodness concrete classes when the TUP is actually used

class TUP{T1,T2} is -- Simple version of the library tuple class attr t1:T1; attr t2:T2; create(t1:T1, t2:T2): SAME is -- Standard create routine. Arguments use the type parameters res ::= new; -- Using static type inference - new returns SAME res.t1 := t1; -- The types of res.t1 and the argument t1 -- are both T1 so the assignment is legal res.t2 := t2; return res; end; end;

We can now create a tuple object that holds, for instance, a pair consisting of a string and an integer:

t ::= #TUP{INT,STR}(5,"this"); -- Create a new tuple. -- Uses ::= to determine the type of 't' #OUT + t.t1 + "\n";

2.8.1 Arrays

a:ARRAY{INT} := |2,5,7|;  
-- Special syntax for initializing an array with values 2,5,7
#OUT+a[1];  
 -- Return the second element of the array

main(args:ARRAY{STR})  is
 #OUT+args[0];
    -- On unix, args[0] is the name of the program
end;

a:ARRAY{POINT} := #(3);
a[0] := #POINT(0.0,0.0);
a[1] := #POINT(0.0,1.0);
a[2] := #POINT(2.0,2.0);

2.9 A Running Example: Employees

EMPLOYEE definition

class EMPLOYEE is 
 
 private attr wage:INT; 
 readonly attr name:STR;
 attr id:INT; 
 const high_salary:INT := 40000;
 
 create(a_name:STR, a_id:INT, a_wage:INT):SAME is 
  res ::= new; 
  res.id := a_id;
  res.name := a_name;
  res.wage := a_wage;  
  return(res); 
 end; 
 
 highly_paid:BOOL is   return wage >= high_salary;   end; 
end; 

TESTEMP definition

class TESTEMP is
   
   main is 
        john:EMPLOYEE := #EMPLOYEE("John",100,10000);   
        peter:EMPLOYEE := #EMPLOYEE("Peter",3,10000);   
        john.id := 100;         -- Set the attr "id" in john to 100
        #OUT+ john.name+"\n";   -- Prints "John" 
        #OUT+ peter.id+"\n";    -- Prints "3" 
    end; 
end; 

#OUT+john.wage+"\n";  -- ILLEGAL! "wage" is private 
john.name := "martha";   -- ILLEGAL! "name" is readonly.  

Running the example

cs emp.sa -main TESTEMP -o emp 

bs emp.sa -main TESTEMP