# Control Flow
## simple if expression
Simple if expressions produce a value specified in the if body.
Since the else part is missing, it is assumed to be a `null`.
In REPL, a multiline if statement can be executed by suffixing
a back-slash character (`\`) at the end of the line to indicate
that the next line is a continuation.
```
let n = 0;
let s = if n == 0 { \
"zero" \
};
puts(s);
```
Note: There should not be any space following the `\` character.
Alternatively, instead of using the slash suffix, you can also
create file via the cat command available in posix systems.
## if-else expression
Save the following script in a file. e.g. 'if.p2'.
On posix systems, you can use 'cat' with 'EOF' to create this file
on your terminal. Alternatively, an editor may also be used.
```
cat > if.p2 <<EOF
if len(argv) < 2 {
exit(1);
}
let n = int(argv[1]);
let s = if n < 0 {
"Negative"
} else if n == 0 {
"Zero"
} else {
"+ve"
};
puts(s);
EOF
```
Note that `if` is not a statement but an expression that produces a value.
Execute the script as follows:
```
p2sh if.p2 0
Zero
p2sh if.p2 1
+ve
p2sh if.p2 -1
-ve
```
## match expressions
The match expressions work similar to the one found in `Rust`. It matches a
condition expression with multiple match arms using patterns. If a match is
successful, the body of the match arm is executed. Otherwise, it continues until
a match is found. Once a match is found, the control flow breaks out of the check.
Note that there is no fallthrough mechanism similar to a switch statment in c.
```
cat > match.p2 <<EOF
let s = input("-->> ");
let r = match tolower(s) {
_ => { "others" }
};
puts(r);
EOF
```
Execute the program as follows:
```
p2sh match.p2
-->> a
vowel
p2sh match.p2
-->> b
consonant
p2sh match.p2
-->> ?
others
```
## Loop statements
The loop statement executes the loop body infinitely. To break out of the loop,
use the break statement.
```
let n = 1;
loop { \
if n > 5 { \
break; \
} \
puts(n); \
n = n + 1; \
}
```
Output:
```
1
2
3
4
5
true
```
Note that the `true` at the end is the value of the last expression
evaluated in the loop and can be ignored. In this case it is the
result of the if expression.
## While
The same code can be written using while
```
let n = 1;
while n <= 5 { \
puts(n); \
n = n + 1; \
}
```
Output:
```
1
2
3
4
5
false
```
### loop labels
break and continue statements can also have labels in them. This is helpful
when loops are nested.
```
cat >> while.p2 <<EOF
let i = 1;
outer: while i <= 3 {
let j = 1;
while j <= 3 {
if j == 2 {
j = j + 1;
i = i + 1;
continue outer;
}
println("{},{}", i, j);
j = j + 1;
}
i = i + 1;
}
EOF
```
Execution
```
p2sh while.p2
1,1
2,1
3,1
```
### continue statements
The continue statement can be used to continue to the execution of the
next iteration of the loop without executing the rest of the loop body.
Save the following file in `loop.p2`
```
cat > loop.p2 <<EOF
let n = 1;
while n <= 5 {
if n == 3 {
n = n + 1;
continue;
}
puts(n);
n = n + 1;
}
EOF
```
Execution
```
p2sh loop.p2
1
2
4
5
```
## Functions
### Using the let keyword
```
>> let add = fn(a, b) { a + b };
>> add(1,2)
3
```
### Function statements
```
>> fn f1() { 1; }
>> fn f2() { return 2; }
>> f1();
1
>> f2();
2
```
### Closures
Closures are functions that can capture the surrounding variables at the time
of its definitions. In the following example, the inner anonymous function is
a closure that closes over the variable 'value' that is passed as an argument.
In this case, the values of that variable are `doughnut` and `bagel`.
Note that the inner anonymous function uses the surrounding variable `value`.
```
>> fn make_closure(value) { return fn() { puts(value); } }
<closure>
>> let doughnut = make_closure("doughnut");
<closure>
>> let bagel = make_closure("bagel");
<closure>
>> doughnut();
doughnut
>> bagel();
bagel
```
A more useful example
```
cat >> filter.p2 <<EOF
fn filter(a) {
let i = 0;
let t = [];
while i < len(a) {
let is_even = fn() { a[i] % 2 == 0 };
if is_even() {
push(t, a[i]);
}
i = i + 1;
}
t
}
let numbers = filter([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
puts(numbers);
EOF
```
Execution
```
p2sh filter.p2
[2, 4, 6, 8, 10]
```