Variable

// A variable gives a value a name. `let` makes one: a name, an `=` and a value, and from then on
// the name stands for that value. A `let` variable never changes — the next lesson, Mutable,
// introduces the kind that does. Reach for `let` first: a name that cannot change is one less
// thing to keep track of while reading the code.
import Io::PrintLine;

func Main() -> int {
    // With no type written, the compiler infers one from the value. A whole number makes an
    // `int`, a number with a decimal point makes a `float64`, text in double quotes makes a
    // string, and `true` or `false` makes a `bool`.
    let year = 2026;
    let price = 4.99;
    let language = "Rux";
    let ready = true;

    // Each `{}` in the text is replaced by the next value after it. The Console lesson has the
    // details; until then, this is how a value gets printed.
    PrintLine("year      {}", year);
    PrintLine("price     {}", price);
    PrintLine("language  {}", language);
    PrintLine("ready     {}", ready);

    // A type can also be written after the name, following a colon. Then the value has to fit
    // that type: 100 fits in an `int8`, which holds -128 to 127, but 300 would not.
    let small: int8 = 100;
    let large: int64 = 100;
    PrintLine("small     {}", small);
    PrintLine("large     {}", large);

    // The value can be any expression, including one that uses earlier variables.
    let nextYear = year + 1;
    PrintLine("next year {}", nextYear);

    // Two things the compiler refuses. Neither can appear in a program that builds, so they are
    // written here rather than run:
    //
    //     let total = 5;
    //     total = 6;
    //         error: cannot modify immutable variable 'total'
    //         help: declare 'total' with 'var' to make it mutable
    //
    //     let name = 1;
    //     let name = 2;
    //         error: variable 'name' is already declared in this scope
    //
    // The second is worth meeting early if you come from a language where declaring a name again
    // quietly hides the old one. In Rux a name means one thing for the whole scope it lives in.
    return 0;
}