152 lines
3.8 KiB
TypeScript
152 lines
3.8 KiB
TypeScript
import { mathRandom } from "../random/index.js";
|
|
import { RandomGenerator } from "../random/types.js";
|
|
import { BigIntRangeSequence, ConcatSequence, SequenceMarker, FunctionSequence, GeneratorSequence, RangeSequence, RepeatSequence, RepeatForeverSequence, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet, WrappedArray, EMPTY, ZippedSequence } from "./impl.js";
|
|
import { Sequence } from "./types.js";
|
|
|
|
export function wrap<T = any>(iterable: Iterable<T>): Sequence<T> {
|
|
if (isSequence<T>(iterable)) {
|
|
return iterable;
|
|
}
|
|
|
|
if (Array.isArray(iterable)) {
|
|
return array(iterable);
|
|
}
|
|
|
|
if (iterable instanceof Set) {
|
|
return set<T>(iterable);
|
|
}
|
|
|
|
if (iterable instanceof Map) {
|
|
return map(iterable) as unknown as Sequence<T>;
|
|
}
|
|
|
|
return sequence(iterable);
|
|
}
|
|
|
|
export function sequence<T = any>(iterable: Iterable<T>): Sequence<T> {
|
|
return new WrappedIterable(iterable);
|
|
}
|
|
|
|
export function empty<T = any>(): Sequence<T> {
|
|
return EMPTY;
|
|
}
|
|
|
|
export function single<T>(obj: T): Sequence<T> {
|
|
return new WrappedObject(obj);
|
|
}
|
|
|
|
export function array<T = any>(array: ReadonlyArray<T>): Sequence<T> {
|
|
return new WrappedArray(array);
|
|
}
|
|
|
|
export function arrayLike<T = any>(arrayLike: ArrayLike<T>): Sequence<T> {
|
|
return new WrappedArrayLike(arrayLike);
|
|
}
|
|
|
|
export function set<T>(set: ReadonlySet<T>): Sequence<T> {
|
|
return new WrappedSet(set);
|
|
}
|
|
|
|
export function map<K, V>(map: ReadonlyMap<K, V>): Sequence<[K, V]> {
|
|
return new WrappedMap(map);
|
|
}
|
|
|
|
export function of<T>(...elements: T[]): Sequence<T> {
|
|
switch (elements.length) {
|
|
case 0:
|
|
return empty();
|
|
case 1:
|
|
return single(elements[0]);
|
|
default:
|
|
return array(elements);
|
|
}
|
|
}
|
|
|
|
export function ofPropertyKeys<T extends PropertyKey>(...elements: T[]): Sequence<T> {
|
|
return of(...elements);
|
|
}
|
|
|
|
export function entries<T>(o: Record<string, T> | ArrayLike<T>): Sequence<[string, T]> {
|
|
return array(Object.entries(o));
|
|
}
|
|
|
|
export function keys(o: object): Sequence<string> {
|
|
return array(Object.keys(o));
|
|
}
|
|
|
|
export function func<T>(f: () => T): Sequence<T> {
|
|
return new FunctionSequence(f);
|
|
}
|
|
|
|
export function generator<T>(generator: () => Iterable<T>): Sequence<T> {
|
|
return new GeneratorSequence(generator);
|
|
}
|
|
|
|
export function range(max: number): Sequence<number>
|
|
export function range(min: number, max: number): Sequence<number>
|
|
export function range(min: number, max: number, step: number): Sequence<number>
|
|
export function range(a: number, b?: number, c?: number): Sequence<number> {
|
|
if (b === undefined) {
|
|
b = a;
|
|
a = 0;
|
|
}
|
|
|
|
if (c === undefined) {
|
|
c = 1;
|
|
}
|
|
|
|
return new RangeSequence(a, b, c);
|
|
}
|
|
|
|
export function bigintRange(max: bigint): Sequence<bigint>
|
|
export function bigintRange(min: bigint, max: bigint): Sequence<bigint>
|
|
export function bigintRange(min: bigint, max: bigint, step: bigint): Sequence<bigint>
|
|
export function bigintRange(a: bigint, b?: bigint, c?: bigint): Sequence<bigint> {
|
|
if (b === undefined) {
|
|
b = a;
|
|
a = 0n;
|
|
}
|
|
|
|
if (c === undefined) {
|
|
c = 1n;
|
|
}
|
|
|
|
return new BigIntRangeSequence(a, b, c);
|
|
}
|
|
|
|
export function repeat<T>(value: T, count?: number): Sequence<T> {
|
|
if (count == undefined) {
|
|
return new RepeatForeverSequence(value);
|
|
}
|
|
|
|
if (count < 0) {
|
|
throw new RangeError();
|
|
}
|
|
|
|
if (count === 0) {
|
|
return empty();
|
|
}
|
|
|
|
if (count === 1) {
|
|
return new WrappedObject(value);
|
|
}
|
|
|
|
return new RepeatSequence(value, count);
|
|
}
|
|
|
|
export function randomSequence(random?: RandomGenerator): Sequence<number> {
|
|
return new FunctionSequence(random ?? mathRandom);
|
|
}
|
|
|
|
export function concat<T>(...sequences: Sequence<T>[]): Sequence<T> {
|
|
return new ConcatSequence(sequences);
|
|
}
|
|
|
|
export function zip<T>(first: Sequence<T>, second: Sequence<T>): Sequence<[T, T]> {
|
|
return new ZippedSequence(first, second);
|
|
}
|
|
|
|
export function isSequence<T = any>(obj: any): obj is Sequence<T> {
|
|
return obj instanceof SequenceMarker;
|
|
}
|