Function

// A function gives a piece of work a name, so it can be written once and run
// from as many places as need it. `Main` has been one since the first lesson;
// this lesson writes others and calls them from `Main`.
//
// The shape is always the same: `func`, a name, the parameters in parentheses,
// `->` and the type of the result, then a body that hands the result back with
// `return`.
import Io::PrintLine;

// Every parameter is written `name: type`, separated by commas. A call must
// supply one argument for each, in the same order.
func Add(left: int, right: int) -> int {
    return left + right;
}

func Square(value: int) -> int {
    return value * value;
}

// The result type is whatever the work produces. Here two `float64` values go
// in and one `float64` comes out.
func Average(first: float64, second: float64) -> float64 {
    return (first + second) / 2.0;
}

func CelsiusToFahrenheit(celsius: float64) -> float64 {
    return celsius * 9.0 / 5.0 + 32.0;
}

// Parameters are immutable inside the body, exactly like `let` bindings, so a
// running value needs a local `var` of its own.
func SumUpTo(last: int) -> int {
    var total = 0;
    for i in 1..=last {
        total += i;
    }
    return total;
}

func Main() -> int {
    PrintLine("Add(2, 3)                    {}", Add(2, 3));
    PrintLine("Square(7)                    {}", Square(7));
    PrintLine("Average(4.0, 7.0)            {}", Average(4.0, 7.0));
    PrintLine("CelsiusToFahrenheit(100.0)   {}", CelsiusToFahrenheit(100.0));
    PrintLine("SumUpTo(10)                  {}", SumUpTo(10));

    // A call is an ordinary value. It can be bound to a name...
    let side = Add(4, 5);
    PrintLine("side                         {}", side);

    // ...or passed straight into another call. The inner call runs first.
    PrintLine("Square(Add(1, 2))            {}", Square(Add(1, 2)));
    PrintLine("Add(Square(3), Square(4))    {}", Add(Square(3), Square(4)));

    // Arguments must match the parameter types. `Square(2.5)` is rejected,
    // because `2.5` is a `float64` and `Square` takes an `int` — the value is
    // not converted for you. And assigning to a parameter inside its function
    // is an error:
    //
    //     func Bump(n: int) -> int { n = n + 1; return n; }
    //         error: cannot modify parameter 'n'
    return 0;
}