--- /dev/null
+# 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
+~~~
nitlanguage / nit.git / blobdiff