implement Lazy with CamlinternalLazy

Author: namenu

jscomp/runtime/caml_module.res

@@ -53,7 +53,7 @@ let init_mod = (loc: (string, int, int), shape: shape) => {
   let rec loop = (shape: shape, struct_: Obj.t, idx) =>
     switch shape {
     | Function => set_field(struct_, idx, Obj.magic(undef_module))
-    | Lazy => set_field(struct_, idx, Obj.magic(lazy undef_module))
+    | Lazy => set_field(struct_, idx, Obj.magic(undef_module))
     | Class =>
       set_field(
         struct_,

jscomp/stdlib-406/camlinternalLazy.res

@@ -35,6 +35,7 @@ type t<'a> = {
 %%private(external fnToVal: ((. unit) => 'a) => 'a = "%identity")
 %%private(external valToFn: 'a => (. unit) => 'a = "%identity")
 %%private(external castToConcrete: lazy_t<'a> => t<'a> = "%identity")
+%%private(external castFromConcrete: t<'a> => lazy_t<'a> = "%identity")
 
 let is_val = (type a, l: lazy_t<a>): bool => castToConcrete(l).tag
 
@@ -90,3 +91,19 @@ let force_val = (type a, lzv: lazy_t<a>): a => {
     force_val_lazy_block(lzv)
   }
 }
+
+let from_fun = (type a, closure: (. unit) => a): lazy_t<a> => {
+  let blk = {
+    tag: false,
+    value: fnToVal(closure),
+  }
+  castFromConcrete(blk)
+}
+
+let from_val = (type a, value: a): lazy_t<a> => {
+  let blk = {
+    tag: true,
+    value: value,
+  }
+  castFromConcrete(blk)
+}

jscomp/stdlib-406/camlinternalLazy.resi

@@ -25,3 +25,7 @@ let force: lazy_t<'a> => 'a
 let force_val: lazy_t<'a> => 'a
 
 let is_val: lazy_t<'a> => bool
+
+let from_fun: ((. unit) => 'a) => lazy_t<'a>
+
+let from_val: 'a => lazy_t<'a>

jscomp/stdlib-406/hashtbl.res

@@ -56,7 +56,7 @@ let randomized = ref(randomized_default)
 let randomize = () => randomized := true
 let is_randomized = () => randomized.contents
 
-let prng = lazy Random.State.make_self_init()
+let prng = Lazy.from_fun(() => Random.State.make_self_init())
 
 /* Creating a fresh, empty table */
 

jscomp/stdlib-406/lazy.res

@@ -55,9 +55,9 @@ external force: t<'a> => 'a = "%lazy_force"
 
 let force_val = CamlinternalLazy.force_val
 
-let from_fun = f => lazy f()
+let from_fun = f => CamlinternalLazy.from_fun((. ) => f())
 
-let from_val = v => lazy v
+let from_val = v => CamlinternalLazy.from_val(v)
 
 let is_val = CamlinternalLazy.is_val
 

jscomp/stdlib-406/stream.res

@@ -218,13 +218,13 @@ let iapp = (i, s) => Some({count: 0, data: Sapp(data(i), data(s))})
 let icons = (i, s) => Some({count: 0, data: Scons(i, data(s))})
 let ising = i => Some({count: 0, data: Scons(i, Sempty)})
 
-let lapp = (f, s) => Some({count: 0, data: Slazy(lazy Sapp(data(f()), data(s)))})
+let lapp = (f, s) => Some({count: 0, data: Slazy(Lazy.from_fun(() => Sapp(data(f()), data(s))))})
 
-let lcons = (f, s) => Some({count: 0, data: Slazy(lazy Scons(f(), data(s)))})
-let lsing = f => Some({count: 0, data: Slazy(lazy Scons(f(), Sempty))})
+let lcons = (f, s) => Some({count: 0, data: Slazy(Lazy.from_fun(() => Scons(f(), data(s))))})
+let lsing = f => Some({count: 0, data: Slazy(Lazy.from_fun(() => Scons(f(), Sempty)))})
 
 let sempty = None
-let slazy = f => Some({count: 0, data: Slazy(lazy data(f()))})
+let slazy = f => Some({count: 0, data: Slazy(Lazy.from_fun(() => data(f())))})
 
 /* For debugging use */
 

jscomp/test/build.ninja

@@ -32,7 +32,7 @@ type t = [
   | #Dir(string)
 ]
 
-let cwd = lazy Sys.getcwd()
+let cwd = Lazy.from_fun(() => Sys.getcwd())
 
 let \"//" = Filename.concat
 
@@ -211,7 +211,7 @@ let rec find_root_filename = (~cwd, filename) =>
 
 let find_package_json_dir = cwd => find_root_filename(~cwd, Test_literals.bsconfig_json)
 
-let package_dir = lazy find_package_json_dir(Lazy.force(cwd))
+let package_dir = Lazy.from_fun(() => find_package_json_dir(Lazy.force(cwd)))
 
 let module_name_of_file = file =>
   String.capitalize_ascii(\"@@"(Filename.chop_extension, Filename.basename(file)))

jscomp/test/demo_int_map.js

@@ -1,14 +1,14 @@
 type rec t<'a> = Fix(lazy_t<t<'a>>)
 
-let rec fix = () => Fix(lazy fix())
+let rec fix = () => Fix(Lazy.from_fun(fix))
 
 let rec unfixLeak = (Fix(f)) => \"@@"(unfixLeak, Lazy.force(f))
 
 let unfix = p =>
   while true {
     p :=
       switch p.contents {
-      | Fix(lazy h) => h
+      | Fix(h) => Lazy.force(h)
       }
   }
 /* ;; unfixLeak (fix ()) */