move Lazy module to Stdlib (#7399)

Author: tsnobip

CHANGELOG.md

@@ -37,6 +37,7 @@
 
 - Improve error message for missing value when the identifier is also the name of a module in scope. https://github.com/rescript-lang/rescript/pull/7384
 - Upgrade Flow parser to 0.267.0. https://github.com/rescript-lang/rescript/pull/7390
+- Move `Lazy` module to Stdlib. https://github.com/rescript-lang/rescript/pull/7399
 
 # 12.0.0-alpha.11
 

lib/es6/Stdlib.js

@@ -12,7 +12,7 @@ function assertEqual(a, b) {
     RE_EXN_ID: "Assert_failure",
     _1: [
       "Stdlib.res",
-      119,
+      120,
       4
     ],
     Error: new Error()
@@ -49,6 +49,8 @@ let $$Intl;
 
 let $$JSON;
 
+let Lazy;
+
 let List;
 
 let $$Math;
@@ -133,6 +135,7 @@ export {
   Int,
   $$Intl,
   $$JSON,
+  Lazy,
   List,
   $$Math,
   Null,

lib/es6/Lazy.js renamed to lib/es6/Stdlib_Lazy.js

@@ -2,6 +2,12 @@
 
 import * as Primitive_lazy from "./Primitive_lazy.js";
 
+let make = Primitive_lazy.from_fun;
+
+let get = Primitive_lazy.force;
+
+let isEvaluated = Primitive_lazy.is_val;
+
 let Undefined = Primitive_lazy.Undefined;
 
 let force = Primitive_lazy.force;
@@ -15,6 +21,9 @@ let from_val = Primitive_lazy.from_val;
 let is_val = Primitive_lazy.is_val;
 
 export {
+  make,
+  get,
+  isEvaluated,
   Undefined,
   force,
   force_val,

lib/js/Stdlib.js

@@ -12,7 +12,7 @@ function assertEqual(a, b) {
     RE_EXN_ID: "Assert_failure",
     _1: [
       "Stdlib.res",
-      119,
+      120,
       4
     ],
     Error: new Error()
@@ -49,6 +49,8 @@ let $$Intl;
 
 let $$JSON;
 
+let Lazy;
+
 let List;
 
 let $$Math;
@@ -132,6 +134,7 @@ exports.Float = Float;
 exports.Int = Int;
 exports.$$Intl = $$Intl;
 exports.$$JSON = $$JSON;
+exports.Lazy = Lazy;
 exports.List = List;
 exports.$$Math = $$Math;
 exports.Null = Null;

lib/js/Lazy.js renamed to lib/js/Stdlib_Lazy.js

@@ -2,6 +2,12 @@
 
 let Primitive_lazy = require("./Primitive_lazy.js");
 
+let make = Primitive_lazy.from_fun;
+
+let get = Primitive_lazy.force;
+
+let isEvaluated = Primitive_lazy.is_val;
+
 let Undefined = Primitive_lazy.Undefined;
 
 let force = Primitive_lazy.force;
@@ -14,6 +20,9 @@ let from_val = Primitive_lazy.from_val;
 
 let is_val = Primitive_lazy.is_val;
 
+exports.make = make;
+exports.get = get;
+exports.isEvaluated = isEvaluated;
 exports.Undefined = Undefined;
 exports.force = force;
 exports.force_val = force_val;

packages/artifacts.txt

@@ -114,7 +114,6 @@ lib/es6/Jsx.js
 lib/es6/JsxDOM.js
 lib/es6/JsxDOMStyle.js
 lib/es6/JsxEvent.js
-lib/es6/Lazy.js
 lib/es6/Obj.js
 lib/es6/Pervasives.js
 lib/es6/Primitive_array.js
@@ -178,6 +177,7 @@ lib/es6/Stdlib_Intl_Segmenter.js
 lib/es6/Stdlib_Intl_Segments.js
 lib/es6/Stdlib_Iterator.js
 lib/es6/Stdlib_JSON.js
+lib/es6/Stdlib_Lazy.js
 lib/es6/Stdlib_List.js
 lib/es6/Stdlib_Map.js
 lib/es6/Stdlib_Math.js
@@ -287,7 +287,6 @@ lib/js/Jsx.js
 lib/js/JsxDOM.js
 lib/js/JsxDOMStyle.js
 lib/js/JsxEvent.js
-lib/js/Lazy.js
 lib/js/Obj.js
 lib/js/Pervasives.js
 lib/js/Primitive_array.js
@@ -351,6 +350,7 @@ lib/js/Stdlib_Intl_Segmenter.js
 lib/js/Stdlib_Intl_Segments.js
 lib/js/Stdlib_Iterator.js
 lib/js/Stdlib_JSON.js
+lib/js/Stdlib_Lazy.js
 lib/js/Stdlib_List.js
 lib/js/Stdlib_Map.js
 lib/js/Stdlib_Math.js
@@ -809,12 +809,6 @@ lib/ocaml/JsxEvent.cmi
 lib/ocaml/JsxEvent.cmj
 lib/ocaml/JsxEvent.cmt
 lib/ocaml/JsxEvent.res
-lib/ocaml/Lazy.cmi
-lib/ocaml/Lazy.cmj
-lib/ocaml/Lazy.cmt
-lib/ocaml/Lazy.cmti
-lib/ocaml/Lazy.res
-lib/ocaml/Lazy.resi
 lib/ocaml/Obj.cmi
 lib/ocaml/Obj.cmj
 lib/ocaml/Obj.cmt
@@ -1109,6 +1103,12 @@ lib/ocaml/Stdlib_JSON.cmt
 lib/ocaml/Stdlib_JSON.cmti
 lib/ocaml/Stdlib_JSON.res
 lib/ocaml/Stdlib_JSON.resi
+lib/ocaml/Stdlib_Lazy.cmi
+lib/ocaml/Stdlib_Lazy.cmj
+lib/ocaml/Stdlib_Lazy.cmt
+lib/ocaml/Stdlib_Lazy.cmti
+lib/ocaml/Stdlib_Lazy.res
+lib/ocaml/Stdlib_Lazy.resi
 lib/ocaml/Stdlib_List.cmi
 lib/ocaml/Stdlib_List.cmj
 lib/ocaml/Stdlib_List.cmt

runtime/Lazy.resi

@@ -13,6 +13,7 @@ module Float = Stdlib_Float
 module Int = Stdlib_Int
 module Intl = Stdlib_Intl
 module JSON = Stdlib_JSON
+module Lazy = Stdlib_Lazy
 module List = Stdlib_List
 module Math = Stdlib_Math
 module Null = Stdlib_Null

runtime/Stdlib.res

@@ -1,11 +1,13 @@
-// FIXME:
-//   This exists for compatibility reason.
-//   Move this into Pervasives or Core
-
 type t<'a> = lazy_t<'a>
 
 exception Undefined = Primitive_lazy.Undefined
 
+let make = Primitive_lazy.from_fun
+
+let get = Primitive_lazy.force
+
+let isEvaluated = Primitive_lazy.is_val
+
 let force = Primitive_lazy.force
 
 let force_val = Primitive_lazy.force_val

runtime/Lazy.res renamed to runtime/Stdlib_Lazy.res

@@ -0,0 +1,111 @@
+/***
+    This module  provides a type `Lazy.t` and functions to create and
+    manipulate lazy values.  A lazy value is a value that is not
+    computed until it is needed.  This is useful for deferring
+    computations that may be expensive or unnecessary.
+ */
+
+/**
+    The type of a lazy value.  `Lazy.t<'a>` represents a lazy value
+    that will eventually yield a value of type `'a` when accessed.
+    The value is computed only once, and the result is cached for
+    subsequent accesses.  If the computation raises an exception,
+    the same exception is raised again on subsequent accesses.
+ */
+type t<'a> = lazy_t<'a>
+
+/** 
+    `Lazy.make(f)` creates a lazy value from `f` which is the
+    computation to be deferred of type `unit => 'a`. 
+    The function returns a lazy value of type `Lazy.t<'a>`.  
+    The computation is not executed until the lazy value is accessed.
+
+    ## Examples 
+    ```rescript 
+    let lazyValue = Lazy.make(() => {
+      // Some expensive computation
+      Console.log("Computing...")
+      42
+    });
+    lazyValue->Lazy.get->assertEqual(42)
+    ```
+*/
+let make: (unit => 'a) => t<'a>
+
+/**
+    `Lazy.get(x)` forces the suspension `x` and returns its result.
+    If `x` has already been forced, `Lazy.get(x)` returns the
+    same value again without recomputing it.  If it raised an
+    exception, the same exception is raised again.
+    Raise `Undefined` if the forcing of `x` tries to force `x`  itself
+    recursively.  This is a runtime error.
+ */
+let get: t<'a> => 'a
+
+/**
+    `Lazy.isEvaluated(x)` returns `true` if the suspension `x` has
+    already been forced and did not raise an exception.  Otherwise, 
+    it returns `false`.  This is useful for checking if a lazy value
+    has been computed before accessing it.
+
+    ## Examples
+    ```rescript 
+    let lazyValue = Lazy.make(() => {
+      // Some expensive computation
+      Console.log("Computing...")
+      42
+    })
+    Lazy.isEvaluated(lazyValue)->assertEqual(false)
+    lazyValue->Lazy.get->assertEqual(42)
+    lazyValue->Lazy.isEvaluated->assertEqual(true)
+    ```
+ */
+let isEvaluated: t<'a> => bool
+
+exception Undefined
+
+/** 
+    `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,
+    the same exception is raised again.
+    Raise `Undefined` if the forcing of `x` tries to force `x` itself
+    recursively.
+*/
+@deprecated("Use `Lazy.get` instead")
+let force: t<'a> => 'a
+
+/** 
+    `force_val(x)` forces the suspension `x` and returns its
+    result.  If `x` has already been forced, `force_val(x)`
+    returns the same value again without recomputing it.
+    Raise `Undefined` if the forcing of `x` tries to force `x` itself
+    recursively.
+    If the computation of `x` raises an exception, it is unspecified
+    whether `force_val(x)` raises the same exception or `Undefined`.
+*/
+@deprecated("Use `Lazy.get` instead")
+let force_val: t<'a> => 'a
+
+/** 
+    `Lazy.from_fun(f)` creates a lazy value from `f` which is the
+    computation to be deferred of type `unit => 'a`. 
+    The function returns a lazy value of type `Lazy.t<'a>`.  
+    The computation is not executed until the lazy value is accessed.
+*/
+@deprecated("Use `Lazy.make` instead")
+let from_fun: (unit => 'a) => t<'a>
+
+/** 
+    `from_val(v)` returns an already-forced suspension of `v`.
+    This is for special purposes only.
+*/
+@deprecated("Use `Lazy.make` instead")
+let from_val: 'a => t<'a>
+
+/** 
+    `is_val(x)` returns `true` if `x has already been forced and
+    did not raise an exception.
+*/
+@deprecated("Use `Lazy.isEvaluated` instead")
+let is_val: t<'a> => bool

runtime/Stdlib_Lazy.resi

@@ -1,26 +1,26 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Lazy from "rescript/lib/es6/Lazy.js";
+import * as Stdlib_Lazy from "rescript/lib/es6/Stdlib_Lazy.js";
 
 function fix() {
   return {
     TAG: "Fix",
-    _0: Lazy.from_fun(fix)
+    _0: Stdlib_Lazy.from_fun(fix)
   };
 }
 
 function unfixLeak(_f) {
   while (true) {
     let f = _f;
-    _f = Lazy.force(f._0);
+    _f = Stdlib_Lazy.force(f._0);
     continue;
   };
 }
 
 function unfix(p) {
   while (true) {
     let h = p.contents;
-    p.contents = Lazy.force(h._0);
+    p.contents = Stdlib_Lazy.force(h._0);
   };
 }