// Simplest
f := fn {}
f()

// Simple param
f2 := fn a: int {}
f2(1)

// Return value
f3 := fn -> int {
    ret 3
}
f3() <=> 3

// Combined
f4 := fn a: int -> int {
    ret a + a
}
f4(2) <=> 4

// Multiple arguments
adder := fn a: int, b: int -> int {
    ret a + b
}
adder(1, 2) <=> 3

// calls inside calls
adder(f3(), f3() + 1) <=> 7

// Passing functions
h := fn -> int {
    ret 1
}
g := fn f: fn -> int -> int{
    ret f()
}
g(h) <=> 1

// multiple returns
q := fn i: int -> int {
    if i == 1 {
        ret 2
    } else {
        ret 3
    }
}
q(1) <=> 2
q(0) <=> 3

// mixing function and value types
f5 := fn a: fn -> int, b: int -> int {
    ret a() + b
}
f5_inner := fn -> int {
    ret 1
}
f5(f5_inner, 2) <=> 3

// factorial := fn n: int -> int {
//     if n <= 1 {
//         ret 1
//     }
//     ret n * factorial(n - 1)
// }
// factorial(5) <=> 120
// factorial(6) <=> 720
// factorial(12) <=> 479001600