# 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 a variable with ':=' (the type is inferred to be integer)
    my_variable := 123

    # Assign a new value
    my_variable = 99

    # Floating point numbers are similar, but require a decimal point:
    my_num := 2.0

    # Strings can use interpolation with the dollar sign $:
    say("My variable is $my_variable and this is a sum: $(1 + 2)")

    say("
        Multiline strings begin with a " at the end of a line and continue in
        an indented region below.
          You can have leading spaces after the first line
          and they'll be preserved.

        The multiline string won't include a leading or trailing newline.
    ")

    # You can log values for debugging with ">>", which will print the line's
    # source code and the value (with syntax highlighting) to the console on
    # stderr.
    >> 1 + 2

    # For assertions, you can use `assert`:
    assert 2 + 3 == 5

    # Assert takes an optional message string, but either way, assertion
    # failures will print a lot of contextual information.
    assert 2 + 3 == 5, "Math is broken"

    # 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")

    # Lists:
    my_numbers := [10, 20, 30]

    # Empty lists require specifying the type:
    empty_list : [Int]
    assert empty_list.length == 0

    # Lists are 1-indexed, so the first element is at index 1:
    assert my_numbers[1] == 10

    # Negative indices can be used to get items from the back of the list:
    assert my_numbers[-1] == 30

    # If an invalid index outside the list'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"

    # Lists can be created with list comprehensions, which are loops:
    assert [x*10 for x in my_numbers] == [100, 200, 300]
    assert [x*10 for x in my_numbers if x != 20] == [100, 300]

    # Loop control flow uses "skip"/"continue" and "stop"/"break"
    for x in my_numbers
        for y in my_numbers
            if x == y
                skip
                continue # This is the same as `skip`

            # For readability, you can also use postfix conditionals:
            skip if x == y

            if x + y == 60
                # Skip or stop can specify a loop variable if you want to
                # affect an enclosing loop:
                stop x
                break x # This is the same as `stop x`

    # Tables are efficient hash maps
    table := {"one"=1, "two"=2}
    assert table["two"] == 2

    # The value returned is optional because none will be returned if the key
    # is not in the table:
    assert table["xxx"] == none

    # Optional values can be converted to regular values using `!` (which will
    # create a runtime error if the value is null):
    assert table["two"]! == 2

    # You can also use `or` to provide a fallback value to replace none:
    assert table["xxx"] or 0 == 0

    # Empty tables require specifying the key and value types:
    empty_table : {Text:Int}

    # 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
    # list of keys or values in the table.
    assert table.keys == ["one", "two"]
    assert table.values == [1, 2]

    # Tables can have a fallback table that's used as a fallback when the key
    # isn't found in the table itself:
    table2 := {"three"=3; fallback=table}
    assert table2["two"]! == 2
    assert table2["three"]! == 3

    # Tables can also be created with comprehension loops:
    assert {x=10*x for x in 5} == {1=10, 2=20, 3=30, 4=40, 5=50}

    # 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 lists to
    # strings:
    table3 := {[10, 20]="one", [30, 40, 50]="two"}
    assert table3[[10, 20]]! == "one"

    # 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: "(a)llocate").
    my_arr := @[10, 20, 30]
    my_arr[1] = 999
    assert my_arr[] == [999, 20, 30]

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

    # To access the immutable value that resides inside the memory area, you
    # can use the "[]" operator:
    assert 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)
    assert my_arr[] == [20, 30, 999, 1000]
    assert 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()
    assert show_both(1, 2) == "first=1 second=2"

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

    # Arguments can be specified by name, in any order:
    assert 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,
    list_of_ints:[Int],
    table_of_text_to_bools:{Text=Bool},
    pointer_to_mutable_list_of_ints:@[Int],
    optional_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)
    assert alice == Person(name="Alice", age=30)

    # Accessing fields:
    assert alice.age == 30

    # Calling methods:
    alice.say_age()

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

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

    assert "$alice" == 'Person(name="Alice", age=30)' == yes

    table := {alice="first", bob="second"}
    assert 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:
    assert my_shape == other_shape == no

    assert "$my_shape" == "Circle(1)" == yes

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

func demo_lambdas()
    # Lambdas, or anonymous functions, can be used like this:
    add_one := func(x:Int) x + 1
    assert 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
    assert add_n(5) == 15

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