Console

// Every lesson so far has printed with `PrintLine`. This one looks at it closely, together with its
// partner `Print`. The difference between them is one thing: `PrintLine` ends the line it writes,
// and `Print` leaves the cursor where it stopped, so the next output carries on the same line.
import Io::{ Print, PrintLine };

func Main() -> int {
    // Three calls, one line, because only the last call ends it.
    Print("one ");
    Print("two ");
    PrintLine("three");

    // A `\n` inside the text is a line break too, so `PrintLine` is `Print` with one added.
    Print("four\nfive\n");

    // With nothing to print, `PrintLine` writes only the line ending: a blank line.
    PrintLine();

    // A value can be printed on its own, with no text around it.
    PrintLine(42);
    PrintLine(2.5);
    PrintLine(true);

    // More often the value goes inside a message. Each `{}` is filled by the next argument, in
    // the order they are written, and any kind of value can fill one.
    let name = "Rux";
    let major = 0;
    let minor = 4;
    PrintLine("{} version {}.{}", name, major, minor);

    // `Print` takes placeholders as well, so a line can be built from pieces.
    Print("{} + {} = ", 2, 3);
    PrintLine("{}", 2 + 3);

    // To print a brace itself in text that has placeholders, double it. Text passed with no
    // arguments at all is printed exactly as written, so there a brace is single.
    PrintLine("{{}} marks a place for {}", "a value");
    PrintLine("{} with nothing to fill it");

    // Watch the count. Once a call has arguments, the compiler matches them against the
    // placeholders, and a placeholder with no argument, or an argument with no placeholder, is
    // refused:
    //
    //     PrintLine("{} and {}", 1);
    //         error: format string has 2 placeholders, but 1 argument was provided
    //         help: pass one argument for each '{}' placeholder
    //
    // Width, alignment and decimal places inside `{}` wait for the Format lesson.
    return 0;
}