compostjs 0.0.11 → 0.1.0

package/dist/fable_modules/fable-library-js.4.28.0/Result.js

@@ -0,0 +1,165 @@
+import { Union } from "./Types.js";
+import { union_type } from "./Reflection.js";
+import { equals } from "./Util.js";
+import { empty, singleton } from "./List.js";
+import { some } from "./Option.js";
+export function FSharpResult$2_Ok(ResultValue) {
+    return new FSharpResult$2(0, [ResultValue]);
+}
+export function FSharpResult$2_Error(ErrorValue) {
+    return new FSharpResult$2(1, [ErrorValue]);
+}
+export class FSharpResult$2 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Ok", "Error"];
+    }
+}
+export function FSharpResult$2_$reflection(gen0, gen1) {
+    return union_type("FSharp.Core.FSharpResult`2", [gen0, gen1], FSharpResult$2, () => [[["ResultValue", gen0]], [["ErrorValue", gen1]]]);
+}
+export function Result_Map(mapping, result) {
+    if (result.tag === /* Ok */ 0) {
+        return FSharpResult$2_Ok(mapping(result.fields[0]));
+    }
+    else {
+        return FSharpResult$2_Error(result.fields[0]);
+    }
+}
+export function Result_MapError(mapping, result) {
+    if (result.tag === /* Ok */ 0) {
+        return FSharpResult$2_Ok(result.fields[0]);
+    }
+    else {
+        return FSharpResult$2_Error(mapping(result.fields[0]));
+    }
+}
+export function Result_Bind(binder, result) {
+    if (result.tag === /* Ok */ 0) {
+        return binder(result.fields[0]);
+    }
+    else {
+        return FSharpResult$2_Error(result.fields[0]);
+    }
+}
+export function Result_IsOk(result) {
+    if (result.tag === /* Ok */ 0) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function Result_IsError(result) {
+    if (result.tag === /* Ok */ 0) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+export function Result_Contains(value, result) {
+    if (result.tag === /* Ok */ 0) {
+        return equals(result.fields[0], value);
+    }
+    else {
+        return false;
+    }
+}
+export function Result_Count(result) {
+    if (result.tag === /* Ok */ 0) {
+        return 1;
+    }
+    else {
+        return 0;
+    }
+}
+export function Result_DefaultValue(defaultValue, result) {
+    if (result.tag === /* Ok */ 0) {
+        return result.fields[0];
+    }
+    else {
+        return defaultValue;
+    }
+}
+export function Result_DefaultWith(defThunk, result) {
+    if (result.tag === /* Ok */ 0) {
+        return result.fields[0];
+    }
+    else {
+        return defThunk(result.fields[0]);
+    }
+}
+export function Result_Exists(predicate, result) {
+    if (result.tag === /* Ok */ 0) {
+        return predicate(result.fields[0]);
+    }
+    else {
+        return false;
+    }
+}
+export function Result_Fold(folder, state, result) {
+    if (result.tag === /* Ok */ 0) {
+        return folder(state, result.fields[0]);
+    }
+    else {
+        return state;
+    }
+}
+export function Result_FoldBack(folder, result, state) {
+    if (result.tag === /* Ok */ 0) {
+        return folder(result.fields[0], state);
+    }
+    else {
+        return state;
+    }
+}
+export function Result_ForAll(predicate, result) {
+    if (result.tag === /* Ok */ 0) {
+        return predicate(result.fields[0]);
+    }
+    else {
+        return true;
+    }
+}
+export function Result_Iterate(action, result) {
+    if (result.tag === /* Ok */ 0) {
+        action(result.fields[0]);
+    }
+}
+export function Result_ToArray(result) {
+    if (result.tag === /* Ok */ 0) {
+        return [result.fields[0]];
+    }
+    else {
+        return [];
+    }
+}
+export function Result_ToList(result) {
+    if (result.tag === /* Ok */ 0) {
+        return singleton(result.fields[0]);
+    }
+    else {
+        return empty();
+    }
+}
+export function Result_ToOption(result) {
+    if (result.tag === /* Ok */ 0) {
+        return some(result.fields[0]);
+    }
+    else {
+        return undefined;
+    }
+}
+export function Result_ToValueOption(result) {
+    if (result.tag === /* Ok */ 0) {
+        return some(result.fields[0]);
+    }
+    else {
+        return undefined;
+    }
+}

package/dist/fable_modules/fable-library-js.4.28.0/Seq.d.ts

@@ -0,0 +1,165 @@
+import { IComparer, IEqualityComparer, IDisposable, IEnumerator } from "./Util.js";
+import { TypeInfo } from "./Reflection.js";
+import { Option } from "./Option.js";
+import { FSharpList } from "./List.js";
+import { int32 } from "./Int32.js";
+export declare const SR_enumerationAlreadyFinished = "Enumeration already finished.";
+export declare const SR_enumerationNotStarted = "Enumeration has not started. Call MoveNext.";
+export declare const SR_inputSequenceEmpty = "The input sequence was empty.";
+export declare const SR_inputSequenceTooLong = "The input sequence contains more than one element.";
+export declare const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
+export declare const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";
+export declare const SR_resetNotSupported = "Reset is not supported on this enumerator.";
+export declare function Enumerator_noReset<$a>(): $a;
+export declare function Enumerator_notStarted<$a>(): $a;
+export declare function Enumerator_alreadyFinished<$a>(): $a;
+export declare class Enumerator_Seq<T> implements Iterable<T> {
+    readonly f: (() => IEnumerator<T>);
+    constructor(f: (() => IEnumerator<T>));
+    toString(): string;
+    GetEnumerator(): IEnumerator<T>;
+    [Symbol.iterator](): Iterator<T>;
+    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
+}
+export declare function Enumerator_Seq_$reflection(gen0: TypeInfo): TypeInfo;
+export declare function Enumerator_Seq_$ctor_673A07F2<T>(f: (() => IEnumerator<T>)): Enumerator_Seq<T>;
+export declare class Enumerator_FromFunctions$1<T> implements IEnumerator<T>, IDisposable {
+    readonly next: (() => boolean);
+    readonly dispose: (() => void);
+    readonly current: (() => T);
+    constructor(current: (() => T), next: (() => boolean), dispose: (() => void));
+    "System.Collections.Generic.IEnumerator`1.get_Current"(): T;
+    "System.Collections.IEnumerator.get_Current"(): any;
+    "System.Collections.IEnumerator.MoveNext"(): boolean;
+    "System.Collections.IEnumerator.Reset"(): void;
+    Dispose(): void;
+}
+export declare function Enumerator_FromFunctions$1_$reflection(gen0: TypeInfo): TypeInfo;
+export declare function Enumerator_FromFunctions$1_$ctor_58C54629<T>(current: (() => T), next: (() => boolean), dispose: (() => void)): Enumerator_FromFunctions$1<T>;
+export declare function Enumerator_cast<T>(e: IEnumerator<T>): IEnumerator<T>;
+export declare function Enumerator_concat<T, U extends Iterable<T>>(sources: Iterable<U>): IEnumerator<T>;
+export declare function Enumerator_enumerateThenFinally<T>(f: (() => void), e: IEnumerator<T>): IEnumerator<T>;
+export declare function Enumerator_generateWhileSome<T, U>(openf: (() => T), compute: ((arg0: T) => Option<U>), closef: ((arg0: T) => void)): IEnumerator<U>;
+export declare function Enumerator_unfold<State, T>(f: ((arg0: State) => Option<[T, State]>), state: State): IEnumerator<T>;
+export declare function indexNotFound<$a>(): $a;
+export declare function checkNonNull<$a>(argName: string, arg: $a): void;
+export declare function mkSeq<T>(f: (() => IEnumerator<T>)): Iterable<T>;
+export declare function ofSeq<T>(xs: Iterable<T>): IEnumerator<T>;
+export declare function delay<T>(generator: (() => Iterable<T>)): Iterable<T>;
+export declare function concat<Collection extends Iterable<T>, T>(sources: Iterable<Collection>): Iterable<T>;
+export declare function unfold<State, T>(generator: ((arg0: State) => Option<[T, State]>), state: State): Iterable<T>;
+export declare function empty<T>(): Iterable<T>;
+export declare function singleton<T>(x: T): Iterable<T>;
+export declare function ofArray<T>(arr: T[]): Iterable<T>;
+export declare function toArray<T>(xs: Iterable<T>): T[];
+export declare function ofList<T>(xs: FSharpList<T>): Iterable<T>;
+export declare function toList<T>(xs: Iterable<T>): FSharpList<T>;
+export declare function generate<$a, $b>(create: (() => $a), compute: ((arg0: $a) => Option<$b>), dispose: ((arg0: $a) => void)): Iterable<$b>;
+export declare function generateIndexed<$a, $b>(create: (() => $a), compute: ((arg0: int32, arg1: $a) => Option<$b>), dispose: ((arg0: $a) => void)): Iterable<$b>;
+export declare function append<T>(xs: Iterable<T>, ys: Iterable<T>): Iterable<T>;
+export declare function cast<T>(xs: Iterable<T>): Iterable<T>;
+export declare function choose<T, U>(chooser: ((arg0: T) => Option<U>), xs: Iterable<T>): Iterable<U>;
+export declare function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: Iterable<T>, ys: Iterable<T>): int32;
+export declare function contains<T>(value: T, xs: Iterable<T>, comparer: IEqualityComparer<T>): boolean;
+export declare function enumerateFromFunctions<$a, $b>(create: (() => $a), moveNext: ((arg0: $a) => boolean), current: ((arg0: $a) => $b)): Iterable<$b>;
+export declare function enumerateThenFinally<T>(source: Iterable<T>, compensation: (() => void)): Iterable<T>;
+export declare function enumerateUsing<T extends IDisposable, $a extends Iterable<U>, U>(resource: T, source: ((arg0: T) => $a)): Iterable<U>;
+export declare function enumerateWhile<T>(guard: (() => boolean), xs: Iterable<T>): Iterable<T>;
+export declare function filter<T>(f: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T>;
+export declare function exists<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): boolean;
+export declare function exists2<T1, T2>(predicate: ((arg0: T1, arg1: T2) => boolean), xs: Iterable<T1>, ys: Iterable<T2>): boolean;
+export declare function exactlyOne<T>(xs: Iterable<T>): T;
+export declare function tryExactlyOne<T>(xs: Iterable<T>): Option<T>;
+export declare function tryFind<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<T>;
+export declare function find<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): T;
+export declare function tryFindBack<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<T>;
+export declare function findBack<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): T;
+export declare function tryFindIndex<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<int32>;
+export declare function findIndex<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): int32;
+export declare function tryFindIndexBack<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<int32>;
+export declare function findIndexBack<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): int32;
+export declare function fold<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, xs: Iterable<T>): State;
+export declare function foldBack<T, State>(folder: ((arg0: T, arg1: any) => any), xs: Iterable<T>, state: any): any;
+export declare function fold2<T1, T2, State>(folder: ((arg0: State, arg1: T1, arg2: T2) => State), state: State, xs: Iterable<T1>, ys: Iterable<T2>): State;
+export declare function foldBack2<T1, T2, State>(folder: ((arg0: T1, arg1: T2, arg2: State) => State), xs: Iterable<T1>, ys: Iterable<T2>, state: State): State;
+export declare function forAll<$a>(predicate: ((arg0: $a) => boolean), xs: Iterable<$a>): boolean;
+export declare function forAll2<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), xs: Iterable<$a>, ys: Iterable<$b>): boolean;
+export declare function tryHead<T>(xs: Iterable<T>): Option<T>;
+export declare function head<T>(xs: Iterable<T>): T;
+export declare function initialize<$a>(count: int32, f: ((arg0: int32) => $a)): Iterable<$a>;
+export declare function initializeInfinite<$a>(f: ((arg0: int32) => $a)): Iterable<$a>;
+export declare function isEmpty<T>(xs: Iterable<T>): boolean;
+export declare function tryItem<T>(index: int32, xs: Iterable<T>): Option<T>;
+export declare function item<T>(index: int32, xs: Iterable<T>): T;
+export declare function iterate<$a>(action: ((arg0: $a) => void), xs: Iterable<$a>): void;
+export declare function iterate2<$a, $b>(action: ((arg0: $a, arg1: $b) => void), xs: Iterable<$a>, ys: Iterable<$b>): void;
+export declare function iterateIndexed<$a>(action: ((arg0: int32, arg1: $a) => void), xs: Iterable<$a>): void;
+export declare function iterateIndexed2<$a, $b>(action: ((arg0: int32, arg1: $a, arg2: $b) => void), xs: Iterable<$a>, ys: Iterable<$b>): void;
+export declare function tryLast<T>(xs: Iterable<T>): Option<T>;
+export declare function last<T>(xs: Iterable<T>): T;
+export declare function length<T>(xs: Iterable<T>): int32;
+export declare function map<T, U>(mapping: ((arg0: T) => U), xs: Iterable<T>): Iterable<U>;
+export declare function mapIndexed<T, U>(mapping: ((arg0: int32, arg1: T) => U), xs: Iterable<T>): Iterable<U>;
+export declare function indexed<T>(xs: Iterable<T>): Iterable<[int32, T]>;
+export declare function map2<T1, T2, U>(mapping: ((arg0: T1, arg1: T2) => U), xs: Iterable<T1>, ys: Iterable<T2>): Iterable<U>;
+export declare function mapIndexed2<T1, T2, U>(mapping: ((arg0: int32, arg1: T1, arg2: T2) => U), xs: Iterable<T1>, ys: Iterable<T2>): Iterable<U>;
+export declare function map3<T1, T2, T3, U>(mapping: ((arg0: T1, arg1: T2, arg2: T3) => U), xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): Iterable<U>;
+export declare function readOnly<T>(xs: Iterable<T>): Iterable<T>;
+export declare class CachedSeq$1<T> implements Iterable<T>, IDisposable {
+    readonly res: Iterable<T>;
+    readonly cleanup: (() => void);
+    constructor(cleanup: (() => void), res: Iterable<T>);
+    Dispose(): void;
+    GetEnumerator(): IEnumerator<T>;
+    [Symbol.iterator](): Iterator<T>;
+    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
+}
+export declare function CachedSeq$1_$reflection(gen0: TypeInfo): TypeInfo;
+export declare function CachedSeq$1_$ctor_Z7A8347D4<T>(cleanup: (() => void), res: Iterable<T>): CachedSeq$1<T>;
+export declare function CachedSeq$1__Clear<T>(_: CachedSeq$1<T>): void;
+export declare function cache<T>(source: Iterable<T>): Iterable<T>;
+export declare function allPairs<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): Iterable<[T1, T2]>;
+export declare function mapFold<State, T, Result>(mapping: ((arg0: State, arg1: T) => [Result, State]), state: State, xs: Iterable<T>): [Iterable<Result>, State];
+export declare function mapFoldBack<T, State, Result>(mapping: ((arg0: T, arg1: State) => [Result, State]), xs: Iterable<T>, state: State): [Iterable<Result>, State];
+export declare function tryPick<T, $a>(chooser: ((arg0: T) => Option<$a>), xs: Iterable<T>): Option<$a>;
+export declare function pick<T, $a>(chooser: ((arg0: T) => Option<$a>), xs: Iterable<T>): $a;
+export declare function reduce<T>(folder: ((arg0: T, arg1: T) => T), xs: Iterable<T>): T;
+export declare function reduceBack<T>(folder: ((arg0: T, arg1: T) => T), xs: Iterable<T>): T;
+export declare function replicate<$a>(n: int32, x: $a): Iterable<$a>;
+export declare function reverse<T>(xs: Iterable<T>): Iterable<T>;
+export declare function scan<State, T>(folder: ((arg0: State, arg1: T) => State), state: State, xs: Iterable<T>): Iterable<State>;
+export declare function scanBack<T, State>(folder: ((arg0: T, arg1: State) => State), xs: Iterable<T>, state: State): Iterable<State>;
+export declare function skip<T>(count: int32, source: Iterable<T>): Iterable<T>;
+export declare function skipWhile<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T>;
+export declare function tail<T>(xs: Iterable<T>): Iterable<T>;
+export declare function take<T>(count: int32, xs: Iterable<T>): Iterable<T>;
+export declare function takeWhile<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T>;
+export declare function truncate<T>(count: int32, xs: Iterable<T>): Iterable<T>;
+export declare function zip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): Iterable<[T1, T2]>;
+export declare function zip3<T1, T2, T3>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): Iterable<[T1, T2, T3]>;
+export declare function collect<T, Collection extends Iterable<U>, U>(mapping: ((arg0: T) => Collection), xs: Iterable<T>): Iterable<U>;
+export declare function where<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T>;
+export declare function pairwise<T>(xs: Iterable<T>): Iterable<[T, T]>;
+export declare function splitInto<T>(chunks: int32, xs: Iterable<T>): Iterable<T[]>;
+export declare function windowed<T>(windowSize: int32, xs: Iterable<T>): Iterable<T[]>;
+export declare function transpose<$a extends Iterable<T>, T>(xss: Iterable<$a>): Iterable<Iterable<T>>;
+export declare function sortWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: Iterable<T>): Iterable<T>;
+export declare function sort<T>(xs: Iterable<T>, comparer: IComparer<T>): Iterable<T>;
+export declare function sortBy<T, U>(projection: ((arg0: T) => U), xs: Iterable<T>, comparer: IComparer<U>): Iterable<T>;
+export declare function sortDescending<T>(xs: Iterable<T>, comparer: IComparer<T>): Iterable<T>;
+export declare function sortByDescending<T, U>(projection: ((arg0: T) => U), xs: Iterable<T>, comparer: IComparer<U>): Iterable<T>;
+export declare function sum<T>(xs: Iterable<T>, adder: any): T;
+export declare function sumBy<T, U>(f: ((arg0: T) => U), xs: Iterable<T>, adder: any): U;
+export declare function maxBy<T, U>(projection: ((arg0: T) => U), xs: Iterable<T>, comparer: IComparer<U>): T;
+export declare function max<T>(xs: Iterable<T>, comparer: IComparer<T>): T;
+export declare function minBy<T, U>(projection: ((arg0: T) => U), xs: Iterable<T>, comparer: IComparer<U>): T;
+export declare function min<T>(xs: Iterable<T>, comparer: IComparer<T>): T;
+export declare function average<T>(xs: Iterable<T>, averager: any): T;
+export declare function averageBy<T, U>(f: ((arg0: T) => U), xs: Iterable<T>, averager: any): U;
+export declare function permute<T>(f: ((arg0: int32) => int32), xs: Iterable<T>): Iterable<T>;
+export declare function chunkBySize<T>(chunkSize: int32, xs: Iterable<T>): Iterable<T[]>;
+export declare function insertAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T>;
+export declare function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: Iterable<T>): Iterable<T>;
+export declare function removeAt<T>(index: int32, xs: Iterable<T>): Iterable<T>;
+export declare function removeManyAt<T>(index: int32, count: int32, xs: Iterable<T>): Iterable<T>;
+export declare function updateAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T>;