@fable-org/fable-library-ts 1.0.0-beta-001

package/MutableSet.ts

@@ -0,0 +1,248 @@
+import { IMap, IEqualityComparer, IDisposable, disposeSafe, defaultOf, ISet, toIterator, IEnumerator, getEnumerator } from "./Util.js";
+import { iterate, map, iterateIndexed, concat } from "./Seq.js";
+import { int32 } from "./Int32.js";
+import { some, Option } from "./Option.js";
+import { FSharpRef } from "./Types.js";
+import { class_type, TypeInfo } from "./Reflection.js";
+import { getItemFromDict, tryGetValue } from "./MapUtil.js";
+
+export class HashSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
+    readonly comparer: IEqualityComparer<T>;
+    readonly hashMap: IMap<int32, T[]>;
+    "init@9": int32;
+    constructor(items: Iterable<T>, comparer: IEqualityComparer<T>) {
+        const this$: FSharpRef<HashSet<T>> = new FSharpRef<HashSet<T>>(defaultOf());
+        this.comparer = comparer;
+        this$.contents = this;
+        this.hashMap = (new Map<int32, T[]>([]));
+        this["init@9"] = 1;
+        const enumerator: IEnumerator<T> = getEnumerator(items);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const item: T = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                HashSet__Add_2B595<T>(this$.contents, item);
+            }
+        }
+        finally {
+            disposeSafe(enumerator as IDisposable);
+        }
+    }
+    get [Symbol.toStringTag](): string {
+        return "HashSet";
+    }
+    toJSON(): any {
+        const this$: HashSet<T> = this;
+        return Array.from(this$);
+    }
+    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any> {
+        const this$: HashSet<T> = this;
+        return getEnumerator(this$);
+    }
+    GetEnumerator(): IEnumerator<T> {
+        const this$: HashSet<T> = this;
+        return getEnumerator(concat<T[], T>(this$.hashMap.values()));
+    }
+    [Symbol.iterator](): Iterator<T> {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.Generic.ICollection`1.Add2B595"(item: T): void {
+        const this$: HashSet<T> = this;
+        HashSet__Add_2B595<T>(this$, item);
+    }
+    "System.Collections.Generic.ICollection`1.Clear"(): void {
+        const this$: HashSet<T> = this;
+        HashSet__Clear<T>(this$);
+    }
+    "System.Collections.Generic.ICollection`1.Contains2B595"(item: T): boolean {
+        const this$: HashSet<T> = this;
+        return HashSet__Contains_2B595<T>(this$, item);
+    }
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: T[], arrayIndex: int32): void {
+        const this$: HashSet<T> = this;
+        iterateIndexed<T>((i: int32, e: T): void => {
+            array[arrayIndex + i] = e;
+        }, this$);
+    }
+    "System.Collections.Generic.ICollection`1.get_Count"(): int32 {
+        const this$: HashSet<T> = this;
+        return HashSet__get_Count<T>(this$) | 0;
+    }
+    "System.Collections.Generic.ICollection`1.get_IsReadOnly"(): boolean {
+        return false;
+    }
+    "System.Collections.Generic.ICollection`1.Remove2B595"(item: T): boolean {
+        const this$: HashSet<T> = this;
+        return HashSet__Remove_2B595<T>(this$, item);
+    }
+    get size(): int32 {
+        const this$: HashSet<T> = this;
+        return HashSet__get_Count<T>(this$) | 0;
+    }
+    add(k: T): ISet<T> {
+        const this$: HashSet<T> = this;
+        HashSet__Add_2B595<T>(this$, k);
+        return this$;
+    }
+    clear(): void {
+        const this$: HashSet<T> = this;
+        HashSet__Clear<T>(this$);
+    }
+    delete(k: T): boolean {
+        const this$: HashSet<T> = this;
+        return HashSet__Remove_2B595<T>(this$, k);
+    }
+    has(k: T): boolean {
+        const this$: HashSet<T> = this;
+        return HashSet__Contains_2B595<T>(this$, k);
+    }
+    keys(): Iterable<T> {
+        const this$: HashSet<T> = this;
+        return map<T, T>((x: T): T => x, this$);
+    }
+    values(): Iterable<T> {
+        const this$: HashSet<T> = this;
+        return map<T, T>((x: T): T => x, this$);
+    }
+    entries(): Iterable<[T, T]> {
+        const this$: HashSet<T> = this;
+        return map<T, [T, T]>((v: T): [T, T] => ([v, v] as [T, T]), this$);
+    }
+    forEach(f: ((arg0: T, arg1: T, arg2: ISet<T>) => void), thisArg?: Option<any>): void {
+        const this$: HashSet<T> = this;
+        iterate<T>((x: T): void => {
+            f(x, x, this$);
+        }, this$);
+    }
+}
+
+export function HashSet_$reflection(gen0: TypeInfo): TypeInfo {
+    return class_type("Fable.Collections.HashSet", [gen0], HashSet);
+}
+
+export function HashSet_$ctor_Z6150332D<T>(items: Iterable<T>, comparer: IEqualityComparer<T>): HashSet<T> {
+    return new HashSet(items, comparer);
+}
+
+function HashSet__TryFindIndex_2B595<T>(this$: HashSet<T>, k: T): [boolean, int32, int32] {
+    const h: int32 = this$.comparer.GetHashCode(k) | 0;
+    let matchValue: [boolean, T[]];
+    let outArg: T[] = defaultOf();
+    matchValue = ([tryGetValue(this$.hashMap, h, new FSharpRef<T[]>((): T[] => outArg, (v: T[]): void => {
+        outArg = v;
+    })), outArg] as [boolean, T[]]);
+    if (matchValue[0]) {
+        return [true, h, matchValue[1].findIndex((v_1: T): boolean => this$.comparer.Equals(k, v_1))] as [boolean, int32, int32];
+    }
+    else {
+        return [false, h, -1] as [boolean, int32, int32];
+    }
+}
+
+function HashSet__TryFind_2B595<T>(this$: HashSet<T>, k: T): Option<T> {
+    const matchValue: [boolean, int32, int32] = HashSet__TryFindIndex_2B595<T>(this$, k);
+    let matchResult: int32;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return some(getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]]);
+        default:
+            return void 0;
+    }
+}
+
+export function HashSet__get_Comparer<T>(this$: HashSet<T>): IEqualityComparer<T> {
+    return this$.comparer;
+}
+
+export function HashSet__Clear<T>(this$: HashSet<T>): void {
+    this$.hashMap.clear();
+}
+
+export function HashSet__get_Count<T>(this$: HashSet<T>): int32 {
+    let count = 0;
+    let enumerator: any = getEnumerator(this$.hashMap.values());
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const items: T[] = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            count = ((count + items.length) | 0);
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    return count | 0;
+}
+
+export function HashSet__Add_2B595<T>(this$: HashSet<T>, k: T): boolean {
+    const matchValue: [boolean, int32, int32] = HashSet__TryFindIndex_2B595<T>(this$, k);
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            return false;
+        }
+        else {
+            const value: any = void (getItemFromDict(this$.hashMap, matchValue[1]).push(k));
+            return true;
+        }
+    }
+    else {
+        this$.hashMap.set(matchValue[1], [k]);
+        return true;
+    }
+}
+
+export function HashSet__Contains_2B595<T>(this$: HashSet<T>, k: T): boolean {
+    const matchValue: [boolean, int32, int32] = HashSet__TryFindIndex_2B595<T>(this$, k);
+    let matchResult: int32;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return true;
+        default:
+            return false;
+    }
+}
+
+export function HashSet__Remove_2B595<T>(this$: HashSet<T>, k: T): boolean {
+    const matchValue: [boolean, int32, int32] = HashSet__TryFindIndex_2B595<T>(this$, k);
+    let matchResult: int32;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);
+            return true;
+        }
+        default:
+            return false;
+    }
+}
+

package/Native.ts

@@ -0,0 +1,11 @@
+import { int32 } from "./Int32.js";
+
+export function Helpers_allocateArrayFromCons<T>(cons: any, len: int32): T[] {
+    if ((typeof cons) === "function") {
+        return new cons(len);
+    }
+    else {
+        return new Array(len);
+    }
+}
+

package/Numeric.ts

@@ -0,0 +1,80 @@
+import { IComparable } from "./Util.js";
+
+export const symbol = Symbol("numeric");
+
+export interface CustomNumeric extends IComparable<Numeric> {
+    [symbol](): {
+        multiply(y: Numeric): Numeric,
+        toPrecision(sd?: number): string,
+        toExponential(dp?: number): string,
+        toFixed(dp?: number): string,
+        toHex(): string,
+    }
+}
+
+export type Numeric = number | bigint | CustomNumeric;
+
+export function isNumeric(x: any) {
+    return typeof x === "number" || typeof x === "bigint" || x?.[symbol];
+}
+
+export function compare(x: Numeric, y: number) {
+    if (typeof x === "number") {
+        return x < y ? -1 : (x > y ? 1 : 0);
+    } else if (typeof x === "bigint") {
+        return x < y ? -1 : (x > y ? 1 : 0);
+    } else {
+        return x.CompareTo(y);
+    }
+}
+
+export function multiply(x: Numeric, y: number) {
+    if (typeof x === "number") {
+        return x * y;
+    } else if (typeof x === "bigint") {
+        return x * BigInt(y);
+    } else {
+        return x[symbol]().multiply(y);
+    }
+}
+
+export function toFixed(x: Numeric, dp?: number) {
+    if (typeof x === "number") {
+        return x.toFixed(dp);
+    } else if (typeof x === "bigint") {
+        return x;
+    } else {
+        return x[symbol]().toFixed(dp);
+    }
+}
+
+export function toPrecision(x: Numeric, sd?: number) {
+    if (typeof x === "number") {
+        return x.toPrecision(sd);
+    } else if (typeof x === "bigint") {
+        return x;
+    } else {
+        return x[symbol]().toPrecision(sd);
+    }
+}
+
+export function toExponential(x: Numeric, dp?: number) {
+    if (typeof x === "number") {
+        return x.toExponential(dp);
+    } else if (typeof x === "bigint") {
+        return x;
+    } else {
+        return x[symbol]().toExponential(dp);
+    }
+}
+
+export function toHex(x: Numeric) {
+    if (typeof x === "number") {
+        return (Number(x) >>> 0).toString(16);
+    } else if (typeof x === "bigint") {
+        // TODO: properly handle other bit sizes
+        return BigInt.asUintN(64, x).toString(16);
+    } else {
+        return x[symbol]().toHex();
+    }
+}

package/Observable.ts

@@ -0,0 +1,156 @@
+
+import { FSharpChoice$2_$union, Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.js";
+import { Option, value } from "./Option.js";
+import { IDisposable } from "./Util.js";
+
+export interface IObserver<T> {
+  OnNext: (x: T) => void;
+  OnError: (e: any) => void;
+  OnCompleted: () => void;
+}
+
+export class Observer<T> implements IObserver<T> {
+  public OnNext: (x: T) => void;
+  public OnError: (e: any) => void;
+  public OnCompleted: () => void;
+
+  constructor(onNext: (x: T) => void, onError?: (e: any) => void, onCompleted?: () => void) {
+    this.OnNext = onNext;
+    this.OnError = onError || ((_e: any) => { return; });
+    this.OnCompleted = onCompleted || (() => { return; });
+  }
+}
+
+export interface IObservable<T> {
+  Subscribe: (o: IObserver<T>) => IDisposable;
+}
+
+class Observable<T> implements IObservable<T> {
+  public Subscribe: (o: IObserver<T>) => IDisposable;
+
+  constructor(subscribe: (o: IObserver<T>) => IDisposable) {
+    this.Subscribe = subscribe;
+  }
+}
+
+function protect<T>(f: () => T, succeed: (x: T) => void, fail: (e: any) => void) {
+  try {
+    return succeed(f());
+  } catch (e) {
+    fail(e);
+  }
+}
+
+export function add<T>(callback: (x: T) => void, source: IObservable<T>): void {
+  source.Subscribe(new Observer(callback));
+}
+
+export function choose<T, U>(chooser: (x: T) => Option<U>, source: IObservable<T>): Observable<U> {
+  return new Observable<U>((observer) =>
+    source.Subscribe(new Observer<T>((t) =>
+      protect(
+        () => chooser(t),
+        (u) => { if (u != null) { observer.OnNext(value(u)); } },
+        observer.OnError),
+      observer.OnError, observer.OnCompleted)));
+}
+
+export function filter<T>(predicate: (x: T) => boolean, source: IObservable<T>): IObservable<T> {
+  return choose((x) => predicate(x) ? x : void 0, source);
+}
+
+export function map<T, U>(mapping: (x: T) => U, source: IObservable<T>): IObservable<U> {
+  return new Observable<U>((observer) =>
+    source.Subscribe(new Observer<T>((t) => {
+      protect(
+        () => mapping(t),
+        observer.OnNext,
+        observer.OnError);
+    }, observer.OnError, observer.OnCompleted)));
+}
+
+export function merge<T>(source1: IObservable<T>, source2: IObservable<T>): IObservable<T> {
+  return new Observable((observer) => {
+    let stopped = false;
+    let completed1 = false;
+    let completed2 = false;
+    const h1 = source1.Subscribe(new Observer<T>(
+      (v) => { if (!stopped) { observer.OnNext(v); } },
+      (e) => {
+        if (!stopped) {
+          stopped = true;
+          observer.OnError(e);
+        }
+      },
+      () => {
+        if (!stopped) {
+          completed1 = true;
+          if (completed2) {
+            stopped = true;
+            observer.OnCompleted();
+          }
+        }
+      }));
+    const h2 = source2.Subscribe(new Observer<T>(
+      (v) => { if (!stopped) { observer.OnNext(v); } },
+      (e) => {
+        if (!stopped) {
+          stopped = true;
+          observer.OnError(e);
+        }
+      },
+      () => {
+        if (!stopped) {
+          completed2 = true;
+          if (completed1) {
+            stopped = true;
+            observer.OnCompleted();
+          }
+        }
+      }));
+    return {
+      Dispose() {
+        h1.Dispose();
+        h2.Dispose();
+      },
+    };
+  });
+}
+
+export function pairwise<T>(source: IObservable<T>): IObservable<[T, T]> {
+  return new Observable<[T, T]>((observer) => {
+    let last: T;
+    return source.Subscribe(new Observer<T>((next) => {
+      if (last != null) {
+        observer.OnNext([last, next]);
+      }
+      last = next;
+    }, observer.OnError, observer.OnCompleted));
+  });
+}
+
+export function partition<T>(predicate: (x: T) => boolean, source: IObservable<T>): [Observable<T>, Observable<T>] {
+  return [filter(predicate, source), filter((x) => !predicate(x), source)];
+}
+
+export function scan<U, T>(collector: (u: U, t: T) => U, state: U, source: IObservable<T>): IObservable<U> {
+  return new Observable<U>((observer) => {
+    return source.Subscribe(new Observer<T>((t) => {
+      protect(
+        () => collector(state, t),
+        (u) => { state = u; observer.OnNext(u); },
+        observer.OnError);
+    }, observer.OnError, observer.OnCompleted));
+  });
+}
+
+export function split<T, U1, U2>(splitter: (x: T) => FSharpChoice$2_$union<U1, U2>, source: IObservable<T>): [Observable<U1>, Observable<U2>] {
+  return [
+    choose((v) => Choice_tryValueIfChoice1Of2(splitter(v)), source),
+    choose((v) => Choice_tryValueIfChoice2Of2(splitter(v)), source)
+  ];
+}
+
+export function subscribe<T>(callback: (x: T) => void, source: IObservable<T>): IDisposable {
+  return source.Subscribe(new Observer(callback));
+}

package/Option.ts

@@ -0,0 +1,137 @@
+import { structuralHash, equals, compare } from "./Util.js";
+
+// Options are erased in runtime by Fable, but we have
+// the `Some` type below to wrap values that would evaluate
+// to `undefined` in runtime. These two rules must be followed:
+
+// 1- `None` is always `undefined` in runtime, a non-strict null check
+//    (`x == null`) is enough to check the case of an option.
+// 2- To get the value of an option the `value` helper
+//    below must **always** be used.
+
+// Note: We use non-strict null check for backwards compatibility with
+// code that use F# options to represent values that could be null in JS
+
+export type Nullable<T> = T | null | undefined;
+
+export type Option<T> = T | Some<T> | undefined;
+
+// Using a class here for better compatibility with TS files importing Some
+export class Some<T> {
+  public value: T;
+
+  constructor(value: T) {
+    this.value = value;
+  }
+
+  public toJSON() {
+    return this.value;
+  }
+
+  // Don't add "Some" for consistency with erased options
+  public toString() {
+    return String(this.value);
+  }
+
+  public GetHashCode() {
+    return structuralHash(this.value);
+  }
+
+  public Equals(other: Option<T>): boolean {
+    if (other == null) {
+      return false;
+    } else {
+      return equals(this.value, other instanceof Some ? other.value : other);
+    }
+  }
+
+  public CompareTo(other: Option<T>) {
+    if (other == null) {
+      return 1;
+    } else {
+      return compare(this.value, other instanceof Some ? other.value : other);
+    }
+  }
+}
+
+export function value<T>(x: Option<T>) {
+  if (x == null) {
+    throw new Error("Option has no value");
+  } else {
+    return x instanceof Some ? x.value : x;
+  }
+}
+
+export function unwrap<T>(opt: Option<T>): T | undefined {
+  return opt instanceof Some ? opt.value : opt;
+}
+
+export function some<T>(x: T): Option<T> {
+  return x == null || x instanceof Some ? new Some(x) : x;
+}
+
+export function ofNullable<T>(x: Nullable<T>): Option<T> {
+  // This will fail with unit probably, an alternative would be:
+  // return x === null ? undefined : (x === undefined ? new Some(x) : x);
+  return x == null ? undefined : x;
+}
+
+export function toNullable<T>(x: Option<T>): Nullable<T> {
+  return x == null ? null : value(x);
+}
+
+export function flatten<T>(x: Option<Option<T>>) {
+  return x == null ? undefined : value(x);
+}
+
+export function toArray<T>(opt: Option<T>): T[] {
+  return (opt == null) ? [] : [value(opt)];
+}
+
+export function defaultArg<T>(opt: Option<T>, defaultValue: T): T {
+  return (opt != null) ? value(opt) : defaultValue;
+}
+
+export function defaultArgWith<T>(opt: Option<T>, defThunk: () => T): T {
+  return (opt != null) ? value(opt) : defThunk();
+}
+
+export function orElse<T>(opt: Option<T>, ifNone: Option<T>): Option<T> {
+  return opt == null ? ifNone : opt;
+}
+
+export function orElseWith<T>(opt: Option<T>, ifNoneThunk: () => Option<T>): Option<T> {
+  return opt == null ? ifNoneThunk() : opt;
+}
+
+export function filter<T>(predicate: (arg: T) => boolean, opt: Option<T>): Option<T> {
+  return (opt != null) ? (predicate(value(opt)) ? opt : undefined) : opt;
+}
+
+export function map<T, U>(mapping: (arg: T) => U, opt: Option<T>): Option<U> {
+  return (opt != null) ? some(mapping(value(opt))) : undefined;
+}
+
+export function map2<T1, T2, U>(
+  mapping: (arg1: T1, arg2: T2) => Option<U>,
+  opt1: Option<T1>, opt2: Option<T2>): Option<U> {
+  return (opt1 != null && opt2 != null) ? mapping(value(opt1), value(opt2)) : undefined;
+}
+
+export function map3<T1, T2, T3, U>(
+  mapping: (arg1: T1, arg2: T2, arg3: T3) => Option<U>,
+  opt1: Option<T1>, opt2: Option<T2>, opt3: Option<T3>): Option<U> {
+  return (opt1 != null && opt2 != null && opt3 != null) ? mapping(value(opt1), value(opt2), value(opt3)) : undefined;
+}
+
+export function bind<T, U>(binder: (arg: T) => Option<U>, opt: Option<T>): Option<U> {
+  return opt != null ? binder(value(opt)) : undefined;
+}
+
+export function tryOp<T, U>(op: (x: T) => U, arg: T): Option<U> {
+  try {
+    return some(op(arg));
+  } catch {
+    return undefined;
+  }
+}

package/README.md

@@ -0,0 +1,3 @@
+# fable-library
+
+Core library used by F# projects compiled with [Fable](https://fable.io).