set up Null.t

Author: zth

src/Core__Null.res

@@ -1,4 +1,4 @@
-type t<'a> = Js.Null.t<'a>
+@unboxed type t<'a> = Js.Null.t<'a> = Value('a) | @as(null) Null
 
 external asNullable: t<'a> => Core__Nullable.t<'a> = "%identity"
 

src/Core__Null.resi

@@ -7,7 +7,8 @@ If you also need to cover `undefined`, check out `Nullable` instead.
 /**
 A type representing a value that can be either `'a` or `null`.
 */
-type t<'a> = Js.Null.t<'a>
+@unboxed
+type t<'a> = Js.Null.t<'a> = Value('a) | @as(null) Null
 
 /**
 Converts a `Null.t` into a `Nullable.t`.

src/Core__Nullable.res

@@ -1,4 +1,4 @@
-@unboxed type t<'a> = Js.Nullable.t<'a> = Present('a) | @as(null) Null | @as(undefined) Undefined
+@unboxed type t<'a> = Js.Nullable.t<'a> = Value('a) | @as(null) Null | @as(undefined) Undefined
 
 external null: t<'a> = "#null"
 

src/Core__Nullable.resi

@@ -9,7 +9,7 @@ Type representing a nullable value.
 A nullable value can be the value `'a`, `null` or `undefined`.
 */
 @unboxed
-type t<'a> = Js.Nullable.t<'a> = Present('a) | @as(null) Null | @as(undefined) Undefined
+type t<'a> = Js.Nullable.t<'a> = Value('a) | @as(null) Null | @as(undefined) Undefined
 
 /**
 The value `null`.

src/RescriptCore.res

@@ -64,6 +64,11 @@ type null<+'a> = Js.null<'a>
 
 type undefined<+'a> = Js.undefined<'a>
 
-type nullable<+'a> = Js.nullable<'a>
+// We're intentionally only bringing the constructors of `nullable` into scope
+// here. Reason is if we do the same for `null`, we'll get issues with inference
+// in the global scope, and we prioritize nullable higher because that covers
+// more cases.
+@unboxed
+type nullable<+'a> = Js.nullable<'a> = Value('a) | @as(null) Null | @as(undefined) Undefined
 
 let panic = Core__Error.panic

test/NullableTests.mjs

@@ -5,7 +5,7 @@ import * as Test from "./Test.mjs";
 function shouldHandleNullableValues(param) {
   var tNull = null;
   var tUndefined = undefined;
-  var tPresent = "hello";
+  var tValue = "hello";
   var tmp;
   tmp = (tNull === null || tNull === undefined) && tNull === null ? true : false;
   Test.run([
@@ -33,15 +33,15 @@ function shouldHandleNullableValues(param) {
           return prim0 === prim1;
         }), true);
   var tmp$2;
-  tmp$2 = tPresent === null || tPresent === undefined || tPresent !== "hello" ? false : true;
+  tmp$2 = tValue === null || tValue === undefined || tValue !== "hello" ? false : true;
   Test.run([
         [
           "NullableTests.res",
           29,
           15,
-          38
+          36
         ],
-        "Should handle present"
+        "Should handle value"
       ], tmp$2, (function (prim0, prim1) {
           return prim0 === prim1;
         }), true);

test/NullableTests.res

@@ -3,13 +3,13 @@ open RescriptCore
 let shouldHandleNullableValues = () => {
   let tNull: Nullable.t<string> = %raw("null")
   let tUndefined: Nullable.t<string> = %raw("undefined")
-  let tPresent: Nullable.t<string> = %raw(`"hello"`)
+  let tValue: Nullable.t<string> = %raw(`"hello"`)
 
   Test.run(
     __POS_OF__("Should handle null"),
     switch tNull {
     | Null => true
-    | Present(_) | Undefined => false
+    | Value(_) | Undefined => false
     },
     \"==",
     true,
@@ -19,16 +19,16 @@ let shouldHandleNullableValues = () => {
     __POS_OF__("Should handle undefined"),
     switch tUndefined {
     | Undefined => true
-    | Present(_) | Null => false
+    | Value(_) | Null => false
     },
     \"==",
     true,
   )
 
   Test.run(
-    __POS_OF__("Should handle present"),
-    switch tPresent {
-    | Present("hello") => true
+    __POS_OF__("Should handle value"),
+    switch tValue {
+    | Value("hello") => true
     | _ => false
     },
     \"==",