Function overloading

[tiansivive]

By taking advantage of type unions, we can introduce function overloading.

This can be useful for having different APIs, for example, curried vs uncurried versions or different parameter order for readability purposes

[tiansivive]

Proposed syntax could be:

let overload
    | Foo: (Int, Int) -> Int                = \(x,y) -> x + y 
    | Bar: (String, Int) -> Int             = \(x,y) -> read x + y 
    | Baz: (Int, String) -> Int             = \(x,y) -> x + read y 
    | Curried: Curry (String, Int) -> Int   = \x y -> x + y

There could be potential conflicts with normal type expression parsing.
Investigate whether it's worthwhile to introduce an "inhabited" concept. There are some different considerations here.

1. Different meaning of inhabited types than haskell and co.
2. Do all members need to be inhabited if at least more than one is so?
3. How does this map to logic programming constructs and potential backtracking & non-determinism?
4. Is this only usable for overloading functions?
   4a. If not, should it be restricted to functions?

Assuming there are answers to all of the above, this would be resolved by the Elaboration process, where determining the types of an application of overload would add some implicit parameter - the associated tag - to route the remaining arguments to the correct version of the function