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

package/Array.ts

@@ -1,26 +1,26 @@
 
-import { int32 } from "./Int32.js";
-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, Option, some } from "./Option.js";
-import { min as min_1, max as max_1 } from "./Double.js";
-import { IComparer, IDisposable, disposeSafe, IEnumerator, getEnumerator, copyToArray, Nullable, IEqualityComparer, defaultOf } from "./Util.js";
-import { SR_indexOutOfBounds } from "./Global.js";
-import { Operators_IsNull } from "./FSharp.Core.js";
-import { FSharpRef } from "./Types.js";
+import { IComparer, IDisposable, disposeSafe, IEnumerator, getEnumerator, copyToArray, IEqualityComparer, defaultOf, MutableArray, Exception } from "./Util.ts";
+import { int32 } from "./Int32.ts";
+import { Helpers_allocateArrayFromCons } from "./Native.ts";
+import { setItem as setItem_1, item as item_2 } from "./Array.ts";
+import { value as value_2, map as map_1, defaultArg, Option, some } from "./Option.ts";
+import { min as min_1, max as max_1 } from "./Double.ts";
+import { SR_indexOutOfBounds } from "./Global.ts";
+import { Operators_IsNull } from "./FSharp.Core.ts";
+import { FSharpRef } from "./Types.ts";
 
 function indexNotFound<$a>(): $a {
-    throw new Error("An index satisfying the predicate was not found in the collection.");
+    throw new Exception("An index satisfying the predicate was not found in the collection.");
 }
 
 function differentLengths<$a>(): $a {
-    throw new Error("Arrays had different lengths");
+    throw new Exception("Arrays had different lengths");
 }
 
-export function append<T>(array1: T[], array2: T[], cons?: any): T[] {
+export function append<T>(array1: MutableArray<T>, array2: MutableArray<T>, cons?: any): MutableArray<T> {
     const len1: int32 = array1.length | 0;
     const len2: int32 = array2.length | 0;
-    const newArray: T[] = Helpers_allocateArrayFromCons<T>(cons, len1 + len2);
+    const newArray: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, len1 + len2);
     for (let i = 0; i <= (len1 - 1); i++) {
         setItem_1(newArray, i, item_2(i, array1));
     }
@@ -30,28 +30,28 @@ export function append<T>(array1: T[], array2: T[], cons?: any): T[] {
     return newArray;
 }
 
-export function filter<T>(predicate: ((arg0: T) => boolean), array: T[]): T[] {
+export function filter<T>(predicate: ((arg0: T) => boolean), array: MutableArray<T>): MutableArray<T> {
     return array.filter(predicate);
 }
 
-export function fill<T>(target: T[], targetIndex: int32, count: int32, value: T): T[] {
+export function fill<T>(target: MutableArray<T>, targetIndex: int32, count: int32, value: T): MutableArray<T> {
     const start: int32 = targetIndex | 0;
     return target.fill(value, start, (start + count));
 }
 
-export function getSubArray<T>(array: T[], start: int32, count: int32): T[] {
+export function getSubArray<T>(array: MutableArray<T>, start: int32, count: int32): MutableArray<T> {
     const start_1: int32 = start | 0;
     return array.slice(start_1, (start_1 + count));
 }
 
-export function last<T>(array: T[]): T {
+export function last<T>(array: MutableArray<T>): T {
     if (array.length === 0) {
-        throw new Error("The input array was empty\\nParameter name: array");
+        throw new Exception("The input array was empty\\nParameter name: array");
     }
     return item_2(array.length - 1, array);
 }
 
-export function tryLast<T>(array: T[]): Option<T> {
+export function tryLast<T>(array: MutableArray<T>): Option<T> {
     if (array.length === 0) {
         return undefined;
     }
@@ -60,118 +60,118 @@ export function tryLast<T>(array: T[]): Option<T> {
     }
 }
 
-export function mapIndexed<T, U>(f: ((arg0: int32, arg1: T) => U), source: T[], cons?: any): U[] {
+export function mapIndexed<T, U>(f: ((arg0: int32, arg1: T) => U), source: MutableArray<T>, cons?: any): MutableArray<U> {
     const len: int32 = source.length | 0;
-    const target: U[] = Helpers_allocateArrayFromCons<U>(cons, len);
+    const target: MutableArray<U> = Helpers_allocateArrayFromCons<U>(cons, len);
     for (let i = 0; i <= (len - 1); i++) {
         setItem_1(target, i, f(i, item_2(i, source)));
     }
     return target;
 }
 
-export function map<T, U>(f: ((arg0: T) => U), source: T[], cons?: any): U[] {
+export function map<T, U>(f: ((arg0: T) => U), source: MutableArray<T>, cons?: any): MutableArray<U> {
     const len: int32 = source.length | 0;
-    const target: U[] = Helpers_allocateArrayFromCons<U>(cons, len);
+    const target: MutableArray<U> = Helpers_allocateArrayFromCons<U>(cons, len);
     for (let i = 0; i <= (len - 1); i++) {
         setItem_1(target, i, f(item_2(i, source)));
     }
     return target;
 }
 
-export function mapIndexed2<T1, T2, U>(f: ((arg0: int32, arg1: T1, arg2: T2) => U), source1: T1[], source2: T2[], cons?: any): U[] {
+export function mapIndexed2<T1, T2, U>(f: ((arg0: int32, arg1: T1, arg2: T2) => U), source1: MutableArray<T1>, source2: MutableArray<T2>, cons?: any): MutableArray<U> {
     if (source1.length !== source2.length) {
-        throw new Error("Arrays had different lengths");
+        throw new Exception("Arrays had different lengths");
     }
-    const result: U[] = Helpers_allocateArrayFromCons<U>(cons, source1.length);
+    const result: MutableArray<U> = Helpers_allocateArrayFromCons<U>(cons, source1.length);
     for (let i = 0; i <= (source1.length - 1); i++) {
         setItem_1(result, i, f(i, item_2(i, source1), item_2(i, source2)));
     }
     return result;
 }
 
-export function map2<T1, T2, U>(f: ((arg0: T1, arg1: T2) => U), source1: T1[], source2: T2[], cons?: any): U[] {
+export function map2<T1, T2, U>(f: ((arg0: T1, arg1: T2) => U), source1: MutableArray<T1>, source2: MutableArray<T2>, cons?: any): MutableArray<U> {
     if (source1.length !== source2.length) {
-        throw new Error("Arrays had different lengths");
+        throw new Exception("Arrays had different lengths");
     }
-    const result: U[] = Helpers_allocateArrayFromCons<U>(cons, source1.length);
+    const result: MutableArray<U> = Helpers_allocateArrayFromCons<U>(cons, source1.length);
     for (let i = 0; i <= (source1.length - 1); i++) {
         setItem_1(result, i, f(item_2(i, source1), item_2(i, source2)));
     }
     return result;
 }
 
-export function mapIndexed3<T1, T2, T3, U>(f: ((arg0: int32, arg1: T1, arg2: T2, arg3: T3) => U), source1: T1[], source2: T2[], source3: T3[], cons?: any): U[] {
+export function mapIndexed3<T1, T2, T3, U>(f: ((arg0: int32, arg1: T1, arg2: T2, arg3: T3) => U), source1: MutableArray<T1>, source2: MutableArray<T2>, source3: MutableArray<T3>, cons?: any): MutableArray<U> {
     if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {
-        throw new Error("Arrays had different lengths");
+        throw new Exception("Arrays had different lengths");
     }
-    const result: U[] = Helpers_allocateArrayFromCons<U>(cons, source1.length);
+    const result: MutableArray<U> = Helpers_allocateArrayFromCons<U>(cons, source1.length);
     for (let i = 0; i <= (source1.length - 1); i++) {
         setItem_1(result, i, f(i, item_2(i, source1), item_2(i, source2), item_2(i, source3)));
     }
     return result;
 }
 
-export function map3<T1, T2, T3, U>(f: ((arg0: T1, arg1: T2, arg2: T3) => U), source1: T1[], source2: T2[], source3: T3[], cons?: any): U[] {
+export function map3<T1, T2, T3, U>(f: ((arg0: T1, arg1: T2, arg2: T3) => U), source1: MutableArray<T1>, source2: MutableArray<T2>, source3: MutableArray<T3>, cons?: any): MutableArray<U> {
     if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {
-        throw new Error("Arrays had different lengths");
+        throw new Exception("Arrays had different lengths");
     }
-    const result: U[] = Helpers_allocateArrayFromCons<U>(cons, source1.length);
+    const result: MutableArray<U> = Helpers_allocateArrayFromCons<U>(cons, source1.length);
     for (let i = 0; i <= (source1.length - 1); i++) {
         setItem_1(result, i, f(item_2(i, source1), item_2(i, source2), item_2(i, source3)));
     }
     return result;
 }
 
-export function mapFold<T, State, Result>(mapping: ((arg0: State, arg1: T) => [Result, State]), state: State, array: T[], cons?: any): [Result[], State] {
+export function mapFold<T, State, Result>(mapping: ((arg0: State, arg1: T) => [Result, State]), state: State, array: MutableArray<T>, cons?: any): [MutableArray<Result>, State] {
     const matchValue: int32 = array.length | 0;
     if (matchValue === 0) {
-        return [[], state] as [Result[], State];
+        return [[], state] as [MutableArray<Result>, State];
     }
     else {
         let acc: State = state;
-        const res: Result[] = Helpers_allocateArrayFromCons<Result>(cons, matchValue);
+        const res: MutableArray<Result> = Helpers_allocateArrayFromCons<Result>(cons, matchValue);
         for (let i = 0; i <= (array.length - 1); i++) {
             const patternInput: [Result, State] = mapping(acc, item_2(i, array));
             setItem_1(res, i, patternInput[0]);
             acc = patternInput[1];
         }
-        return [res, acc] as [Result[], State];
+        return [res, acc] as [MutableArray<Result>, State];
     }
 }
 
-export function mapFoldBack<T, State, Result>(mapping: ((arg0: T, arg1: State) => [Result, State]), array: T[], state: State, cons?: any): [Result[], State] {
+export function mapFoldBack<T, State, Result>(mapping: ((arg0: T, arg1: State) => [Result, State]), array: MutableArray<T>, state: State, cons?: any): [MutableArray<Result>, State] {
     const matchValue: int32 = array.length | 0;
     if (matchValue === 0) {
-        return [[], state] as [Result[], State];
+        return [[], state] as [MutableArray<Result>, State];
     }
     else {
         let acc: State = state;
-        const res: Result[] = Helpers_allocateArrayFromCons<Result>(cons, matchValue);
+        const res: MutableArray<Result> = Helpers_allocateArrayFromCons<Result>(cons, matchValue);
         for (let i: int32 = array.length - 1; i >= 0; i--) {
             const patternInput: [Result, State] = mapping(item_2(i, array), acc);
             setItem_1(res, i, patternInput[0]);
             acc = patternInput[1];
         }
-        return [res, acc] as [Result[], State];
+        return [res, acc] as [MutableArray<Result>, State];
     }
 }
 
-export function indexed<T>(source: T[]): [int32, T][] {
+export function indexed<T>(source: MutableArray<T>): MutableArray<[int32, T]> {
     const len: int32 = source.length | 0;
-    const target: [int32, T][] = new Array(len);
+    const target: MutableArray<[int32, T]> = new Array(len);
     for (let i = 0; i <= (len - 1); i++) {
         setItem_1(target, i, [i, item_2(i, source)] as [int32, T]);
     }
     return target;
 }
 
-export function truncate<T>(count: int32, array: T[]): T[] {
+export function truncate<T>(count: int32, array: MutableArray<T>): MutableArray<T> {
     const count_1: int32 = max_1(0, count) | 0;
     return array.slice(0, (0 + count_1));
 }
 
-export function concat<T>(arrays: Iterable<T[]>, cons?: any): T[] {
-    const arrays_1: T[][] = Array.isArray(arrays) ? (arrays as T[][]) : (Array.from(arrays));
+export function concat<T>(arrays: Iterable<MutableArray<T>>, cons?: any): MutableArray<T> {
+    const arrays_1: MutableArray<MutableArray<T>> = Array.isArray(arrays) ? (arrays as MutableArray<MutableArray<T>>) : (Array.from(arrays));
     const matchValue: int32 = arrays_1.length | 0;
     switch (matchValue) {
         case 0:
@@ -182,12 +182,12 @@ export function concat<T>(arrays: Iterable<T[]>, cons?: any): T[] {
             let totalIdx = 0;
             let totalLength = 0;
             for (let idx = 0; idx <= (arrays_1.length - 1); idx++) {
-                const arr_1: T[] = item_2(idx, arrays_1);
+                const arr_1: MutableArray<T> = item_2(idx, arrays_1);
                 totalLength = ((totalLength + arr_1.length) | 0);
             }
-            const result: T[] = Helpers_allocateArrayFromCons<T>(cons, totalLength);
+            const result: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, totalLength);
             for (let idx_1 = 0; idx_1 <= (arrays_1.length - 1); idx_1++) {
-                const arr_2: T[] = item_2(idx_1, arrays_1);
+                const arr_2: MutableArray<T> = item_2(idx_1, arrays_1);
                 for (let j = 0; j <= (arr_2.length - 1); j++) {
                     setItem_1(result, totalIdx, item_2(j, arr_2));
                     totalIdx = ((totalIdx + 1) | 0);
@@ -198,15 +198,15 @@ export function concat<T>(arrays: Iterable<T[]>, cons?: any): T[] {
     }
 }
 
-export function collect<T, U>(mapping: ((arg0: T) => U[]), array: T[], cons?: any): U[] {
-    return concat<U>(map<T, U[]>(mapping, array, defaultOf()), cons);
+export function collect<T, U>(mapping: ((arg0: T) => MutableArray<U>), array: MutableArray<T>, cons?: any): MutableArray<U> {
+    return concat<U>(map<T, MutableArray<U>>(mapping, array, defaultOf()), cons);
 }
 
-export function where<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): $a[] {
+export function where<$a>(predicate: ((arg0: $a) => boolean), array: MutableArray<$a>): MutableArray<$a> {
     return array.filter(predicate);
 }
 
-export function indexOf<T>(array: T[], item_1: T, start: Option<int32>, count: Option<int32>, eq: IEqualityComparer<T>): int32 {
+export function indexOf<T>(array: MutableArray<T>, item_1: T, start: Option<int32>, count: Option<int32>, eq: IEqualityComparer<T>): int32 {
     const start_1: int32 = defaultArg<int32>(start, 0) | 0;
     const end$0027: int32 = defaultArg(map_1<int32, int32>((c: int32): int32 => ((start_1 + c) | 0), count), array.length) | 0;
     const loop = (i_mut: int32): int32 => {
@@ -229,38 +229,38 @@ export function indexOf<T>(array: T[], item_1: T, start: Option<int32>, count: O
     return loop(start_1) | 0;
 }
 
-export function contains<T>(value: T, array: T[], eq: IEqualityComparer<T>): boolean {
+export function contains<T>(value: T, array: MutableArray<T>, eq: IEqualityComparer<T>): boolean {
     return indexOf<T>(array, value, undefined, undefined, eq) >= 0;
 }
 
-export function empty<$a>(cons: Nullable<any>): $a[] {
+export function empty<$a>(cons: any): MutableArray<$a> {
     return Helpers_allocateArrayFromCons<$a>(cons, 0);
 }
 
-export function singleton<T>(value: T, cons?: any): T[] {
-    const ar: T[] = Helpers_allocateArrayFromCons<T>(cons, 1);
+export function singleton<T>(value: T, cons?: any): MutableArray<T> {
+    const ar: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, 1);
     setItem_1(ar, 0, value);
     return ar;
 }
 
-export function initialize<T>(count: int32, initializer: ((arg0: int32) => T), cons?: any): T[] {
+export function initialize<T>(count: int32, initializer: ((arg0: int32) => T), cons?: any): MutableArray<T> {
     if (count < 0) {
-        throw new Error("The input must be non-negative\\nParameter name: count");
+        throw new Exception("The input must be non-negative\\nParameter name: count");
     }
-    const result: T[] = Helpers_allocateArrayFromCons<T>(cons, count);
+    const result: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, count);
     for (let i = 0; i <= (count - 1); i++) {
         setItem_1(result, i, initializer(i));
     }
     return result;
 }
 
-export function pairwise<T>(array: T[]): [T, T][] {
+export function pairwise<T>(array: MutableArray<T>): MutableArray<[T, T]> {
     if (array.length < 2) {
         return [];
     }
     else {
         const count: int32 = (array.length - 1) | 0;
-        const result: [T, T][] = new Array(count);
+        const result: MutableArray<[T, T]> = new Array(count);
         for (let i = 0; i <= (count - 1); i++) {
             setItem_1(result, i, [item_2(i, array), item_2(i + 1, array)] as [T, T]);
         }
@@ -268,32 +268,32 @@ export function pairwise<T>(array: T[]): [T, T][] {
     }
 }
 
-export function replicate<T>(count: int32, initial: T, cons?: any): T[] {
+export function replicate<T>(count: int32, initial: T, cons?: any): MutableArray<T> {
     if (count < 0) {
-        throw new Error("The input must be non-negative\\nParameter name: count");
+        throw new Exception("The input must be non-negative\\nParameter name: count");
     }
-    const result: T[] = Helpers_allocateArrayFromCons<T>(cons, count);
+    const result: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, count);
     for (let i = 0; i <= (result.length - 1); i++) {
         setItem_1(result, i, initial);
     }
     return result;
 }
 
-export function copy<T>(array: T[]): T[] {
+export function copy<T>(array: MutableArray<T>): MutableArray<T> {
     return array.slice();
 }
 
-export function copyTo<T>(source: T[], sourceIndex: int32, target: T[], targetIndex: int32, count: int32): void {
+export function copyTo<T>(source: MutableArray<T>, sourceIndex: int32, target: MutableArray<T>, targetIndex: int32, count: int32): void {
     copyToArray(source, sourceIndex, target, targetIndex, count);
 }
 
-export function reverse<T>(array: T[]): T[] {
-    const array_2: T[] = array.slice();
+export function reverse<T>(array: MutableArray<T>): MutableArray<T> {
+    const array_2: MutableArray<T> = array.slice();
     return array_2.reverse();
 }
 
-export function scan<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, array: T[], cons?: any): State[] {
-    const res: State[] = Helpers_allocateArrayFromCons<State>(cons, array.length + 1);
+export function scan<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, array: MutableArray<T>, cons?: any): MutableArray<State> {
+    const res: MutableArray<State> = Helpers_allocateArrayFromCons<State>(cons, array.length + 1);
     setItem_1(res, 0, state);
     for (let i = 0; i <= (array.length - 1); i++) {
         setItem_1(res, i + 1, folder(item_2(i, res), item_2(i, array)));
@@ -301,8 +301,8 @@ export function scan<T, State>(folder: ((arg0: State, arg1: T) => State), state:
     return res;
 }
 
-export function scanBack<T, State>(folder: ((arg0: T, arg1: State) => State), array: T[], state: State, cons?: any): State[] {
-    const res: State[] = Helpers_allocateArrayFromCons<State>(cons, array.length + 1);
+export function scanBack<T, State>(folder: ((arg0: T, arg1: State) => State), array: MutableArray<T>, state: State, cons?: any): MutableArray<State> {
+    const res: MutableArray<State> = Helpers_allocateArrayFromCons<State>(cons, array.length + 1);
     setItem_1(res, array.length, state);
     for (let i: int32 = array.length - 1; i >= 0; i--) {
         setItem_1(res, i, folder(item_2(i, array), item_2(i + 1, res)));
@@ -310,9 +310,9 @@ export function scanBack<T, State>(folder: ((arg0: T, arg1: State) => State), ar
     return res;
 }
 
-export function skip<T>(count: int32, array: T[], cons?: any): T[] {
+export function skip<T>(count: int32, array: MutableArray<T>, cons?: any): MutableArray<T> {
     if (count > array.length) {
-        throw new Error("count is greater than array length\\nParameter name: count");
+        throw new Exception("count is greater than array length\\nParameter name: count");
     }
     if (count === array.length) {
         return Helpers_allocateArrayFromCons<T>(cons, 0);
@@ -323,7 +323,7 @@ export function skip<T>(count: int32, array: T[], cons?: any): T[] {
     }
 }
 
-export function skipWhile<T>(predicate: ((arg0: T) => boolean), array: T[], cons?: any): T[] {
+export function skipWhile<T>(predicate: ((arg0: T) => boolean), array: MutableArray<T>, cons?: any): MutableArray<T> {
     let count = 0;
     while ((count < array.length) && predicate(item_2(count, array))) {
         count = ((count + 1) | 0);
@@ -337,12 +337,12 @@ export function skipWhile<T>(predicate: ((arg0: T) => boolean), array: T[], cons
     }
 }
 
-export function take<T>(count: int32, array: T[], cons?: any): T[] {
+export function take<T>(count: int32, array: MutableArray<T>, cons?: any): MutableArray<T> {
     if (count < 0) {
-        throw new Error("The input must be non-negative\\nParameter name: count");
+        throw new Exception("The input must be non-negative\\nParameter name: count");
     }
     if (count > array.length) {
-        throw new Error("count is greater than array length\\nParameter name: count");
+        throw new Exception("count is greater than array length\\nParameter name: count");
     }
     if (count === 0) {
         return Helpers_allocateArrayFromCons<T>(cons, 0);
@@ -352,7 +352,7 @@ export function take<T>(count: int32, array: T[], cons?: any): T[] {
     }
 }
 
-export function takeWhile<T>(predicate: ((arg0: T) => boolean), array: T[], cons?: any): T[] {
+export function takeWhile<T>(predicate: ((arg0: T) => boolean), array: MutableArray<T>, cons?: any): MutableArray<T> {
     let count = 0;
     while ((count < array.length) && predicate(item_2(count, array))) {
         count = ((count + 1) | 0);
@@ -366,6 +366,15 @@ export function takeWhile<T>(predicate: ((arg0: T) => boolean), array: T[], cons
     }
 }
 
+export function findAll<T>(predicate: ((arg0: T) => boolean), array: T[]): T[] {
+    return array.filter(predicate);
+}
+
+export function getRange<T>(array: T[], start: int32, count: int32): T[] {
+    const start_1: int32 = start | 0;
+    return array.slice(start_1, (start_1 + count));
+}
+
 export function addInPlace<T>(x: T, array: T[]): void {
     array.push(x);
 }
@@ -387,7 +396,7 @@ export function insertRangeInPlace<T>(index: int32, range: Iterable<T>, array: T
     const enumerator: IEnumerator<T> = getEnumerator(range);
     try {
         while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-            let index_1: int32;
+            let index_1: int32 = undefined as any;
             const x: T = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
             (index_1 = (i | 0), array.splice(index_1, 0, x));
             i = ((i + 1) | 0);
@@ -411,7 +420,9 @@ export function removeInPlace<T>(item_1: T, array: T[], eq: IEqualityComparer<T>
 
 export function removeAllInPlace<T>(predicate: ((arg0: T) => boolean), array: T[]): int32 {
     const countRemoveAll = (count: int32): int32 => {
-        const i: int32 = (array.findIndex(predicate)) | 0;
+        let i: int32;
+        const array_1: MutableArray<T> = array;
+        i = (array_1.findIndex(predicate));
         if (i > -1) {
             array.splice(i, 1);
             return (countRemoveAll(count) + 1) | 0;
@@ -423,10 +434,10 @@ export function removeAllInPlace<T>(predicate: ((arg0: T) => boolean), array: T[
     return countRemoveAll(0) | 0;
 }
 
-export function partition<T>(f: ((arg0: T) => boolean), source: T[], cons?: any): [T[], T[]] {
+export function partition<T>(f: ((arg0: T) => boolean), source: MutableArray<T>, cons?: any): [MutableArray<T>, MutableArray<T>] {
     const len: int32 = source.length | 0;
-    const res1: T[] = Helpers_allocateArrayFromCons<T>(cons, len);
-    const res2: T[] = Helpers_allocateArrayFromCons<T>(cons, len);
+    const res1: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, len);
+    const res2: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, len);
     let iTrue = 0;
     let iFalse = 0;
     for (let i = 0; i <= (len - 1); i++) {
@@ -439,10 +450,10 @@ export function partition<T>(f: ((arg0: T) => boolean), source: T[], cons?: any)
             iFalse = ((iFalse + 1) | 0);
         }
     }
-    return [truncate<T>(iTrue, res1), truncate<T>(iFalse, res2)] as [T[], T[]];
+    return [truncate<T>(iTrue, res1), truncate<T>(iFalse, res2)] as [MutableArray<T>, MutableArray<T>];
 }
 
-export function find<T>(predicate: ((arg0: T) => boolean), array: T[]): T {
+export function find<T>(predicate: ((arg0: T) => boolean), array: MutableArray<T>): T {
     const matchValue: Option<T> = array.find(predicate);
     if (matchValue == null) {
         return indexNotFound<T>();
@@ -452,11 +463,11 @@ export function find<T>(predicate: ((arg0: T) => boolean), array: T[]): T {
     }
 }
 
-export function tryFind<T>(predicate: ((arg0: T) => boolean), array: T[]): Option<T> {
+export function tryFind<T>(predicate: ((arg0: T) => boolean), array: MutableArray<T>): Option<T> {
     return array.find(predicate);
 }
 
-export function findIndex<T>(predicate: ((arg0: T) => boolean), array: T[]): int32 {
+export function findIndex<T>(predicate: ((arg0: T) => boolean), array: MutableArray<T>): int32 {
     const matchValue: int32 = (array.findIndex(predicate)) | 0;
     if (matchValue > -1) {
         return matchValue | 0;
@@ -467,7 +478,7 @@ export function findIndex<T>(predicate: ((arg0: T) => boolean), array: T[]): int
     }
 }
 
-export function tryFindIndex<T>(predicate: ((arg0: T) => boolean), array: T[]): Option<int32> {
+export function tryFindIndex<T>(predicate: ((arg0: T) => boolean), array: MutableArray<T>): Option<int32> {
     const matchValue: int32 = (array.findIndex(predicate)) | 0;
     if (matchValue > -1) {
         return matchValue;
@@ -477,7 +488,7 @@ export function tryFindIndex<T>(predicate: ((arg0: T) => boolean), array: T[]):
     }
 }
 
-export function pick<$a, $b>(chooser: ((arg0: $a) => Option<$b>), array: $a[]): $b {
+export function pick<$a, $b>(chooser: ((arg0: $a) => Option<$b>), array: MutableArray<$a>): $b {
     const loop = (i_mut: int32): $b => {
         loop:
         while (true) {
@@ -501,7 +512,7 @@ export function pick<$a, $b>(chooser: ((arg0: $a) => Option<$b>), array: $a[]):
     return loop(0);
 }
 
-export function tryPick<$a, $b>(chooser: ((arg0: $a) => Option<$b>), array: $a[]): Option<$b> {
+export function tryPick<$a, $b>(chooser: ((arg0: $a) => Option<$b>), array: MutableArray<$a>): Option<$b> {
     const loop = (i_mut: int32): Option<$b> => {
         loop:
         while (true) {
@@ -525,7 +536,7 @@ export function tryPick<$a, $b>(chooser: ((arg0: $a) => Option<$b>), array: $a[]
     return loop(0);
 }
 
-export function findBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): $a {
+export function findBack<$a>(predicate: ((arg0: $a) => boolean), array: MutableArray<$a>): $a {
     const loop = (i_mut: int32): $a => {
         loop:
         while (true) {
@@ -546,7 +557,7 @@ export function findBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): $
     return loop(array.length - 1);
 }
 
-export function tryFindBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): Option<$a> {
+export function tryFindBack<$a>(predicate: ((arg0: $a) => boolean), array: MutableArray<$a>): Option<$a> {
     const loop = (i_mut: int32): Option<$a> => {
         loop:
         while (true) {
@@ -567,7 +578,7 @@ export function tryFindBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[])
     return loop(array.length - 1);
 }
 
-export function findLastIndex<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): int32 {
+export function findLastIndex<$a>(predicate: ((arg0: $a) => boolean), array: MutableArray<$a>): int32 {
     const loop = (i_mut: int32): int32 => {
         loop:
         while (true) {
@@ -588,7 +599,7 @@ export function findLastIndex<$a>(predicate: ((arg0: $a) => boolean), array: $a[
     return loop(array.length - 1) | 0;
 }
 
-export function findIndexBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): int32 {
+export function findIndexBack<$a>(predicate: ((arg0: $a) => boolean), array: MutableArray<$a>): int32 {
     const loop = (i_mut: int32): int32 => {
         loop:
         while (true) {
@@ -610,7 +621,7 @@ export function findIndexBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[
     return loop(array.length - 1) | 0;
 }
 
-export function tryFindIndexBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): Option<int32> {
+export function tryFindIndexBack<$a>(predicate: ((arg0: $a) => boolean), array: MutableArray<$a>): Option<int32> {
     const loop = (i_mut: int32): Option<int32> => {
         loop:
         while (true) {
@@ -631,7 +642,7 @@ export function tryFindIndexBack<$a>(predicate: ((arg0: $a) => boolean), array:
     return loop(array.length - 1);
 }
 
-export function choose<T, U>(chooser: ((arg0: T) => Option<U>), array: T[], cons?: any): U[] {
+export function choose<T, U>(chooser: ((arg0: T) => Option<U>), array: MutableArray<T>, cons?: any): MutableArray<U> {
     const res: U[] = [];
     for (let i = 0; i <= (array.length - 1); i++) {
         const matchValue: Option<U> = chooser(item_2(i, array));
@@ -648,28 +659,28 @@ export function choose<T, U>(chooser: ((arg0: T) => Option<U>), array: T[], cons
     }
 }
 
-export function foldIndexed<T, State>(folder: ((arg0: int32, arg1: State, arg2: T) => State), state: State, array: T[]): State {
+export function foldIndexed<T, State>(folder: ((arg0: int32, arg1: State, arg2: T) => State), state: State, array: MutableArray<T>): State {
     return array.reduce(((delegateArg: State, delegateArg_1: T, delegateArg_2: int32): State => folder(delegateArg_2, delegateArg, delegateArg_1)), state);
 }
 
-export function fold<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, array: T[]): State {
+export function fold<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, array: MutableArray<T>): State {
     const folder_1: ((arg0: State, arg1: T) => State) = folder;
     return array.reduce((folder_1), state);
 }
 
-export function iterate<T>(action: ((arg0: T) => void), array: T[]): void {
+export function iterate<T>(action: ((arg0: T) => void), array: MutableArray<T>): void {
     for (let i = 0; i <= (array.length - 1); i++) {
         action(item_2(i, array));
     }
 }
 
-export function iterateIndexed<T>(action: ((arg0: int32, arg1: T) => void), array: T[]): void {
+export function iterateIndexed<T>(action: ((arg0: int32, arg1: T) => void), array: MutableArray<T>): void {
     for (let i = 0; i <= (array.length - 1); i++) {
         action(i, item_2(i, array));
     }
 }
 
-export function iterate2<T1, T2>(action: ((arg0: T1, arg1: T2) => void), array1: T1[], array2: T2[]): void {
+export function iterate2<T1, T2>(action: ((arg0: T1, arg1: T2) => void), array1: MutableArray<T1>, array2: MutableArray<T2>): void {
     if (array1.length !== array2.length) {
         differentLengths<void>();
     }
@@ -678,7 +689,7 @@ export function iterate2<T1, T2>(action: ((arg0: T1, arg1: T2) => void), array1:
     }
 }
 
-export function iterateIndexed2<T1, T2>(action: ((arg0: int32, arg1: T1, arg2: T2) => void), array1: T1[], array2: T2[]): void {
+export function iterateIndexed2<T1, T2>(action: ((arg0: int32, arg1: T1, arg2: T2) => void), array1: MutableArray<T1>, array2: MutableArray<T2>): void {
     if (array1.length !== array2.length) {
         differentLengths<void>();
     }
@@ -687,33 +698,33 @@ export function iterateIndexed2<T1, T2>(action: ((arg0: int32, arg1: T1, arg2: T
     }
 }
 
-export function isEmpty<T>(array: T[]): boolean {
+export function isEmpty<T>(array: MutableArray<T>): boolean {
     return array.length === 0;
 }
 
-export function forAll<T>(predicate: ((arg0: T) => boolean), array: T[]): boolean {
+export function forAll<T>(predicate: ((arg0: T) => boolean), array: MutableArray<T>): boolean {
     return array.every(predicate);
 }
 
-export function permute<T>(f: ((arg0: int32) => int32), array: T[]): T[] {
+export function permute<T>(f: ((arg0: int32) => int32), array: MutableArray<T>): MutableArray<T> {
     const size: int32 = array.length | 0;
-    const res: T[] = array.slice();
-    const checkFlags: int32[] = new Array(size);
+    const res: MutableArray<T> = array.slice();
+    const checkFlags: MutableArray<int32> = new Array(size);
     iterateIndexed<T>((i: int32, x: T): void => {
         const j: int32 = f(i) | 0;
         if ((j < 0) ? true : (j >= size)) {
-            throw new Error("Not a valid permutation");
+            throw new Exception("Not a valid permutation");
         }
         setItem_1(res, j, x);
         setItem_1(checkFlags, j, 1);
     }, array);
     if (!(checkFlags.every((y: int32): boolean => (1 === y)))) {
-        throw new Error("Not a valid permutation");
+        throw new Exception("Not a valid permutation");
     }
     return res;
 }
 
-export function setSlice<T>(target: T[], lower: Option<int32>, upper: Option<int32>, source: T[]): void {
+export function setSlice<T>(target: MutableArray<T>, lower: Option<int32>, upper: Option<int32>, source: MutableArray<T>): void {
     const lower_1: int32 = defaultArg<int32>(lower, 0) | 0;
     const upper_1: int32 = defaultArg<int32>(upper, -1) | 0;
     const length: int32 = (((upper_1 >= 0) ? upper_1 : (target.length - 1)) - lower_1) | 0;
@@ -722,49 +733,49 @@ export function setSlice<T>(target: T[], lower: Option<int32>, upper: Option<int
     }
 }
 
-export function sortInPlaceBy<a, b>(projection: ((arg0: a) => b), xs: a[], comparer: IComparer<b>): void {
+export function sortInPlaceBy<a, b>(projection: ((arg0: a) => b), xs: MutableArray<a>, comparer: IComparer<b>): void {
     xs.sort((x: a, y: a): int32 => (comparer.Compare(projection(x), projection(y)) | 0));
 }
 
-export function sortInPlace<T>(xs: T[], comparer: IComparer<T>): void {
-    xs.sort((x: Nullable<T>, y: Nullable<T>): int32 => (comparer.Compare(x, y) | 0));
+export function sortInPlace<T>(xs: MutableArray<T>, comparer: IComparer<T>): void {
+    xs.sort((x: T, y: T): int32 => (comparer.Compare(x, y) | 0));
 }
 
-export function sort<T>(xs: T[], comparer: IComparer<T>): T[] {
-    const xs_1: T[] = xs.slice();
+export function sort<T>(xs: MutableArray<T>, comparer: IComparer<T>): MutableArray<T> {
+    const xs_1: MutableArray<T> = xs.slice();
     xs_1.sort((x: T, y: T): int32 => (comparer.Compare(x, y) | 0));
     return xs_1;
 }
 
-export function sortBy<a, b>(projection: ((arg0: a) => b), xs: a[], comparer: IComparer<b>): a[] {
-    const xs_1: a[] = xs.slice();
+export function sortBy<a, b>(projection: ((arg0: a) => b), xs: MutableArray<a>, comparer: IComparer<b>): MutableArray<a> {
+    const xs_1: MutableArray<a> = xs.slice();
     xs_1.sort((x: a, y: a): int32 => (comparer.Compare(projection(x), projection(y)) | 0));
     return xs_1;
 }
 
-export function sortDescending<T>(xs: T[], comparer: IComparer<T>): T[] {
-    const xs_1: T[] = xs.slice();
+export function sortDescending<T>(xs: MutableArray<T>, comparer: IComparer<T>): MutableArray<T> {
+    const xs_1: MutableArray<T> = xs.slice();
     xs_1.sort((x: T, y: T): int32 => ((comparer.Compare(x, y) * -1) | 0));
     return xs_1;
 }
 
-export function sortByDescending<a, b>(projection: ((arg0: a) => b), xs: a[], comparer: IComparer<b>): a[] {
-    const xs_1: a[] = xs.slice();
+export function sortByDescending<a, b>(projection: ((arg0: a) => b), xs: MutableArray<a>, comparer: IComparer<b>): MutableArray<a> {
+    const xs_1: MutableArray<a> = xs.slice();
     xs_1.sort((x: a, y: a): int32 => ((comparer.Compare(projection(x), projection(y)) * -1) | 0));
     return xs_1;
 }
 
-export function sortWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: T[]): T[] {
+export function sortWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: MutableArray<T>): MutableArray<T> {
     const comparer_1: ((arg0: T, arg1: T) => int32) = comparer;
-    const xs_1: T[] = xs.slice();
+    const xs_1: MutableArray<T> = xs.slice();
     xs_1.sort(comparer_1);
     return xs_1;
 }
 
-export function allPairs<T1, T2>(xs: T1[], ys: T2[]): [T1, T2][] {
+export function allPairs<T1, T2>(xs: MutableArray<T1>, ys: MutableArray<T2>): MutableArray<[T1, T2]> {
     const len1: int32 = xs.length | 0;
     const len2: int32 = ys.length | 0;
-    const res: [T1, T2][] = new Array(len1 * len2);
+    const res: MutableArray<[T1, T2]> = new Array(len1 * len2);
     for (let i = 0; i <= (xs.length - 1); i++) {
         for (let j = 0; j <= (ys.length - 1); j++) {
             setItem_1(res, (i * len2) + j, [item_2(i, xs), item_2(j, ys)] as [T1, T2]);
@@ -773,7 +784,7 @@ export function allPairs<T1, T2>(xs: T1[], ys: T2[]): [T1, T2][] {
     return res;
 }
 
-export function unfold<T, State>(generator: ((arg0: State) => Option<[T, State]>), state: State): T[] {
+export function unfold<T, State>(generator: ((arg0: State) => Option<[T, State]>), state: State): MutableArray<T> {
     const res: T[] = [];
     const loop = (state_1_mut: State): void => {
         loop:
@@ -794,88 +805,86 @@ export function unfold<T, State>(generator: ((arg0: State) => Option<[T, State]>
     return res;
 }
 
-export function unzip<$a, $b>(array: [$a, $b][]): [$a[], $b[]] {
+export function unzip<$a, $b>(array: MutableArray<[$a, $b]>): [MutableArray<$a>, MutableArray<$b>] {
     const len: int32 = array.length | 0;
-    const res1: $a[] = new Array(len);
-    const res2: $b[] = new Array(len);
+    const res1: MutableArray<$a> = new Array(len);
+    const res2: MutableArray<$b> = new Array(len);
     iterateIndexed<[$a, $b]>((i: int32, tupledArg: [$a, $b]): void => {
         setItem_1(res1, i, tupledArg[0]);
         setItem_1(res2, i, tupledArg[1]);
     }, array);
-    return [res1, res2] as [$a[], $b[]];
+    return [res1, res2] as [MutableArray<$a>, MutableArray<$b>];
 }
 
-export function unzip3<$a, $b, $c>(array: [$a, $b, $c][]): [$a[], $b[], $c[]] {
+export function unzip3<$a, $b, $c>(array: MutableArray<[$a, $b, $c]>): [MutableArray<$a>, MutableArray<$b>, MutableArray<$c>] {
     const len: int32 = array.length | 0;
-    const res1: $a[] = new Array(len);
-    const res2: $b[] = new Array(len);
-    const res3: $c[] = new Array(len);
+    const res1: MutableArray<$a> = new Array(len);
+    const res2: MutableArray<$b> = new Array(len);
+    const res3: MutableArray<$c> = new Array(len);
     iterateIndexed<[$a, $b, $c]>((i: int32, tupledArg: [$a, $b, $c]): void => {
         setItem_1(res1, i, tupledArg[0]);
         setItem_1(res2, i, tupledArg[1]);
         setItem_1(res3, i, tupledArg[2]);
     }, array);
-    return [res1, res2, res3] as [$a[], $b[], $c[]];
+    return [res1, res2, res3] as [MutableArray<$a>, MutableArray<$b>, MutableArray<$c>];
 }
 
-export function zip<T, U>(array1: T[], array2: U[]): [T, U][] {
+export function zip<T, U>(array1: MutableArray<T>, array2: MutableArray<U>): MutableArray<[T, U]> {
     if (array1.length !== array2.length) {
         differentLengths<void>();
     }
-    const result: [T, U][] = new Array(array1.length);
+    const result: MutableArray<[T, U]> = new Array(array1.length);
     for (let i = 0; i <= (array1.length - 1); i++) {
         setItem_1(result, i, [item_2(i, array1), item_2(i, array2)] as [T, U]);
     }
     return result;
 }
 
-export function zip3<T, U, V>(array1: T[], array2: U[], array3: V[]): [T, U, V][] {
+export function zip3<T, U, V>(array1: MutableArray<T>, array2: MutableArray<U>, array3: MutableArray<V>): MutableArray<[T, U, V]> {
     if ((array1.length !== array2.length) ? true : (array2.length !== array3.length)) {
         differentLengths<void>();
     }
-    const result: [T, U, V][] = new Array(array1.length);
+    const result: MutableArray<[T, U, V]> = new Array(array1.length);
     for (let i = 0; i <= (array1.length - 1); i++) {
         setItem_1(result, i, [item_2(i, array1), item_2(i, array2), item_2(i, array3)] as [T, U, V]);
     }
     return result;
 }
 
-export function chunkBySize<T>(chunkSize: int32, array: T[]): T[][] {
+export function chunkBySize<T>(chunkSize: int32, array: MutableArray<T>): MutableArray<MutableArray<T>> {
     if (chunkSize < 1) {
-        throw new Error("The input must be positive.\\nParameter name: size");
-    }
-    if (array.length === 0) {
-        return [[]];
+        throw new Exception("The input must be positive.\\nParameter name: size");
     }
-    else {
-        const result: T[][] = [];
-        for (let x = 0; x <= (~~Math.ceil(array.length / chunkSize) - 1); x++) {
-            let slice: T[];
+    const result: MutableArray<T>[] = [];
+    if (array.length > 0) {
+        const chunks: int32 = ~~Math.ceil(array.length / chunkSize) | 0;
+        for (let x = 0; x <= (chunks - 1); x++) {
+            let slice: MutableArray<T>;
             const start_1: int32 = (x * chunkSize) | 0;
             slice = (array.slice(start_1, (start_1 + chunkSize)));
             result.push(slice);
         }
-        return result;
     }
+    return result;
 }
 
-export function splitAt<T>(index: int32, array: T[]): [T[], T[]] {
+export function splitAt<T>(index: int32, array: MutableArray<T>): [MutableArray<T>, MutableArray<T>] {
     if ((index < 0) ? true : (index > array.length)) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     }
-    return [array.slice(0, (0 + index)), array.slice(index)] as [T[], T[]];
+    return [array.slice(0, (0 + index)), array.slice(index)] as [MutableArray<T>, MutableArray<T>];
 }
 
-export function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), source1: T[], source2: T[]): int32 {
-    if (Operators_IsNull<Nullable<any>>(source1)) {
-        if (Operators_IsNull<Nullable<any>>(source2)) {
+export function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), source1: MutableArray<T>, source2: MutableArray<T>): int32 {
+    if (Operators_IsNull<any>(source1)) {
+        if (Operators_IsNull<any>(source2)) {
             return 0;
         }
         else {
             return -1;
         }
     }
-    else if (Operators_IsNull<Nullable<any>>(source2)) {
+    else if (Operators_IsNull<any>(source2)) {
         return 1;
     }
     else {
@@ -903,16 +912,16 @@ export function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), source1:
     }
 }
 
-export function compareTo<T>(comparer: ((arg0: T, arg1: T) => int32), source1: T[], source2: T[]): int32 {
-    if (Operators_IsNull<Nullable<any>>(source1)) {
-        if (Operators_IsNull<Nullable<any>>(source2)) {
+export function compareTo<T>(comparer: ((arg0: T, arg1: T) => int32), source1: MutableArray<T>, source2: MutableArray<T>): int32 {
+    if (Operators_IsNull<any>(source1)) {
+        if (Operators_IsNull<any>(source2)) {
             return 0;
         }
         else {
             return -1;
         }
     }
-    else if (Operators_IsNull<Nullable<any>>(source2)) {
+    else if (Operators_IsNull<any>(source2)) {
         return 1;
     }
     else {
@@ -936,16 +945,16 @@ export function compareTo<T>(comparer: ((arg0: T, arg1: T) => int32), source1: T
     }
 }
 
-export function equalsWith<T>(equals: ((arg0: T, arg1: T) => boolean), source1: T[], source2: T[]): boolean {
-    if (Operators_IsNull<Nullable<any>>(source1)) {
-        if (Operators_IsNull<Nullable<any>>(source2)) {
+export function equalsWith<T>(equals: ((arg0: T, arg1: T) => boolean), source1: MutableArray<T>, source2: MutableArray<T>): boolean {
+    if (Operators_IsNull<any>(source1)) {
+        if (Operators_IsNull<any>(source2)) {
             return true;
         }
         else {
             return false;
         }
     }
-    else if (Operators_IsNull<Nullable<any>>(source2)) {
+    else if (Operators_IsNull<any>(source2)) {
         return false;
     }
     else {
@@ -969,18 +978,18 @@ export function equalsWith<T>(equals: ((arg0: T, arg1: T) => boolean), source1:
     }
 }
 
-export function exactlyOne<T>(array: T[]): T {
+export function exactlyOne<T>(array: MutableArray<T>): T {
     switch (array.length) {
         case 1:
             return item_2(0, array);
         case 0:
-            throw new Error("The input sequence was empty\\nParameter name: array");
+            throw new Exception("The input sequence was empty\\nParameter name: array");
         default:
-            throw new Error("Input array too long\\nParameter name: array");
+            throw new Exception("Input array too long\\nParameter name: array");
     }
 }
 
-export function tryExactlyOne<T>(array: T[]): Option<T> {
+export function tryExactlyOne<T>(array: MutableArray<T>): Option<T> {
     if (array.length === 1) {
         return some(item_2(0, array));
     }
@@ -989,16 +998,16 @@ export function tryExactlyOne<T>(array: T[]): Option<T> {
     }
 }
 
-export function head<T>(array: T[]): T {
+export function head<T>(array: MutableArray<T>): T {
     if (array.length === 0) {
-        throw new Error("The input array was empty\\nParameter name: array");
+        throw new Exception("The input array was empty\\nParameter name: array");
     }
     else {
         return item_2(0, array);
     }
 }
 
-export function tryHead<T>(array: T[]): Option<T> {
+export function tryHead<T>(array: MutableArray<T>): Option<T> {
     if (array.length === 0) {
         return undefined;
     }
@@ -1007,32 +1016,32 @@ export function tryHead<T>(array: T[]): Option<T> {
     }
 }
 
-export function tail<T>(array: T[]): T[] {
+export function tail<T>(array: MutableArray<T>): MutableArray<T> {
     if (array.length === 0) {
-        throw new Error("Not enough elements\\nParameter name: array");
+        throw new Exception("Not enough elements\\nParameter name: array");
     }
     return array.slice(1);
 }
 
-export function item<T>(index: int32, array: T[]): T {
+export function item<T>(index: int32, array: MutableArray<T>): T {
     if ((index < 0) ? true : (index >= array.length)) {
-        throw new Error("Index was outside the bounds of the array.\\nParameter name: index");
+        throw new Exception("Index was outside the bounds of the array.\\nParameter name: index");
     }
     else {
         return array[index];
     }
 }
 
-export function setItem<T>(array: T[], index: int32, value: T): void {
+export function setItem<T>(array: MutableArray<T>, index: int32, value: T): void {
     if ((index < 0) ? true : (index >= array.length)) {
-        throw new Error("Index was outside the bounds of the array.\\nParameter name: index");
+        throw new Exception("Index was outside the bounds of the array.\\nParameter name: index");
     }
     else {
         array[index] = value;
     }
 }
 
-export function tryItem<T>(index: int32, array: T[]): Option<T> {
+export function tryItem<T>(index: int32, array: MutableArray<T>): Option<T> {
     if ((index < 0) ? true : (index >= array.length)) {
         return undefined;
     }
@@ -1041,18 +1050,18 @@ export function tryItem<T>(index: int32, array: T[]): Option<T> {
     }
 }
 
-export function foldBackIndexed<T, State>(folder: ((arg0: int32, arg1: T, arg2: State) => State), array: T[], state: State): State {
+export function foldBackIndexed<T, State>(folder: ((arg0: int32, arg1: T, arg2: State) => State), array: MutableArray<T>, state: State): State {
     return array.reduceRight(((delegateArg: State, delegateArg_1: T, delegateArg_2: int32): State => folder(delegateArg_2, delegateArg_1, delegateArg)), state);
 }
 
-export function foldBack<T, State>(folder: ((arg0: T, arg1: State) => State), array: T[], state: State): State {
+export function foldBack<T, State>(folder: ((arg0: T, arg1: State) => State), array: MutableArray<T>, state: State): State {
     return array.reduceRight(((delegateArg: State, delegateArg_1: T): State => folder(delegateArg_1, delegateArg)), state);
 }
 
-export function foldIndexed2<$a, $b, $c>(folder: ((arg0: int32, arg1: $a, arg2: $b, arg3: $c) => $a), state: $a, array1: $b[], array2: $c[]): $a {
+export function foldIndexed2<$a, $b, $c>(folder: ((arg0: int32, arg1: $a, arg2: $b, arg3: $c) => $a), state: $a, array1: MutableArray<$b>, array2: MutableArray<$c>): $a {
     let acc: $a = state;
     if (array1.length !== array2.length) {
-        throw new Error("Arrays have different lengths");
+        throw new Exception("Arrays have different lengths");
     }
     for (let i = 0; i <= (array1.length - 1); i++) {
         acc = folder(i, acc, item_2(i, array1), item_2(i, array2));
@@ -1060,11 +1069,11 @@ export function foldIndexed2<$a, $b, $c>(folder: ((arg0: int32, arg1: $a, arg2:
     return acc;
 }
 
-export function fold2<T1, T2, State>(folder: ((arg0: State, arg1: T1, arg2: T2) => State), state: State, array1: T1[], array2: T2[]): State {
+export function fold2<T1, T2, State>(folder: ((arg0: State, arg1: T1, arg2: T2) => State), state: State, array1: MutableArray<T1>, array2: MutableArray<T2>): State {
     return foldIndexed2<State, T1, T2>((_arg: int32, acc: State, x: T1, y: T2): State => folder(acc, x, y), state, array1, array2);
 }
 
-export function foldBackIndexed2<T1, T2, State>(folder: ((arg0: int32, arg1: T1, arg2: T2, arg3: State) => State), array1: T1[], array2: T2[], state: State): State {
+export function foldBackIndexed2<T1, T2, State>(folder: ((arg0: int32, arg1: T1, arg2: T2, arg3: State) => State), array1: MutableArray<T1>, array2: MutableArray<T2>, state: State): State {
     let acc: State = state;
     if (array1.length !== array2.length) {
         differentLengths<void>();
@@ -1076,34 +1085,34 @@ export function foldBackIndexed2<T1, T2, State>(folder: ((arg0: int32, arg1: T1,
     return acc;
 }
 
-export function foldBack2<T1, T2, State>(f: ((arg0: T1, arg1: T2, arg2: State) => State), array1: T1[], array2: T2[], state: State): State {
+export function foldBack2<T1, T2, State>(f: ((arg0: T1, arg1: T2, arg2: State) => State), array1: MutableArray<T1>, array2: MutableArray<T2>, state: State): State {
     return foldBackIndexed2<T1, T2, State>((_arg: int32, x: T1, y: T2, acc: State): State => f(x, y, acc), array1, array2, state);
 }
 
-export function reduce<T>(reduction: ((arg0: T, arg1: T) => T), array: T[]): T {
+export function reduce<T>(reduction: ((arg0: T, arg1: T) => T), array: MutableArray<T>): T {
     if (array.length === 0) {
-        throw new Error("The input array was empty");
+        throw new Exception("The input array was empty");
     }
     const reduction_1: ((arg0: T, arg1: T) => T) = reduction;
     return array.reduce(reduction_1);
 }
 
-export function reduceBack<T>(reduction: ((arg0: T, arg1: T) => T), array: T[]): T {
+export function reduceBack<T>(reduction: ((arg0: T, arg1: T) => T), array: MutableArray<T>): T {
     if (array.length === 0) {
-        throw new Error("The input array was empty");
+        throw new Exception("The input array was empty");
     }
     const reduction_1: ((arg0: T, arg1: T) => T) = reduction;
     return array.reduceRight(reduction_1);
 }
 
-export function forAll2<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), array1: $a[], array2: $b[]): boolean {
+export function forAll2<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), array1: MutableArray<$a>, array2: MutableArray<$b>): boolean {
     return fold2<$a, $b, boolean>((acc: boolean, x: $a, y: $b): boolean => (acc && predicate(x, y)), true, array1, array2);
 }
 
-export function existsOffset<T>(predicate_mut: ((arg0: T) => boolean), array_mut: T[], index_mut: int32): boolean {
+export function existsOffset<T>(predicate_mut: ((arg0: T) => boolean), array_mut: MutableArray<T>, index_mut: int32): boolean {
     existsOffset:
     while (true) {
-        const predicate: ((arg0: T) => boolean) = predicate_mut, array: T[] = array_mut, index: int32 = index_mut;
+        const predicate: ((arg0: T) => boolean) = predicate_mut, array: MutableArray<T> = array_mut, index: int32 = index_mut;
         if (index === array.length) {
             return false;
         }
@@ -1120,14 +1129,14 @@ export function existsOffset<T>(predicate_mut: ((arg0: T) => boolean), array_mut
     }
 }
 
-export function exists<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): boolean {
+export function exists<$a>(predicate: ((arg0: $a) => boolean), array: MutableArray<$a>): boolean {
     return existsOffset<$a>(predicate, array, 0);
 }
 
-export function existsOffset2<$a, $b>(predicate_mut: ((arg0: $a, arg1: $b) => boolean), array1_mut: $a[], array2_mut: $b[], index_mut: int32): boolean {
+export function existsOffset2<$a, $b>(predicate_mut: ((arg0: $a, arg1: $b) => boolean), array1_mut: MutableArray<$a>, array2_mut: MutableArray<$b>, index_mut: int32): boolean {
     existsOffset2:
     while (true) {
-        const predicate: ((arg0: $a, arg1: $b) => boolean) = predicate_mut, array1: $a[] = array1_mut, array2: $b[] = array2_mut, index: int32 = index_mut;
+        const predicate: ((arg0: $a, arg1: $b) => boolean) = predicate_mut, array1: MutableArray<$a> = array1_mut, array2: MutableArray<$b> = array2_mut, index: int32 = index_mut;
         if (index === array1.length) {
             return false;
         }
@@ -1145,14 +1154,14 @@ export function existsOffset2<$a, $b>(predicate_mut: ((arg0: $a, arg1: $b) => bo
     }
 }
 
-export function exists2<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), array1: $a[], array2: $b[]): boolean {
+export function exists2<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), array1: MutableArray<$a>, array2: MutableArray<$b>): boolean {
     if (array1.length !== array2.length) {
         differentLengths<void>();
     }
     return existsOffset2<$a, $b>(predicate, array1, array2, 0);
 }
 
-export function sum<T>(array: T[], adder: any): T {
+export function sum<T>(array: MutableArray<T>, adder: any): T {
     let acc: T = adder.GetZero();
     for (let i = 0; i <= (array.length - 1); i++) {
         acc = adder.Add(acc, item_2(i, array));
@@ -1160,7 +1169,7 @@ export function sum<T>(array: T[], adder: any): T {
     return acc;
 }
 
-export function sumBy<T, T2>(projection: ((arg0: T) => T2), array: T[], adder: any): T2 {
+export function sumBy<T, T2>(projection: ((arg0: T) => T2), array: MutableArray<T>, adder: any): T2 {
     let acc: T2 = adder.GetZero();
     for (let i = 0; i <= (array.length - 1); i++) {
         acc = adder.Add(acc, projection(item_2(i, array)));
@@ -1168,25 +1177,25 @@ export function sumBy<T, T2>(projection: ((arg0: T) => T2), array: T[], adder: a
     return acc;
 }
 
-export function maxBy<a, b>(projection: ((arg0: a) => b), xs: a[], comparer: IComparer<b>): a {
+export function maxBy<a, b>(projection: ((arg0: a) => b), xs: MutableArray<a>, comparer: IComparer<b>): a {
     return reduce<a>((x: a, y: a): a => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);
 }
 
-export function max<a>(xs: a[], comparer: IComparer<a>): a {
+export function max<a>(xs: MutableArray<a>, comparer: IComparer<a>): a {
     return reduce<a>((x: a, y: a): a => ((comparer.Compare(y, x) > 0) ? y : x), xs);
 }
 
-export function minBy<a, b>(projection: ((arg0: a) => b), xs: a[], comparer: IComparer<b>): a {
+export function minBy<a, b>(projection: ((arg0: a) => b), xs: MutableArray<a>, comparer: IComparer<b>): a {
     return reduce<a>((x: a, y: a): a => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);
 }
 
-export function min<a>(xs: a[], comparer: IComparer<a>): a {
+export function min<a>(xs: MutableArray<a>, comparer: IComparer<a>): a {
     return reduce<a>((x: a, y: a): a => ((comparer.Compare(y, x) > 0) ? x : y), xs);
 }
 
-export function average<T>(array: T[], averager: any): T {
+export function average<T>(array: MutableArray<T>, averager: any): T {
     if (array.length === 0) {
-        throw new Error("The input array was empty\\nParameter name: array");
+        throw new Exception("The input array was empty\\nParameter name: array");
     }
     let total: T = averager.GetZero();
     for (let i = 0; i <= (array.length - 1); i++) {
@@ -1195,9 +1204,9 @@ export function average<T>(array: T[], averager: any): T {
     return averager.DivideByInt(total, array.length);
 }
 
-export function averageBy<T, T2>(projection: ((arg0: T) => T2), array: T[], averager: any): T2 {
+export function averageBy<T, T2>(projection: ((arg0: T) => T2), array: MutableArray<T>, averager: any): T2 {
     if (array.length === 0) {
-        throw new Error("The input array was empty\\nParameter name: array");
+        throw new Exception("The input array was empty\\nParameter name: array");
     }
     let total: T2 = averager.GetZero();
     for (let i = 0; i <= (array.length - 1); i++) {
@@ -1206,11 +1215,11 @@ export function averageBy<T, T2>(projection: ((arg0: T) => T2), array: T[], aver
     return averager.DivideByInt(total, array.length);
 }
 
-export function windowed<T>(windowSize: int32, source: T[]): T[][] {
+export function windowed<T>(windowSize: int32, source: MutableArray<T>): MutableArray<MutableArray<T>> {
     if (windowSize <= 0) {
-        throw new Error("windowSize must be positive");
+        throw new Exception("windowSize must be positive");
     }
-    let res: T[][];
+    let res: MutableArray<MutableArray<T>>;
     const len: int32 = max_1(0, (source.length - windowSize) + 1) | 0;
     res = (new Array(len));
     for (let i: int32 = windowSize; i <= source.length; i++) {
@@ -1219,42 +1228,39 @@ export function windowed<T>(windowSize: int32, source: T[]): T[][] {
     return res;
 }
 
-export function splitInto<T>(chunks: int32, array: T[]): T[][] {
+export function splitInto<T>(chunks: int32, array: MutableArray<T>): MutableArray<MutableArray<T>> {
     if (chunks < 1) {
-        throw new Error("The input must be positive.\\nParameter name: chunks");
-    }
-    if (array.length === 0) {
-        return [[]];
+        throw new Exception("The input must be positive.\\nParameter name: chunks");
     }
-    else {
-        const result: T[][] = [];
+    const result: MutableArray<T>[] = [];
+    if (array.length > 0) {
         const chunks_1: int32 = min_1(chunks, array.length) | 0;
         const minChunkSize: int32 = ~~(array.length / chunks_1) | 0;
         const chunksWithExtraItem: int32 = (array.length % chunks_1) | 0;
         for (let i = 0; i <= (chunks_1 - 1); i++) {
             const chunkSize: int32 = ((i < chunksWithExtraItem) ? (minChunkSize + 1) : minChunkSize) | 0;
-            let slice: T[];
+            let slice: MutableArray<T>;
             const start_1: int32 = ((i * minChunkSize) + min_1(chunksWithExtraItem, i)) | 0;
             slice = (array.slice(start_1, (start_1 + chunkSize)));
             result.push(slice);
         }
-        return result;
     }
+    return result;
 }
 
-export function transpose<T>(arrays: Iterable<T[]>, cons?: any): T[][] {
-    const arrays_1: T[][] = Array.isArray(arrays) ? (arrays as T[][]) : (Array.from(arrays));
+export function transpose<T>(arrays: Iterable<MutableArray<T>>, cons?: any): MutableArray<MutableArray<T>> {
+    const arrays_1: MutableArray<MutableArray<T>> = Array.isArray(arrays) ? (arrays as MutableArray<MutableArray<T>>) : (Array.from(arrays));
     const len: int32 = arrays_1.length | 0;
     if (len === 0) {
         return new Array(0);
     }
     else {
-        const firstArray: T[] = item_2(0, arrays_1);
+        const firstArray: MutableArray<T> = item_2(0, arrays_1);
         const lenInner: int32 = firstArray.length | 0;
-        if (!forAll<T[]>((a: T[]): boolean => (a.length === lenInner), arrays_1)) {
+        if (!forAll<MutableArray<T>>((a: MutableArray<T>): boolean => (a.length === lenInner), arrays_1)) {
             differentLengths<void>();
         }
-        const result: T[][] = new Array(lenInner);
+        const result: MutableArray<MutableArray<T>> = new Array(lenInner);
         for (let i = 0; i <= (lenInner - 1); i++) {
             setItem_1(result, i, Helpers_allocateArrayFromCons<T>(cons, len));
             for (let j = 0; j <= (len - 1); j++) {
@@ -1265,12 +1271,12 @@ export function transpose<T>(arrays: Iterable<T[]>, cons?: any): T[][] {
     }
 }
 
-export function insertAt<T>(index: int32, y: T, xs: T[], cons?: any): T[] {
+export function insertAt<T>(index: int32, y: T, xs: MutableArray<T>, cons?: any): MutableArray<T> {
     const len: int32 = xs.length | 0;
     if ((index < 0) ? true : (index > len)) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     }
-    const target: T[] = Helpers_allocateArrayFromCons<T>(cons, len + 1);
+    const target: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, len + 1);
     for (let i = 0; i <= (index - 1); i++) {
         setItem_1(target, i, item_2(i, xs));
     }
@@ -1281,14 +1287,14 @@ export function insertAt<T>(index: int32, y: T, xs: T[], cons?: any): T[] {
     return target;
 }
 
-export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: T[], cons?: any): T[] {
+export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: MutableArray<T>, cons?: any): MutableArray<T> {
     const len: int32 = xs.length | 0;
     if ((index < 0) ? true : (index > len)) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     }
-    const ys_1: T[] = Array.from(ys);
+    const ys_1: MutableArray<T> = Array.from(ys);
     const len2: int32 = ys_1.length | 0;
-    const target: T[] = Helpers_allocateArrayFromCons<T>(cons, len + len2);
+    const target: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, len + len2);
     for (let i = 0; i <= (index - 1); i++) {
         setItem_1(target, i, item_2(i, xs));
     }
@@ -1301,9 +1307,9 @@ export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: T[], cons?: a
     return target;
 }
 
-export function removeAt<T>(index: int32, xs: T[]): T[] {
+export function removeAt<T>(index: int32, xs: MutableArray<T>): MutableArray<T> {
     if ((index < 0) ? true : (index >= xs.length)) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     }
     let i = -1;
     return filter<T>((_arg: T): boolean => {
@@ -1312,10 +1318,10 @@ export function removeAt<T>(index: int32, xs: T[]): T[] {
     }, xs);
 }
 
-export function removeManyAt<T>(index: int32, count: int32, xs: T[]): T[] {
+export function removeManyAt<T>(index: int32, count: int32, xs: MutableArray<T>): MutableArray<T> {
     let i = -1;
     let status = -1;
-    const ys: T[] = filter<T>((_arg: T): boolean => {
+    const ys: MutableArray<T> = filter<T>((_arg: T): boolean => {
         i = ((i + 1) | 0);
         if (i === index) {
             status = 0;
@@ -1336,30 +1342,30 @@ export function removeManyAt<T>(index: int32, count: int32, xs: T[]): T[] {
     }, xs);
     const status_1: int32 = (((status === 0) && ((i + 1) === (index + count))) ? 1 : status) | 0;
     if (status_1 < 1) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + ((status_1 < 0) ? "index" : "count"));
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + ((status_1 < 0) ? "index" : "count"));
     }
     return ys;
 }
 
-export function updateAt<T>(index: int32, y: T, xs: T[], cons?: any): T[] {
+export function updateAt<T>(index: int32, y: T, xs: MutableArray<T>, cons?: any): MutableArray<T> {
     const len: int32 = xs.length | 0;
     if ((index < 0) ? true : (index >= len)) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     }
-    const target: T[] = Helpers_allocateArrayFromCons<T>(cons, len);
+    const target: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, len);
     for (let i = 0; i <= (len - 1); i++) {
         setItem_1(target, i, (i === index) ? y : item_2(i, xs));
     }
     return target;
 }
 
-export function resize<T>(xs: FSharpRef<T[]>, newSize: int32, zero?: Option<T>, cons?: any): void {
-    let array: T[], array_1: T[], start_2: int32, count_2: int32;
+export function resize<T>(xs: FSharpRef<MutableArray<T>>, newSize: int32, zero?: Option<T>, cons?: any): void {
+    let array: MutableArray<T> = (undefined as any), array_1: MutableArray<T> = (undefined as any), start_2: int32 = (undefined as any), count_2: int32 = (undefined as any);
     if (newSize < 0) {
-        throw new Error("The input must be non-negative.\\nParameter name: newSize");
+        throw new Exception("The input must be non-negative.\\nParameter name: newSize");
     }
     const zero_1: T = defaultArg<T>(zero, defaultOf());
-    if (Operators_IsNull<Nullable<any>>(xs.contents)) {
+    if (Operators_IsNull<any>(xs.contents)) {
         xs.contents = ((array = Helpers_allocateArrayFromCons<T>(cons, newSize), array.fill(zero_1, 0, (0 + newSize))));
     }
     else {
@@ -1368,7 +1374,7 @@ export function resize<T>(xs: FSharpRef<T[]>, newSize: int32, zero?: Option<T>,
             xs.contents = ((array_1 = xs.contents, array_1.slice(0, (0 + newSize))));
         }
         else if (newSize > len) {
-            const target: T[] = Helpers_allocateArrayFromCons<T>(cons, newSize);
+            const target: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, newSize);
             if (len > 0) {
                 copyTo<T>(xs.contents, 0, target, 0, len);
             }