Hacking around with PostScript, I’m being reacquainted with its unusual language structure.

The whole thing is stack oriented, like Forth. Adding two numbers is done by pushing the two numbers on the stack, then invoking the add operator, which pops two numbers, adds them, and pushes the result:

2 2 add   % leaves 4 on the stack

Control structures work the same way. The ifelse operator takes three things from the stack: a boolean and two executable blocks. If the boolean is true, it executes the first block and discards the second. If the boolean is false, it executes the second block and discards the first:

1 2 eq { (y) } { (n) } ifelse   % leaves "n" on the stack

The for operator is used for looping. It takes a start value, an increment, an end value, and an executable block as operands:

% Calls doSomething ten times with 1 through 10 as arguments
1 1 10 { doSomething } for

Here’s where it gets tricky: these control operators take their values from the stack, and it doesn’t matter how the values got there. Often, as in these examples, they’ll have been pushed there by literals just before the operator is called. But they can be placed there any other way, and the operators will still work:

% Loop up or down, depending on the value of up?
up? { 1 1 10 } { 10 -1 1 } ifelse
{ doSomething } for

This will loop from 1 to 10 if up? is true, and from 10 to 1 if up? is false.

Also, because executable blocks are objects on the stack that can be passed around and manipulated like any other object, you can write your own control operators:

% probability block 'domaybe' -
% Excecute the block randomly, determined by the probability.
/domaybe {
    exch            % bring the probability to the top
    1000 mul        % scale the probability to 0-1000
    rand 1000 mod   % pick a random integer in 0-999
    lt              % should we execute the procedure?
    exch            % swap args to make them right for if
    if              % execute the block if we should
} def

.01 { veryInfrequently } domaybe
.95 { almostCertainly } domaybe

Not that you’d want to build large systems in PostScript, but it’s good to bend your brain in different ways occasionally. Smalltalk has a similar build-your-own-control-structures descriptive power, though it is not stack based.