Explore default arguments in uncurried functions without a final unit argument

Functions such as this one

```res
let foo1 = (~x=3, ~y) => x+y
```

 normally require a final unit unlabeled argument to indicate that the optional argument `x` is not passed.

In this example, writing

```res
let r1 = foo1(~y=11)
```

makes `r1` a function that is still expecting the `x` argument.

Requiring a final unit argument, and passing it as `foo1(~y=11, ())` is the only way to omit `x` in  practice.

With uncurried functions, there's the opportunity to treat `foo1(~y=11)` in a special way, meaning that argument `x` is omitted.

TODO:
- Figure out what to do with the warning ""This optional parameter in final position will, in practice, not be optional"
- Figure out the case of all optional arguments. There's no way to pass zero arguments. One could interpret `foo()`, which actually passes `()` as single unlabelled argument, in a special way when `foo` does not accept unlabelled arguments, and use it to mean zero arguments passed.

Author: cristianoc

CHANGELOG.md

@@ -23,6 +23,7 @@ subset of the arguments, and return a curried type with the remaining ones https
 - Parser/Printer: unify uncurried functions of arity 0, and of arity 1 taking unit. There's now only arity 1 in the source language. https://github.com/rescript-lang/rescript-compiler/pull/5825
 - Add support for default arguments in uncurried functions https://github.com/rescript-lang/rescript-compiler/pull/5835
 - Inline uncurried application when it is safe https://github.com/rescript-lang/rescript-compiler/pull/5847
+- Allow default arguments in uncurried functions without a final unit argument
 
 #### :boom: Breaking Change
 

jscomp/ml/typecore.ml

@@ -3024,13 +3024,23 @@ and type_application uncurried env funct (sargs : sargs) : targs * Types.type_ex
   in
   let rec type_unknown_args max_arity (args : lazy_args) omitted ty_fun (syntax_args : sargs)
      : targs * _ = 
-    match syntax_args with 
-    |  [] ->
-        (List.map
-            (function l, None -> l, None
-                | l, Some f -> l, Some (f ()))
-           (List.rev args),
-         instance env (result_type omitted ty_fun))
+    match syntax_args with
+    | [] ->
+        let collect_args () =
+          (List.map
+              (function l, None -> l, None
+                  | l, Some f -> l, Some (f ()))
+            (List.rev args),
+          instance env (result_type omitted ty_fun)) in
+        if List.length args < max_arity && uncurried then
+          (match (expand_head env ty_fun).desc with
+          | Tarrow (Optional l,t1,t2,_) ->
+            ignored := (Optional l,t1,ty_fun.level) :: !ignored;
+            let arg = Optional l, Some (fun () -> option_none (instance env t1) Location.none) in
+            type_unknown_args max_arity (arg::args) omitted t2 []
+          | _ -> collect_args ())
+        else
+          collect_args ()
     | (l1, sarg1) :: sargl ->
         let (ty1, ty2) =
           let ty_fun = expand_head env ty_fun in
@@ -3082,7 +3092,7 @@ and type_application uncurried env funct (sargs : sargs) : targs * Types.type_ex
         let sargs, omitted,  arg =          
             match extract_label name sargs with 
             | None ->          
-                if optional && label_assoc Nolabel sargs
+                if optional && (uncurried || label_assoc Nolabel sargs)
                 then begin
                   ignored := (l,ty,lv) :: !ignored;
                   sargs, omitted , Some (fun () -> option_none (instance env ty) Location.none)

jscomp/test/uncurried_default.args.js

@@ -45,9 +45,30 @@ var partial$1 = Curry._1((function (param) {
 
 var total$1 = withOpt$1(10, 3)(4, 11);
 
+function foo1(xOpt, y) {
+  var x = xOpt !== undefined ? xOpt : 3;
+  return x + y | 0;
+}
+
+var x = 3;
+
+var r1 = x + 11 | 0;
+
+function foo2(y, xOpt, zOpt) {
+  var x = xOpt !== undefined ? xOpt : 3;
+  var z = zOpt !== undefined ? zOpt : 4;
+  return (x + y | 0) + z | 0;
+}
+
+var r2 = foo2(11, undefined, undefined);
+
 exports.StandardNotation = StandardNotation;
 exports.withOpt = withOpt$1;
 exports.testWithOpt = testWithOpt$1;
 exports.partial = partial$1;
 exports.total = total$1;
+exports.foo1 = foo1;
+exports.r1 = r1;
+exports.foo2 = foo2;
+exports.r2 = r2;
 /* testWithOpt Not a pure module */

jscomp/test/uncurried_default.args.res

@@ -13,3 +13,9 @@ let withOpt = (~x=1, y) => (~z=1, w) => x+y+z+w
 let testWithOpt = withOpt(3)(4)
 let partial = withOpt(. ~x=10)(. 3)(. ~z=4)(. 11)
 let total = withOpt(~x=10, 3)(~z=4, 11)
+
+let foo1 = (~x=3, ~y) => x+y
+let r1 = foo1(~y=11)
+
+let foo2 = @warning("-16") (~y, ~x=3, ~z=4) => x+y+z
+let r2 = foo2(~y=11)