hbecher/sequence-js
1
0
Fork 0
Code Activity

sequence type fixes and refactor

Browse Source
This commit is contained in:
Hervé BECHER
2024-05-17 22:12:16 +02:00
parent 85033018cf
commit 595d9fd5fc
7 changed files with 287 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
src/sync/impl.ts
View File

@@ -6,7 +6,7 @@ import { getRandomElement } from "../random/index.js";
import { RandomOptions } from "../random/types.js";
import { Converter, FilterPredicate, Equater, BiConverter, Predicate, Accumulator, Comparer, Action } from "../types.js";
import { strictEquals, identity, operatorCompare, reverseComparer, wrapAsIterable, defaultArrayComparer, combineComparers } from "../utils.js";
import { array, empty, wrap } from "./index.js";
import { array, empty } from "./index.js";
import { Sequence, GroupedSequence, OrderedSequence } from "./types.js";
export class SequenceMarker { }
@@ -26,7 +26,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new SelectSequence<TElement, TResult>(this, converter);
}
selectMany<TResult>(converter: Converter<TElement, Iterable<TResult>>): Sequence<TResult> {
selectMany<TResult>(converter: Converter<TElement, Sequence<TResult>>): Sequence<TResult> {
return new SelectManySequence<TElement, TResult>(this, converter);
}
@@ -38,12 +38,12 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new GroupBySequence<TElement, TKey, TResult>(this, keySelector, elementSelector, keyComparer);
}
join<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult> {
return new JoinSequence<TElement, TOther, TKey, TResult>(this, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
join<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult> {
return new JoinSequence<TElement, TOther, TKey, TResult>(this, sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
groupJoin<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult> {
return new GroupJoinSequence<TElement, TOther, TKey, TResult>(this, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
groupJoin<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult> {
return new GroupJoinSequence<TElement, TOther, TKey, TResult>(this, sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
contains(obj: TElement, equater?: Equater<TElement>) {
@@ -60,15 +60,13 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return false;
}
sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
if (this === iterable) {
sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
if (this === sequence) {
return true;
}
const that = wrap(iterable);
const thisCount = this.nonEnumeratedCount();
const thatCount = that.nonEnumeratedCount();
const thatCount = sequence.nonEnumeratedCount();
if (thisCount >= 0 && thatCount >= 0 && thisCount !== thatCount) {
return false;
@@ -79,7 +77,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
}
const thisIterator = this.iterator();
const thatIterator = that.iterator();
const thatIterator = sequence.iterator();
while (true) {
const thisNext = thisIterator.next();
@@ -111,15 +109,15 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new RemoveSequence<TElement>(this, obj, all, equater);
}
concat(...iterables: Iterable<TElement>[]) {
if (iterables.length === 0) {
concat(...sequences: Sequence<TElement>[]) {
if (sequences.length === 0) {
return this;
}
const arr: Sequence<TElement>[] = [this];
for (const iterable of iterables) {
arr.push(wrap(iterable));
for (const sequence of sequences) {
arr.push(sequence);
}
return new ConcatSequence(arr);
@@ -470,28 +468,28 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new DistinctBySequence<TElement, TBy>(this, selector, equater);
}
union(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement> {
return new UnionSequence<TElement>(this, wrap(iterable), equater);
union(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement> {
return new UnionSequence<TElement>(this, sequence, equater);
}
unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement> {
return new UnionBySequence<TElement, TBy>(this, wrap(iterable), selector, equater);
unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement> {
return new UnionBySequence<TElement, TBy>(this, sequence, selector, equater);
}
except(iterable: Iterable<TElement>): Sequence<TElement> {
return new ExceptSequence<TElement>(this, wrap(iterable));
except(sequence: Sequence<TElement>): Sequence<TElement> {
return new ExceptSequence<TElement>(this, sequence);
}
exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new ExceptBySequence<TElement, TBy>(this, wrap(iterable), selector);
exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new ExceptBySequence<TElement, TBy>(this, sequence, selector);
}
intersect(iterable: Iterable<TElement>): Sequence<TElement> {
return new IntersectSequence<TElement>(this, wrap(iterable));
intersect(sequence: Sequence<TElement>): Sequence<TElement> {
return new IntersectSequence<TElement>(this, sequence);
}
intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new IntersectBySequence<TElement, TBy>(this, wrap(iterable), selector);
intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new IntersectBySequence<TElement, TBy>(this, sequence, selector);
}
all(predicate: Predicate<TElement>) {
@@ -600,8 +598,8 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
}
}
zip<TOther>(iterable: Iterable<TOther>): Sequence<[TElement, TOther]> {
return new ZippedSequence<TElement, TOther>(this, wrap(iterable));
zip<TOther>(sequence: Sequence<TOther>): Sequence<[TElement, TOther]> {
return new ZippedSequence<TElement, TOther>(this, sequence);
}
indexed(): Sequence<[number, TElement]> {
@@ -726,7 +724,7 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.select(selector);
}
selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>) {
selectMany<TResult>(selector: Converter<TElement, Sequence<TResult>>) {
return this.#sequence.selectMany(selector);
}
@@ -734,27 +732,30 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.where(predicate);
}
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: Equater<TKey>) {
//@ts-ignore
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: Equater<TKey> | undefined): Sequence<GroupedSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: Equater<TKey> | undefined): Sequence<GroupedSequence<TKey, TResult>>;
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
}
join<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>) {
//@ts-ignore
return this.#sequence.join(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
join<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey> | undefined): Sequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey> | undefined): Sequence<TResult>;
join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
groupJoin<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>) {
//@ts-ignore
return this.#sequence.groupJoin(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
groupJoin<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey> | undefined): Sequence<GroupedSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey> | undefined): Sequence<TResult>;
groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.groupJoin(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
contains(obj: TElement, equater?: Equater<TElement>) {
return this.#sequence.contains(obj, equater);
}
sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
return this.#sequence.sequenceEquals(iterable, equater);
sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
return this.#sequence.sequenceEquals(sequence, equater);
}
append(obj: TElement) {
@@ -769,8 +770,8 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.remove(obj, all, equater);
}
concat(...iterables: Iterable<TElement>[]) {
return this.#sequence.concat(...iterables);
concat(...sequences: Sequence<TElement>[]) {
return this.#sequence.concat(...sequences);
}
first(predicate?: Predicate<TElement>) {
@@ -857,41 +858,43 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.distinctBy(selector, equater);
}
union(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
return this.#sequence.union(iterable, equater);
union(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
return this.#sequence.union(sequence, equater);
}
unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.unionBy(iterable, selector, equater);
unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.unionBy(sequence, selector, equater);
}
except(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
return this.#sequence.except(iterable, equater);
except(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
return this.#sequence.except(sequence, equater);
}
exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.exceptBy(iterable, selector, equater);
exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.exceptBy(sequence, selector, equater);
}
intersect(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
return this.#sequence.intersect(iterable, equater);
intersect(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
return this.#sequence.intersect(sequence, equater);
}
intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.intersectBy(iterable, selector, equater);
intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.intersectBy(sequence, selector, equater);
}
all(predicate: Predicate<TElement>) {
return this.#sequence.all(predicate);
}
any(predicate?: Predicate<TElement>) {
//@ts-ignore
any(predicate: Predicate<TElement>): boolean;
any(): boolean;
any(predicate?: any) {
return this.#sequence.any(predicate);
}
none(predicate?: Predicate<TElement>) {
//@ts-ignore
none(predicate: Predicate<TElement>): boolean;
none(): boolean;
none(predicate?: any) {
return this.#sequence.none(predicate);
}
@@ -927,8 +930,8 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
this.#sequence.forEach(action);
}
zip<TOther>(iterable: Iterable<TOther>) {
return this.#sequence.zip(iterable);
zip<TOther>(sequence: Sequence<TOther>) {
return this.#sequence.zip(sequence);
}
indexed() {
@@ -951,6 +954,10 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.cached();
}
// awaited(): AsyncSequence<Awaited<TElement>> {
// return this.#sequence.awaited();
// }
asArray() {
return this.#sequence.asArray();
}
@@ -1053,16 +1060,10 @@ export abstract class BaseOrderedSequence<TElement> extends BaseSequence<TElemen
}
export class EmptySequence<T> extends BaseSequence<T> {
static readonly INSTANCE = new EmptySequence<any>();
override nonEnumeratedCount() {
return 0;
}
override maxCount() {
return 0;
}
override *iterator() { }
}
@@ -1552,9 +1553,9 @@ class WhereSequence<TElement, TFiltered extends TElement> extends BaseSequence<T
class SelectManySequence<T, U> extends BaseSequence<U> {
readonly #sequence: Sequence<T>;
readonly #converter: Converter<T, Iterable<U>>;
readonly #converter: Converter<T, Sequence<U>>;
constructor(sequence: Sequence<T>, converter: Converter<T, Iterable<U>>) {
constructor(sequence: Sequence<T>, converter: Converter<T, Sequence<U>>) {
super();
this.#sequence = sequence;
@@ -2479,3 +2480,17 @@ class PartitionBySequence<TElement, TBy> extends BaseSequence<TElement[]> {
yield* partitions.values();
}
}
// class AwaitedSequence<T> extends BaseAsyncSequence<Awaited<T>> {
// readonly #sequence: Sequence<T>;
// constructor(sequence: Sequence<T>) {
// super();
// this.#sequence = sequence;
// }
// override async *iterator() {
// yield* this.#sequence;
// }
// }