# 3. Some Miscellaneous Functions

Our first module, entitled lifemisc and stored in the file lifemisc.icl, defines some basic list operations in CLEAN, for use in the other modules. Each CLEAN implementation module has a corresponding definition module which lists exported type and macro definitions and function type declarations. These definitions can be imported with the IMPORT declaration. Here we import CLEAN's standard library modules deltaC, deltaI, deltaB, deltaM and deltaS :

```IMPLEMENTATION MODULE lifemisc;
IMPORT deltaC, deltaI, deltaB, deltaM, deltaS;
```

The constant Huge is macro-defined to be (2^31)-1 using the bit operations SHIFTL% and NOT% defined in the deltaI library. This constant can be used as a virtual infinity:

```MACRO
Huge -> NOT% (SHIFTL% 1 31);
```

The RULE keyword introduces a group of function type declarations and definitions. The Min function takes two integer arguments and produces an integer result. The ! annotations indicate that Min is strict on both its arguments, i.e. the arguments are evaluated eagerly. Functions with strict INT, BOOL, CHAR, REAL, STRING, or FILE arguments are implemented more efficiently than lazy functions in CLEAN.

```RULE
:: Min !INT !INT -> INT;
Min x y -> x, IF < x y
-> y;
```

The definition of Min uses a guarded right-hand side: Min x y rewrites to x if x is less than y, and to y otherwise (i.e. Min x y rewrites to the minimum of its two arguments). Notice that all binary operators in CLEAN are written in prefix notation, i.e. < x y rather than x<y. The Max function is defined in a similar way to Min:

```:: Max !INT !INT -> INT;
Max x y -> x, IF > x y
-> y;
```

The well-known Map function is defined by pattern-matching on cases. CLEAN's list notation is similar to that of PROLOG. Notice that the arrow operator on types, like all binary operators, is written in prefix notation. Although a function must be declared with a fixed arity (in this case, 2) matching the arity in the definition, functions can be used as curried objects. For example, Map can be used with the type => (=> x y) (=> ![x] [y]), which would be more readable written in infix notation as (x => y) => ![x] => [y].

```:: Map (=> x y) ![x] -> [y];
Map f [] -> [];
Map f [h|t] -> [f h | Map f t];
```

The list-length function Len can be efficiently implemented using the tail-recursive auxiliary function LenAux which has a strict accumulating parameter. This technique allows Len to execute in constant space.

```:: Len ![x] -> INT;
Len l -> LenAux 0 l;
```

The function LenAux is strict on its second (list) argument, since pattern-matching forces evaluation to weak head normal form. This strictness is inferred by CLEAN's strictness analyser. The strictness of Len could be inferred from this, but Len must be declared strict for export purposes. The ++ operation increments its argument (and similarly -- decrements it).

```:: LenAux !INT [x] -> INT;
LenAux i [] -> i;
LenAux i [h|t] -> LenAux (++ i) t;
```

A similar technique can be used to concatenate a list of strings, generalising the binary string concatenation operation +S:

```:: Concat ![STRING] -> STRING;
Concat l -> ConcatAux "" l;

:: ConcatAux !STRING [STRING] -> STRING;
ConcatAux s [] -> s;
ConcatAux s [h|t] -> ConcatAux (+S s h) t;
```

The Drop function removes a specified number of elements from a list. Since rules are examined in sequence, Drop 0 [h|t] rewrites to [h|t] and not to Drop (-- i) t:

```:: Drop !INT ![x] -> [x];
Drop 0 l -> l;
Drop i [] -> [];
Drop i [h|t] -> Drop (-- i) t;
```

The Take operation is defined similarly. It is not strict on its list argument:

```
:: Take !INT [x] -> [x];
Take 0 l -> [];
Take i [] -> [];
Take i [h|t] -> [h | Take (-- i) t];
```

The lifemisc definition module lists the exported macro and functions. It is stored in the file lifemisc.dcl.

Top Level

Why Program in CLEAN?

lifemisc.dcl

Representing Patterns for the Game of Life