@fable-org/fable-library-ts 2.0.0-beta.4 → 2.0.0-beta.6

package/Set.ts

@@ -1,14 +1,15 @@
 
-import { record_type, bool_type, list_type, option_type, class_type, TypeInfo } from "./Reflection.js";
-import { some, value as value_3, Option } from "./Option.js";
-import { int32 } from "./Int32.js";
-import { structuralHash, ISet, toIterator, IDisposable, disposeSafe, getEnumerator, isArrayLike, IEnumerator, IComparer, Nullable } from "./Util.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";
-import { exists as exists_1, cache, forAll as forAll_1, fold as fold_3, reduce, iterate as iterate_1, map as map_1 } from "./Seq.js";
-import { HashSet__get_Comparer, HashSet_$ctor_Z6150332D, HashSet } from "./MutableSet.js";
+import { record_type, bool_type, list_type, option_type, class_type, TypeInfo } from "./Reflection.ts";
+import { some, value as value_3, Option } from "./Option.ts";
+import { int32 } from "./Int32.ts";
+import { structuralHash, ISet, toIterator, IDisposable, disposeSafe, getEnumerator, isArrayLike, MutableArray, IEnumerator, IComparer, Exception } from "./Util.ts";
+import { Record } from "./Types.ts";
+import { fold as fold_2, cons, singleton as singleton_1, empty as empty_1, ofArrayWithTail, tail, head, isEmpty as isEmpty_1, FSharpList } from "./List.ts";
+import { fold as fold_1, fill, setItem } from "./Array.ts";
+import { join } from "./String.ts";
+import { NotSupportedException_$ctor_Z721C83C5 } from "./System.ts";
+import { exists as exists_1, cache, forAll as forAll_1, fold as fold_3, reduce, iterate as iterate_1, map as map_1 } from "./Seq.ts";
+import { HashSet__get_Comparer, HashSet_$ctor_Z6150332D, HashSet } from "./MutableSet.ts";
 
 export class SetTreeLeaf$1<T> {
     readonly k: T;
@@ -93,7 +94,7 @@ export function SetTreeModule_count<$a>(s: Option<SetTreeLeaf$1<$a>>): int32 {
 }
 
 export function SetTreeModule_mk<T>(l: Option<SetTreeLeaf$1<T>>, k: T, r: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>> {
-    let tn: SetTreeNode$1<T>, tn_1: SetTreeNode$1<T>;
+    let tn: SetTreeNode$1<T> = (undefined as any), tn_1: SetTreeNode$1<T> = (undefined as any);
     let hl: int32;
     const t: Option<SetTreeLeaf$1<T>> = l;
     if (t != null) {
@@ -122,7 +123,7 @@ export function SetTreeModule_mk<T>(l: Option<SetTreeLeaf$1<T>>, k: T, r: Option
 }
 
 export function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t2: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>> {
-    let tn: SetTreeNode$1<T>, tn_1: SetTreeNode$1<T>, t_2: Option<SetTreeLeaf$1<T>>, t2_3: SetTreeLeaf$1<T>, tn_2: SetTreeNode$1<T>, t_3: Option<SetTreeLeaf$1<T>>, t2_4: SetTreeLeaf$1<T>, tn_3: SetTreeNode$1<T>;
+    let tn: SetTreeNode$1<T> = (undefined as any), tn_1: SetTreeNode$1<T> = (undefined as any), t_2: Option<SetTreeLeaf$1<T>> = (undefined as any), t2_3: SetTreeLeaf$1<T> = (undefined as any), tn_2: SetTreeNode$1<T> = (undefined as any), t_3: Option<SetTreeLeaf$1<T>> = (undefined as any), t2_4: SetTreeLeaf$1<T> = (undefined as any), tn_3: SetTreeNode$1<T> = (undefined as any);
     let t1h: int32;
     const t: Option<SetTreeLeaf$1<T>> = t1;
     if (t != null) {
@@ -152,7 +153,7 @@ export function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t
                     return SetTreeModule_mk<T>(SetTreeModule_mk<T>(t1, v, SetTreeNode$1__get_Left<T>(t2l)), SetTreeLeaf$1__get_Key<T>(t2l), SetTreeModule_mk<T>(SetTreeNode$1__get_Right<T>(t2l), SetTreeLeaf$1__get_Key<T>(t2$0027), SetTreeNode$1__get_Right<T>(t2$0027)));
                 }
                 else {
-                    throw new Error("internal error: Set.rebalance");
+                    throw new Exception("internal error: Set.rebalance");
                 }
             }
             else {
@@ -160,7 +161,7 @@ export function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t
             }
         }
         else {
-            throw new Error("internal error: Set.rebalance");
+            throw new Exception("internal error: Set.rebalance");
         }
     }
     else if (t1h > (t2h + 2)) {
@@ -174,7 +175,7 @@ export function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t
                     return SetTreeModule_mk<T>(SetTreeModule_mk<T>(SetTreeNode$1__get_Left<T>(t1$0027), SetTreeLeaf$1__get_Key<T>(t1$0027), SetTreeNode$1__get_Left<T>(t1r)), SetTreeLeaf$1__get_Key<T>(t1r), SetTreeModule_mk<T>(SetTreeNode$1__get_Right<T>(t1r), v, t2));
                 }
                 else {
-                    throw new Error("internal error: Set.rebalance");
+                    throw new Exception("internal error: Set.rebalance");
                 }
             }
             else {
@@ -182,7 +183,7 @@ export function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t
             }
         }
         else {
-            throw new Error("internal error: Set.rebalance");
+            throw new Exception("internal error: Set.rebalance");
         }
     }
     else {
@@ -193,7 +194,7 @@ export function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t
 export function SetTreeModule_add<T>(comparer: IComparer<T>, k: T, t: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>> {
     if (t != null) {
         const t2: SetTreeLeaf$1<T> = value_3(t);
-        const c: int32 = comparer.Compare(k, SetTreeLeaf$1__get_Key<Nullable<T>>(t2)) | 0;
+        const c: int32 = comparer.Compare(k, SetTreeLeaf$1__get_Key<T>(t2)) | 0;
         if (t2 instanceof SetTreeNode$1) {
             const tn = t2 as SetTreeNode$1<T>;
             if (c < 0) {
@@ -207,7 +208,7 @@ export function SetTreeModule_add<T>(comparer: IComparer<T>, k: T, t: Option<Set
             }
         }
         else {
-            const c_1: int32 = comparer.Compare(k, SetTreeLeaf$1__get_Key<Nullable<T>>(t2)) | 0;
+            const c_1: int32 = comparer.Compare(k, SetTreeLeaf$1__get_Key<T>(t2)) | 0;
             if (c_1 < 0) {
                 return SetTreeNode$1_$ctor_5F465FC9<T>(k, SetTreeModule_empty<T>(), t, 2);
             }
@@ -260,12 +261,12 @@ export function SetTreeModule_balance<T>(comparer: IComparer<T>, t1: Option<SetT
     }
 }
 
-export 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 function SetTreeModule_split<T>(comparer: IComparer<T>, pivot: T, t: Option<SetTreeLeaf$1<T>>): [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>] {
     if (t != null) {
         const t2: SetTreeLeaf$1<T> = value_3(t);
         if (t2 instanceof SetTreeNode$1) {
             const tn = t2 as SetTreeNode$1<T>;
-            const c: int32 = comparer.Compare(pivot, SetTreeLeaf$1__get_Key<Nullable<T>>(tn)) | 0;
+            const c: int32 = comparer.Compare(pivot, SetTreeLeaf$1__get_Key<T>(tn)) | 0;
             if (c < 0) {
                 const patternInput: [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>] = SetTreeModule_split<T>(comparer, pivot, SetTreeNode$1__get_Left<T>(tn));
                 return [patternInput[0], patternInput[1], SetTreeModule_balance<T>(comparer, patternInput[2], SetTreeLeaf$1__get_Key<T>(tn), SetTreeNode$1__get_Right<T>(tn))] as [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>];
@@ -279,7 +280,7 @@ export function SetTreeModule_split<T>(comparer: IComparer<T>, pivot: Nullable<T
             }
         }
         else {
-            const c_1: int32 = comparer.Compare(SetTreeLeaf$1__get_Key<Nullable<T>>(t2), pivot) | 0;
+            const c_1: int32 = comparer.Compare(SetTreeLeaf$1__get_Key<T>(t2), pivot) | 0;
             if (c_1 < 0) {
                 return [t, false, SetTreeModule_empty<T>()] as [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>];
             }
@@ -314,14 +315,14 @@ export function SetTreeModule_spliceOutSuccessor<T>(t: Option<SetTreeLeaf$1<T>>)
         }
     }
     else {
-        throw new Error("internal error: Set.spliceOutSuccessor");
+        throw new Exception("internal error: Set.spliceOutSuccessor");
     }
 }
 
-export function SetTreeModule_remove<T>(comparer: IComparer<T>, k: Nullable<T>, t: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>> {
+export function SetTreeModule_remove<T>(comparer: IComparer<T>, k: T, t: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>> {
     if (t != null) {
         const t2: SetTreeLeaf$1<T> = value_3(t);
-        const c: int32 = comparer.Compare(k, SetTreeLeaf$1__get_Key<Nullable<T>>(t2)) | 0;
+        const c: int32 = comparer.Compare(k, SetTreeLeaf$1__get_Key<T>(t2)) | 0;
         if (t2 instanceof SetTreeNode$1) {
             const tn = t2 as SetTreeNode$1<T>;
             if (c < 0) {
@@ -355,13 +356,13 @@ export function SetTreeModule_remove<T>(comparer: IComparer<T>, k: Nullable<T>,
     }
 }
 
-export function SetTreeModule_mem<T>(comparer_mut: IComparer<T>, k_mut: Nullable<T>, t_mut: Option<SetTreeLeaf$1<T>>): boolean {
+export function SetTreeModule_mem<T>(comparer_mut: IComparer<T>, k_mut: T, t_mut: Option<SetTreeLeaf$1<T>>): boolean {
     SetTreeModule_mem:
     while (true) {
-        const comparer: IComparer<T> = comparer_mut, k: Nullable<T> = k_mut, t: Option<SetTreeLeaf$1<T>> = t_mut;
+        const comparer: IComparer<T> = comparer_mut, k: T = k_mut, t: Option<SetTreeLeaf$1<T>> = t_mut;
         if (t != null) {
             const t2: SetTreeLeaf$1<T> = value_3(t);
-            const c: int32 = comparer.Compare(k, SetTreeLeaf$1__get_Key<Nullable<T>>(t2)) | 0;
+            const c: int32 = comparer.Compare(k, SetTreeLeaf$1__get_Key<T>(t2)) | 0;
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 if (c < 0) {
@@ -526,12 +527,12 @@ export function SetTreeModule_exists<T>(f_mut: ((arg0: T) => boolean), t_mut: Op
 }
 
 export function SetTreeModule_subset<$a>(comparer: IComparer<$a>, a: Option<SetTreeLeaf$1<$a>>, b: Option<SetTreeLeaf$1<$a>>): boolean {
-    return SetTreeModule_forall<Nullable<$a>>((x: Nullable<$a>): boolean => SetTreeModule_mem<$a>(comparer, x, b), a);
+    return SetTreeModule_forall<$a>((x: $a): boolean => SetTreeModule_mem<$a>(comparer, x, b), a);
 }
 
 export function SetTreeModule_properSubset<T>(comparer: IComparer<T>, a: Option<SetTreeLeaf$1<T>>, b: Option<SetTreeLeaf$1<T>>): boolean {
-    if (SetTreeModule_forall<Nullable<T>>((x: Nullable<T>): boolean => SetTreeModule_mem<T>(comparer, x, b), a)) {
-        return SetTreeModule_exists<Nullable<T>>((x_1: Nullable<T>): boolean => !SetTreeModule_mem<T>(comparer, x_1, a), b);
+    if (SetTreeModule_forall<T>((x: T): boolean => SetTreeModule_mem<T>(comparer, x, b), a)) {
+        return SetTreeModule_exists<T>((x_1: T): boolean => !SetTreeModule_mem<T>(comparer, x_1, a), b);
     }
     else {
         return false;
@@ -584,11 +585,11 @@ export function SetTreeModule_diffAux<T>(comparer_mut: IComparer<T>, t_mut: Opti
                 const tn = t2 as SetTreeNode$1<T>;
                 comparer_mut = comparer;
                 t_mut = SetTreeNode$1__get_Left<T>(tn);
-                acc_mut = SetTreeModule_diffAux<T>(comparer, SetTreeNode$1__get_Right<T>(tn), SetTreeModule_remove<T>(comparer, SetTreeLeaf$1__get_Key<Nullable<T>>(tn), acc));
+                acc_mut = SetTreeModule_diffAux<T>(comparer, SetTreeNode$1__get_Right<T>(tn), SetTreeModule_remove<T>(comparer, SetTreeLeaf$1__get_Key<T>(tn), acc));
                 continue SetTreeModule_diffAux;
             }
             else {
-                return SetTreeModule_remove<T>(comparer, SetTreeLeaf$1__get_Key<Nullable<T>>(t2), acc);
+                return SetTreeModule_remove<T>(comparer, SetTreeLeaf$1__get_Key<T>(t2), acc);
             }
         }
         else {
@@ -612,11 +613,11 @@ export function SetTreeModule_union<T>(comparer: IComparer<T>, t1: Option<SetTre
                 if (t2$0027 instanceof SetTreeNode$1) {
                     const t2n = t2$0027 as SetTreeNode$1<T>;
                     if (SetTreeNode$1__get_Height<T>(t1n) > SetTreeNode$1__get_Height<T>(t2n)) {
-                        const patternInput: [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>] = SetTreeModule_split<T>(comparer, SetTreeLeaf$1__get_Key<Nullable<T>>(t1n), t2);
+                        const patternInput: [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>] = SetTreeModule_split<T>(comparer, SetTreeLeaf$1__get_Key<T>(t1n), t2);
                         return SetTreeModule_balance<T>(comparer, SetTreeModule_union<T>(comparer, SetTreeNode$1__get_Left<T>(t1n), patternInput[0]), SetTreeLeaf$1__get_Key<T>(t1n), SetTreeModule_union<T>(comparer, SetTreeNode$1__get_Right<T>(t1n), patternInput[2]));
                     }
                     else {
-                        const patternInput_1: [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>] = SetTreeModule_split<T>(comparer, SetTreeLeaf$1__get_Key<Nullable<T>>(t2n), t1);
+                        const patternInput_1: [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>] = SetTreeModule_split<T>(comparer, SetTreeLeaf$1__get_Key<T>(t2n), t1);
                         return SetTreeModule_balance<T>(comparer, SetTreeModule_union<T>(comparer, SetTreeNode$1__get_Left<T>(t2n), patternInput_1[0]), SetTreeLeaf$1__get_Key<T>(t2n), SetTreeModule_union<T>(comparer, SetTreeNode$1__get_Right<T>(t2n), patternInput_1[2]));
                     }
                 }
@@ -646,14 +647,14 @@ export function SetTreeModule_intersectionAux<T>(comparer_mut: IComparer<T>, b_m
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 const acc_1: Option<SetTreeLeaf$1<T>> = SetTreeModule_intersectionAux<T>(comparer, b, SetTreeNode$1__get_Right<T>(tn), acc);
-                const acc_2: Option<SetTreeLeaf$1<T>> = SetTreeModule_mem<T>(comparer, SetTreeLeaf$1__get_Key<Nullable<T>>(tn), b) ? SetTreeModule_add<T>(comparer, SetTreeLeaf$1__get_Key<T>(tn), acc_1) : acc_1;
+                const acc_2: Option<SetTreeLeaf$1<T>> = SetTreeModule_mem<T>(comparer, SetTreeLeaf$1__get_Key<T>(tn), b) ? SetTreeModule_add<T>(comparer, SetTreeLeaf$1__get_Key<T>(tn), acc_1) : acc_1;
                 comparer_mut = comparer;
                 b_mut = b;
                 t_mut = SetTreeNode$1__get_Left<T>(tn);
                 acc_mut = acc_2;
                 continue SetTreeModule_intersectionAux;
             }
-            else if (SetTreeModule_mem<T>(comparer, SetTreeLeaf$1__get_Key<Nullable<T>>(t2), b)) {
+            else if (SetTreeModule_mem<T>(comparer, SetTreeLeaf$1__get_Key<T>(t2), b)) {
                 return SetTreeModule_add<T>(comparer, SetTreeLeaf$1__get_Key<T>(t2), acc);
             }
             else {
@@ -794,7 +795,7 @@ export function SetTreeModule_maximumElementOpt<T>(t: Option<SetTreeLeaf$1<T>>):
 export function SetTreeModule_minimumElement<$a>(s: Option<SetTreeLeaf$1<$a>>): $a {
     const matchValue: Option<$a> = SetTreeModule_minimumElementOpt<$a>(s);
     if (matchValue == null) {
-        throw new Error("Set contains no elements");
+        throw new Exception("Set contains no elements");
     }
     else {
         return value_3(matchValue);
@@ -804,7 +805,7 @@ export function SetTreeModule_minimumElement<$a>(s: Option<SetTreeLeaf$1<$a>>):
 export function SetTreeModule_maximumElement<$a>(s: Option<SetTreeLeaf$1<$a>>): $a {
     const matchValue: Option<$a> = SetTreeModule_maximumElementOpt<$a>(s);
     if (matchValue == null) {
-        throw new Error("Set contains no elements");
+        throw new Exception("Set contains no elements");
     }
     else {
         return value_3(matchValue);
@@ -860,11 +861,11 @@ export function SetTreeModule_mkIterator<$a>(s: Option<SetTreeLeaf$1<$a>>): SetT
 }
 
 export function SetTreeModule_notStarted<$a>(): $a {
-    throw new Error("Enumeration not started");
+    throw new Exception("Enumeration not started");
 }
 
 export function SetTreeModule_alreadyFinished<$a>(): $a {
-    throw new Error("Enumeration already started");
+    throw new Exception("Enumeration already started");
 }
 
 export function SetTreeModule_current<$a>(i: SetTreeModule_SetIterator$1<$a>): $a {
@@ -878,7 +879,7 @@ export function SetTreeModule_current<$a>(i: SetTreeModule_SetIterator$1<$a>): $
             return SetTreeLeaf$1__get_Key<$a>(t);
         }
         else {
-            throw new Error("Please report error: Set iterator, unexpected stack for current");
+            throw new Exception("Please report error: Set iterator, unexpected stack for current");
         }
     }
     else {
@@ -893,7 +894,7 @@ export function SetTreeModule_moveNext<T>(i: SetTreeModule_SetIterator$1<T>): bo
             if (head(matchValue) != null) {
                 const t: SetTreeLeaf$1<T> = value_3(head(matchValue));
                 if (t instanceof SetTreeNode$1) {
-                    throw new Error("Please report error: Set iterator, unexpected stack for moveNext");
+                    throw new Exception("Please report error: Set iterator, unexpected stack for moveNext");
                 }
                 else {
                     i.stack = SetTreeModule_collapseLHS<T>(tail(matchValue));
@@ -901,7 +902,7 @@ export function SetTreeModule_moveNext<T>(i: SetTreeModule_SetIterator$1<T>): bo
                 }
             }
             else {
-                throw new Error("Please report error: Set iterator, unexpected stack for moveNext");
+                throw new Exception("Please report error: Set iterator, unexpected stack for moveNext");
             }
         }
         else {
@@ -920,7 +921,7 @@ export function SetTreeModule_mkIEnumerator<a>(s: Option<SetTreeLeaf$1<a>>): IEn
         "System.Collections.Generic.IEnumerator`1.get_Current"(): a {
             return SetTreeModule_current<a>(i);
         },
-        "System.Collections.IEnumerator.get_Current"(): Nullable<any> {
+        "System.Collections.IEnumerator.get_Current"(): any {
             return SetTreeModule_current<a>(i);
         },
         "System.Collections.IEnumerator.MoveNext"(): boolean {
@@ -953,7 +954,7 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                 if (x2_3 instanceof SetTreeNode$1) {
                                     const x2n_2 = x2_3 as SetTreeNode$1<T>;
                                     if (SetTreeNode$1__get_Left<T>(x2n_2) == null) {
-                                        const c: int32 = comparer.Compare(SetTreeLeaf$1__get_Key<Nullable<T>>(x1n_2), SetTreeLeaf$1__get_Key<Nullable<T>>(x2n_2)) | 0;
+                                        const c: int32 = comparer.Compare(SetTreeLeaf$1__get_Key<T>(x1n_2), SetTreeLeaf$1__get_Key<T>(x2n_2)) | 0;
                                         if (c !== 0) {
                                             return c | 0;
                                         }
@@ -965,7 +966,7 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                         }
                                     }
                                     else {
-                                        let matchResult: int32, t1_6: FSharpList<Option<SetTreeLeaf$1<T>>>, x1_4: SetTreeLeaf$1<T>, t2_6: FSharpList<Option<SetTreeLeaf$1<T>>>, x2_4: SetTreeLeaf$1<T>;
+                                        let matchResult: int32 = (undefined as any), t1_6: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x1_4: SetTreeLeaf$1<T> = (undefined as any), t2_6: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x2_4: SetTreeLeaf$1<T> = (undefined as any);
                                         if (!isEmpty_1(l1)) {
                                             if (head(l1) != null) {
                                                 matchResult = 0;
@@ -1029,12 +1030,12 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                                     continue SetTreeModule_compareStacks;
                                                 }
                                             default:
-                                                throw new Error("unexpected state in SetTree.compareStacks");
+                                                throw new Exception("unexpected state in SetTree.compareStacks");
                                         }
                                     }
                                 }
                                 else {
-                                    const c_1: int32 = comparer.Compare(SetTreeLeaf$1__get_Key<Nullable<T>>(x1n_2), SetTreeLeaf$1__get_Key<Nullable<T>>(x2_3)) | 0;
+                                    const c_1: int32 = comparer.Compare(SetTreeLeaf$1__get_Key<T>(x1n_2), SetTreeLeaf$1__get_Key<T>(x2_3)) | 0;
                                     if (c_1 !== 0) {
                                         return c_1 | 0;
                                     }
@@ -1047,7 +1048,7 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                 }
                             }
                             else {
-                                let matchResult_1: int32, t1_7: FSharpList<Option<SetTreeLeaf$1<T>>>, x1_5: SetTreeLeaf$1<T>, t2_7: FSharpList<Option<SetTreeLeaf$1<T>>>, x2_5: SetTreeLeaf$1<T>;
+                                let matchResult_1: int32 = (undefined as any), t1_7: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x1_5: SetTreeLeaf$1<T> = (undefined as any), t2_7: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x2_5: SetTreeLeaf$1<T> = (undefined as any);
                                 if (!isEmpty_1(l1)) {
                                     if (head(l1) != null) {
                                         matchResult_1 = 0;
@@ -1111,14 +1112,14 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                             continue SetTreeModule_compareStacks;
                                         }
                                     default:
-                                        throw new Error("unexpected state in SetTree.compareStacks");
+                                        throw new Exception("unexpected state in SetTree.compareStacks");
                                 }
                             }
                         }
                         else if (x2_3 instanceof SetTreeNode$1) {
                             const x2n_5 = x2_3 as SetTreeNode$1<T>;
                             if (SetTreeNode$1__get_Left<T>(x2n_5) == null) {
-                                const c_2: int32 = comparer.Compare(SetTreeLeaf$1__get_Key<Nullable<T>>(x1_3), SetTreeLeaf$1__get_Key<Nullable<T>>(x2n_5)) | 0;
+                                const c_2: int32 = comparer.Compare(SetTreeLeaf$1__get_Key<T>(x1_3), SetTreeLeaf$1__get_Key<T>(x2n_5)) | 0;
                                 if (c_2 !== 0) {
                                     return c_2 | 0;
                                 }
@@ -1130,7 +1131,7 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                 }
                             }
                             else {
-                                let matchResult_2: int32, t1_8: FSharpList<Option<SetTreeLeaf$1<T>>>, x1_6: SetTreeLeaf$1<T>, t2_8: FSharpList<Option<SetTreeLeaf$1<T>>>, x2_6: SetTreeLeaf$1<T>;
+                                let matchResult_2: int32 = (undefined as any), t1_8: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x1_6: SetTreeLeaf$1<T> = (undefined as any), t2_8: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x2_6: SetTreeLeaf$1<T> = (undefined as any);
                                 if (!isEmpty_1(l1)) {
                                     if (head(l1) != null) {
                                         matchResult_2 = 0;
@@ -1194,12 +1195,12 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                             continue SetTreeModule_compareStacks;
                                         }
                                     default:
-                                        throw new Error("unexpected state in SetTree.compareStacks");
+                                        throw new Exception("unexpected state in SetTree.compareStacks");
                                 }
                             }
                         }
                         else {
-                            const c_3: int32 = comparer.Compare(SetTreeLeaf$1__get_Key<Nullable<T>>(x1_3), SetTreeLeaf$1__get_Key<Nullable<T>>(x2_3)) | 0;
+                            const c_3: int32 = comparer.Compare(SetTreeLeaf$1__get_Key<T>(x1_3), SetTreeLeaf$1__get_Key<T>(x2_3)) | 0;
                             if (c_3 !== 0) {
                                 return c_3 | 0;
                             }
@@ -1213,7 +1214,7 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                     }
                     else {
                         const x2: SetTreeLeaf$1<T> = value_3(head(l2));
-                        let matchResult_3: int32, t1_2: FSharpList<Option<SetTreeLeaf$1<T>>>, x1: SetTreeLeaf$1<T>, t2_2: FSharpList<Option<SetTreeLeaf$1<T>>>, x2_1: SetTreeLeaf$1<T>;
+                        let matchResult_3: int32 = (undefined as any), t1_2: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x1: SetTreeLeaf$1<T> = (undefined as any), t2_2: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x2_1: SetTreeLeaf$1<T> = (undefined as any);
                         if (!isEmpty_1(l1)) {
                             if (head(l1) != null) {
                                 matchResult_3 = 0;
@@ -1277,13 +1278,13 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                     continue SetTreeModule_compareStacks;
                                 }
                             default:
-                                throw new Error("unexpected state in SetTree.compareStacks");
+                                throw new Exception("unexpected state in SetTree.compareStacks");
                         }
                     }
                 }
                 else if (head(l1) != null) {
                     const x1_1: SetTreeLeaf$1<T> = value_3(head(l1));
-                    let matchResult_4: int32, t1_4: FSharpList<Option<SetTreeLeaf$1<T>>>, x1_2: SetTreeLeaf$1<T>, t2_4: FSharpList<Option<SetTreeLeaf$1<T>>>, x2_2: SetTreeLeaf$1<T>;
+                    let matchResult_4: int32 = (undefined as any), t1_4: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x1_2: SetTreeLeaf$1<T> = (undefined as any), t2_4: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x2_2: SetTreeLeaf$1<T> = (undefined as any);
                     if (!isEmpty_1(l1)) {
                         if (head(l1) != null) {
                             matchResult_4 = 0;
@@ -1347,7 +1348,7 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                 continue SetTreeModule_compareStacks;
                             }
                         default:
-                            throw new Error("unexpected state in SetTree.compareStacks");
+                            throw new Exception("unexpected state in SetTree.compareStacks");
                     }
                 }
                 else {
@@ -1418,7 +1419,7 @@ export function SetTreeModule_toList<T>(t: Option<SetTreeLeaf$1<T>>): FSharpList
     return loop(t, empty_1<T>());
 }
 
-export function SetTreeModule_copyToArray<$a>(s: Option<SetTreeLeaf$1<$a>>, arr: $a[], i: int32): void {
+export function SetTreeModule_copyToArray<$a>(s: Option<SetTreeLeaf$1<$a>>, arr: MutableArray<$a>, i: int32): void {
     let j: int32 = i;
     SetTreeModule_iter<$a>((x: $a): void => {
         setItem(arr, j, x);
@@ -1426,9 +1427,9 @@ export function SetTreeModule_copyToArray<$a>(s: Option<SetTreeLeaf$1<$a>>, arr:
     }, s);
 }
 
-export function SetTreeModule_toArray<$a>(s: Option<SetTreeLeaf$1<$a>>): $a[] {
+export function SetTreeModule_toArray<$a>(s: Option<SetTreeLeaf$1<$a>>): MutableArray<$a> {
     const n: int32 = SetTreeModule_count<$a>(s) | 0;
-    const res: $a[] = fill(new Array(n), 0, n, null);
+    const res: MutableArray<$a> = fill(new Array(n), 0, n, null);
     SetTreeModule_copyToArray<$a>(s, res, 0);
     return res;
 }
@@ -1450,7 +1451,7 @@ export function SetTreeModule_mkFromEnumerator<$a>(comparer_mut: IComparer<$a>,
     }
 }
 
-export function SetTreeModule_ofArray<$a>(comparer: IComparer<$a>, l: $a[]): Option<SetTreeLeaf$1<$a>> {
+export function SetTreeModule_ofArray<$a>(comparer: IComparer<$a>, l: MutableArray<$a>): Option<SetTreeLeaf$1<$a>> {
     return fold_1<$a, Option<SetTreeLeaf$1<$a>>>((acc: Option<SetTreeLeaf$1<$a>>, k: $a): Option<SetTreeLeaf$1<$a>> => SetTreeModule_add<$a>(comparer, k, acc), SetTreeModule_empty<$a>(), l);
 }
 
@@ -1487,8 +1488,8 @@ export class FSharpSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
         const this$: FSharpSet<T> = this;
         return FSharpSet__ComputeHashCode<T>(this$) | 0;
     }
-    Equals(other: Nullable<any>): boolean {
-        let that: FSharpSet<T>;
+    Equals(other: any): boolean {
+        let that: FSharpSet<T> = undefined as any;
         const this$: FSharpSet<T> = this;
         return (other instanceof FSharpSet) && ((that = (other as FSharpSet<T>), SetTreeModule_compare<T>(FSharpSet__get_Comparer<T>(this$), FSharpSet__get_Tree<T>(this$), FSharpSet__get_Tree<T>(that)) === 0));
     }
@@ -1503,25 +1504,25 @@ export class FSharpSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
         const this$: FSharpSet<T> = this;
         return Array.from(this$);
     }
-    CompareTo(other: Nullable<any>): int32 {
-        let that: FSharpSet<T>;
+    CompareTo(other: any): int32 {
+        let that: FSharpSet<T> = undefined as any;
         const this$: FSharpSet<T> = this;
         return ((other instanceof FSharpSet) ? ((that = (other as FSharpSet<T>), SetTreeModule_compare<T>(FSharpSet__get_Comparer<T>(this$), FSharpSet__get_Tree<T>(this$), FSharpSet__get_Tree<T>(that)))) : 1) | 0;
     }
     "System.Collections.Generic.ICollection`1.Add2B595"(x: T): void {
-        throw new Error("ReadOnlyCollection");
+        throw NotSupportedException_$ctor_Z721C83C5("ReadOnlyCollection");
     }
     "System.Collections.Generic.ICollection`1.Clear"(): void {
-        throw new Error("ReadOnlyCollection");
+        throw NotSupportedException_$ctor_Z721C83C5("ReadOnlyCollection");
     }
     "System.Collections.Generic.ICollection`1.Remove2B595"(x: T): boolean {
-        throw new Error("ReadOnlyCollection");
+        throw NotSupportedException_$ctor_Z721C83C5("ReadOnlyCollection");
     }
     "System.Collections.Generic.ICollection`1.Contains2B595"(x: T): boolean {
         const s: FSharpSet<T> = this;
         return SetTreeModule_mem<T>(FSharpSet__get_Comparer<T>(s), x, FSharpSet__get_Tree<T>(s));
     }
-    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(arr: T[], i: int32): void {
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(arr: MutableArray<T>, i: int32): void {
         const s: FSharpSet<T> = this;
         SetTreeModule_copyToArray<T>(FSharpSet__get_Tree<T>(s), arr, i);
     }
@@ -1553,14 +1554,14 @@ export class FSharpSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
     }
     add(k: T): ISet<T> {
         const s: FSharpSet<T> = this;
-        throw new Error("Set cannot be mutated");
+        throw new Exception("Set cannot be mutated");
         return s;
     }
     clear(): void {
-        throw new Error("Set cannot be mutated");
+        throw new Exception("Set cannot be mutated");
     }
     delete(k: T): boolean {
-        throw new Error("Set cannot be mutated");
+        throw new Exception("Set cannot be mutated");
         return false;
     }
     has(k: T): boolean {
@@ -1611,7 +1612,7 @@ export function FSharpSet__Add<T>(s: FSharpSet<T>, value: T): FSharpSet<T> {
     return FSharpSet_$ctor<T>(FSharpSet__get_Comparer<T>(s), SetTreeModule_add<T>(FSharpSet__get_Comparer<T>(s), value, FSharpSet__get_Tree<T>(s)));
 }
 
-export function FSharpSet__Remove<T>(s: FSharpSet<T>, value: Nullable<T>): FSharpSet<T> {
+export function FSharpSet__Remove<T>(s: FSharpSet<T>, value: T): FSharpSet<T> {
     return FSharpSet_$ctor<T>(FSharpSet__get_Comparer<T>(s), SetTreeModule_remove<T>(FSharpSet__get_Comparer<T>(s), value, FSharpSet__get_Tree<T>(s)));
 }
 
@@ -1619,7 +1620,7 @@ export function FSharpSet__get_Count<T>(s: FSharpSet<T>): int32 {
     return SetTreeModule_count<T>(FSharpSet__get_Tree<T>(s)) | 0;
 }
 
-export function FSharpSet__Contains<T>(s: FSharpSet<T>, value: Nullable<T>): boolean {
+export function FSharpSet__Contains<T>(s: FSharpSet<T>, value: T): boolean {
     return SetTreeModule_mem<T>(FSharpSet__get_Comparer<T>(s), value, FSharpSet__get_Tree<T>(s));
 }
 
@@ -1747,7 +1748,7 @@ export function FSharpSet__ToList<T>(x: FSharpSet<T>): FSharpList<T> {
     return SetTreeModule_toList<T>(FSharpSet__get_Tree<T>(x));
 }
 
-export function FSharpSet__ToArray<T>(x: FSharpSet<T>): T[] {
+export function FSharpSet__ToArray<T>(x: FSharpSet<T>): MutableArray<T> {
     return SetTreeModule_toArray<T>(FSharpSet__get_Tree<T>(x));
 }
 
@@ -1770,7 +1771,7 @@ export function isEmpty<T>(set$: FSharpSet<T>): boolean {
     return FSharpSet__get_IsEmpty<T>(set$);
 }
 
-export function contains<T>(element: Nullable<T>, set$: FSharpSet<T>): boolean {
+export function contains<T>(element: T, set$: FSharpSet<T>): boolean {
     return FSharpSet__Contains<T>(set$, element);
 }
 
@@ -1782,7 +1783,7 @@ export function singleton<T>(value: T, comparer: IComparer<T>): FSharpSet<T> {
     return FSharpSet__Add<T>(FSharpSet_Empty<T>(comparer), value);
 }
 
-export function remove<T>(value: Nullable<T>, set$: FSharpSet<T>): FSharpSet<T> {
+export function remove<T>(value: T, set$: FSharpSet<T>): FSharpSet<T> {
     return FSharpSet__Remove<T>(set$, value);
 }
 
@@ -1846,7 +1847,7 @@ export function ofList<T>(elements: Iterable<T>, comparer: IComparer<T>): FSharp
     return FSharpSet_$ctor<T>(comparer, SetTreeModule_ofSeq<T>(comparer, elements));
 }
 
-export function ofArray<T>(array: T[], comparer: IComparer<T>): FSharpSet<T> {
+export function ofArray<T>(array: MutableArray<T>, comparer: IComparer<T>): FSharpSet<T> {
     return FSharpSet_$ctor<T>(comparer, SetTreeModule_ofArray<T>(comparer, array));
 }
 
@@ -1854,7 +1855,7 @@ export function toList<T>(set$: FSharpSet<T>): FSharpList<T> {
     return FSharpSet__ToList<T>(set$);
 }
 
-export function toArray<T>(set$: FSharpSet<T>): T[] {
+export function toArray<T>(set$: FSharpSet<T>): MutableArray<T> {
     return FSharpSet__ToArray<T>(set$);
 }