Ad-hoc types

[bvssvni]

Closes #236

This PR adds ad-hoc types to Dyon. It is a very simple type check that works well with dynamic modules, where ordinary type definitions are difficult to use since dynamic modules might be loaded in different orders and with different imports. Ad-hoc types makes it possible to have some extra type checks within the design space of Dyon.

How to use Ad-Hoc Types

Ad-hoc types in Dyon means you can write a name in front of the type of an argument, and the type checker will treat it as a distinct type. You can use any name that is not a built-in type in Dyon:

fn km(v: f64) -> km f64 { return clone(v) }

fn walk(distance: km f64) { ... }

If you omit the type, Dyon will use {} by default. It is common to use CamelCase for such types:

fn new_person(name: str, age: f64) -> Person {
    return { name: name, age: age }
}

The inner type and the ad-hoc type works with each other, so you can pass Person to {} and vice versa:

fn call(person: Person) {
    println("Hi " + person.name + "!")
}

call({ name: "John" })

Restricted algebra with Ad-hoc types

One usage of ad-hoc types is to add physical units safety to your program. For this reason, the ad-hoc types disallow + or - between an ad-hoc type and a built-in type:

 --- ERROR --- 
In `source/test.dyon`:

Type mismatch: Binary operator can not be used with `km f64` and `f64`
2,21:     println(km(5) + 4)
2,21:                     ^

When you use + or -, the result will be inferred to be the same ad-hoc type as both arguments.

Multiplication is not allowed because this often changes the physical unit. To do multiplication, you need a function that unwraps the type before multiplication:

fn main() {
    println(mul(km: km(5), km: km(4)))
}

fn km(v: f64) -> km f64 { return clone(v) }

fn km2(v: f64) -> km2 f64 { return clone(v) }

fn unwrap_km(v: km f64) -> f64 { return clone(v) }

fn mul_km_km(a: km f64, b: km f64) -> km2 f64 {
    return km2(unwrap(km: a) * unwrap(km: b))
}