Figure out function types and subtyping story

[polybuildr]

Currently, balloon naively treats all functions' types as equal. However, when checking function calls, since it traces the actual call, it points out incorrect number of arguments (which must match exactly, unlike JS or PHP).

So, in

fn call(g, x) {
    g(x);
}

call(fn () {}, 1);

you get

in test.bl, line 5, col 1:
issue in function call:
5 | call(fn () {}, 1);
    ^^^^^^^^^^^^^^^^^
in function in test.bl, line 2, col 5:
arguments mismatch: function `g` called with incorrect number of arguments
2 |     g(x);
        ^^^^

We need to figure out if accepting less or more arguments is part of subtyping. This could matter in cases like callbacks.

After this, we should make function types account for arity as well as return types.

[polybuildr]

@bollu, any advice here?

[bollu]

no real type theory knowledge.

This was discussed a lot in Rust, where they considered allowing optional arguments to be called with python's default argument syntax.

def f(name: Option<String>, age: Option<Int>)
...

f("foo") // name -> Some("foo"), age -> None
f(age=10) // name -> None, age -> Some(10)

This is implementable.

However, from all that I have read, subtyping wrecks with type inference due to the overlapping constraints that you can get. I don't really know Scala does it, but that would be the first place to start for actual type theory knowledge. Or, read TAPL.