semantic-typescript 0.0.8 → 0.2.5

package/dist/collectable.d.ts

@@ -0,0 +1,84 @@
+import { Collector } from "./collector";
+import { Optional } from "./optional";
+import { Semantic } from "./semantic";
+import type { BiConsumer, BiFunctional, Comparator, Consumer, Functional, Predicate, Supplier, TriFunctional, Generator, BiPredicate, TriPredicate } from "./utility";
+export declare abstract class Collectable<E> {
+    protected readonly Collectable: symbol;
+    constructor();
+    anyMatch(predicate: Predicate<E>): boolean;
+    allMatch(predicate: Predicate<E>): boolean;
+    collect<A, R>(collector: Collector<E, A, R>): R;
+    collect<A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): R;
+    count(): bigint;
+    isEmpty(): boolean;
+    findAny(): Optional<E>;
+    findFirst(): Optional<E>;
+    findLast(): Optional<E>;
+    forEach(action: Consumer<E>): void;
+    forEach(action: BiConsumer<E, bigint>): void;
+    group<K>(classifier: Functional<E, K>): Map<K, Array<E>>;
+    groupBy<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Map<K, Array<V>>;
+    join(): string;
+    join(delimiter: string): string;
+    join(prefix: string, delimiter: string, suffix: string): string;
+    join(prefiex: string, accumulator: BiFunctional<string, E, string>, suffix: string): string;
+    join(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): string;
+    log(): void;
+    log(accumulator: BiFunctional<string, E, string>): void;
+    log(accumulator: BiFunctional<string, E, string> | TriFunctional<string, E, bigint, string>): void;
+    log(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): void;
+    log(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): void;
+    nonMatch(predicate: Predicate<E>): boolean;
+    partition(count: bigint): Array<Array<E>>;
+    partitionBy(classifier: Functional<E, bigint>): Array<Array<E>>;
+    reduce(accumulator: BiFunctional<E, E, E>): Optional<E>;
+    reduce(accumulator: TriFunctional<E, E, bigint, E>): Optional<E>;
+    reduce(identity: E, accumulator: BiFunctional<E, E, E>): E;
+    reduce(identity: E, accumulator: TriFunctional<E, E, bigint, E>): E;
+    reduce<R>(identity: R, accumulator: BiFunctional<R, E, R>, finisher: BiFunctional<R, R, R>): R;
+    reduce<R>(identity: R, accumulator: TriFunctional<R, E, bigint, R>, finisher: BiFunctional<R, R, R>): R;
+    semantic(): Semantic<E>;
+    protected abstract source(): Generator<E> | Iterable<E>;
+    toArray(): Array<E>;
+    toMap<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Map<K, V>;
+    toSet(): Set<E>;
+    write(stream: WritableStream<string>): Promise<WritableStream<string>>;
+    write(stream: WritableStream<string>, accumulator: BiFunctional<E, bigint, string>): Promise<WritableStream<string>>;
+    write(stream: WritableStream<Uint8Array>, accumulator: BiFunctional<E, bigint, Uint8Array>): Promise<WritableStream<Uint8Array>>;
+}
+export declare class UnorderedCollectable<E> extends Collectable<E> {
+    protected readonly UnorderedCollectable: symbol;
+    protected generator: Generator<E>;
+    constructor(generator: Generator<E>);
+    source(): Generator<E>;
+}
+type Indexed<K, V> = {
+    index: K;
+    value: V;
+};
+export declare class OrderedCollectable<E> extends Collectable<E> {
+    protected readonly OrderedCollectable: symbol;
+    protected ordered: Array<Indexed<bigint, E>>;
+    constructor(iterable: Iterable<E>);
+    constructor(iterable: Iterable<E>, comparator: Comparator<E>);
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    source(): Generator<E> | Iterable<E>;
+}
+export declare class WindowCollectable<E> extends OrderedCollectable<E> {
+    protected readonly WindowCollectable: symbol;
+    constructor(iterable: Iterable<E>);
+    constructor(iterable: Iterable<E>, comparator: Comparator<E>);
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    slide(size: bigint, step?: bigint): Semantic<Semantic<E>>;
+    tumble(size: bigint): Semantic<Semantic<E>>;
+}
+export {};

package/dist/collectable.js

@@ -0,0 +1,476 @@
+import { Collector } from "./collector";
+import { from } from "./factory";
+import { isCollector, isFunction, isIterable, isObject, isString } from "./guard";
+import { useCompare } from "./hook";
+import { Optional } from "./optional";
+import { Semantic } from "./semantic";
+import { CollectableSymbol, OrderedCollectableSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
+import { invalidate, validate } from "./utility";
+export class Collectable {
+    Collectable = CollectableSymbol;
+    constructor() {
+    }
+    anyMatch(predicate) {
+        return this.collect(() => {
+            return false;
+        }, (element) => {
+            return predicate(element);
+        }, (result, element) => {
+            return result || predicate(element);
+        }, (result) => {
+            return result;
+        });
+    }
+    allMatch(predicate) {
+        return this.collect(() => {
+            return true;
+        }, (element) => {
+            return !predicate(element);
+        }, (result, element) => {
+            return result && predicate(element);
+        }, (result) => {
+            return result;
+        });
+    }
+    collect(argument1, argument2, argument3, argument4) {
+        let source = this.source();
+        if (isCollector(argument1)) {
+            let collector = argument1;
+            return collector.collect(source);
+        }
+        if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3)) {
+            let identity = argument1;
+            let accumulator = argument2;
+            let finisher = argument3;
+            let collector = Collector.full(identity, accumulator, finisher);
+            return collector.collect(source);
+        }
+        if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3) && isFunction(argument4)) {
+            let identity = argument1;
+            let interrupt = argument2;
+            let accumulator = argument3;
+            let finisher = argument4;
+            let collector = Collector.shortable(identity, interrupt, accumulator, finisher);
+            return collector.collect(source);
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    count() {
+        return this.collect(() => {
+            return 0n;
+        }, (count) => {
+            return count + 1n;
+        }, (count) => {
+            return count;
+        });
+    }
+    isEmpty() {
+        return this.count() === 0n;
+    }
+    findAny() {
+        return this.collect(() => {
+            return Optional.ofNullable();
+        }, () => {
+            return true;
+        }, (result, element) => {
+            return result.isPresent() && Math.random() > 0.5 ? result : Optional.of(element);
+        }, (result) => {
+            return result;
+        });
+    }
+    findFirst() {
+        return this.collect(() => {
+            return Optional.ofNullable();
+        }, () => {
+            return true;
+        }, (result, element) => {
+            return result.isPresent() ? result : Optional.of(element);
+        }, (result) => {
+            return result;
+        });
+    }
+    findLast() {
+        return this.collect(() => {
+            return Optional.ofNullable();
+        }, () => {
+            return true;
+        }, (result, element) => {
+            return result.isPresent() ? result : Optional.of(element);
+        }, (result) => {
+            return result;
+        });
+    }
+    forEach(action) {
+        if (isFunction(action)) {
+            this.collect(() => {
+                return 0n;
+            }, (count, element) => {
+                action(element, count);
+                return count + 1n;
+            }, (count) => {
+                return count;
+            });
+        }
+    }
+    group(classifier) {
+        if (isFunction(classifier)) {
+            return this.collect(() => {
+                return new Map();
+            }, (map, element) => {
+                let key = classifier(element);
+                let raw = map.get(key);
+                let array = validate(raw) ? raw : [];
+                array.push(element);
+                map.set(key, array);
+                return map;
+            }, (map) => {
+                return map;
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    groupBy(keyExtractor, valueExtractor) {
+        return this.collect(() => {
+            return new Map();
+        }, (map, element) => {
+            let key = keyExtractor(element);
+            let value = valueExtractor(element);
+            let group = (validate(map.get(key)) ? map.get(key) : []);
+            group.push(value);
+            map.set(key, group);
+            return map;
+        }, (map) => {
+            return map;
+        });
+    }
+    join(argument1, argument2, argument3) {
+        if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            return this.collect(() => {
+                return "[";
+            }, (text, element) => {
+                return text + element + ",";
+            }, (text) => {
+                return text.substring(0, text.length - 1) + "]";
+            });
+        }
+        if (isString(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            let delimiter = argument1;
+            return this.collect(() => {
+                return "[";
+            }, (text, element) => {
+                return text + element + delimiter;
+            }, (text) => {
+                return text.substring(0, text.length - 1) + "]";
+            });
+        }
+        if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+            let prefix = argument1;
+            let accumulator = argument2;
+            let suffix = argument3;
+            return this.collect(() => {
+                return prefix;
+            }, (text, element, index) => {
+                return text + accumulator(text, element, index);
+            }, (text) => {
+                return text + suffix;
+            });
+        }
+        if (isString(argument1) && isString(argument2) && isString(argument3)) {
+            let prefix = argument1;
+            let delimiter = argument2;
+            let suffix = argument3;
+            return this.collect(() => {
+                return prefix;
+            }, (text, element) => {
+                return text + element + delimiter;
+            }, (text) => {
+                return text + suffix;
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    log(argument1, argument2, argument3) {
+        if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            let text = this.join();
+            console.log(text);
+        }
+        else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            let accumulator = argument1;
+            let text = this.join("[", accumulator, "]");
+            console.log(text);
+        }
+        else {
+            throw new TypeError("Invalid arguments.");
+        }
+    }
+    nonMatch(predicate) {
+        return this.collect(() => {
+            return true;
+        }, (element) => {
+            return predicate(element);
+        }, (result, element) => {
+            return result || predicate(element);
+        }, (result) => {
+            return result;
+        });
+    }
+    partition(count) {
+        let limited = count > 1n ? count : 1n;
+        return this.collect(() => {
+            return [];
+        }, (array, element) => {
+            let index = limited % BigInt(array.length);
+            if (index === 0n) {
+                array.push([]);
+            }
+            array[Number(index)].push(element);
+            return array;
+        }, (result) => {
+            return result;
+        });
+    }
+    partitionBy(classifier) {
+        return this.collect(() => {
+            return [];
+        }, (array, element) => {
+            let index = classifier(element);
+            while (index > BigInt(array.length) - 1n) {
+                array.push([]);
+            }
+            array[Number(index)].push(element);
+            return array;
+        }, (result) => {
+            return result;
+        });
+    }
+    reduce(argument1, argument2, argument3) {
+        if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            let accumulator = argument1;
+            return this.collect(() => Optional.ofNullable(), (result, element, index) => {
+                if (result.isEmpty()) {
+                    return Optional.of(element);
+                }
+                else {
+                    let current = result.get();
+                    return Optional.of(accumulator(current, element, index));
+                }
+            }, (result) => result);
+        }
+        else if (validate(argument1) && isFunction(argument2) && invalidate(argument3)) {
+            let identity = argument1;
+            let accumulator = argument2;
+            return this.collect(() => identity, (result, element, index) => {
+                return accumulator(result, element, index);
+            }, (result) => result);
+        }
+        else if (validate(argument1) && isFunction(argument2) && isFunction(argument3)) {
+            let identity = argument1;
+            let accumulator = argument2;
+            let finisher = argument3;
+            return this.collect(() => identity, (result, element, index) => {
+                return accumulator(result, element, index);
+            }, (result) => finisher(result, result));
+        }
+        else {
+            throw new TypeError("Invalid arguments.");
+        }
+    }
+    semantic() {
+        let source = this.source();
+        if (isIterable(source)) {
+            return from(source);
+        }
+        else if (isFunction(source)) {
+            return new Semantic(source);
+        }
+        else {
+            throw new TypeError("Invalid source.");
+        }
+    }
+    toArray() {
+        return this.collect(() => {
+            return [];
+        }, (array, element) => {
+            array.push(element);
+            return array;
+        }, (result) => {
+            return result;
+        });
+    }
+    toMap(keyExtractor, valueExtractor) {
+        return this.collect(() => {
+            return new Map();
+        }, (map, element) => {
+            let key = keyExtractor(element);
+            let value = valueExtractor(element);
+            map.set(key, value);
+            return map;
+        }, (map) => {
+            return map;
+        });
+    }
+    toSet() {
+        return this.collect(() => {
+            return new Set();
+        }, (set, element) => {
+            set.add(element);
+            return set;
+        }, (result) => {
+            return result;
+        });
+    }
+    write(stream, accumulator) {
+        if (isObject(stream) && invalidate(accumulator)) {
+            let optional = this.collect(() => {
+                return Optional.ofNonNull(stream);
+            }, (result, element) => {
+                try {
+                    return result.map((stream) => {
+                        let writer = stream.getWriter();
+                        writer.write(String(element));
+                        return stream;
+                    });
+                }
+                catch (reason) {
+                    return Optional.empty();
+                }
+            }, (a) => {
+                return a;
+            });
+            return new Promise((resolve, reject) => {
+                optional.ifPresent(resolve, reject);
+            });
+        }
+        else if (isObject(stream) && isFunction(accumulator)) {
+            let optional = this.collect(() => {
+                return Optional.ofNonNull(stream);
+            }, (result, element, index) => {
+                try {
+                    return result.map((stream) => {
+                        let writer = stream.getWriter();
+                        writer.write(accumulator(element, index));
+                        return stream;
+                    });
+                }
+                catch (reason) {
+                    return Optional.empty();
+                }
+            }, (a) => {
+                return a;
+            });
+            return new Promise((resolve, reject) => {
+                optional.ifPresent(resolve, reject);
+            });
+        }
+        else {
+            throw new TypeError("Invalid arguments.");
+        }
+    }
+}
+;
+export class UnorderedCollectable extends Collectable {
+    UnorderedCollectable = UnorderedCollectableSymbol;
+    generator;
+    constructor(generator) {
+        super();
+        this.generator = generator;
+    }
+    source() {
+        return this.generator;
+    }
+}
+;
+export class OrderedCollectable extends Collectable {
+    OrderedCollectable = OrderedCollectableSymbol;
+    ordered = [];
+    constructor(argument1, argument2) {
+        super();
+        let buffer = [];
+        if (isIterable(argument1)) {
+            let iterable = argument1;
+            let index = 0n;
+            for (let element of iterable) {
+                buffer.push({
+                    index: index,
+                    value: element
+                });
+                index++;
+            }
+        }
+        else if (isFunction(argument1)) {
+            let generator = argument1;
+            generator((element, index) => {
+                buffer.push({
+                    index: index,
+                    value: element
+                });
+            }, () => false);
+        }
+        else {
+            throw new TypeError("Invalid arguments.");
+        }
+        buffer.map((indexed, _index, array) => {
+            let length = BigInt(array.length);
+            return {
+                index: ((indexed.index % length) + length) % length,
+                value: indexed.value
+            };
+        }).sort((a, b) => {
+            if (isFunction(argument2)) {
+                let comparator = argument2;
+                return comparator(a.value, b.value);
+            }
+            else {
+                return useCompare(a.index, b.index);
+            }
+        }).forEach((indexed) => {
+            this.ordered.push(indexed);
+        });
+    }
+    source() {
+        return this.ordered.map((indexed) => indexed.value);
+    }
+}
+;
+export class WindowCollectable extends OrderedCollectable {
+    WindowCollectable = WindowCollectableSymbol;
+    constructor(parameter, comparator) {
+        if (isIterable(parameter)) {
+            if (isFunction(comparator)) {
+                super(parameter, comparator);
+            }
+            else {
+                super(parameter);
+            }
+        }
+        else if (isFunction(parameter)) {
+            if (isFunction(comparator)) {
+                super(parameter, comparator);
+            }
+            else {
+                super(parameter);
+            }
+        }
+    }
+    slide(size, step = 1n) {
+        if (size > 0n && step > 0n) {
+            let source = this.toArray();
+            let windows = [];
+            let windowStartIndex = 0n;
+            while (windowStartIndex < BigInt(source.length)) {
+                let windowEnd = windowStartIndex + size;
+                let window = source.slice(Number(windowStartIndex), Number(windowEnd));
+                if (window.length > 0) {
+                    windows.push(window);
+                }
+                windowStartIndex += step;
+            }
+            return from(windows).map((window) => from(window));
+        }
+        throw new RangeError("Invalid arguments.");
+    }
+    tumble(size) {
+        return this.slide(size, size);
+    }
+}
+;

package/dist/collector.d.ts

@@ -0,0 +1,24 @@
+import type { Semantic } from "./semantic";
+import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, Generator, TriPredicate } from "./utility";
+export declare class Collector<E, A, R> {
+    protected identity: Supplier<A>;
+    protected interrupt: Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
+    protected accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>;
+    protected finisher: Functional<A, R>;
+    protected readonly Collector: symbol;
+    protected constructor(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
+    collect(generator: Generator<E>): R;
+    collect(iterable: Iterable<E>): R;
+    collect(semantic: Semantic<E>): R;
+    static full<E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static full<E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+}

package/dist/collector.js

@@ -0,0 +1,63 @@
+import { isFunction, isIterable, isSemantic } from "./guard";
+import { CollectableSymbol } from "./symbol";
+export class Collector {
+    identity;
+    interrupt;
+    accumulator;
+    finisher;
+    Collector = CollectableSymbol;
+    constructor(identity, interruptor, accumulator, finisher) {
+        if (isFunction(identity) && isFunction(interruptor) && isFunction(accumulator) && isFunction(finisher)) {
+            this.identity = identity;
+            this.interrupt = interruptor;
+            this.accumulator = accumulator;
+            this.finisher = finisher;
+        }
+        else {
+            throw new TypeError("Invalid arguments");
+        }
+    }
+    collect(parameter) {
+        let accumulator = this.identity();
+        let count = 0n;
+        if (isFunction(parameter)) {
+            parameter((element, index) => {
+                accumulator = this.accumulator(accumulator, element, index);
+                count++;
+            }, (element, index) => this.interrupt(element, index, accumulator));
+        }
+        else if (isIterable(parameter)) {
+            let iterable = parameter;
+            let index = 0n;
+            for (let element of iterable) {
+                if (this.interrupt(element, index, accumulator)) {
+                    break;
+                }
+                accumulator = this.accumulator(accumulator, element, count);
+                count++;
+                index++;
+            }
+        }
+        else if (isSemantic(parameter)) {
+            let semantic = parameter;
+            let generator = Reflect.get(semantic, "generator");
+            if (isFunction(generator)) {
+                generator((element, index) => {
+                    accumulator = this.accumulator(accumulator, element, index);
+                    count++;
+                }, (element, index) => this.interrupt(element, index, accumulator));
+            }
+            else {
+                throw new TypeError("Invalid arguments");
+            }
+        }
+        return this.finisher(accumulator);
+    }
+    static full(identity, accumulator, finisher) {
+        return new Collector(identity, () => false, accumulator, finisher);
+    }
+    static shortable(identity, interruptor, accumulator, finisher) {
+        return new Collector(identity, interruptor, accumulator, finisher);
+    }
+}
+;

package/dist/factory.d.ts

@@ -0,0 +1,11 @@
+import { Semantic } from "./semantic";
+import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, Generator } from "./utility";
+export declare let blob: Functional<Blob, Semantic<Uint8Array>> & BiFunctional<Blob, bigint, Semantic<Uint8Array>>;
+export declare let empty: <E>() => Semantic<E>;
+export declare let fill: (<E>(element: E, count: bigint) => Semantic<E>) & (<E>(supplier: Supplier<E>, count: bigint) => Semantic<E>);
+export declare let from: <E>(iterable: Iterable<E>) => Semantic<E>;
+export declare let generate: (<E>(supplier: Supplier<E>, interrupt: Predicate<E>) => Semantic<E>) & (<E>(supplier: Supplier<E>, interrupt: BiPredicate<E, bigint>) => Semantic<E>);
+export declare let interval: Functional<number, Semantic<number>> & BiFunctional<number, number, Semantic<number>>;
+export declare let iterate: <E>(generator: Generator<E>) => Semantic<E>;
+export declare let range: BiFunctional<number, number, Semantic<number>> & TriFunctional<number, number, number, Semantic<number>>;
+export declare let websocket: Functional<WebSocket, Semantic<MessageEvent | CloseEvent | Event>>;