Counter

The Counter example is a minimal example of a class from which one can instantiate objects with state. Several variations are possible; here is the one we choose:

module Counter where

struct Counter where
  incr  :: Action
  decr  :: Action
  value :: Request Int

counter = class

   n := 0

   incr  = action n := n+1

   decr  = action n := n-1
   
   value = request result n

   result Counter{..}

Comments:

The first four lines of the module body define a struct, or record, type, called Counter. This type has three methods, and will act as an interface to counter objects.
The rest of the module defines a class counter. Instances of this class have an internal state consisting of a single integer state variable n, initialised to 0 when the instance is created. The effects on the state when methods are invoked on this object is described. Finally, the result statement declares that object creation returns a Counter interface to the object. Thus counter has type Class Counter.
To create an object of this class, one writes (within a method or another class definition)
```
ctr = new counter
```
The variable ctr has type Counter, and the newly created object can be updated by method calls ctr.incr and ctr.decr. The state can be read by
```
val <- ctr.value
```
Any method call has exclusive access to the state of the object; there is no need for the programmer to protect calls further.
The two action methods are invoked asynchronously, while the value-returning request of course requires synchronous communication.
The notation Counter{..} means "assemble an object of type Counter from definitions in scope". It would be possible, and maybe preferrable in this small example, to define the methods within the result expression as follows:
```
counter = class

   n := 0

   result
     struct
       incr  = action n := n+1
       decr  = action n := n-1
       value = request result n
```
In more complex situations, the {..} is a useful convenience.
To see an example of use of counter, see EchoServer2.

Variation

Java programmers and others may miss constructor methods in the class definition. In fact, counter itself has the role played by constructor methods as seen from the usage indication above. To, hopefully, make this clearer we note that one might want to create counter objects with some other initial value than 0. We can easily achieve this by a slight modification of counter:

counterInit init = class
  
   n := init

   ...

The rest of the class is as before. To create an object with initial value 5, we would write

ctr = new counterInit 5

Thus, we have the typing counterInit :: Int -> Class Counter.

We might still keep the definition of counter, but this would mean code duplication that should be avoided. Instead, we could write

counter = counterInit 0

and get a class counter with the same usage as our original definition.