ALGOL 68

ALGOL 68 was defined using a two-level grammar formalism invented by Adriaan van Wijngaarden. Van Wijngaarden grammars use a context-free grammar to generate an infinite set of productions that will recognize a particular ALGOL 68 program; notably, they are able to express the kind of requirements that in many other programming language standards are labelled "semantics" and have to be expressed in ambiguity-prone natural language prose, and then implemented in compilers as ad hoc code attached to the formal language parser.

The main principles of design are completeness and clarity of design, orthogonal design, security, efficiency, the latter by static mode checking, mode-independent parsing, independent compilation and loop optimization.

Critics of ALGOL 68, prominently C. A. R. Hoare, point out that it abandoned the simplicity of ALGOL 60 and became a vehicle for various complex ideas of its designers. The language also did little to make the compiler writer's task easy, in contrast to deliberately simple contemporaries (and competitors) C, S-algol and Pascal.

The ALGOL 68 heritage is acknowledged by Scheme, and by C++.

For a full length treatment of the language, see Programming Algol 68 Made Easy by Dr. Sian Leitch.

Notable Language Elements

Units (Expressions)

Declarations

Expressions and compound statements

As another example, to express the mathematical idea of a sum of f(i) from i=1 to N, the following ALGOL 68 integer expression suffices:
(int sum := 0; for i to N do sum +:= f(i) od; sum)
Note that, being an integer expression, the former block of code can be used in any context where an integer value can be used. A block of code returns the value of the last expression it evaluated; this idea is present in Perl, among other languages.

Compound statements are all terminated by distinctive (if somewhat irreverent) closing brackets:
if condition then statements [ else statements ] fi
[ for index from first [ by inc ] to last ] [ while condition ] do statements od case switch in statements esac
This scheme not only avoids the dangling else problem but also avoids having to use begin and end in embedded statement sequences. Furthermore, the symbol pattern if...then...else...fi may be replaced by the more compact ...|...|... (see example below).

Arrays and structures

Procedures

Operators

Input and output

Parallel processing

Code sample

This sample program implements the Sieve of Eratosthenes to find all the prime numbers that are less than 100. nil is the ALGOL 68 analogue of the null pointer in other languages. The notation x of y accesses a member x of a struct or union y.

begin # Algol-68 prime number sieve, functional style #
proc error = (string s) void:
(print(( newline, " error: ", s, newline)); goto stop);
proc one to = (int n) list:
(proc f = (int m,n) list: m>n | nil | cons(m, f(m+1,n)); f(1,n));
mode list = ref node;
mode node = struct (int h, list t);
proc cons = (int n, list l) list: heap node := (n,l);
proc hd = (list l) int: l is nil | error("hd nil"); skip | h of l;
proc tl = (list l) list: l is nil | error("tl nil"); skip | t of l;
proc show = (list l) void: l isnt nil | print((" ",whole(hd(l),0))); show(tl(l));
proc filter = (proc (int) bool p, list l) list:
if l is nil then nil elif p(hd(l)) then cons(hd(l), filter(p,tl(l)))
else filter(p, tl(l))
fi;
proc sieve = (list l) list:
if l is nil then nil else proc not multiple = (int n) bool: n mod hd(l) ~= 0;
cons(hd(l), sieve( filter( not multiple, tl(l) )))
fi;
proc primes = (int n) list: sieve( tl( one to(n) ));
show( primes(100) )
end

Program representation