CLU is a programming language created at MIT by Barbara Liskov and her students between 1974 and 1975. It was notable for its use of constructors for abstract data types that included the code that operated on them, a key step in the direction of object-oriented programming (OOP). However many of the other features of OOP are (intentionally) missing, notably inheritance. CLU Is therefore referred to as an "object-based" language, but not fully "object-oriented".

Clusters

The syntax of CLU was based on ALGOL, then the starting point for most new language designs. The key addition was the concept of a cluster, CLU's type extension system and the root of the language's name (CLUster).^[2] Clusters correspond generally to the concept of an "class" in an OO language, and have similar syntax. For instance, here is the CLU syntax for a cluster that implements complex numbers:

    complex_number = cluster is add, subtract, multiply, ...
        rep = record [ real_part: real, imag_part: real ]
        add = proc ... end add;
        subtract = proc ... end subtract;
        multiply = proc ... end multiply;
        ...
    end complex_number;

A cluster is a module that encapsulates all of its components except for those explicitly named in the "is" clause. These correspond to the public components of a class in recent OO languages. A cluster also defines a type that can be named outside the cluster (in this case, "complex_number"), but its representation type (rep) is hidden from external clients.

Cluster names are global, and no namespace mechanism was provided to group clusters or allow them to be created "locally" inside other clusters.

CLU does not perform implicit type conversions. In a cluster, the explicit type conversions 'up' and 'down' change between the abstract type and the representation. There is a universal type 'any', and a procedure force[] to check that an object is a certain type. Objects may be mutable or immutable, the latter being "base types" such as integers, booleans, characters and strings.^[2]

Other features

Another key feature of the CLU type system are iterators, which return objects from a collection one after the other.^[2] Iterators offer an identical API no matter what data they are being used with. Thus the iterator for a collection of complex_numbers can be used interchangeably with that for an array of integers. A distinctive feature of CLU iterators is that they are implemented as coroutines, with each value being provided to the caller via a "yield" statement. Iterators like those in CLU are now a common feature of many modern languages, such as C#, Ruby, and Python, though recently they are often referred to as generators.(See Iterator).

CLU also includes exception handling, based on various attempts in other languages; exceptions are raised using signal and handled with except. Unlike most other languages with exception handling, exceptions are not implicitly resignaled up the calling chain; exceptions that are neither caught nor resignaled explicitly are immediately converted into a special failure exception that typically terminates the program.

CLU is often credited as being the first language with type-safe variant types (called oneofs), preceding ML in this respect.

A final distinctive feature in CLU is multiple assignment, where more than one variable can appear on the left hand side of an assignment operator. For instance, writing x,y = y,x would exchange values of x and y. In the same way, functions could return several values, like x,y,z = f(t).

All objects in a CLU program live in the heap, and memory management is automatic.

CLU supported type parameterized user-defined data abstractions. It was the first language to offer type-safe bounded parameterized types, using structure "where clauses" to express constraints on actual type arguments.

Influence on other programming languages

• Python and Ruby borrowed several concepts from CLU (such as call by sharing, the yield statement, and multiple assignment^{[citation needed]})
• CLU and Ada were major inspirations for C++ templates.
• CLU's exception handling mechanisms also influenced newer languages like Java and C++.
• C++, C#, Python, and Sather include iterators, which first appeared in CLU.
• Lua took multiple assignment and multiple returns from function calls from CLU.^[3]

References

External links

• CLU Home Page
• A History of CLU (pdf)
• clu2c: a program to compile CLU code to C
• Dictionary of Programming Languages
• CLU comparison at '99 bottles of beer' multi-language demo algorithm site