Description
I'd like to consider relaxing the function subtyping rules from Section 13.5 of the spec.
I recently run into limitations with the current rule that I think are unnecessary. Consider this example:
typedef Dynamic Fun1(Dynamic p);
typedef Dynamic Fun2([Dynamic p]);
f1(p) => print("1 $p");
f2([p=null]) => print("2 $p");
main() {
Fun1 test1 = f1;
Fun2 test2 = f2;
Fun1 test3 = f2; // error today, would be OK if we change the rules
Fun2 test4 = f1; // error today, should continue to be error
test1("hi1");
test2("hi2");
test3("hi3"); // this could be allowed if we change the rules.
test4("hi4");
test4(); // this error is correctly prevented by the current rules
}
In this example, the type system will give errors on the assignment of test3 and test4. I claim that test3 should be considered a valid assignment, but test4 continue to be an error.
In terms of the type system. Currently we compare these 2 types:
(T1, ... Tn, [Tx1 x1, ..., Txk xk]) -> T
(S1, ... Sn; [Sy1 y1; ..., Sym ym]) -> S
And we force that the total number of positional arguments (n) is the same.
I'd like to relax by considering the named arguments of the second type a possible replacement for missing positional arguments, that is:
(T1, ... Tn, [Tx1 x1, ..., Txk xk]) -> T
(S1, ... Sj; [Sy1 y1; ..., Sym ym]) -> S
The rules could check that j + ym >= n. Let yn be such that j+yn = n. Then compare (T1... Tn) with (S1 ... Sj Sy1 ... Syn).