quick lazy

Author: cristianoc

compiler/ml/predef.ml

@@ -53,7 +53,7 @@ and ident_dict = ident_create "dict"
 
 and ident_bigint = ident_create "bigint"
 
-and ident_lazy_t = ident_create "lazy_t"
+and ident_lazy_t = ident_create "lazy_t_to_remove"
 
 and ident_string = ident_create "string"
 

runtime/Primitive_lazy.res

@@ -24,6 +24,8 @@
 
 @@config({flags: ["-bs-no-cross-module-opt"]})
 
+type lazy_t<+'a>
+
 /* Internals of forcing lazy values. */
 type t<'a> = {
   @as("LAZY_DONE") mutable tag: bool,

runtime/Primitive_lazy.resi

@@ -1,5 +1,7 @@
 exception Undefined
 
+type lazy_t<+'a>
+
 /** [force x] forces the suspension [x] and returns its result.
    If [x] has already been forced, [Lazy.force x] returns the
    same value again without recomputing it.  If it raised an exception,

runtime/Stdlib_Lazy.res

@@ -1,4 +1,4 @@
-type t<'a> = lazy_t<'a>
+type t<+'a> = Primitive_lazy.lazy_t<'a>
 
 exception Undefined = Primitive_lazy.Undefined
 

runtime/Stdlib_Lazy.resi

@@ -12,7 +12,8 @@
     subsequent accesses.  If the computation raises an exception,
     the same exception is raised again on subsequent accesses.
  */
-type t<'a> = lazy_t<'a>
+@notUndefined
+type t<+'a>
 
 /** 
     `Lazy.make(f)` creates a lazy value from `f` which is the

tests/tests/src/recursive_module.mjs

@@ -41,139 +41,40 @@ Primitive_module.update({
     ]]
 }, Int3, Int3);
 
-let Inta = Primitive_module.init([
-  "recursive_module.res",
-  29,
-  4
-], {
-  TAG: "Module",
-  _0: [[
-      "Lazy",
-      "a"
-    ]]
-});
-
-let Intb = Primitive_module.init([
-  "recursive_module.res",
-  34,
-  4
-], {
-  TAG: "Module",
-  _0: [[
-      "Lazy",
-      "a"
-    ]]
-});
-
-let a = Stdlib_Lazy.make(() => Stdlib_Lazy.get(Intb.a));
+let a = Stdlib_Lazy.make(() => 2);
 
-Primitive_module.update({
-  TAG: "Module",
-  _0: [[
-      "Lazy",
-      "a"
-    ]]
-}, Inta, {
+let Intb = {
   a: a
-});
+};
 
-let a$1 = Stdlib_Lazy.make(() => Stdlib_Lazy.get(Inta.a) + 1 | 0);
+let a$1 = Stdlib_Lazy.make(() => Stdlib_Lazy.get(Intb.a) + 1 | 0);
 
-Primitive_module.update({
-  TAG: "Module",
-  _0: [[
-      "Lazy",
-      "a"
-    ]]
-}, Intb, {
+let Inta = {
   a: a$1
-});
-
-let tmp;
-
-try {
-  tmp = Stdlib_Lazy.get(Intb.a);
-} catch (raw_exn) {
-  let exn = Primitive_exceptions.internalToException(raw_exn);
-  if (exn.RE_EXN_ID === Stdlib_Lazy.Undefined) {
-    tmp = -1;
-  } else {
-    throw exn;
-  }
-}
-
-eq("File \"recursive_module.res\", line 39, characters 2-9", -1, tmp);
-
-let Inta$1 = Primitive_module.init([
-  "recursive_module.res",
-  49,
-  6
-], {
-  TAG: "Module",
-  _0: [[
-      "Lazy",
-      "a"
-    ]]
-});
-
-let Intb$1 = Primitive_module.init([
-  "recursive_module.res",
-  54,
-  6
-], {
-  TAG: "Module",
-  _0: [[
-      "Lazy",
-      "a"
-    ]]
-});
-
-let a$2 = Stdlib_Lazy.make(() => Stdlib_Lazy.get(Intb$1.a) + 1 | 0);
-
-Primitive_module.update({
-  TAG: "Module",
-  _0: [[
-      "Lazy",
-      "a"
-    ]]
-}, Inta$1, {
-  a: a$2
-});
-
-let a$3 = Stdlib_Lazy.make(() => 2);
-
-Primitive_module.update({
-  TAG: "Module",
-  _0: [[
-      "Lazy",
-      "a"
-    ]]
-}, Intb$1, {
-  a: a$3
-});
+};
 
 let A = {
-  Inta: Inta$1,
-  Intb: Intb$1
+  Inta: Inta,
+  Intb: Intb
 };
 
-eq("File \"recursive_module.res\", line 59, characters 3-10", Stdlib_Lazy.get(Inta$1.a), 3);
+eq("File \"recursive_module.res\", line 40, characters 3-10", Stdlib_Lazy.get(a$1), 3);
 
-let tmp$1;
+let tmp;
 
 try {
   Int3.u(3);
-  tmp$1 = 3;
-} catch (raw_exn$1) {
-  let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
-  if (exn$1.RE_EXN_ID === "Undefined_recursive_module") {
-    tmp$1 = 4;
+  tmp = 3;
+} catch (raw_exn) {
+  let exn = Primitive_exceptions.internalToException(raw_exn);
+  if (exn.RE_EXN_ID === "Undefined_recursive_module") {
+    tmp = 4;
   } else {
-    throw exn$1;
+    throw exn;
   }
 }
 
-eq("File \"recursive_module.res\", line 62, characters 2-9", 4, tmp$1);
+eq("File \"recursive_module.res\", line 43, characters 2-9", 4, tmp);
 
 Mt.from_pair_suites("Recursive_module", suites.contents);
 
@@ -189,8 +90,6 @@ export {
   Xx,
   uuu,
   Int3,
-  Inta,
-  Intb,
   A,
 }
 /* Int3 Not a pure module */

tests/tests/src/recursive_module.res

@@ -24,25 +24,6 @@ module rec Int3: {
   let u: int => int
 } = Int3
 
-module rec Inta: {
-  let a: Lazy.t<int>
-} = {
-  let a = Lazy.make(() => Lazy.get(Intb.a))
-}
-and Intb: {
-  let a: Lazy.t<int>
-} = {
-  let a = Lazy.make(() => Lazy.get(Inta.a) + 1)
-}
-
-eq(
-  __LOC__,
-  -1,
-  try Lazy.get(Intb.a) catch {
-  | Lazy.Undefined => -1
-  },
-)
-
 module A = {
   module rec Inta: {
     let a: Lazy.t<int>