a fun language for serious programming

Control Structures

Traditional procedural control structures exist in Nit. They also often exist in two versions: a one-liner and a block version.

Control Flow

Control structures dictate the control flow of the program. Nit heavily refers to the control flow in its specification:

  • No unreachable statement;

  • No usage of undefined variables;

  • No function without a return with a value;

  • Adaptive typing.

Some structures alter the control flow but are not described in this section: and, or, not, or else and return.

Note that the control flow is determined only from the position, the order and the nesting of the control structures. The real value of the expressions used has no effect on the control flow analyses.

if true then
    return
else
    return
end
print 1 # Compile error: unreachable statement

if true then
    return
end
print 1 # OK, but never executed

if

if exp then stm
if exp then stm else stm
if exp then
    stms
end

if exp then
    stms
else if exp then
    stms
else
    stms
end

Note that the following example is invalid since the first line is syntactically complete thus the newline terminate the whole if structure; then an error is signaled since a statement cannot begin with else.

if exp then stm # OK: complete 'if' structure
else stm # Syntax error: unexpected 'else'

while

while exp do stm
while exp do
    stms
end

for

for declares an automatic variable used to iterates on Collection (Array and Range are both Collection).

for x in [1..5] do print x # outputs 1 2 3 4 5
for x in [1, 4, 6] do
    print x # outputs 1 4 6
end

for can also be used with reversed ranges to iterate in reverse order.

Step can also be used to specify the size of each increment at the end of a for cycle.

for x in [9 .. 4].step(-1) do print x # outputs 9 8 7 6 5 4
for x in [9 .. 4[.step(-2) do print x # outputs 9 7 5

loop

Infinite loops are mainly used with breaks. They are useful to implement until loops or to simulate the exit when control of Ada.

loop
    stms
    if exp then break
    stms
end

Note that loop is different from while true because the control flow does not consider the values of expression.

do

Single do are used to create scope for variables or to be attached with labeled breaks.

do
    var x = 5
    print x
end
# x is not defined here

break, continue and label

Unlabeled break exits the current for, while, loop, Unlabeled continue skips the current for, while, loop.

label can be used with break or continue to act on a specific control structure (not necessary the current one). The corresponding label must be defined after the end keyword of the designated control structure.

for i in [0..width[ do
    for j in [0..height[ do
        if foo(i, j) then break label outer_loop
        # The 'break' breaks the 'for i' loop
    end
end label outer_loop

label can also be used with break and single do structures.

do
    stmts
    if expr then break label block
    stmts
end label block

abort

abort stops the program with a fatal error and prints a stack trace. Since there is currently no exception nor run-time-errors, abort is somewhat used to simulate them.

assert

assert verifies that a given Boolean expression is true, or else it aborts. An optional label can be precised, it will be displayed on the error message. An optional else can also be added and will be executed before the abort.

assert bla: whatever else
    # "bla" is the label
    # "whatever" is the expression to verify
    print "Fatal error in module blablabla."
    print "Please contact the customer service."
end