// Tomo is a statically typed, garbage collected imperative language with
// emphasis on simplicity, safety, and speed. Tomo code cross compiles to C,
// which is compiled to a binary using your C compiler of choice.

// To begin with, let's define a main function:
func main():
    // This function's code will run if you run this file.

    // Print to the console
    say("Hello world!")

    // Declare an integer variable (types are inferred)
    my_variable := 123

    // Assign a new value
    my_variable = 99

    // Floating point numbers are similar, but have a decimal point:
    my_num := 2.0

    // Strings can use interpolation with curly braces:
    say("My variable is {my_variable}")

    // Docstring tests use ">>" and when the program runs, they will print
    // their source code to the console on stderr.
    >> 1 + 2

    // If there is a following line with "=", you can perform a check that
    // the output matches what was expected.
    >> 2 + 3
    = 5
    // If there is a mismatch, the program will halt and print a useful
    // error message.

    // Booleans use "yes" and "no" instead of "true" and "false"
    my_bool := yes

    // Conditionals:
    if my_bool:
        say("It worked!")
    else if my_variable == 99:
        say("else if")
    else:
        say("else")

    // Arrays:
    my_numbers := [10, 20, 30]

    // Arrays are 1-indexed, so the first element is at index 1:
    >> my_numbers[1]
    = 10

    // Negative indices can be used to get items from the back of the array:
    >> my_numbers[-1]
    = 30

    // If an invalid index outside the array's bounds is used (e.g.
    // my_numbers[999]), an error message will be printed and the program will
    // exit.

    // Iteration:
    for num in my_numbers:
        >> num

    // Optionally, you can use an iteration index as well:
    for index, num in my_numbers:
        pass // Pass means "do nothing"

    // Loop control flow uses "skip" and "stop"
    for num in my_numbers:
        if num == 20:
            // You can specify which loop variable you're skipping/stopping if
            // there is any ambiguity.
            skip num

        if num == 30:
            stop

        >> num
    
    // Tables are efficient hash maps
    table := {"one": 1, "two": 2}
    >> table["two"]
    = 2

    // Tables can be iterated over either by key or key,value:
    for key in table:
        pass

    for key, value in table:
        pass

    // Tables also have ".keys" and ".values" fields to explicitly access the
    // array of keys or values in the table.
    >> table.keys
    = ["one", "two"]
    >> table.values
    = [1, 2]

    // Tables can have default values and fallbacks:
    table2 := {"three": 3; fallback=table; default=0}
    >> table2["two"]
    = 2
    >> table2["three"]
    = 3
    >> table2["???"]
    = 0

    // If no default is provided and a missing key is looked up, the program
    // will print an error message and halt.

    // Any types can be used in tables, for example, a table mapping arrays to
    // strings:
    >> {[10, 20]: "one", [30, 40, 50]: "two"}

    // So far, the datastructures that have been discussed are all *immutable*,
    // meaning you can't add, remove, or change their contents. If you want to
    // have mutable data, you need to allocate an area of memory which can hold
    // different values using the "@" operator (think: "@llocate").
    my_arr := @[10, 20, 30]
    my_arr[1] = 999
    >> my_arr
    = @[999, 20, 30]

    // To call a method, you must use ":" and the name of the method:
    my_arr:sort()
    >> my_arr
    = @[20, 30, 999]

    // To access the immutable value that resides inside the memory area, you
    // can use the "[]" operator:
    >> my_arr[]
    = [20, 30, 999]

    // You can think of this like taking a photograph of what's at that memory
    // location. Later, a new value might end up there, but the photograph will
    // remain unchanged.
    snapshot := my_arr[]
    my_arr:insert(1000)
    >> my_arr
    = @[20, 30, 999, 1000]
    >> snapshot
    = [20, 30, 999]
    // Internally, this is implemented using copy-on-write, so it's quite
    // efficient.

    // These demos are defined below:
    demo_keyword_args()
    demo_structs()
    demo_enums()
    demo_lambdas()

// Functions must be declared at the top level of a file and must specify the
// types of all of their arguments and return value (if any):
func add(x:Int, y:Int)->Int:
    return x + y

// Default values for arguments can be provided in place of a type (the type is
// inferred from the default value):
func show_both(first:Int, second=0)->Text:
    return "first={first} second={second}"

func demo_keyword_args():
    >> show_both(1, 2)
    = "first=1 second=2"

    // If unspecified, the default argument is used:
    >> show_both(1)
    = "first=1 second=0"

    // Arguments can be specified by name, in any order:
    >> show_both(second=20, 10)
    = "first=10 second=20"

// Here are some different type signatures:
func takes_many_types(
    boolean:Bool,
    integer:Int,
    floating_point_number:Num,
    text_aka_string:Text,
    array_of_ints:[Int],
    table_of_text_to_bools:{Text:Bool},
    pointer_to_mutable_array_of_ints:@[Int],
    maybe_null_pointer_to_int:@Int?,
    function_from_int_to_text:func(x:Int)->Text,
):
    pass

// Now let's define our own datastructure, a humble struct:
struct Person(name:Text, age:Int):
    // We can define constants here if we want to:
    max_age := 122

    // Methods are defined here as well:
    func say_age(self:Person):
        say("My age is {self.age}")

    // If you want to mutate a value, you must have a mutable pointer:
    func increase_age(self:@Person, amount=1):
        self.age += amount

    // Methods don't have to take a Person as their first argument:
    func get_cool_name()->Text:
        return "Blade"

func demo_structs():
    // Creating a struct:
    alice := Person("Alice", 30)
    >> alice
    = Person(name="Alice", age=30)

    // Accessing fields:
    >> alice.age
    = 30

    // Calling methods:
    alice:say_age()

    // You can call static methods by using the class name and ".":
    >> Person.get_cool_name()
    = "Blade"

    // Comparisons, conversion to text, and hashing are all handled
    // automatically when you create a struct:
    bob := Person("Bob", 30)
    >> alice == bob
    = no

    >> "{alice}" == 'Person(name="Alice", age=30)'
    = yes

    table := {alice: "first", bob: "second"}
    >> table[alice]
    = "first"


// Now let's look at another feature: enums. Tomo enums are tagged unions, also
// known as "sum types". You enumerate all the different types of values
// something could have, and it's stored internally as a small integer that
// indicates which type it is, and any data you want to associate with it.
enum Shape(
    Point,
    Circle(radius:Num),
    Rectangle(width:Num, height:Num),
):
    // Just like with structs, you define methods and constants inside a level
    // of indentation:
    func get_area(self:Shape)->Num:
        // In order to work with an enum, it's most often handy to use a 'when'
        // statement to get the internal values:
        when self is Point:
            return 0
        is Circle(r):
            return Num.PI * r^2
        is Rectangle(w, h):
            return w * h
        // 'when' statements are checked for exhaustiveness, so the compiler
        // will give an error if you forgot any cases. You can also use 'else:'
        // if you want a fallback to handle other cases.

func demo_enums():
    // Enums are constructed like this:
    my_shape := Shape.Circle(1.0)

    // If an enum type doesn't have any associated data, it is not invoked as a
    // function, but is just a static value:
    other_shape := Shape.Point

    // Similar to structs, enums automatically define comparisons, conversion
    // to text, and hashing:
    >> my_shape == other_shape
    = no

    >> "{my_shape}" == "Shape.Circle(radius=1)"
    = yes

    >> {my_shape:"nice"}
    = {Shape.Circle(radius=1):"nice"}

func demo_lambdas():
    // Lambdas, or anonymous functions, can be used like this:
    add_one := func(x:Int): x + 1
    >> add_one(5)
    = 6

    // Lambdas can capture closure values, but only as a snapshot from when the
    // lambda was created:
    n := 10
    add_n := func(x:Int): x + n
    >> add_n(5)
    = 15

    // The lambda's closure won't change when this variable is reassigned:
    n = -999
    >> add_n(5)
    = 15