lazy_t cleanup part 2

Author: cknitt

compiler/ml/predef.ml

@@ -53,8 +53,6 @@ and ident_dict = ident_create "dict"
 
 and ident_bigint = ident_create "bigint"
 
-and ident_lazy_t = ident_create "lazy_t"
-
 and ident_string = ident_create "string"
 
 and ident_extension_constructor = ident_create "extension_constructor"
@@ -98,8 +96,6 @@ and path_dict = Pident ident_dict
 
 and path_bigint = Pident ident_bigint
 
-and path_lazy_t = Pident ident_lazy_t
-
 and path_string = Pident ident_string
 
 and path_unkonwn = Pident ident_unknown
@@ -132,8 +128,6 @@ and type_dict t = newgenty (Tconstr (path_dict, [t], ref Mnil))
 
 and type_bigint = newgenty (Tconstr (path_bigint, [], ref Mnil))
 
-and type_lazy_t t = newgenty (Tconstr (path_lazy_t, [t], ref Mnil))
-
 and type_string = newgenty (Tconstr (path_string, [], ref Mnil))
 
 and type_unknown = newgenty (Tconstr (path_unkonwn, [], ref Mnil))
@@ -332,14 +326,6 @@ let common_initial_env add_type add_extension empty_env =
           ];
       type_unboxed = Types.unboxed_true_default_false;
     }
-  and decl_lazy_t =
-    let tvar = newgenvar () in
-    {
-      decl_abstr with
-      type_params = [tvar];
-      type_arity = 1;
-      type_variance = [Variance.covariant];
-    }
   and decl_promise =
     let tvar = newgenvar () in
     {
@@ -381,7 +367,6 @@ let common_initial_env add_type add_extension empty_env =
   |> add_type ident_exn decl_exn
   |> add_type ident_option decl_option
   |> add_type ident_result decl_result
-  |> add_type ident_lazy_t decl_lazy_t
   |> add_type ident_promise decl_promise
   |> add_type ident_array decl_array
   |> add_type ident_list decl_list

compiler/ml/predef.mli

@@ -31,7 +31,6 @@ val type_result : type_expr -> type_expr -> type_expr
 val type_dict : type_expr -> type_expr
 
 val type_bigint : type_expr
-val type_lazy_t : type_expr -> type_expr
 val type_extension_constructor : type_expr
 
 val path_int : Path.t
@@ -48,7 +47,6 @@ val path_result : Path.t
 val path_dict : Path.t
 
 val path_bigint : Path.t
-val path_lazy_t : Path.t
 val path_extension_constructor : Path.t
 val path_promise : Path.t
 

compiler/ml/transl_recmodule.ml

@@ -66,16 +66,6 @@ let init_shape modl =
                   non_const = cstr_non_const;
                   attrs = [];
                 } )
-        | {desc = Tconstr (p, _, _)} when Path.same p Predef.path_lazy_t ->
-          Const_pointer
-            ( 1,
-              Pt_constructor
-                {
-                  name = "Lazy";
-                  const = cstr_const;
-                  non_const = cstr_non_const;
-                  attrs = [];
-                } )
         | _ -> raise Not_found
       in
       add_name init_v id :: init_shape_struct env rem

compiler/ml/typeopt.ml

@@ -42,7 +42,7 @@ let rec type_cannot_contain_undefined (typ : Types.type_expr) (env : Env.t) =
   | Tconstr (p, _, _) -> (
     (* all built in types could not inhabit none-like values:
        int, char, float, bool, unit, exn, array, list, nativeint,
-       int32, int64, lazy_t, bytes
+       int32, int64, bytes
     *)
     match Predef.type_is_builtin_path_but_option p with
     | For_sure_yes -> true

lib/es6/Stdlib.js

@@ -12,7 +12,7 @@ function assertEqual(a, b) {
     RE_EXN_ID: "Assert_failure",
     _1: [
       "Stdlib.res",
-      122,
+      124,
       4
     ],
     Error: new Error()

lib/js/Stdlib.js

@@ -12,7 +12,7 @@ function assertEqual(a, b) {
     RE_EXN_ID: "Assert_failure",
     _1: [
       "Stdlib.res",
-      122,
+      124,
       4
     ],
     Error: new Error()

runtime/Primitive_lazy.res

@@ -34,10 +34,10 @@ 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")
+%%private(external castToConcrete: t<'a> => t<'a> = "%identity")
+%%private(external castFromConcrete: t<'a> => t<'a> = "%identity")
 
-let is_val = (type a, l: lazy_t<a>): bool => castToConcrete(l).tag
+let is_val = (type a, l: t<a>): bool => castToConcrete(l).tag
 
 exception Undefined
 
@@ -74,7 +74,7 @@ exception Undefined
   }
 )
 
-let force = (type a, lzv: lazy_t<a>): a => {
+let force = (type a, lzv: t<a>): a => {
   let lzv: t<_> = castToConcrete(lzv)
   if lzv.tag {
     lzv.value
@@ -83,7 +83,7 @@ let force = (type a, lzv: lazy_t<a>): a => {
   }
 }
 
-let force_val = (type a, lzv: lazy_t<a>): a => {
+let force_val = (type a, lzv: t<a>): a => {
   let lzv: t<_> = castToConcrete(lzv)
   if lzv.tag {
     lzv.value
@@ -92,15 +92,15 @@ let force_val = (type a, lzv: lazy_t<a>): a => {
   }
 }
 
-let from_fun = (type a, closure: unit => a): lazy_t<a> => {
+let from_fun = (type a, closure: unit => a): t<a> => {
   let blk = {
     tag: false,
     value: fnToVal(closure),
   }
   castFromConcrete(blk)
 }
 
-let from_val = (type a, value: a): lazy_t<a> => {
+let from_val = (type a, value: a): t<a> => {
   let blk = {
     tag: true,
     value,

runtime/Primitive_lazy.resi

@@ -1,13 +1,16 @@
 exception Undefined
 
+@notUndefined
+type 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,
    the same exception is raised again.
    Raise {!Undefined} if the forcing of [x] tries to force [x] itself
    recursively.
 */
-let force: lazy_t<'a> => 'a
+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]
@@ -17,23 +20,23 @@ let force: lazy_t<'a> => 'a
     If the computation of [x] raises an exception, it is unspecified
     whether [force_val x] raises the same exception or {!Undefined}.
 */
-let force_val: lazy_t<'a> => 'a
+let force_val: t<'a> => 'a
 
 /** [from_fun f] is the same as [lazy (f ())] but slightly more efficient.
 
     [from_fun] should only be used if the function [f] is already defined.
     In particular it is always less efficient to write
     [from_fun (fun () => expr)] than [lazy expr].
 */
-let from_fun: (unit => 'a) => lazy_t<'a>
+let from_fun: (unit => 'a) => t<'a>
 
 /** [from_val v] returns an already-forced suspension of [v].
     This is for special purposes only and should not be confused with
     [lazy (v)].
 */
-let from_val: 'a => lazy_t<'a>
+let from_val: 'a => t<'a>
 
 /** [is_val x] returns [true] if [x] has already been forced and
     did not raise an exception.
 */
-let is_val: lazy_t<'a> => bool
+let is_val: t<'a> => bool

runtime/Stdlib.res

@@ -57,6 +57,8 @@ type date = Date.t
 type null<+'a> = Primitive_js_extern.null<'a>
 type undefined<+'a> = Primitive_js_extern.undefined<'a>
 type nullable<+'a> = Primitive_js_extern.nullable<'a>
+@deprecated("Use Lazy.t instead")
+type lazy_t<'a> = Lazy.t<'a>
 
 @deprecated("Use rescript-webapi instead") @val external window: Dom.window = "window"
 @deprecated("Use rescript-webapi instead") @val external document: Dom.document = "document"

runtime/Stdlib_Lazy.res

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

runtime/Stdlib_Lazy.resi

@@ -12,16 +12,17 @@
     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
-    computation to be deferred of type `unit => 'a`. 
-    The function returns a lazy value of type `Lazy.t<'a>`.  
+    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 
+    ## Examples
+    ```rescript
     let lazyValue = Lazy.make(() => {
       // Some expensive computation
       Console.log("Computing...")
@@ -44,12 +45,12 @@ 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, 
+    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 
+    ```rescript
     let lazyValue = Lazy.make(() => {
       // Some expensive computation
       Console.log("Computing...")
@@ -64,7 +65,7 @@ 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,
@@ -75,7 +76,7 @@ exception Undefined
 @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.
@@ -87,23 +88,23 @@ let force: t<'a> => 'a
 @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>`.  
+    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.
 */

tests/tests/src/lazy_test.res

@@ -52,8 +52,8 @@ let f006: Lazy.t<unit => int> = Lazy.make(() => {
   _ => x
 })
 
-let f007 = Lazy.make(() => raise(Not_found))
-let f008 = Lazy.make(() => {
+let f007: Lazy.t<string> = Lazy.make(() => raise(Not_found))
+let f008: Lazy.t<string> = Lazy.make(() => {
   Js.log("hi")
   raise(Not_found)
 })
@@ -62,7 +62,7 @@ let a2 = x => Lazy.from_val(x)
 
 let a3 = Lazy.from_val(3)
 let a4 = a2(3)
-let a5 = Lazy.from_val(None)
+let a5: Lazy.t<option<string>> = Lazy.from_val(None)
 let a6 = Lazy.from_val()
 
 let a7 = Lazy.get(a5)