hbecher/sequence-js
1
0
Fork 0
Code Activity

sync

Browse Source
This commit is contained in:
Herve BECHER
2024-10-14 07:38:23 +02:00
parent c2196e11c9
commit e5e6bffe1e
9 changed files with 193 additions and 309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
src/async/impl.ts
View File

@@ -6,10 +6,10 @@ import { getRandomElementAsync } from "../random/index.js";
import { AsyncRandomOptions } from "../random/types.js";
import { selectionSorter } from "../sorting.js";
import { Sequence } from "../sync/types.js";
import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybeAsyncSequence } from "../types.js";
import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybeAsyncSequence, MaybePromise } from "../types.js";
import { strictEquals, identity, operatorCompare, defaultArrayComparer, combineAsyncComparers, asAsyncIterable } from "../utils.js";
import { array, empty, wrap } from "./index.js";
import { AsyncSequence, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
import { AsyncSequence, AsyncSequencePipeline, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
export class AsyncSequenceMarker { }
@@ -20,7 +20,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
abstract iterator(): AsyncIterator<TElement>;
apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult {
apply<TResult>(pipeline: AsyncSequencePipeline<TElement, TResult>): MaybePromise<TResult> {
return pipeline(this);
}
@@ -397,7 +397,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
let next = await iterator.next();
if (next.done) {
throw new Error("Sequence contains no element.")
throw new Error("Sequence contains no element.");
}
if (!selector) {
@@ -620,15 +620,15 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new ReversedAsyncSequence<TElement>(this);
}
chunked(size: number, asArray?: false): AsyncSequence<AsyncSequence<TElement>>;
chunked(size: number, asArray: true): AsyncSequence<TElement[]>;
chunked(size: number, asArray?: boolean): AsyncSequence<AsyncSequence<TElement>> | AsyncSequence<TElement[]> {
chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
chunked<TResult>(size: number, transformer: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<TResult>;
chunked<TResult>(size: number, transformer?: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<AsyncSequence<TElement>> | AsyncSequence<TResult> {
if (size <= 0) {
throw new Error("Chunk size must be positive.");
}
const sequence = new ChunkedAsyncSequence<TElement>(this, size);
return asArray ? sequence : sequence.select(array);
const result = new ChunkedAsyncSequence<TElement>(this, size);
return transformer ? result.select(transformer) : result;
}
async random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
@@ -721,10 +721,6 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence;
}
protected set sequence(value: AsyncSequence<TElement>) {
this.#sequence = value;
}
[Symbol.asyncIterator]() {
return this.iterator();
}
@@ -733,7 +729,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.iterator();
}
apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult) {
apply<TResult>(pipeline: AsyncSequencePipeline<TElement, TResult>) {
return this.#sequence.apply(pipeline);
}
@@ -978,10 +974,10 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.reversed();
}
chunked(size: number, asArray?: false): AsyncSequence<AsyncSequence<TElement>>;
chunked(size: number, asArray: true): AsyncSequence<TElement[]>;
chunked(size: number, asArray?: any): AsyncSequence<AsyncSequence<TElement>> | AsyncSequence<TElement[]> {
return this.#sequence.chunked(size, asArray);
chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
chunked<TResult>(size: number, transformer: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<TResult>;
chunked(size: number, transformer?: any): any {
return this.#sequence.chunked(size, transformer);
}
random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
@@ -1186,9 +1182,9 @@ export class WrappedObjectAsync<T> extends BaseAsyncSequence<T> {
}
export class WrappedArrayAsync<T> extends BaseAsyncSequence<T> {
readonly #array: MaybePromiseLike<T>[];
readonly #array: ReadonlyArray<MaybePromiseLike<T>>;
constructor(array: MaybePromiseLike<T>[]) {
constructor(array: ReadonlyArray<MaybePromiseLike<T>>) {
super();
this.#array = array;
@@ -1694,6 +1690,10 @@ class AppendAsyncSequence<T> extends BaseAsyncSequence<T> {
return n < 0 ? -1 : n + 1;
}
override async maxCount() {
return await this.#sequence.maxCount() + 1;
}
override async *iterator() {
yield* this.#sequence;
yield this.#obj;
@@ -1716,23 +1716,29 @@ class PrependAsyncSequence<T> extends BaseAsyncSequence<T> {
return n < 0 ? -1 : n + 1;
}
override async maxCount() {
return await this.#sequence.maxCount() + 1;
}
override async *iterator() {
yield this.#obj;
yield* this.#sequence;
}
}
class PeekAsyncSequence<T> extends DelegatedAsyncSequence<T> {
class PeekAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #sequence: AsyncSequence<T>;
readonly #action: MaybeAsyncAction<T>;
constructor(sequence: AsyncSequence<T>, action: MaybeAsyncAction<T>) {
super(sequence);
super();
this.#sequence = sequence;
this.#action = action;
}
override async *iterator() {
for await (const obj of this.sequence) {
for await (const obj of this.#sequence) {
await this.#action(obj);
yield obj;
}
@@ -2023,7 +2029,7 @@ class GroupByAsyncSequence<TElement, TKey, TResult> extends BaseAsyncSequence<Gr
}
}
class ChunkedAsyncSequence<T> extends BaseAsyncSequence<T[]> {
class ChunkedAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
readonly #sequence: AsyncSequence<T>;
readonly #size: number;
@@ -2046,13 +2052,13 @@ class ChunkedAsyncSequence<T> extends BaseAsyncSequence<T[]> {
chunk.push(obj);
if (chunk.length === this.#size) {
yield chunk;
yield array(chunk);
chunk = [];
}
}
if (chunk.length > 0) {
yield chunk;
yield array(chunk);
}
}
}
@@ -2179,7 +2185,18 @@ class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
}
override async *iterator() {
yield* this.#cache ??= await this.#sequence.toArray();
if (this.#cache) {
yield* this.#cache;
} else {
const cache = [];
for await (const e of this.#sequence) {
cache.push(e);
yield e;
}
this.#cache = cache;
}
}
}

2
src/async/index.ts
View File

@@ -33,7 +33,7 @@ export function single<T>(obj: MaybePromiseLike<T>): AsyncSequence<T> {
return new WrappedObjectAsync(obj);
}
export function array<T>(array: MaybePromiseLike<T>[]): AsyncSequence<T> {
export function array<T>(array: ReadonlyArray<MaybePromiseLike<T>>): AsyncSequence<T> {
return new WrappedArrayAsync(array);
}

10
src/async/types.ts
View File

@@ -1,11 +1,13 @@
import { Collector } from "../collector/types.js";
import { AsyncRandomOptions } from "../random/types.js";
import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybeAsyncSequence } from "../types.js";
import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybeAsyncSequence, MaybeAsyncFunction, MaybePromise } from "../types.js";
export type AsyncSequencePipeline<TElement, TResult> = MaybeAsyncFunction<(sequence: AsyncSequence<TElement>) => TResult>;
export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
iterator(): AsyncIterator<TElement>;
apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult;
apply<TResult>(pipeline: AsyncSequencePipeline<TElement, TResult>): MaybePromise<TResult>;
count(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<number>;
nonEnumeratedCount(): Promise<number>;
@@ -105,8 +107,8 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
reversed(): AsyncSequence<TElement>;
chunked(size: number, asArray?: false): AsyncSequence<AsyncSequence<TElement>>;
chunked(size: number, asArray: true): AsyncSequence<TElement[]>;
chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
chunked<TResult>(size: number, transformer: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<TResult>;
random(options?: AsyncRandomOptions<TElement>): Promise<TElement | undefined>;

2
src/equality-set.ts
View File

@@ -93,7 +93,7 @@ class CustomEqualitySet<T> implements EqualitySet<T> {
}
values() {
return this[Symbol.iterator]();
return this.#list.values();
}
[Symbol.iterator]() {

380
src/sync/impl.ts
View File

@@ -1,5 +1,3 @@
import util from "util";
import { BaseAsyncSequence } from "../async/impl.js";
import { AsyncSequence } from "../async/types.js";
import { Collector } from "../collector/types.js";
@@ -11,7 +9,7 @@ import { RandomOptions } from "../random/types.js";
import { AnyPredicate, Converter, FilterPredicate, Equater, BiConverter, Accumulator, Comparer, Action } from "../types.js";
import { strictEquals, identity, operatorCompare, reverseComparer, asIterable, defaultArrayComparer, combineComparers } from "../utils.js";
import { array, empty } from "./index.js";
import { Sequence, GroupedSequence, OrderedSequence } from "./types.js";
import { Sequence, GroupedSequence, OrderedSequence, SequencePipeline } from "./types.js";
export class SequenceMarker { }
@@ -20,10 +18,6 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return this.iterator();
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return "Sequence {}";
}
override valueOf() {
return this.toJSON();
}
@@ -141,26 +135,33 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new ConcatSequence(arr);
}
count(predicate?: AnyPredicate<TElement>) {
_countWithPredicate(predicate: AnyPredicate<TElement>) {
let count = 0;
if (predicate) {
for (const element of this) {
if (predicate(element)) {
count++;
}
}
} else {
return count;
}
_countWithoutPredicate() {
let count = 0;
const iterator = this.iterator();
while (!iterator.next().done) {
count++;
}
}
return count;
}
count(predicate?: AnyPredicate<TElement>) {
return predicate ? this._countWithPredicate(predicate) : this._countWithoutPredicate();
}
nonEnumeratedCount() {
return -1;
}
@@ -175,7 +176,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return n >= 0 ? n : Infinity;
}
#tryGetFirst(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement | undefined } {
#tryGetFirst(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement | undefined; } {
if (predicate) {
for (const element of this) {
if (predicate(element)) {
@@ -217,7 +218,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return result.found ? result.element : def;
}
#tryGetLast(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement } {
#tryGetLast(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement; } {
let found = false;
let result: TElement | undefined = undefined;
@@ -257,7 +258,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return result.found ? result.element : def;
}
#tryGetSingle(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement, reason?: number } {
#tryGetSingle(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement, reason?: number; } {
if (predicate) {
let result: { found: boolean; element: TElement; } | undefined = undefined;
@@ -405,7 +406,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
let next = iterator.next();
if (next.done) {
throw new Error("Sequence contains no element.")
throw new Error("Sequence contains no element.");
}
if (!selector) {
@@ -454,6 +455,58 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return this.#find(x => x < 0, converter, comparer);
}
#findBounds<TResult>(selector?: Converter<TElement, TResult>, comparer?: Comparer<TResult>) {
const iterator = this.iterator();
let next = iterator.next();
if (next.done) {
throw new Error("Sequence contains no element.");
}
if (!selector) {
selector = identity as Converter<TElement, TResult>;
}
if (!comparer) {
comparer = operatorCompare;
}
let minBound = next.value, maxBound = minBound;
let convertedMinBound = selector(minBound), convertedMaxBound = convertedMinBound;
while (true) {
next = iterator.next();
if (next.done) {
break;
}
const value = next.value;
const convertedValue = selector(value);
if (comparer(convertedMinBound, convertedValue) > 0) {
minBound = value;
convertedMinBound = convertedValue;
}
if (comparer(convertedMaxBound, convertedValue) < 0) {
maxBound = value;
convertedMaxBound = convertedValue;
}
}
return { min: minBound, max: maxBound };
}
bounds(comparer?: Comparer<TElement>) {
return this.#findBounds(undefined, comparer);
}
boundsBy<TBy>(converter: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
return this.#findBounds(converter, comparer);
}
order(comparer?: Comparer<TElement>): OrderedSequence<TElement> {
return new OrderSequence<TElement>(this, false, comparer);
}
@@ -628,15 +681,15 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new ReversedSequence<TElement>(this);
}
chunked(size: number, asArray?: false): Sequence<Sequence<TElement>>;
chunked(size: number, asArray: true): Sequence<TElement[]>;
chunked(size: number, asArray?: boolean): Sequence<Sequence<TElement>> | Sequence<TElement[]> {
chunked(size: number): Sequence<Sequence<TElement>>;
chunked<TResult>(size: number, transformer: SequencePipeline<TElement, TResult>): Sequence<TResult>;
chunked<TResult>(size: number, transformer?: SequencePipeline<TElement, TResult>): Sequence<Sequence<TElement>> | Sequence<TResult> {
if (size <= 0) {
throw new Error("Chunk size must be positive.");
}
const sequence = new ChunkedSequence<TElement>(this, size);
return asArray ? sequence : sequence.select(array);
const result = new ChunkedSequence<TElement>(this, size);
return transformer ? result.select(transformer) : result;
}
random(options?: RandomOptions<TElement>) {
@@ -729,10 +782,6 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.iterator();
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return inspect(this.#sequence);
}
toJSON() {
return this.#sequence.toJSON();
}
@@ -869,6 +918,14 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.maxBy(selector, comparer);
}
bounds(comparer?: Comparer<TElement>) {
return this.#sequence.bounds(comparer);
}
boundsBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
return this.#sequence.boundsBy(selector, comparer);
}
order(comparer?: Comparer<TElement>) {
return this.#sequence.order(comparer);
}
@@ -985,10 +1042,10 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.reversed();
}
chunked(size: number, asArray?: false): Sequence<Sequence<TElement>>;
chunked(size: number, asArray: true): Sequence<TElement[]>;
chunked(size: number, asArray?: any): Sequence<Sequence<TElement>> | Sequence<TElement[]> {
return this.#sequence.chunked(size, asArray);
chunked(size: number): Sequence<Sequence<TElement>>;
chunked<TResult>(size: number, transformer: SequencePipeline<TElement, TResult>): Sequence<TResult>;
chunked(size: number, transformer?: any): any {
return this.#sequence.chunked(size, transformer);
}
random(options?: RandomOptions<TElement>) {
@@ -1045,10 +1102,6 @@ export class GroupedSequenceImpl<TKey, TElement> extends DelegatedSequence<TElem
return this.#key;
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Group { key: ${inspect(this.#key)}, sequence: ${inspect(this.sequence)} }`;
}
override toJSON() {
return { key: this.#key, items: this.toArray() };
}
@@ -1131,10 +1184,6 @@ class EmptySequence<T> extends BaseSequence<T> {
}
override *iterator() { }
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Empty {}`;
}
}
export const EMPTY = new EmptySequence<any>();
@@ -1169,10 +1218,6 @@ export class RangeSequence extends BaseSequence<number> {
yield i;
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Range { start: ${inspect(this.#min)}, end: ${inspect(this.#max)}, step: ${inspect(this.#step)} }`;
}
}
export class BigIntRangeSequence extends BaseSequence<bigint> {
@@ -1205,10 +1250,6 @@ export class BigIntRangeSequence extends BaseSequence<bigint> {
yield i;
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `BigIntRange { start: ${inspect(this.#min)}, end: ${inspect(this.#max)}, step: ${inspect(this.#step)} }`;
}
}
export class RepeatSequence<T> extends BaseSequence<T> {
@@ -1237,10 +1278,6 @@ export class RepeatSequence<T> extends BaseSequence<T> {
yield this.#value;
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Repeat { value: ${inspect(this.#value)}, amount: ${inspect(this.#count)} }`;
}
}
export class RepeatForeverSequence<T> extends BaseSequence<T> {
@@ -1265,10 +1302,6 @@ export class RepeatForeverSequence<T> extends BaseSequence<T> {
yield this.#value;
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `RepeatForever { value: ${inspect(this.#value)} }`;
}
}
export class WrappedObject<T> extends BaseSequence<T> {
@@ -1291,10 +1324,6 @@ export class WrappedObject<T> extends BaseSequence<T> {
override *iterator() {
yield this.#obj;
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `WrappedObject { value: ${inspect(this.#obj)} }`;
}
}
export class WrappedIterable<T> extends BaseSequence<T> {
@@ -1309,13 +1338,9 @@ export class WrappedIterable<T> extends BaseSequence<T> {
override iterator() {
return this.#iterable[Symbol.iterator]();
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `WrappedIterable { value: ${inspect(this.#iterable)} }`;
}
}
export class WrappedReadonlyArray<T> extends BaseSequence<T> {
export class WrappedArray<T> extends BaseSequence<T> {
readonly #array: ReadonlyArray<T>;
constructor(array: ReadonlyArray<T>) {
@@ -1377,24 +1402,6 @@ export class WrappedReadonlyArray<T> extends BaseSequence<T> {
}
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `WrappedArray { value: ${inspect(this.#array)} }`;
}
}
export class WrappedArray<T> extends WrappedReadonlyArray<T> {
constructor(array: T[]) {
super(array);
}
override asArray() {
return this.array as T[];
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `WrappedArray { value: ${inspect(this.array)} }`;
}
}
export class WrappedArrayLike<T> extends BaseSequence<T> {
@@ -1431,10 +1438,6 @@ export class WrappedArrayLike<T> extends BaseSequence<T> {
}
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `WrappedArrayLike { value: ${inspect(this.#arrayLike)} }`;
}
}
export class WrappedSet<T> extends BaseSequence<T> {
@@ -1465,10 +1468,6 @@ export class WrappedSet<T> extends BaseSequence<T> {
override iterator() {
return this.#set.values();
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `WrappedSet { value: ${inspect(this.#set)} }`;
}
}
export class WrappedMap<K, V> extends BaseSequence<[K, V]> {
@@ -1503,10 +1502,6 @@ export class WrappedMap<K, V> extends BaseSequence<[K, V]> {
override iterator() {
return this.#map.entries();
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `WrappedMap { value: ${inspect(this.#map)} }`;
}
}
export class GeneratorSequence<T> extends BaseSequence<T> {
@@ -1521,10 +1516,6 @@ export class GeneratorSequence<T> extends BaseSequence<T> {
override iterator() {
return this.#generator()[Symbol.iterator]();
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `WrappedGenerator { value: ${inspect(this.#generator)} }`;
}
}
export class FunctionSequence<T> extends BaseSequence<T> {
@@ -1549,10 +1540,6 @@ export class FunctionSequence<T> extends BaseSequence<T> {
yield this.#f();
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `WrappedFunction { value: ${inspect(this.#f)} }`;
}
}
export class ConcatSequence<T> extends BaseSequence<T> {
@@ -1605,10 +1592,6 @@ export class ConcatSequence<T> extends BaseSequence<T> {
yield* sequence;
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Concat { sequences: ${inspect(this.#sequences)} }`;
}
}
class DistinctSequence<T> extends BaseSequence<T> {
@@ -1635,10 +1618,6 @@ class DistinctSequence<T> extends BaseSequence<T> {
}
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Distinct { equater: ${inspect(this.#equater)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class DistinctBySequence<T, U> extends BaseSequence<T> {
@@ -1667,10 +1646,6 @@ class DistinctBySequence<T, U> extends BaseSequence<T> {
}
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `DistinctBy { converter: ${inspect(this.#converter)}, equater: ${inspect(this.#equater)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class WhereSequence<TElement, TFiltered extends TElement> extends BaseSequence<TFiltered> {
@@ -1695,10 +1670,6 @@ class WhereSequence<TElement, TFiltered extends TElement> extends BaseSequence<T
}
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Where { predicate: ${inspect(this.#predicate)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class SelectManySequence<T, U> extends BaseSequence<U> {
@@ -1717,10 +1688,6 @@ class SelectManySequence<T, U> extends BaseSequence<U> {
yield* this.#converter(obj);
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `SelectMany { converter: ${inspect(this.#converter)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class IndexedSequence<T> extends BaseSequence<[number, T]> {
@@ -1747,10 +1714,6 @@ class IndexedSequence<T> extends BaseSequence<[number, T]> {
yield [i++, obj] as [number, T];
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Indexed { sequence: ${inspect(this.#sequence)} }`;
}
}
class SelectSequence<T, U> extends BaseSequence<U> {
@@ -1777,10 +1740,6 @@ class SelectSequence<T, U> extends BaseSequence<U> {
yield this.#converter(obj);
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Select { converter: ${inspect(this.#converter)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class SkipWhileSequence<T> extends BaseSequence<T> {
@@ -1810,10 +1769,6 @@ class SkipWhileSequence<T> extends BaseSequence<T> {
yield* e;
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `SkipWhile { predicate: ${inspect(this.#predicate)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class SkipLastSequence<T> extends BaseSequence<T> {
@@ -1859,10 +1814,6 @@ class SkipLastSequence<T> extends BaseSequence<T> {
i = (i + 1) % this.#n;
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `SkipLast { amount: ${inspect(this.#n)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class SkipSequence<T> extends BaseSequence<T> {
@@ -1899,10 +1850,6 @@ class SkipSequence<T> extends BaseSequence<T> {
yield* asIterable(iterator);
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Skip { amount: ${inspect(this.#n)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class TakeWhileSequence<T> extends BaseSequence<T> {
@@ -1929,10 +1876,6 @@ class TakeWhileSequence<T> extends BaseSequence<T> {
yield obj;
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `TakeWhile { predicate: ${inspect(this.#predicate)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class TakeLastSequence<T> extends BaseSequence<T> {
@@ -1964,10 +1907,6 @@ class TakeLastSequence<T> extends BaseSequence<T> {
yield* queue;
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `TakeLast { amount: ${inspect(this.#n)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class TakeSequence<T> extends BaseSequence<T> {
@@ -2005,20 +1944,12 @@ class TakeSequence<T> extends BaseSequence<T> {
i--;
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Take { amount: ${inspect(this.#n)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class OrderSequence<T> extends BaseOrderedSequence<T> {
constructor(sequence: Sequence<T>, descending: boolean, sorter?: Comparer<T>) {
super(sequence, sorter, descending);
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Order${this.descending ? "Descending" : ""} { sequence: ${inspect(this.sequence)} }`;
}
}
class OrderBySequence<T, U> extends BaseOrderedSequence<T> {
@@ -2030,10 +1961,6 @@ class OrderBySequence<T, U> extends BaseOrderedSequence<T> {
this.#selector = selector;
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `OrderBy${this.descending ? "Descending" : ""} { converter: ${inspect(this.#selector)}, sequence: ${inspect(this.sequence)} }`;
}
static #createSorter<T, U>(selector: Converter<T, U>, sorter?: Comparer<U>) {
const _sorter = sorter ?? defaultArrayComparer;
return (a: T, b: T) => _sorter(selector(a), selector(b));
@@ -2044,10 +1971,6 @@ class ThenOrderSequence<T> extends BaseOrderedSequence<T> {
constructor(sequence: OrderedSequence<T>, descending: boolean, sorter?: Comparer<T>) {
super(sequence, combineComparers(sequence.comparer ?? defaultArrayComparer, sorter ?? defaultArrayComparer), descending);
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `ThenOrder${this.descending ? "Descending" : ""} { sequence: ${inspect(this.sequence)} }`;
}
}
class ThenOrderBySequence<T, U> extends BaseOrderedSequence<T> {
@@ -2059,10 +1982,6 @@ class ThenOrderBySequence<T, U> extends BaseOrderedSequence<T> {
this.#selector = selector;
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `ThenOrderBy${this.descending ? "Descending" : ""} { converter: ${inspect(this.#selector)}, sequence: ${inspect(this.sequence)} }`;
}
static #createCombinedSorter<T, U>(baseSorter: Comparer<T> | undefined, selector: Converter<T, U>, sorter?: Comparer<U>) {
const _baseSorter = baseSorter ?? defaultArrayComparer;
const _sorter = sorter ?? defaultArrayComparer;
@@ -2094,10 +2013,6 @@ class AppendSequence<T> extends BaseSequence<T> {
yield* this.#sequence;
yield this.#obj;
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Append { value: ${inspect(this.#obj)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class PrependSequence<T> extends BaseSequence<T> {
@@ -2124,34 +2039,36 @@ class PrependSequence<T> extends BaseSequence<T> {
yield this.#obj;
yield* this.#sequence;
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Prepend { value: ${inspect(this.#obj)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class PeekSequence<T> extends DelegatedSequence<T> {
class PeekSequence<T> extends BaseSequence<T> {
readonly #sequence: Sequence<T>;
readonly #action: Action<T>;
constructor(sequence: Sequence<T>, action: Action<T>) {
super(sequence);
super();
this.#sequence = sequence;
this.#action = action;
}
override nonEnumeratedCount() {
return this.#sequence.nonEnumeratedCount();
}
override maxCount() {
return this.#sequence.maxCount();
}
override *iterator() {
for (const obj of this.sequence) {
for (const obj of this.#sequence) {
this.#action(obj);
yield obj;
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Prepend { action: ${inspect(this.#action)}, sequence: ${inspect(this.sequence)} }`;
}
}
class ZippedSequence<T, U> extends BaseSequence<[T, U]> {
export class ZippedSequence<T, U> extends BaseSequence<[T, U]> {
readonly #first: Sequence<T>;
readonly #second: Sequence<U>;
@@ -2188,10 +2105,6 @@ class ZippedSequence<T, U> extends BaseSequence<[T, U]> {
yield [firstNext.value, secondNext.value] as [T, U];
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Zip { first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
}
}
class UnionSequence<T> extends BaseSequence<T> {
@@ -2225,10 +2138,6 @@ class UnionSequence<T> extends BaseSequence<T> {
}
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Union { first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
}
}
class UnionBySequence<T, U> extends BaseSequence<T> {
@@ -2264,10 +2173,6 @@ class UnionBySequence<T, U> extends BaseSequence<T> {
}
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Zip { converter: ${inspect(this.#selector)}, equater: ${inspect(this.#equater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
}
}
class ExceptSequence<T> extends BaseSequence<T> {
@@ -2300,10 +2205,6 @@ class ExceptSequence<T> extends BaseSequence<T> {
}
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Except { equater: ${inspect(this.#equater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
}
}
class ExceptBySequence<T, U> extends BaseSequence<T> {
@@ -2338,10 +2239,6 @@ class ExceptBySequence<T, U> extends BaseSequence<T> {
}
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `ExceptBy { converter: ${inspect(this.#selector)}, equater: ${inspect(this.#equater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
}
}
class IntersectSequence<T> extends BaseSequence<T> {
@@ -2374,10 +2271,6 @@ class IntersectSequence<T> extends BaseSequence<T> {
}
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Intersect { equater: ${inspect(this.#equater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
}
}
class IntersectBySequence<T, U> extends BaseSequence<T> {
@@ -2412,10 +2305,6 @@ class IntersectBySequence<T, U> extends BaseSequence<T> {
}
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `IntersectBy { converter: ${inspect(this.#selector)}, equater: ${inspect(this.#equater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
}
}
class ReversedSequence<T> extends BaseSequence<T> {
@@ -2446,10 +2335,6 @@ class ReversedSequence<T> extends BaseSequence<T> {
yield buffer.pop()!;
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Reversed { sequence: ${inspect(this.#sequence)} }`;
}
}
class GroupBySequence<TElement, TKey, TResult> extends BaseSequence<GroupedSequence<TKey, TResult>> {
@@ -2491,13 +2376,9 @@ class GroupBySequence<TElement, TKey, TResult> extends BaseSequence<GroupedSeque
yield new GroupedSequenceImpl(entry[0], array(entry[1]));
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `GroupBy { keySelector: ${inspect(this.#keySelector)}, elementSelector: ${inspect(this.#elementSelector)}, keyEquater: ${inspect(this.#keyEquater)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class ChunkedSequence<T> extends BaseSequence<T[]> {
class ChunkedSequence<T> extends BaseSequence<Sequence<T>> {
readonly #sequence: Sequence<T>;
readonly #size: number;
@@ -2524,19 +2405,15 @@ class ChunkedSequence<T> extends BaseSequence<T[]> {
chunk.push(obj);
if (chunk.length === this.#size) {
yield chunk;
yield array(chunk);
chunk = [];
}
}
if (chunk.length > 0) {
yield chunk;
yield array(chunk);
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `ChunkedAsArray { size: ${inspect(this.#size, options)} sequence: ${inspect(this.#sequence, options)} }`;
}
}
class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult> {
@@ -2579,10 +2456,6 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
}
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Join { firstKeySelector: ${inspect(this.#firstKeySelector)}, secondKeySelector: ${inspect(this.#secondKeySelector)}, resultSelector: ${inspect(this.#resultSelector)}, keyEquater: ${inspect(this.#keyEquater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
}
}
class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult> {
@@ -2632,10 +2505,6 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
yield this.#resultSelector(firstObj, array(secondObjs));
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `GroupJoin { firstKeySelector: ${inspect(this.#firstKeySelector)}, secondKeySelector: ${inspect(this.#secondKeySelector)}, resultSelector: ${inspect(this.#resultSelector)}, keyEquater: ${inspect(this.#keyEquater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
}
}
class RemoveSequence<T> extends BaseSequence<T> {
@@ -2675,30 +2544,31 @@ class RemoveSequence<T> extends BaseSequence<T> {
yield obj;
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Remove { value: ${inspect(this.#obj)}, all: ${inspect(this.#all)}, equater: ${inspect(this.#equater)} sequence: ${inspect(this.#sequence)} }`;
}
}
class CacheSequence<T> extends DelegatedSequence<T> {
#cached = false;
class CacheSequence<T> extends BaseSequence<T> {
readonly #sequence: Sequence<T>;
#cache: T[] | undefined;
constructor(sequence: Sequence<T>) {
super(sequence);
super();
this.#sequence = sequence;
}
override iterator() {
if (!this.#cached) {
this.sequence = array(this.sequence.toArray());
this.#cached = true;
override *iterator() {
if (this.#cache) {
yield* this.#cache;
} else {
const cache = [];
for (const e of this.#sequence) {
cache.push(e);
yield e;
}
return super.iterator();
this.#cache = cache;
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Cached { sequence: ${inspect(this.sequence)} }`;
}
}
@@ -2730,10 +2600,6 @@ class PartitionSequence<T> extends BaseSequence<Sequence<T>> {
yield array(partition);
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Partition { equater: ${inspect(this.#equater)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class PartitionBySequence<TElement, TBy> extends BaseSequence<Sequence<TElement>> {
@@ -2767,10 +2633,6 @@ class PartitionBySequence<TElement, TBy> extends BaseSequence<Sequence<TElement>
yield array(partition);
}
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `PartitionBy { converter: ${inspect(this.#selector)}, equater: ${inspect(this.#equater)}, sequence: ${inspect(this.#sequence)} }`;
}
}
class AwaitedSequence<T> extends BaseAsyncSequence<Awaited<T>> {
@@ -2785,8 +2647,4 @@ class AwaitedSequence<T> extends BaseAsyncSequence<Awaited<T>> {
override async *iterator() {
yield* this.#sequence;
}
[util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
return `Awaited { sequence: ${inspect(this.#sequence)} }`;
}
}

8
src/sync/index.ts
View File

@@ -1,6 +1,6 @@
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, WrappedReadonlyArray, EMPTY } from "./impl.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> {
@@ -36,7 +36,7 @@ export function single<T>(obj: T): Sequence<T> {
}
export function array<T = any>(array: ReadonlyArray<T>): Sequence<T> {
return new WrappedReadonlyArray(array);
return new WrappedArray(array);
}
export function arrayLike<T = any>(arrayLike: ArrayLike<T>): Sequence<T> {
@@ -142,6 +142,10 @@ 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;
}

7
src/sync/types.ts
View File

@@ -66,6 +66,9 @@ export interface Sequence<TElement> extends Iterable<TElement> {
max(comparer?: Comparer<TElement>): TElement;
maxBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): TElement;
bounds(comparer?: Comparer<TElement>): { min: TElement, max: TElement; };
boundsBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): { min: TElement, max: TElement; };
order(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
@@ -111,8 +114,8 @@ export interface Sequence<TElement> extends Iterable<TElement> {
reversed(): Sequence<TElement>;
chunked(size: number, asArray?: false): Sequence<Sequence<TElement>>;
chunked(size: number, asArray: true): Sequence<TElement[]>;
chunked(size: number): Sequence<Sequence<TElement>>;
chunked<TResult>(size: number, transformer: SequencePipeline<TElement, TResult>): Sequence<TResult>;
random(options?: RandomOptions<TElement>): TElement | undefined;

2
src/types.ts
View File

@@ -6,7 +6,7 @@ export type AnyPredicate<T> = (obj: T) => unknown;
export type FilterPredicate<TElement, TFiltered extends TElement> = (obj: TElement) => obj is TFiltered;
export type Converter<TFrom, TTo> = (obj: TFrom) => TTo;
export type BiConverter<TFromFirst, TFromSecond, TTo> = (first: TFromFirst, second: TFromSecond) => TTo;
export type Action<T> = (obj: T) => void;
export type Action<T> = (obj: T) => unknown;
export type Accumulator<TElement, TAccumulator> = (acc: TAccumulator, obj: TElement) => TAccumulator;
export type Comparer<T> = (first: T, second: T) => number;
export type Equater<T> = (first: T, second: T) => boolean;

2
src/utils.ts
View File

@@ -1,4 +1,4 @@
import { Comparer, MaybeAsyncComparer, AsyncComparer, MaybeAsyncIterator } from "./types.js";
import { Comparer, MaybeAsyncComparer, AsyncComparer } from "./types.js";
export function isDefined<T = any>(obj: T): obj is NonNullable<T> {
return obj !== undefined && obj !== null;