Pseudo imperative programming

Procedural programming

The aim of our following constructs is naturally to allow the user to program in a style that's natural in procedural programming, although in a self-contained manner. The procedural interpretation of our while statement thus clearly mimics the while statement of procedural languages. This allows the user to try a variety of programming styles even while keeping the code's logic or functional properties.

Imperative programming: code is a recipe of instructions. The interpreter will execute these instructions in order. Variables are cells that can be set to different values.

Procedural programming: in addition to the above, code may contain control structures such as 'if' or 'while' that change the flow of execution.

while

Here is an example of a while construct.

init i=1
while(i<6)
	print(i)//1,2,3,4,5
	next i=1+i
print(i)//6

The code will successively write every integer from 1 to 6.

Logical interpretation

while(A) B: If the condition A is true, then B holds, and remains so while A holds. Conversely, B is true until A stops holding.

Procedural interpretation

The condition A is tried; if it holds, execution proceeds to the code in B, if not, leave the while statement. This is repeated until the condition doesn't hold.

Temporal variables

For lack of a better term, let's call i a temporal variable. It's fitting, if we think of it as a variable for which the value changes over time.

These expressions are relevant for a temporal variable.

init i: the initial value of the variable.

next i: the value it'll hold in the next loop or iteration.

The term i by itself is the final value of the variable.

In our example, the variable is increased each time, meaning that the condition eventually stops holding.

for

The classic for-statement is simply an extension of the while statement. It's perhaps not necessary, but we thought best to include it.

for(init i=1; i<6; next i=1+i;)
	print(i)//1,2,3,4,5
print(i)//6

The only difference is that we made the parts of code concerned with iteration clear by placing them separate from the body; our variable iterates from 1 to 5, increasing by 1 each time, and it is written.

Generic for

A simple way to do so is also by using a generic mechanism.

range=math.range
for(x in range(1,6))
	print(x)//1,2,3,4,5

The relation range is used to iterate through 1 to 6.

for(x in [1,2,3])
	print(x)//1,2,3

We may also incidentally move through any data structure in such a way, as long as an iteration mechanism is provided for them.

Some

It's curious that we started by mimicking procedural languages, and arrived at a way of expressing what are essentially logic idioms. Consider,

for(x in l)
	human(x)

some(x in l)
	human(x)

This expresses that all x are human or some x are human, respectively.

Operator	Idiom
for	"For all x, x is y" (All X are Y.)
some	"There is at least one x, such that x is y" (Some X are Y.)

Some examples may illustrate the idea.

>for(x in [1,2,3]) odd(x)
| false
>some(x in [1,2,3]) odd(x)
| true
>for(x in {1,1,1}) x=1
| true
>some(x in {2,1,1}) x=1
| true