Cleanup 2

Author: cknitt

runtime/Primitive_lazy.res

@@ -24,10 +24,10 @@
 
 @@config({flags: ["-bs-no-cross-module-opt"]})
 
-type lazy_t<+'a>
+type t<+'a>
 
 /* Internals of forcing lazy values. */
-type t<'a> = {
+type internal<'a> = {
   @as("LAZY_DONE") mutable tag: bool,
   /* Invariant: name */
   @as("VAL") mutable value: 'a,
@@ -36,15 +36,15 @@ 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> => internal<'a> = "%identity")
+%%private(external castFromConcrete: internal<'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
 
 %%private(
-  let forward_with_closure = (type a, blk: t<a>, closure: unit => a): a => {
+  let forward_with_closure = (type a, blk: internal<a>, closure: unit => a): a => {
     let result = closure()
     blk.value = result
     blk.tag = true
@@ -56,7 +56,7 @@ exception Undefined
 
 /* Assume [blk] is a block with tag lazy */
 %%private(
-  let force_lazy_block = (type a, blk: t<a>): a => {
+  let force_lazy_block = (type a, blk: internal<a>): a => {
     let closure = valToFn(blk.value)
     blk.value = fnToVal(raise_undefined)
     try forward_with_closure(blk, closure) catch {
@@ -69,40 +69,40 @@ exception Undefined
 
 /* Assume [blk] is a block with tag lazy */
 %%private(
-  let force_val_lazy_block = (type a, blk: t<a>): a => {
+  let force_val_lazy_block = (type a, blk: internal<a>): a => {
     let closure = valToFn(blk.value)
     blk.value = fnToVal(raise_undefined)
     forward_with_closure(blk, closure)
   }
 )
 
-let force = (type a, lzv: lazy_t<a>): a => {
-  let lzv: t<_> = castToConcrete(lzv)
+let force = (type a, lzv: t<a>): a => {
+  let lzv: internal<_> = castToConcrete(lzv)
   if lzv.tag {
     lzv.value
   } else {
     force_lazy_block(lzv)
   }
 }
 
-let force_val = (type a, lzv: lazy_t<a>): a => {
-  let lzv: t<_> = castToConcrete(lzv)
+let force_val = (type a, lzv: t<a>): a => {
+  let lzv: internal<_> = castToConcrete(lzv)
   if lzv.tag {
     lzv.value
   } else {
     force_val_lazy_block(lzv)
   }
 }
 
-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,6 +1,6 @@
 exception Undefined
 
-type lazy_t<+'a>
+type t<+'a>
 
 /** [force x] forces the suspension [x] and returns its result.
    If [x] has already been forced, [Lazy.force x] returns the
@@ -9,7 +9,7 @@ type lazy_t<+'a>
    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]
@@ -19,23 +19,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_Lazy.res

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