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