@fable-org/fable-library-js 2.0.0-beta.3 → 2.0.0-beta.4

package/Array.d.ts

@@ -1,6 +1,6 @@
 import { int32 } from "./Int32.js";
 import { Option } from "./Option.js";
-import { IComparer, IEqualityComparer } from "./Util.js";
+import { IComparer, Nullable, IEqualityComparer } from "./Util.js";
 import { FSharpRef } from "./Types.js";
 export declare function append<T>(array1: T[], array2: T[], cons?: any): T[];
 export declare function filter<T>(predicate: ((arg0: T) => boolean), array: T[]): T[];
@@ -23,7 +23,7 @@ export declare function collect<T, U>(mapping: ((arg0: T) => U[]), array: T[], c
 export declare function where<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): $a[];
 export declare function indexOf<T>(array: T[], item_1: T, start: Option<int32>, count: Option<int32>, eq: IEqualityComparer<T>): int32;
 export declare function contains<T>(value: T, array: T[], eq: IEqualityComparer<T>): boolean;
-export declare function empty<$a>(cons: any): $a[];
+export declare function empty<$a>(cons: Nullable<any>): $a[];
 export declare function singleton<T>(value: T, cons?: any): T[];
 export declare function initialize<T>(count: int32, initializer: ((arg0: int32) => T), cons?: any): T[];
 export declare function pairwise<T>(array: T[]): [T, T][];
@@ -82,7 +82,7 @@ export declare function chunkBySize<T>(chunkSize: int32, array: T[]): T[][];
 export declare function splitAt<T>(index: int32, array: T[]): [T[], T[]];
 export declare function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), source1: T[], source2: T[]): int32;
 export declare function compareTo<T>(comparer: ((arg0: T, arg1: T) => int32), source1: T[], source2: T[]): int32;
-export declare function equalsWith<T>(equals: ((arg0: T, arg1: T) => boolean), array1: T[], array2: T[]): boolean;
+export declare function equalsWith<T>(equals: ((arg0: T, arg1: T) => boolean), source1: T[], source2: T[]): boolean;
 export declare function exactlyOne<T>(array: T[]): T;
 export declare function tryExactlyOne<T>(array: T[]): Option<T>;
 export declare function head<T>(array: T[]): T;

package/Array.js

@@ -2,7 +2,7 @@ import { Helpers_allocateArrayFromCons } from "./Native.js";
 import { setItem as setItem_1, item as item_2 } from "./Array.js";
 import { value as value_2, map as map_1, defaultArg, some } from "./Option.js";
 import { min as min_1, max as max_1 } from "./Double.js";
-import { equals as equals_1, disposeSafe, getEnumerator, copyToArray, defaultOf } from "./Util.js";
+import { disposeSafe, getEnumerator, copyToArray, defaultOf } from "./Util.js";
 import { SR_indexOutOfBounds } from "./Global.js";
 import { Operators_IsNull } from "./FSharp.Core.js";
 function indexNotFound() {
@@ -574,7 +574,7 @@ export function choose(chooser, array, cons) {
             res.push(y);
         }
     }
-    if (equals_1(cons, defaultOf())) {
+    if (cons == null) {
         return res;
     }
     else {
@@ -841,23 +841,23 @@ export function compareTo(comparer, source1, source2) {
         }
     }
 }
-export function equalsWith(equals, array1, array2) {
-    if (Operators_IsNull(array1)) {
-        if (Operators_IsNull(array2)) {
+export function equalsWith(equals, source1, source2) {
+    if (Operators_IsNull(source1)) {
+        if (Operators_IsNull(source2)) {
             return true;
         }
         else {
             return false;
         }
     }
-    else if (Operators_IsNull(array2)) {
+    else if (Operators_IsNull(source2)) {
         return false;
     }
     else {
         let i = 0;
         let result = true;
-        const length1 = array1.length | 0;
-        const length2 = array2.length | 0;
+        const length1 = source1.length | 0;
+        const length2 = source2.length | 0;
         if (length1 > length2) {
             return false;
         }
@@ -866,7 +866,7 @@ export function equalsWith(equals, array1, array2) {
         }
         else {
             while ((i < length1) && result) {
-                result = equals(item_2(i, array1), item_2(i, array2));
+                result = equals(item_2(i, source1), item_2(i, source2));
                 i = ((i + 1) | 0);
             }
             return result;

package/BitConverter.d.ts

@@ -2,16 +2,16 @@ import { uint8, int16, uint16, int32, uint32, float32, float64 } from "./Int32.j
 import { int64, uint64 } from "./BigInt.js";
 import { char } from "./Char.js";
 export declare function isLittleEndian(): boolean;
-export declare function getBytesBoolean(value: boolean): Uint8Array;
-export declare function getBytesChar(value: char): Uint8Array;
-export declare function getBytesInt16(value: int16): Uint8Array;
-export declare function getBytesInt32(value: int32): Uint8Array;
-export declare function getBytesInt64(value: int64): Uint8Array;
-export declare function getBytesUInt16(value: uint16): Uint8Array;
-export declare function getBytesUInt32(value: uint32): Uint8Array;
-export declare function getBytesUInt64(value: uint64): Uint8Array;
-export declare function getBytesSingle(value: float32): Uint8Array;
-export declare function getBytesDouble(value: float64): Uint8Array;
+export declare function getBytesBoolean(value: boolean): Uint8Array<ArrayBuffer>;
+export declare function getBytesChar(value: char): Uint8Array<ArrayBuffer>;
+export declare function getBytesInt16(value: int16): Uint8Array<ArrayBuffer>;
+export declare function getBytesInt32(value: int32): Uint8Array<ArrayBuffer>;
+export declare function getBytesInt64(value: int64): Uint8Array<ArrayBuffer>;
+export declare function getBytesUInt16(value: uint16): Uint8Array<ArrayBuffer>;
+export declare function getBytesUInt32(value: uint32): Uint8Array<ArrayBuffer>;
+export declare function getBytesUInt64(value: uint64): Uint8Array<ArrayBuffer>;
+export declare function getBytesSingle(value: float32): Uint8Array<ArrayBuffer>;
+export declare function getBytesDouble(value: float64): Uint8Array<ArrayBuffer>;
 export declare function int64BitsToDouble(value: int64): float64;
 export declare function doubleToInt64Bits(value: float64): int64;
 export declare function toBoolean(bytes: ArrayLike<uint8>, offset: int32): boolean;

package/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 2.0.0-beta.4 - 2025-07-25
+
+* [JS/TS] Initial support for Nullable Reference Types (by @ncave)
+
 ## 2.0.0-beta.3 - 2025-03-14
 
 ### Fixed

package/Encoding.d.ts

@@ -1,10 +1,10 @@
 import { uint8 } from "./Int32.js";
 declare class UTF16LE {
-    getBytes(str: string | string[], index?: number, count?: number): Uint8Array;
+    getBytes(str: string | string[], index?: number, count?: number): Uint8Array<ArrayBuffer>;
     getString(bytes: ArrayLike<uint8>, index?: number, count?: number): string;
 }
 declare class UTF8 {
-    getBytes(str: string | string[], index?: number, count?: number): Uint8Array;
+    getBytes(str: string | string[], index?: number, count?: number): Uint8Array<ArrayBuffer>;
     getString(bytes: ArrayLike<uint8>, index?: number, count?: number): string;
 }
 export declare function get_Unicode(): UTF16LE;

package/FSharp.Collections.d.ts

@@ -1,7 +1,7 @@
+import { IComparer, IEqualityComparer, Nullable } from "./Util.js";
 import { int32 } from "./Int32.js";
-import { IComparer, IEqualityComparer } from "./Util.js";
-export declare function HashIdentity_FromFunctions<T>(hash: ((arg0: T) => int32), eq: ((arg0: T, arg1: T) => boolean)): IEqualityComparer<T>;
+export declare function HashIdentity_FromFunctions<T>(hash: ((arg0: T) => int32), eq: ((arg0: Nullable<T>, arg1: Nullable<T>) => boolean)): IEqualityComparer<T>;
 export declare function HashIdentity_Structural<T>(): IEqualityComparer<T>;
 export declare function HashIdentity_Reference<T>(): IEqualityComparer<T>;
-export declare function ComparisonIdentity_FromFunction<T>(comparer: ((arg0: T, arg1: T) => int32)): IComparer<T>;
+export declare function ComparisonIdentity_FromFunction<T>(comparer: ((arg0: Nullable<T>, arg1: Nullable<T>) => int32)): IComparer<T>;
 export declare function ComparisonIdentity_Structural<T>(): IComparer<T>;

package/FSharp.Collections.js

@@ -1,4 +1,4 @@
-import { compare, physicalHash, equals, structuralHash } from "./Util.js";
+import { compare, physicalHash, nullableEquals, structuralHash } from "./Util.js";
 export function HashIdentity_FromFunctions(hash, eq) {
     return {
         Equals(x, y) {
@@ -10,10 +10,10 @@ export function HashIdentity_FromFunctions(hash, eq) {
     };
 }
 export function HashIdentity_Structural() {
-    return HashIdentity_FromFunctions((obj) => (structuralHash(obj) | 0), equals);
+    return HashIdentity_FromFunctions((obj) => (structuralHash(obj) | 0), nullableEquals);
 }
 export function HashIdentity_Reference() {
-    return HashIdentity_FromFunctions((obj) => (physicalHash(obj) | 0), (e, e_1) => (e === e_1));
+    return HashIdentity_FromFunctions((obj) => (physicalHash(obj) | 0), nullableEquals);
 }
 export function ComparisonIdentity_FromFunction(comparer) {
     return {

package/FSharp.Core.d.ts

@@ -1,7 +1,6 @@
-import { IDisposable, IEqualityComparer, IComparer } from "./Util.js";
-import { Nullable, Option } from "./Option.js";
+import { IDisposable, IEqualityComparer, IComparer, Nullable } from "./Util.js";
+import { Option } from "./Option.js";
 import { FSharpChoice$2_$union } from "./Choice.js";
-import { StringBuilder } from "./System.Text.js";
 export declare const LanguagePrimitives_GenericEqualityComparer: any;
 export declare const LanguagePrimitives_GenericEqualityERComparer: any;
 export declare function LanguagePrimitives_FastGenericComparer<T>(): IComparer<T>;
@@ -16,16 +15,16 @@ export declare function Operators_Lock<$a, $b>(_lockObj: $a, action: (() => $b))
 export declare function Operators_IsNull<T>(value: T): boolean;
 export declare function Operators_IsNotNull<T>(value: T): boolean;
 export declare function Operators_IsNullV<T extends any>(value: Nullable<T>): boolean;
-export declare function Operators_NonNull<T>(value: T): T;
+export declare function Operators_NonNull<T>(value: Nullable<T>): T;
 export declare function Operators_NonNullV<T extends any>(value: Nullable<T>): T;
-export declare function Operators_NullMatchPattern<T>(value: T): FSharpChoice$2_$union<void, T>;
+export declare function Operators_NullMatchPattern<T>(value: Nullable<T>): FSharpChoice$2_$union<void, T>;
 export declare function Operators_NullValueMatchPattern<T extends any>(value: Nullable<T>): FSharpChoice$2_$union<void, T>;
-export declare function Operators_NonNullQuickPattern<T>(value: T): T;
+export declare function Operators_NonNullQuickPattern<T>(value: Nullable<T>): T;
 export declare function Operators_NonNullQuickValuePattern<T extends any>(value: Nullable<T>): T;
 export declare function Operators_WithNull<T>(value: T): T;
 export declare function Operators_WithNullV<T extends any>(value: T): T;
 export declare function Operators_NullV<T extends any>(): Nullable<T>;
-export declare function Operators_NullArgCheck<T>(argumentName: string, value: T): T;
+export declare function Operators_NullArgCheck<T>(argumentName: string, value: Nullable<T>): T;
 export declare function ExtraTopLevelOperators_LazyPattern<$a>(input: any): $a;
-export declare function PrintfModule_PrintFormatToStringBuilderThen<$a, $b>(continuation: (() => $a), builder: StringBuilder, format: any): $b;
-export declare function PrintfModule_PrintFormatToStringBuilder<$a>(builder: StringBuilder, format: any): $a;
+export declare function PrintfModule_PrintFormatToStringBuilderThen<$a, $b>(continuation: (() => $a), builder: any, format: any): $b;
+export declare function PrintfModule_PrintFormatToStringBuilder<$a>(builder: any, format: any): $a;

package/FSharp.Core.js

@@ -1,12 +1,12 @@
-import { disposeSafe, defaultOf, structuralHash, equals } from "./Util.js";
+import { disposeSafe, structuralHash, nullableEquals } from "./Util.js";
 import { HashIdentity_Structural, ComparisonIdentity_Structural } from "./FSharp.Collections.js";
-import { value as value_1 } from "./Option.js";
+import { nonNullValue } from "./Option.js";
 import { FSharpChoice$2_Choice2Of2, FSharpChoice$2_Choice1Of2 } from "./Choice.js";
 import { concat } from "./String.js";
 import { StringBuilder__Append_Z721C83C5 } from "./System.Text.js";
 export const LanguagePrimitives_GenericEqualityComparer = {
     "System.Collections.IEqualityComparer.Equals541DA560"(x, y) {
-        return equals(x, y);
+        return nullableEquals(x, y);
     },
     "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1) {
         return structuralHash(x_1) | 0;
@@ -14,7 +14,7 @@ export const LanguagePrimitives_GenericEqualityComparer = {
 };
 export const LanguagePrimitives_GenericEqualityERComparer = {
     "System.Collections.IEqualityComparer.Equals541DA560"(x, y) {
-        return equals(x, y);
+        return nullableEquals(x, y);
     },
     "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1) {
         return structuralHash(x_1) | 0;
@@ -46,7 +46,7 @@ export function Operators_Using(resource, action) {
         return action(resource);
     }
     finally {
-        if (equals(resource, defaultOf())) {
+        if (resource == null) {
         }
         else {
             let copyOfStruct = resource;
@@ -58,7 +58,7 @@ export function Operators_Lock(_lockObj, action) {
     return action();
 }
 export function Operators_IsNull(value) {
-    if (equals(value, defaultOf())) {
+    if (value == null) {
         return true;
     }
     else {
@@ -66,7 +66,7 @@ export function Operators_IsNull(value) {
     }
 }
 export function Operators_IsNotNull(value) {
-    if (equals(value, defaultOf())) {
+    if (value == null) {
         return false;
     }
     else {
@@ -77,7 +77,7 @@ export function Operators_IsNullV(value) {
     return !(value != null);
 }
 export function Operators_NonNull(value) {
-    if (equals(value, defaultOf())) {
+    if (value == null) {
         throw new Error();
     }
     else {
@@ -86,14 +86,14 @@ export function Operators_NonNull(value) {
 }
 export function Operators_NonNullV(value) {
     if (value != null) {
-        return value_1(value);
+        return nonNullValue(value);
     }
     else {
         throw new Error();
     }
 }
 export function Operators_NullMatchPattern(value) {
-    if (equals(value, defaultOf())) {
+    if (value == null) {
         return FSharpChoice$2_Choice1Of2(undefined);
     }
     else {
@@ -102,14 +102,14 @@ export function Operators_NullMatchPattern(value) {
 }
 export function Operators_NullValueMatchPattern(value) {
     if (value != null) {
-        return FSharpChoice$2_Choice2Of2(value_1(value));
+        return FSharpChoice$2_Choice2Of2(nonNullValue(value));
     }
     else {
         return FSharpChoice$2_Choice1Of2(undefined);
     }
 }
 export function Operators_NonNullQuickPattern(value) {
-    if (equals(value, defaultOf())) {
+    if (value == null) {
         throw new Error();
     }
     else {
@@ -118,7 +118,7 @@ export function Operators_NonNullQuickPattern(value) {
 }
 export function Operators_NonNullQuickValuePattern(value) {
     if (value != null) {
-        return value_1(value);
+        return nonNullValue(value);
     }
     else {
         throw new Error();
@@ -131,10 +131,10 @@ export function Operators_WithNullV(value) {
     return value;
 }
 export function Operators_NullV() {
-    return defaultOf();
+    return null;
 }
 export function Operators_NullArgCheck(argumentName, value) {
-    if (equals(value, defaultOf())) {
+    if (value == null) {
         throw new Error(concat("Value cannot be null. (Parameter \'", argumentName, ..."\')"));
     }
     else {

package/List.d.ts

@@ -1,5 +1,5 @@
 import { Option } from "./Option.js";
-import { IComparer, IEqualityComparer, IDisposable, IEnumerator } from "./Util.js";
+import { IComparer, IEqualityComparer, IDisposable, IEnumerator, Nullable } from "./Util.js";
 import { int32 } from "./Int32.js";
 import { Record } from "./Types.js";
 import { TypeInfo } from "./Reflection.js";
@@ -8,10 +8,10 @@ export declare class FSharpList<T> extends Record implements Iterable<T> {
     tail: Option<FSharpList<T>>;
     constructor(head: T, tail: Option<FSharpList<T>>);
     toString(): string;
-    Equals(other: any): boolean;
+    Equals(other: Nullable<any>): boolean;
     GetHashCode(): int32;
     toJSON(): any;
-    CompareTo(other: any): int32;
+    CompareTo(other: Nullable<any>): int32;
     GetEnumerator(): IEnumerator<T>;
     [Symbol.iterator](): Iterator<T>;
     "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
@@ -23,7 +23,7 @@ export declare class ListEnumerator$1<T> implements IEnumerator<T>, IDisposable
     current: T;
     constructor(xs: FSharpList<T>);
     "System.Collections.Generic.IEnumerator`1.get_Current"(): T;
-    "System.Collections.IEnumerator.get_Current"(): any;
+    "System.Collections.IEnumerator.get_Current"(): Nullable<any>;
     "System.Collections.IEnumerator.MoveNext"(): boolean;
     "System.Collections.IEnumerator.Reset"(): void;
     Dispose(): void;

package/List.js

@@ -20,7 +20,8 @@ export class FSharpList extends Record {
         if (xs === other) {
             return true;
         }
-        else {
+        else if (other instanceof FSharpList) {
+            const ys = other;
             const loop = (xs_1_mut, ys_1_mut) => {
                 loop: while (true) {
                     const xs_1 = xs_1_mut, ys_1 = ys_1_mut;
@@ -52,7 +53,10 @@ export class FSharpList extends Record {
                     break;
                 }
             };
-            return loop(xs, other);
+            return loop(xs, ys);
+        }
+        else {
+            return false;
         }
     }
     GetHashCode() {
@@ -87,39 +91,45 @@ export class FSharpList extends Record {
     }
     CompareTo(other) {
         const xs = this;
-        const loop = (xs_1_mut, ys_1_mut) => {
-            loop: while (true) {
-                const xs_1 = xs_1_mut, ys_1 = ys_1_mut;
-                const matchValue = xs_1.tail;
-                const matchValue_1 = ys_1.tail;
-                if (matchValue != null) {
-                    if (matchValue_1 != null) {
-                        const xt = value_1(matchValue);
-                        const yt = value_1(matchValue_1);
-                        const c = compare(xs_1.head, ys_1.head) | 0;
-                        if (c === 0) {
-                            xs_1_mut = xt;
-                            ys_1_mut = yt;
-                            continue loop;
+        if (other instanceof FSharpList) {
+            const ys = other;
+            const loop = (xs_1_mut, ys_1_mut) => {
+                loop: while (true) {
+                    const xs_1 = xs_1_mut, ys_1 = ys_1_mut;
+                    const matchValue = xs_1.tail;
+                    const matchValue_1 = ys_1.tail;
+                    if (matchValue != null) {
+                        if (matchValue_1 != null) {
+                            const xt = value_1(matchValue);
+                            const yt = value_1(matchValue_1);
+                            const c = compare(xs_1.head, ys_1.head) | 0;
+                            if (c === 0) {
+                                xs_1_mut = xt;
+                                ys_1_mut = yt;
+                                continue loop;
+                            }
+                            else {
+                                return c | 0;
+                            }
                         }
                         else {
-                            return c | 0;
+                            return 1;
                         }
                     }
+                    else if (matchValue_1 != null) {
+                        return -1;
+                    }
                     else {
-                        return 1;
+                        return 0;
                     }
+                    break;
                 }
-                else if (matchValue_1 != null) {
-                    return -1;
-                }
-                else {
-                    return 0;
-                }
-                break;
-            }
-        };
-        return loop(xs, other) | 0;
+            };
+            return loop(xs, ys) | 0;
+        }
+        else {
+            return 1;
+        }
     }
     GetEnumerator() {
         const xs = this;

package/Map.d.ts

@@ -1,7 +1,7 @@
 import { TypeInfo } from "./Reflection.js";
 import { Option } from "./Option.js";
 import { int32 } from "./Int32.js";
-import { IMap, IEnumerator, IComparer } from "./Util.js";
+import { IMap, IEnumerator, IComparer, Nullable } from "./Util.js";
 import { FSharpList } from "./List.js";
 import { FSharpRef, Record } from "./Types.js";
 export declare class MapTreeLeaf$2<Key, Value> {
@@ -39,9 +39,9 @@ export declare function MapTreeModule_filter1<Key, $a>(comparer: IComparer<Key>,
 export declare function MapTreeModule_filterAux<Key, Value>(comparer_mut: IComparer<Key>, f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>, acc_mut: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
 export declare function MapTreeModule_filter<Key, $a>(comparer: IComparer<Key>, f: ((arg0: Key, arg1: $a) => boolean), m: Option<MapTreeLeaf$2<Key, $a>>): Option<MapTreeLeaf$2<Key, $a>>;
 export declare function MapTreeModule_spliceOutSuccessor<Key, Value>(m: Option<MapTreeLeaf$2<Key, Value>>): [Key, Value, Option<MapTreeLeaf$2<Key, Value>>];
-export declare function MapTreeModule_remove<Key, Value>(comparer: IComparer<Key>, k: Key, m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
+export declare function MapTreeModule_remove<Key, Value>(comparer: IComparer<Key>, k: Nullable<Key>, m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
 export declare function MapTreeModule_change<Key, Value>(comparer: IComparer<Key>, k: Key, u: ((arg0: Option<Value>) => Option<Value>), m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_mem<Key, Value>(comparer_mut: IComparer<Key>, k_mut: Key, m_mut: Option<MapTreeLeaf$2<Key, Value>>): boolean;
+export declare function MapTreeModule_mem<Key, Value>(comparer_mut: IComparer<Key>, k_mut: Nullable<Key>, m_mut: Option<MapTreeLeaf$2<Key, Value>>): boolean;
 export declare function MapTreeModule_iterOpt<Key, Value>(f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>): void;
 export declare function MapTreeModule_iter<$a, $b>(f: ((arg0: $a, arg1: $b) => void), m: Option<MapTreeLeaf$2<$a, $b>>): void;
 export declare function MapTreeModule_tryPickOpt<Key, Value, $a>(f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>): Option<$a>;
@@ -57,8 +57,8 @@ export declare function MapTreeModule_foldBackOpt<Key, Value, $a>(f_mut: any, m_
 export declare function MapTreeModule_foldBack<$a, $b, $c>(f: ((arg0: $a, arg1: $b, arg2: $c) => $c), m: Option<MapTreeLeaf$2<$a, $b>>, x: $c): $c;
 export declare function MapTreeModule_foldOpt<$a, Key, Value>(f_mut: any, x_mut: $a, m_mut: Option<MapTreeLeaf$2<Key, Value>>): $a;
 export declare function MapTreeModule_fold<$a, $b, $c>(f: ((arg0: $a, arg1: $b, arg2: $c) => $a), x: $a, m: Option<MapTreeLeaf$2<$b, $c>>): $a;
-export declare function MapTreeModule_foldSectionOpt<Key, Value, a>(comparer: IComparer<Key>, lo: Key, hi: Key, f: any, m: Option<MapTreeLeaf$2<Key, Value>>, x: a): a;
-export declare function MapTreeModule_foldSection<Key, $a, $b>(comparer: IComparer<Key>, lo: Key, hi: Key, f: ((arg0: Key, arg1: $a, arg2: $b) => $b), m: Option<MapTreeLeaf$2<Key, $a>>, x: $b): $b;
+export declare function MapTreeModule_foldSectionOpt<Key, Value, a>(comparer: IComparer<Key>, lo: Nullable<Key>, hi: Nullable<Key>, f: any, m: Option<MapTreeLeaf$2<Key, Value>>, x: a): a;
+export declare function MapTreeModule_foldSection<$a, $b, $c>(comparer: IComparer<$a>, lo: Nullable<$a>, hi: Nullable<$a>, f: ((arg0: $a, arg1: $b, arg2: $c) => $c), m: Option<MapTreeLeaf$2<$a, $b>>, x: $c): $c;
 export declare function MapTreeModule_toList<Key, Value>(m: Option<MapTreeLeaf$2<Key, Value>>): FSharpList<[Key, Value]>;
 export declare function MapTreeModule_copyToArray<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>, arr: [$a, $b][], i: int32): void;
 export declare function MapTreeModule_toArray<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>): [$a, $b][];
@@ -87,14 +87,14 @@ export declare class FSharpMap<Key, Value> implements IMap<Key, Value>, Iterable
     readonly comparer: IComparer<Key>;
     constructor(comparer: IComparer<Key>, tree: Option<MapTreeLeaf$2<Key, Value>>);
     GetHashCode(): int32;
-    Equals(that: any): boolean;
+    Equals(other: Nullable<any>): boolean;
     toString(): string;
     get [Symbol.toStringTag](): string;
     toJSON(): any;
     GetEnumerator(): IEnumerator<[Key, Value]>;
     [Symbol.iterator](): Iterator<[Key, Value]>;
     "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-    CompareTo(obj: any): int32;
+    CompareTo(other: Nullable<any>): int32;
     "System.Collections.Generic.ICollection`1.Add2B595"(x: [Key, Value]): void;
     "System.Collections.Generic.ICollection`1.Clear"(): void;
     "System.Collections.Generic.ICollection`1.Remove2B595"(x: [Key, Value]): boolean;
@@ -128,14 +128,14 @@ export declare function FSharpMap__Exists<Key, Value>(m: FSharpMap<Key, Value>,
 export declare function FSharpMap__Filter<Key, Value>(m: FSharpMap<Key, Value>, predicate: ((arg0: Key, arg1: Value) => boolean)): FSharpMap<Key, Value>;
 export declare function FSharpMap__ForAll<Key, Value>(m: FSharpMap<Key, Value>, predicate: ((arg0: Key, arg1: Value) => boolean)): boolean;
 export declare function FSharpMap__Fold<Key, Value, $a>(m: FSharpMap<Key, Value>, f: ((arg0: Key, arg1: Value, arg2: $a) => $a), acc: $a): $a;
-export declare function FSharpMap__FoldSection<Key, Value, z>(m: FSharpMap<Key, Value>, lo: Key, hi: Key, f: ((arg0: Key, arg1: Value, arg2: z) => z), acc: z): z;
+export declare function FSharpMap__FoldSection<Key, Value, $a>(m: FSharpMap<Key, Value>, lo: Nullable<Key>, hi: Nullable<Key>, f: ((arg0: Key, arg1: Value, arg2: $a) => $a), acc: $a): $a;
 export declare function FSharpMap__Iterate<Key, Value>(m: FSharpMap<Key, Value>, f: ((arg0: Key, arg1: Value) => void)): void;
 export declare function FSharpMap__MapRange<Key, Value, Result>(m: FSharpMap<Key, Value>, f: ((arg0: Value) => Result)): FSharpMap<Key, Result>;
 export declare function FSharpMap__Map<Key, Value, b>(m: FSharpMap<Key, Value>, f: ((arg0: Key, arg1: Value) => b)): FSharpMap<Key, b>;
 export declare function FSharpMap__Partition<Key, Value>(m: FSharpMap<Key, Value>, predicate: ((arg0: Key, arg1: Value) => boolean)): [FSharpMap<Key, Value>, FSharpMap<Key, Value>];
 export declare function FSharpMap__get_Count<Key, Value>(m: FSharpMap<Key, Value>): int32;
-export declare function FSharpMap__ContainsKey<Key, Value>(m: FSharpMap<Key, Value>, key: Key): boolean;
-export declare function FSharpMap__Remove<Key, Value>(m: FSharpMap<Key, Value>, key: Key): FSharpMap<Key, Value>;
+export declare function FSharpMap__ContainsKey<Key, Value>(m: FSharpMap<Key, Value>, key: Nullable<Key>): boolean;
+export declare function FSharpMap__Remove<Key, Value>(m: FSharpMap<Key, Value>, key: Nullable<Key>): FSharpMap<Key, Value>;
 export declare function FSharpMap__TryGetValue<Key, Value>(_: FSharpMap<Key, Value>, key: Key, value: FSharpRef<Value>): boolean;
 export declare function FSharpMap__get_Keys<Key, Value>(_: FSharpMap<Key, Value>): Iterable<Key>;
 export declare function FSharpMap__get_Values<Key, Value>(_: FSharpMap<Key, Value>): Iterable<Value>;
@@ -150,8 +150,8 @@ export declare function add<$a, $b>(key: $a, value: $b, table: FSharpMap<$a, $b>
 export declare function change<$a, $b>(key: $a, f: ((arg0: Option<$b>) => Option<$b>), table: FSharpMap<$a, $b>): FSharpMap<$a, $b>;
 export declare function find<$a, $b>(key: $a, table: FSharpMap<$a, $b>): $b;
 export declare function tryFind<$a, $b>(key: $a, table: FSharpMap<$a, $b>): Option<$b>;
-export declare function remove<$a, $b>(key: $a, table: FSharpMap<$a, $b>): FSharpMap<$a, $b>;
-export declare function containsKey<$a, $b>(key: $a, table: FSharpMap<$a, $b>): boolean;
+export declare function remove<$a, $b>(key: Nullable<$a>, table: FSharpMap<$a, $b>): FSharpMap<$a, $b>;
+export declare function containsKey<$a, $b>(key: Nullable<$a>, table: FSharpMap<$a, $b>): boolean;
 export declare function iterate<$a, $b>(action: ((arg0: $a, arg1: $b) => void), table: FSharpMap<$a, $b>): void;
 export declare function tryPick<$a, $b, $c>(chooser: ((arg0: $a, arg1: $b) => Option<$c>), table: FSharpMap<$a, $b>): Option<$c>;
 export declare function pick<$a, $b, $c>(chooser: ((arg0: $a, arg1: $b) => Option<$c>), table: FSharpMap<$a, $b>): $c;

package/Map.js

@@ -1015,13 +1015,13 @@ export class FSharpMap {
         const this$ = this;
         return FSharpMap__ComputeHashCode(this$) | 0;
     }
-    Equals(that) {
+    Equals(other) {
         const this$ = this;
-        if (that instanceof FSharpMap) {
-            const that_1 = that;
+        if (other instanceof FSharpMap) {
+            const that = other;
             const e1 = getEnumerator(this$);
             try {
-                const e2 = getEnumerator(that_1);
+                const e2 = getEnumerator(that);
                 try {
                     const loop = () => {
                         const m1 = e1["System.Collections.IEnumerator.MoveNext"]();
@@ -1080,18 +1080,13 @@ export class FSharpMap {
         const _ = this;
         return MapTreeModule_mkIEnumerator(_.tree);
     }
-    CompareTo(obj) {
-        const m = this;
-        if (obj instanceof FSharpMap) {
-            const m2 = obj;
-            return compareWith((kvp1, kvp2) => {
-                const c = m.comparer.Compare(kvp1[0], kvp2[0]) | 0;
-                return ((c !== 0) ? c : compare(kvp1[1], kvp2[1])) | 0;
-            }, m, m2) | 0;
-        }
-        else {
-            throw new Error("not comparable\\nParameter name: obj");
-        }
+    CompareTo(other) {
+        let that;
+        const this$ = this;
+        return ((other instanceof FSharpMap) ? ((that = other, compareWith((kvp1, kvp2) => {
+            const c = this$.comparer.Compare(kvp1[0], kvp2[0]) | 0;
+            return ((c !== 0) ? c : compare(kvp1[1], kvp2[1])) | 0;
+        }, this$, that))) : 1) | 0;
     }
     "System.Collections.Generic.ICollection`1.Add2B595"(x) {
         throw new Error("Map cannot be mutated");

package/Native.d.ts

@@ -1,2 +1,3 @@
+import { Nullable } from "./Util.js";
 import { int32 } from "./Int32.js";
-export declare function Helpers_allocateArrayFromCons<T>(cons: any, len: int32): T[];
+export declare function Helpers_allocateArrayFromCons<T>(cons: Nullable<any>, len: int32): T[];

package/Native.js

@@ -1,8 +1,14 @@
 export function Helpers_allocateArrayFromCons(cons, len) {
-    if ((typeof cons) === "function") {
-        return new cons(len);
+    if (cons == null) {
+        return new Array(len);
     }
     else {
-        return new Array(len);
+        const cons_1 = cons;
+        if ((typeof cons_1) === "function") {
+            return new cons_1(len);
+        }
+        else {
+            return new Array(len);
+        }
     }
 }

package/Option.d.ts

@@ -1,4 +1,4 @@
-export type Nullable<T> = T | null | undefined;
+import { Nullable } from "./Util.js";
 export type Option<T> = T | Some<T> | undefined;
 export declare class Some<T> {
     value: T;
@@ -9,6 +9,7 @@ export declare class Some<T> {
     Equals(other: Option<T>): boolean;
     CompareTo(other: Option<T>): number;
 }
+export declare function nonNullValue<T>(x: Nullable<T>): T;
 export declare function value<T>(x: Option<T>): T;
 export declare function unwrap<T>(opt: Option<T>): T | undefined;
 export declare function some<T>(x: T): Option<T>;

package/Option.js

@@ -31,6 +31,14 @@ export class Some {
         }
     }
 }
+export function nonNullValue(x) {
+    if (x == null) {
+        throw new Error("Nullable has no value");
+    }
+    else {
+        return x;
+    }
+}
 export function value(x) {
     if (x == null) {
         throw new Error("Option has no value");

package/Random.js

@@ -1,6 +1,6 @@
+import { Operators_IsNull } from "./FSharp.Core.js";
 import { class_type } from "./Reflection.js";
 import { fromFloat64, op_Addition, toInt32_unchecked, toFloat64, compare, fromInt32, toInt64_unchecked } from "./BigInt.js";
-import { Operators_IsNull } from "./FSharp.Core.js";
 import { item, fill, setItem } from "./Array.js";
 function Native_random() {
     return Math.random();

package/Seq.d.ts

@@ -1,4 +1,4 @@
-import { IComparer, IEqualityComparer, IDisposable, IEnumerator } from "./Util.js";
+import { IComparer, IEqualityComparer, Nullable, IDisposable, IEnumerator } from "./Util.js";
 import { TypeInfo } from "./Reflection.js";
 import { Option } from "./Option.js";
 import { FSharpList } from "./List.js";
@@ -29,7 +29,7 @@ export declare class Enumerator_FromFunctions$1<T> implements IEnumerator<T>, ID
     readonly current: (() => T);
     constructor(current: (() => T), next: (() => boolean), dispose: (() => void));
     "System.Collections.Generic.IEnumerator`1.get_Current"(): T;
-    "System.Collections.IEnumerator.get_Current"(): any;
+    "System.Collections.IEnumerator.get_Current"(): Nullable<any>;
     "System.Collections.IEnumerator.MoveNext"(): boolean;
     "System.Collections.IEnumerator.Reset"(): void;
     Dispose(): void;
@@ -42,7 +42,6 @@ export declare function Enumerator_enumerateThenFinally<T>(f: (() => void), e: I
 export declare function Enumerator_generateWhileSome<T, U>(openf: (() => T), compute: ((arg0: T) => Option<U>), closef: ((arg0: T) => void)): IEnumerator<U>;
 export declare function Enumerator_unfold<State, T>(f: ((arg0: State) => Option<[T, State]>), state: State): IEnumerator<T>;
 export declare function indexNotFound<$a>(): $a;
-export declare function checkNonNull<$a>(argName: string, arg: $a): void;
 export declare function mkSeq<T>(f: (() => IEnumerator<T>)): Iterable<T>;
 export declare function ofSeq<T>(xs: Iterable<T>): IEnumerator<T>;
 export declare function delay<T>(generator: (() => Iterable<T>)): Iterable<T>;

package/Seq.js

@@ -1,8 +1,8 @@
-import { clear, defaultOf, equals, isDisposable, isArrayLike, toIterator, disposeSafe, getEnumerator } from "./Util.js";
+import { clear, isDisposable, isArrayLike, toIterator, disposeSafe, getEnumerator } from "./Util.js";
 import { toString } from "./Types.js";
 import { class_type } from "./Reflection.js";
 import { some, value as value_1 } from "./Option.js";
-import { Operators_Lock, Operators_NullArg, Operators_IsNull } from "./FSharp.Core.js";
+import { Operators_Lock, Operators_NullArgCheck } from "./FSharp.Core.js";
 import { chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, map as map_1, windowed as windowed_1, splitInto as splitInto_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, tryItem as tryItem_1, tryHead as tryHead_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from "./Array.js";
 import { length as length_1, tryItem as tryItem_2, isEmpty as isEmpty_1, tryHead as tryHead_2, ofSeq as ofSeq_1, ofArray as ofArray_1, toArray as toArray_1, FSharpList } from "./List.js";
 import { SR_indexOutOfBounds } from "./Global.js";
@@ -296,17 +296,11 @@ export function Enumerator_unfold(f, state) {
 export function indexNotFound() {
     throw new Error(SR_keyNotFoundAlt);
 }
-export function checkNonNull(argName, arg) {
-    if (Operators_IsNull(arg)) {
-        Operators_NullArg(argName);
-    }
-}
 export function mkSeq(f) {
     return Enumerator_Seq_$ctor_673A07F2(f);
 }
 export function ofSeq(xs) {
-    checkNonNull("source", xs);
-    return getEnumerator(xs);
+    return getEnumerator(Operators_NullArgCheck("source", xs));
 }
 export function delay(generator) {
     return mkSeq(() => getEnumerator(generator()));
@@ -365,10 +359,7 @@ export function append(xs, ys) {
     return concat([xs, ys]);
 }
 export function cast(xs) {
-    return mkSeq(() => {
-        checkNonNull("source", xs);
-        return Enumerator_cast(getEnumerator(xs));
-    });
+    return mkSeq(() => Enumerator_cast(getEnumerator(Operators_NullArgCheck("source", xs))));
 }
 export function choose(chooser, xs) {
     return generate(() => ofSeq(xs), (e) => {
@@ -442,7 +433,7 @@ export function enumerateThenFinally(source, compensation) {
 }
 export function enumerateUsing(resource, source) {
     const compensation = () => {
-        if (equals(resource, defaultOf())) {
+        if (resource == null) {
         }
         else {
             let copyOfStruct = resource;
@@ -899,8 +890,7 @@ export function map3(mapping, xs, ys, zs) {
     });
 }
 export function readOnly(xs) {
-    checkNonNull("source", xs);
-    return map((x) => x, xs);
+    return map((x) => x, Operators_NullArgCheck("source", xs));
 }
 export class CachedSeq$1 {
     constructor(cleanup, res) {
@@ -933,7 +923,7 @@ export function CachedSeq$1__Clear(_) {
     _.cleanup();
 }
 export function cache(source) {
-    checkNonNull("source", source);
+    const source_1 = Operators_NullArgCheck("source", source);
     const prefix = [];
     let enumeratorR = undefined;
     return CachedSeq$1_$ctor_Z7A8347D4(() => {
@@ -971,7 +961,7 @@ export function cache(source) {
                     optEnumerator_2 = value_1(enumeratorR);
                 }
                 else {
-                    const optEnumerator = getEnumerator(source);
+                    const optEnumerator = getEnumerator(source_1);
                     enumeratorR = some(optEnumerator);
                     optEnumerator_2 = optEnumerator;
                 }

package/Set.d.ts

@@ -1,7 +1,7 @@
 import { TypeInfo } from "./Reflection.js";
 import { Option } from "./Option.js";
 import { int32 } from "./Int32.js";
-import { ISet, IEnumerator, IComparer } from "./Util.js";
+import { ISet, IEnumerator, IComparer, Nullable } from "./Util.js";
 import { Record } from "./Types.js";
 import { FSharpList } from "./List.js";
 export declare class SetTreeLeaf$1<T> {
@@ -29,10 +29,10 @@ export declare function SetTreeModule_mk<T>(l: Option<SetTreeLeaf$1<T>>, k: T, r
 export declare function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t2: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
 export declare function SetTreeModule_add<T>(comparer: IComparer<T>, k: T, t: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
 export declare function SetTreeModule_balance<T>(comparer: IComparer<T>, t1: Option<SetTreeLeaf$1<T>>, k: T, t2: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_split<T>(comparer: IComparer<T>, pivot: T, t: Option<SetTreeLeaf$1<T>>): [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>];
+export declare function SetTreeModule_split<T>(comparer: IComparer<T>, pivot: Nullable<T>, t: Option<SetTreeLeaf$1<T>>): [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>];
 export declare function SetTreeModule_spliceOutSuccessor<T>(t: Option<SetTreeLeaf$1<T>>): [T, Option<SetTreeLeaf$1<T>>];
-export declare function SetTreeModule_remove<T>(comparer: IComparer<T>, k: T, t: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_mem<T>(comparer_mut: IComparer<T>, k_mut: T, t_mut: Option<SetTreeLeaf$1<T>>): boolean;
+export declare function SetTreeModule_remove<T>(comparer: IComparer<T>, k: Nullable<T>, t: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
+export declare function SetTreeModule_mem<T>(comparer_mut: IComparer<T>, k_mut: Nullable<T>, t_mut: Option<SetTreeLeaf$1<T>>): boolean;
 export declare function SetTreeModule_iter<T>(f_mut: ((arg0: T) => void), t_mut: Option<SetTreeLeaf$1<T>>): void;
 export declare function SetTreeModule_foldBackOpt<T, $a>(f_mut: any, t_mut: Option<SetTreeLeaf$1<T>>, x_mut: $a): $a;
 export declare function SetTreeModule_foldBack<$a, $b>(f: ((arg0: $a, arg1: $b) => $b), m: Option<SetTreeLeaf$1<$a>>, x: $b): $b;
@@ -41,7 +41,7 @@ export declare function SetTreeModule_fold<$a, $b>(f: ((arg0: $a, arg1: $b) => $
 export declare function SetTreeModule_forall<T>(f_mut: ((arg0: T) => boolean), t_mut: Option<SetTreeLeaf$1<T>>): boolean;
 export declare function SetTreeModule_exists<T>(f_mut: ((arg0: T) => boolean), t_mut: Option<SetTreeLeaf$1<T>>): boolean;
 export declare function SetTreeModule_subset<$a>(comparer: IComparer<$a>, a: Option<SetTreeLeaf$1<$a>>, b: Option<SetTreeLeaf$1<$a>>): boolean;
-export declare function SetTreeModule_properSubset<$a>(comparer: IComparer<$a>, a: Option<SetTreeLeaf$1<$a>>, b: Option<SetTreeLeaf$1<$a>>): boolean;
+export declare function SetTreeModule_properSubset<T>(comparer: IComparer<T>, a: Option<SetTreeLeaf$1<T>>, b: Option<SetTreeLeaf$1<T>>): boolean;
 export declare function SetTreeModule_filterAux<T>(comparer_mut: IComparer<T>, f_mut: ((arg0: T) => boolean), t_mut: Option<SetTreeLeaf$1<T>>, acc_mut: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
 export declare function SetTreeModule_filter<$a>(comparer: IComparer<$a>, f: ((arg0: $a) => boolean), s: Option<SetTreeLeaf$1<$a>>): Option<SetTreeLeaf$1<$a>>;
 export declare function SetTreeModule_diffAux<T>(comparer_mut: IComparer<T>, t_mut: Option<SetTreeLeaf$1<T>>, acc_mut: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
@@ -89,11 +89,11 @@ export declare class FSharpSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
     readonly comparer: IComparer<T>;
     constructor(comparer: IComparer<T>, tree: Option<SetTreeLeaf$1<T>>);
     GetHashCode(): int32;
-    Equals(that: any): boolean;
+    Equals(other: Nullable<any>): boolean;
     toString(): string;
     get [Symbol.toStringTag](): string;
     toJSON(): any;
-    CompareTo(that: any): int32;
+    CompareTo(other: Nullable<any>): int32;
     "System.Collections.Generic.ICollection`1.Add2B595"(x: T): void;
     "System.Collections.Generic.ICollection`1.Clear"(): void;
     "System.Collections.Generic.ICollection`1.Remove2B595"(x: T): boolean;
@@ -121,9 +121,9 @@ export declare function FSharpSet__get_Comparer<T>(set$: FSharpSet<T>): ICompare
 export declare function FSharpSet__get_Tree<T>(set$: FSharpSet<T>): Option<SetTreeLeaf$1<T>>;
 export declare function FSharpSet_Empty<T>(comparer: IComparer<T>): FSharpSet<T>;
 export declare function FSharpSet__Add<T>(s: FSharpSet<T>, value: T): FSharpSet<T>;
-export declare function FSharpSet__Remove<T>(s: FSharpSet<T>, value: T): FSharpSet<T>;
+export declare function FSharpSet__Remove<T>(s: FSharpSet<T>, value: Nullable<T>): FSharpSet<T>;
 export declare function FSharpSet__get_Count<T>(s: FSharpSet<T>): int32;
-export declare function FSharpSet__Contains<T>(s: FSharpSet<T>, value: T): boolean;
+export declare function FSharpSet__Contains<T>(s: FSharpSet<T>, value: Nullable<T>): boolean;
 export declare function FSharpSet__Iterate<T>(s: FSharpSet<T>, x: ((arg0: T) => void)): void;
 export declare function FSharpSet__Fold<T, $a>(s: FSharpSet<T>, f: ((arg0: T, arg1: $a) => $a), z: $a): $a;
 export declare function FSharpSet__get_IsEmpty<T>(s: FSharpSet<T>): boolean;
@@ -149,10 +149,10 @@ export declare function FSharpSet__ToList<T>(x: FSharpSet<T>): FSharpList<T>;
 export declare function FSharpSet__ToArray<T>(x: FSharpSet<T>): T[];
 export declare function FSharpSet__ComputeHashCode<T>(this$: FSharpSet<T>): int32;
 export declare function isEmpty<T>(set$: FSharpSet<T>): boolean;
-export declare function contains<T>(element: T, set$: FSharpSet<T>): boolean;
+export declare function contains<T>(element: Nullable<T>, set$: FSharpSet<T>): boolean;
 export declare function add<T>(value: T, set$: FSharpSet<T>): FSharpSet<T>;
 export declare function singleton<T>(value: T, comparer: IComparer<T>): FSharpSet<T>;
-export declare function remove<T>(value: T, set$: FSharpSet<T>): FSharpSet<T>;
+export declare function remove<T>(value: Nullable<T>, set$: FSharpSet<T>): FSharpSet<T>;
 export declare function union<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): FSharpSet<T>;
 export declare function unionMany<T>(sets: Iterable<FSharpSet<T>>, comparer: IComparer<T>): FSharpSet<T>;
 export declare function intersect<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): FSharpSet<T>;

package/Set.js

@@ -1,7 +1,7 @@
 import { record_type, bool_type, list_type, option_type, class_type } from "./Reflection.js";
 import { some, value as value_3 } from "./Option.js";
 import { structuralHash, toIterator, disposeSafe, getEnumerator, isArrayLike } from "./Util.js";
-import { toString, Record } from "./Types.js";
+import { Record } from "./Types.js";
 import { fold as fold_2, cons, singleton as singleton_1, empty as empty_1, ofArrayWithTail, tail, head, isEmpty as isEmpty_1, FSharpList } from "./List.js";
 import { fold as fold_1, fill, setItem } from "./Array.js";
 import { join } from "./String.js";
@@ -1394,17 +1394,14 @@ export class FSharpSet {
         const this$ = this;
         return FSharpSet__ComputeHashCode(this$) | 0;
     }
-    Equals(that) {
-        let that_1;
+    Equals(other) {
+        let that;
         const this$ = this;
-        return (that instanceof FSharpSet) && ((that_1 = that, SetTreeModule_compare(FSharpSet__get_Comparer(this$), FSharpSet__get_Tree(this$), FSharpSet__get_Tree(that_1)) === 0));
+        return (other instanceof FSharpSet) && ((that = other, SetTreeModule_compare(FSharpSet__get_Comparer(this$), FSharpSet__get_Tree(this$), FSharpSet__get_Tree(that)) === 0));
     }
     toString() {
         const this$ = this;
-        return ("set [" + join("; ", map_1((x) => {
-            let copyOfStruct = x;
-            return toString(copyOfStruct);
-        }, this$))) + "]";
+        return ("set [" + join("; ", this$)) + "]";
     }
     get [Symbol.toStringTag]() {
         return "FSharpSet";
@@ -1413,9 +1410,10 @@ export class FSharpSet {
         const this$ = this;
         return Array.from(this$);
     }
-    CompareTo(that) {
-        const s = this;
-        return SetTreeModule_compare(FSharpSet__get_Comparer(s), FSharpSet__get_Tree(s), FSharpSet__get_Tree(that)) | 0;
+    CompareTo(other) {
+        let that;
+        const this$ = this;
+        return ((other instanceof FSharpSet) ? ((that = other, SetTreeModule_compare(FSharpSet__get_Comparer(this$), FSharpSet__get_Tree(this$), FSharpSet__get_Tree(that)))) : 1) | 0;
     }
     "System.Collections.Generic.ICollection`1.Add2B595"(x) {
         throw new Error("ReadOnlyCollection");

package/System.Collections.Generic.d.ts

@@ -1,11 +1,11 @@
+import { IEnumerator, IEqualityComparer, IComparer, Nullable } from "./Util.js";
 import { int32 } from "./Int32.js";
-import { IEnumerator, IEqualityComparer, IComparer } from "./Util.js";
 import { TypeInfo } from "./Reflection.js";
 import { FSharpRef } from "./Types.js";
 export declare class Comparer$1<T> implements IComparer<T> {
     readonly comparison: ((arg0: T, arg1: T) => int32);
     constructor(comparison: ((arg0: T, arg1: T) => int32));
-    Compare(x: T, y: T): int32;
+    Compare(x: Nullable<T>, y: Nullable<T>): int32;
 }
 export declare function Comparer$1_$reflection(gen0: TypeInfo): TypeInfo;
 export declare function Comparer$1_$ctor_47C913C<T>(comparison: ((arg0: T, arg1: T) => int32)): Comparer$1<T>;
@@ -16,7 +16,7 @@ export declare class EqualityComparer$1<T> implements IEqualityComparer<T> {
     readonly getHashCode: ((arg0: T) => int32);
     readonly equals: ((arg0: T, arg1: T) => boolean);
     constructor(equals: ((arg0: T, arg1: T) => boolean), getHashCode: ((arg0: T) => int32));
-    Equals(x: T, y: T): boolean;
+    Equals(x: Nullable<T>, y: Nullable<T>): boolean;
     GetHashCode(x: T): int32;
 }
 export declare function EqualityComparer$1_$reflection(gen0: TypeInfo): TypeInfo;

package/System.Collections.Generic.js

@@ -9,7 +9,7 @@ export class Comparer$1 {
     }
     Compare(x, y) {
         const _ = this;
-        return _.comparison(x, y) | 0;
+        return ((x == null) ? ((y == null) ? 0 : -1) : ((y == null) ? 1 : _.comparison(x, y))) | 0;
     }
 }
 export function Comparer$1_$reflection(gen0) {
@@ -34,7 +34,7 @@ export class EqualityComparer$1 {
     }
     Equals(x, y) {
         const _ = this;
-        return _.equals(x, y);
+        return (x == null) ? (y == null) : ((y == null) ? false : _.equals(x, y));
     }
     GetHashCode(x) {
         const _ = this;

package/System.Text.d.ts

@@ -1,5 +1,6 @@
 import { float64, int32 } from "./Int32.js";
 import { TypeInfo } from "./Reflection.js";
+import { Nullable } from "./Util.js";
 export declare class StringBuilder {
     readonly buf: string[];
     constructor(value: string, capacity: int32);
@@ -10,8 +11,8 @@ export declare function StringBuilder_$ctor_Z18115A39(value: string, capacity: i
 export declare function StringBuilder_$ctor_Z524259A4(capacity: int32): StringBuilder;
 export declare function StringBuilder_$ctor_Z721C83C5(value: string): StringBuilder;
 export declare function StringBuilder_$ctor(): StringBuilder;
-export declare function StringBuilder__Append_Z721C83C5(x: StringBuilder, s: string): StringBuilder;
-export declare function StringBuilder__Append_487EF8FB(x: StringBuilder, s: string, startIndex: int32, count: int32): StringBuilder;
+export declare function StringBuilder__Append_Z721C83C5(x: StringBuilder, s: Nullable<string>): StringBuilder;
+export declare function StringBuilder__Append_487EF8FB(x: StringBuilder, s: Nullable<string>, startIndex: int32, count: int32): StringBuilder;
 export declare function StringBuilder__Append_244C7CD6(x: StringBuilder, c: string): StringBuilder;
 export declare function StringBuilder__Append_61B1CA(x: StringBuilder, c: string, repeatCount: int32): StringBuilder;
 export declare function StringBuilder__Append_Z524259A4(x: StringBuilder, o: int32): StringBuilder;

package/System.Text.js

@@ -1,7 +1,7 @@
 import { replace, format, replicate, substring, isNullOrEmpty, join } from "./String.js";
 import { class_type } from "./Reflection.js";
-import { clear, int32ToString } from "./Util.js";
 import { toString } from "./Types.js";
+import { clear, int32ToString } from "./Util.js";
 export class StringBuilder {
     constructor(value, capacity) {
         this.buf = [];
@@ -30,11 +30,11 @@ export function StringBuilder_$ctor() {
     return StringBuilder_$ctor_Z18115A39("", 16);
 }
 export function StringBuilder__Append_Z721C83C5(x, s) {
-    void (x.buf.push(s));
+    void (x.buf.push(toString(s)));
     return x;
 }
 export function StringBuilder__Append_487EF8FB(x, s, startIndex, count) {
-    void (x.buf.push(substring(s, startIndex, count)));
+    void (x.buf.push(substring(toString(s), startIndex, count)));
     return x;
 }
 export function StringBuilder__Append_244C7CD6(x, c) {
@@ -67,7 +67,7 @@ export function StringBuilder__Append_Z372E4D23(x, cs) {
     return x;
 }
 export function StringBuilder__Append_43A65C09(x, s) {
-    void (x.buf.push(toString(s)));
+    void (x.buf.push(s.toString()));
     return x;
 }
 export function StringBuilder__AppendFormat_433E080(x, fmt, o) {
@@ -152,7 +152,7 @@ export function StringBuilder__Replace_Z766F94C0(x, oldValue, newValue) {
     return x;
 }
 export function StringBuilder__Replace_Z384F8060(x, oldValue, newValue) {
-    const str = replace(toString(x), oldValue, newValue);
+    const str = replace(x.toString(), oldValue, newValue);
     return StringBuilder__Append_Z721C83C5(StringBuilder__Clear(x), str);
 }
 export function StringBuilder__get_Length(x) {
@@ -163,5 +163,5 @@ export function StringBuilder__get_Length(x) {
     return len | 0;
 }
 export function StringBuilder__ToString_Z37302880(x, firstIndex, length) {
-    return substring(toString(x), firstIndex, length);
+    return substring(x.toString(), firstIndex, length);
 }

package/Util.d.ts

@@ -1,3 +1,4 @@
+export type Nullable<T> = T | null | undefined;
 export declare const enum DateKind {
     Unspecified = 0,
     UTC = 1,
@@ -22,10 +23,10 @@ export interface IDisposable {
     Dispose(): void;
 }
 export interface IComparer<T> {
-    Compare(x: T, y: T): number;
+    Compare(x: Nullable<T>, y: Nullable<T>): number;
 }
 export interface IEqualityComparer<T> {
-    Equals(x: T, y: T): boolean;
+    Equals(x: Nullable<T>, y: Nullable<T>): boolean;
     GetHashCode(x: T): number;
 }
 export interface ICollection<T> extends Iterable<T> {
@@ -147,9 +148,10 @@ export declare function arrayHash<T>(x: ArrayLike<T>): number;
 export declare function structuralHash<T>(x: T): number;
 export declare function fastStructuralHash<T>(x: T): number;
 export declare function safeHash<T>(x: T): number;
-export declare function equalArraysWith<T>(x: ArrayLike<T>, y: ArrayLike<T>, eq: (x: T, y: T) => boolean): boolean;
-export declare function equalArrays<T>(x: ArrayLike<T>, y: ArrayLike<T>): boolean;
-export declare function physicalEquality<T>(x: T, y: T): boolean;
+export declare function equalArraysWith<T>(x: Nullable<ArrayLike<T>>, y: Nullable<ArrayLike<T>>, eq: (x: T, y: T) => boolean): boolean;
+export declare function equalArrays<T>(x: Nullable<ArrayLike<T>>, y: Nullable<ArrayLike<T>>): boolean;
+export declare function physicalEquals<T>(x: T, y: T): boolean;
+export declare function nullableEquals<T>(x: Nullable<T>, y: Nullable<T>): boolean;
 export declare function equals<T>(x: T, y: T): boolean;
 export declare function compareDates(x: Date | IDateTime | IDateTimeOffset, y: Date | IDateTime | IDateTimeOffset): 0 | 1 | -1;
 export declare function comparePrimitives<T>(x: T, y: T): number;

package/Util.js

@@ -333,9 +333,18 @@ function equalObjects(x, y) {
     }
     return true;
 }
-export function physicalEquality(x, y) {
+export function physicalEquals(x, y) {
     return x === y;
 }
+export function nullableEquals(x, y) {
+    if (x == null) {
+        return y == null;
+    }
+    if (y == null) {
+        return false;
+    }
+    return equals(x, y);
+}
 export function equals(x, y) {
     if (x === y) {
         return true;

package/package.json

@@ -1,24 +1,24 @@
 {
-  "sideEffects": false,
-  "private": false,
-  "type": "module",
-  "name": "@fable-org/fable-library-js",
-  "version": "2.0.0-beta.3",
-  "description": "Core library used by F# projects compiled with fable.io",
-  "author": "Fable Contributors",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/fable-compiler/Fable.git"
-  },
-  "bugs": {
-    "url": "https://github.com/fable-compiler/Fable/issues"
-  },
-  "homepage": "https://fable.io",
-  "keywords": [
-    "fable",
-    "fable-compiler",
-    "fsharp",
-    "F#"
-  ]
-}
+    "sideEffects": false,
+    "private": false,
+    "type": "module",
+    "name": "@fable-org/fable-library-js",
+    "version": "2.0.0-beta.4",
+    "description": "Core library used by F# projects compiled with fable.io",
+    "author": "Fable Contributors",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/fable-compiler/Fable.git"
+    },
+    "bugs": {
+        "url": "https://github.com/fable-compiler/Fable/issues"
+    },
+    "homepage": "https://fable.io",
+    "keywords": [
+        "fable",
+        "fable-compiler",
+        "fsharp",
+        "F#"
+    ]
+}