snapshot

Author: bobzhang

Diff for: jscomp/Docs.md

@@ -40,6 +40,52 @@ The directory containing unit-test files, some unit tests are copied from OCaml
 ## ounit_tests
 ## others (belt/stdlib/node bindings)
 
+## uncurry 
+
+```ocaml
+f a  b [@bs]
+```
+
+```ocaml
+(unsafeFullApply ((opaque f) a b ))
+```
+case 0
+
+```ocaml
+type 'a fn0 = {
+  _0 : 'a
+} 
+```
+create:
+```
+{_0 = fun () -> ...}
+```
+`(unit -> int) fn0` is different from `(unit -> int) fn1`
+
+When `f` is an external, without opaque
+```ocaml
+apply (Obj.magic f a b) ==> apply (f a b)
+```
+
+`fun [@bs] a b -> c ` is the same as `fun [@bs] a -> fun b -> c `
+from the view of parsetree
+
+
+
+`unit -> int [@bs]` --> `int Js.arity0`
+
+`f () [@bs]` --> `(run0 f)`
+
+`fun [@bs] () -> body` -> `fn_mk0 (fun () -> ...)`
+
+It is special handled due to `fn_mk0`, otherwise it will have arity 1
+
+We can `-open Js.Uncurry` to make names look pretty
+
+```
+bucklescript$bsc -bs-syntax-only -dsource -bs-eval 'let h1 x = fun%x y -> x y'
+let h1 x = [%x fun y -> x y]
+```
 
 # bspack
 

Diff for: jscomp/main/builtin_cmi_datasets.ml

@@ -1,6 +1,5 @@
 'use strict';
 
-var Curry = require("../../lib/js/curry.js");
 
 function sum_float_array(arr) {
   var v = 0;
@@ -36,66 +35,9 @@ function f(x) {
   return x.fight();
 }
 
-function ff(fn, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
-  return fn(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
-}
-
-function ff2(fn, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {
-  return fn(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
-}
-
-function off2(o, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {
-  return o.huge_method(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
-}
-
-function mk_f(param) {
-  return (function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {
-      return Curry.app(a0, [
-                  a1,
-                  a2,
-                  a3,
-                  a4,
-                  a5,
-                  a6,
-                  a7,
-                  a8,
-                  a9,
-                  a10,
-                  a11,
-                  a12
-                ]);
-    });
-}
-
-function omk_f(param) {
-  return {
-          huge_methdo: (function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {
-              return Curry.app(a0, [
-                          a1,
-                          a2,
-                          a3,
-                          a4,
-                          a5,
-                          a6,
-                          a7,
-                          a8,
-                          a9,
-                          a10,
-                          a11,
-                          a12
-                        ]);
-            })
-        };
-}
-
 exports.sum_float_array = sum_float_array;
 exports.sum_int_array = sum_int_array;
 exports.sum_poly = sum_poly;
 exports.test_set = test_set;
 exports.f = f;
-exports.ff = ff;
-exports.ff2 = ff2;
-exports.off2 = off2;
-exports.mk_f = mk_f;
-exports.omk_f = omk_f;
 /* No side effect */

Diff for: jscomp/main/builtin_cmj_datasets.ml

@@ -48,27 +48,27 @@ let f (x : < bark : string -> unit [@bs.meth] ; fight : unit -> unit [@bs.meth]
 (* This type is generated on the fly -- in which case
   it can not be nominal
 *)
-let ff 
+(* let ff 
     (fn :('a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> 'a10 -> 'a11 -> 'a12 [@bs])) a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11  = 
-  fn a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 [@bs]
+  fn a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 [@bs] *)
 
 
-let ff2 
+(* let ff2 
     fn a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 a12 = 
-  fn a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 a12 [@bs]
+  fn a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 a12 [@bs] *)
 
 (* Test [fn_run_method] *)
-let off2 o  a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 a12 = 
-  o##huge_method a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 a12
+(* let off2 o  a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 a12 = 
+  o##huge_method a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 a12 *)
 
 (* Test [fn_mk] *)
-let mk_f () = 
+(* let mk_f () = 
   fun [@bs] a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 a12 -> 
-  a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 a12
+  a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 a12 *)
 
 (* Test [fn_method] *)
-let omk_f ()= 
+(* let omk_f ()= 
   object
    method huge_methdo a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 a12 =
   a0  a1  a2  a3  a4  a5  a6  a7  a8  a9  a10  a11 a12
-  end [@bs]  
+end [@bs]   *)

Diff for: jscomp/test/class_type_ffi_test.js

@@ -2,29 +2,26 @@
 
 var List = require("../../lib/js/list.js");
 var Curry = require("../../lib/js/curry.js");
-var Caml_int32 = require("../../lib/js/caml_int32.js");
 
 function h0(x) {
   return x();
 }
 
 function h00(x) {
-  return Curry._1(x(), /* () */0);
+  return x();
 }
 
-function h1(x) {
-  return (function (param) {
-      return x(param);
-    });
+function h1(x, y) {
+  return x(y);
 }
 
 function h10(x) {
   return x(3);
 }
 
 function h30(x) {
-  return (function (param) {
-      return x(3, 3, param);
+  return (function (a) {
+      return x(3, 3, a);
     });
 }
 
@@ -36,10 +33,10 @@ function h34(x) {
   return Curry._1(x(1, 2, 3), 4);
 }
 
-function ocaml_run(param, param$1) {
+function ocaml_run(b, c) {
   return (function (x, y, z) {
               return (x + y | 0) + z | 0;
-            })(1, param, param$1);
+            })(1, b, c);
 }
 
 function a0() {
@@ -61,29 +58,6 @@ function a3(x, y, z) {
   return (x + y | 0) + z | 0;
 }
 
-function a4(x, y, z, param) {
-  var u = (Caml_int32.imul(x, x) + Caml_int32.imul(y, y) | 0) + Caml_int32.imul(z, z) | 0;
-  return (function (d) {
-              return u + d | 0;
-            })(param);
-}
-
-function a44(x, y, z, d) {
-  var u = (Caml_int32.imul(x, x) + Caml_int32.imul(y, y) | 0) + Caml_int32.imul(z, z) | 0;
-  return u + d | 0;
-}
-
-function b44(param) {
-  return (function (x, y, z, d) {
-      return /* tuple */[
-              x,
-              y,
-              z,
-              d
-            ];
-    });
-}
-
 function xx(param) {
   return (function (param) {
       console.log(3);
@@ -105,9 +79,6 @@ exports.a0 = a0;
 exports.a1 = a1;
 exports.a2 = a2;
 exports.a3 = a3;
-exports.a4 = a4;
-exports.a44 = a44;
-exports.b44 = b44;
 exports.test_as = test_as;
 exports.xx = xx;
 /* No side effect */

Diff for: jscomp/test/class_type_ffi_test.ml

@@ -33,34 +33,38 @@ let () =
 
 *)
 
-let h0 x = Js.Internal.fn_run0 x 
+let h0 x = x () [@bs]
 (* {[
      function h0 (x){
          return x ()
        }
    ]}
 *)
-let h00 x = Js.Internal.fn_run0 x ()
+let h00 x =  x () [@bs]
 
-let h1 x = Js.Internal.fn_run1 x 
-let h10 x = Js.Internal.fn_run1 x 3  
+let h1 x = (fun y -> x y [@bs]) (* weird case *)
+(*
+bucklescript$bsc -bs-syntax-only -dsource -bs-eval 'let h1 x = fun y -> x y'
+let h1 x y = x y
+*)
+let h10 x = x 3 [@bs]
 
-let h30 x = Js.Internal.fn_run3 x 3 3   
-let h33 x = Js.Internal.fn_run3 x 1 2 3
-let h34 x = Js.Internal.fn_run3 x 1 2 3 4
+let h30 x = fun [@bs] a ->  x 3 3 a [@bs]
+let h33 x =  x 1 2 3 [@bs]
+let h34 x = (x 1 2 3 [@bs]) 4
 
 
-let ocaml_run = Js.Internal.fn_run3 (Js.Internal.fn_mk3 (fun x y z -> x + y + z)) 1 
+let ocaml_run = fun[@bs] b c -> (fun [@bs] x y z -> x + y + z) 1  b c[@bs]
 
-let a0 = Js.Internal.fn_mk0 (fun  _ -> Js.log "hi")
-let a1 () = Js.Internal.fn_mk1 (fun x -> x )
-let a2 = Js.Internal.fn_mk2 (fun x y -> x + y)
-let a3 = Js.Internal.fn_mk3 (fun x y z -> x + y + z )
-let a4 = Js.Internal.fn_mk4 (fun x y z -> let u = x * x + y * y + z * z in fun d -> u + d)
+let a0 =  (fun [@bs]  () -> Js.log "hi")
+let a1 () =  (fun[@bs] x -> x )
+let a2 =  (fun[@bs] x y -> x + y)
+let a3 =  (fun [@bs] x y z -> x + y + z )
+(* let a4 = Js.Internal.fn_mk4 (fun x y z -> let u = x * x + y * y + z * z in fun d -> u + d) *)
 
-let a44 = Js.Internal.fn_mk4 (fun x y z d -> let u = x * x + y * y + z * z in  u + d)
+(* let a44 = Js.Internal.fn_mk4 (fun x y z d -> let u = x * x + y * y + z * z in  u + d) *)
 
-let b44 () = Js.Internal.fn_mk4 (fun x y z d -> (x,y,z,d))
+(* let b44 () = Js.Internal.fn_mk4 (fun x y z d -> (x,y,z,d)) *)
 (* polymoprhic restriction *)
 
 let test_as : ('a -> 'a)  -> (_ as 'b)  ->  'b = List.map

Diff for: jscomp/test/event_ffi.js

@@ -21,24 +21,24 @@ var v = [
     1,
     2,
     3
-  ].map((function (param, param$1) {
-        return f(param)(param$1);
+  ].map((function (a, b) {
+        return f(a)(b);
       }));
 
 var vv = [
     1,
     2,
     3
-  ].map((function (prim, prim$1) {
-        return prim + prim$1 | 0;
+  ].map((function (a, b) {
+        return a + b | 0;
       }));
 
 var hh = [
     "1",
     "2",
     "3"
-  ].map((function (prim) {
-        return parseInt(prim);
+  ].map((function (x) {
+        return parseInt(x);
       }));
 
 function u() {
@@ -112,56 +112,7 @@ Mt.from_pair_suites("Ffi_arity_test", /* :: */[
                         ]);
               })
           ],
-          /* :: */[
-            /* tuple */[
-              "File \"ffi_arity_test.ml\", line 48, characters 4-11",
-              (function (param) {
-                  return /* Eq */Block.__(0, [
-                            [
-                                  1,
-                                  2,
-                                  3
-                                ].map((function (x) {
-                                      return (function (y) {
-                                          return x + y | 0;
-                                        });
-                                    })).map((function (y) {
-                                    return Caml_int32.imul(Curry._1(y, 0), Curry._1(y, 1));
-                                  })),
-                            [
-                              2,
-                              6,
-                              12
-                            ]
-                          ]);
-                })
-            ],
-            /* :: */[
-              /* tuple */[
-                "File \"ffi_arity_test.ml\", line 53, characters 4-11",
-                (function (param) {
-                    return /* Eq */Block.__(0, [
-                              [
-                                  1,
-                                  2,
-                                  3
-                                ].map((function (x, param) {
-                                      var y = Caml_int32.imul(x, x);
-                                      return (function (i) {
-                                                  return y + i | 0;
-                                                })(param);
-                                    })),
-                              [
-                                1,
-                                5,
-                                11
-                              ]
-                            ]);
-                  })
-              ],
-              /* [] */0
-            ]
-          ]
+          /* [] */0
         ]
       ]
     ]);