hbecher/sequence-js
1
0
Fork 0
Code Activity

sync

Browse Source
This commit is contained in:
Hervé BECHER
2025-05-24 12:11:44 +02:00
parent 9af08e71fc
commit c98e462142
24 changed files with 1702 additions and 688 deletions
Download Patch File Download Diff File Expand all files Collapse all files

373
src/sync/impl.ts
View File

@@ -1,14 +1,17 @@
import { BaseAsyncSequence } from "../async/impl.js";
import { AsyncSequence } from "../async/types.js";
import { Collector } from "../collector/types.js";
import { asComparer, combineNullableComparers, createComparerUsing, defaultComparer } from "../comparer/sync.js";
import { ComparisonOrComparer, Comparer } from "../comparer/types.js";
import { strictEquals, identity } from "../equality-comparer/index.js";
import { EqualityComparison } from "../equality-comparer/types.js";
import { createEqualityMap } from "../equality-map.js";
import { createEqualitySet } from "../equality-set.js";
import { createQueue } from "../queue.js";
import { getRandomElement } from "../random/index.js";
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 { AnyPredicate, Converter, TypePredicate, BiConverter, Accumulator, Action } from "../types.js";
import { array, empty, wrap } from "./index.js";
import { Sequence, GroupedSequence, OrderedSequence, SequencePipeline } from "./types.js";
export class SequenceMarker { }
@@ -36,29 +39,29 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new SelectSequence<TElement, TResult>(this, converter);
}
selectMany<TResult>(converter: Converter<TElement, Sequence<TResult>>): Sequence<TResult> {
selectMany<TResult>(converter: Converter<TElement, Iterable<TResult>>): Sequence<TResult> {
return new SelectManySequence<TElement, TResult>(this, converter);
}
where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
where<TFiltered extends TElement>(predicate: TypePredicate<TElement, TFiltered>): Sequence<TFiltered>;
where(predicate: AnyPredicate<TElement>): Sequence<TElement>;
where(predicate: any) {
return new WhereSequence<TElement, any>(this, predicate);
}
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TResult>> {
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TKey, TResult>> {
return new GroupBySequence<TElement, TKey, TResult>(this, keySelector, elementSelector, 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);
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult> {
return new JoinSequence<TElement, TOther, TKey, TResult>(this, wrap(sequence), 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);
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult> {
return new GroupJoinSequence<TElement, TOther, TKey, TResult>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
contains(obj: TElement, equater?: Equater<TElement>) {
contains(obj: TElement, equater?: EqualityComparison<TElement>) {
if (!equater) {
equater = strictEquals;
}
@@ -72,13 +75,15 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return false;
}
sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
if (this === sequence) {
return true;
}
const other = wrap(sequence);
const thisCount = this.nonEnumeratedCount();
const thatCount = sequence.nonEnumeratedCount();
const thatCount = other.nonEnumeratedCount();
if (thisCount >= 0 && thatCount >= 0 && thisCount !== thatCount) {
return false;
@@ -89,7 +94,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
}
const thisIterator = this.iterator();
const thatIterator = sequence.iterator();
const thatIterator = other.iterator();
while (true) {
const thisNext = thisIterator.next();
@@ -117,11 +122,11 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new PrependSequence<TElement>(this, obj);
}
remove(obj: TElement, all?: boolean, equater?: Equater<TElement>): Sequence<TElement> {
remove(obj: TElement, all?: boolean, equater?: EqualityComparison<TElement>): Sequence<TElement> {
return new RemoveSequence<TElement>(this, obj, all, equater);
}
concat(...sequences: Sequence<TElement>[]) {
concat(...sequences: Iterable<TElement>[]) {
if (sequences.length === 0) {
return this;
}
@@ -129,7 +134,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
const arr: Sequence<TElement>[] = [this];
for (const sequence of sequences) {
arr.push(sequence);
arr.push(wrap(sequence));
}
return new ConcatSequence(arr);
@@ -400,7 +405,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return acc as unknown as TResult;
}
#find<TResult>(sorter: AnyPredicate<number>, selector?: Converter<TElement, TResult>, comparer?: Comparer<TResult>) {
#find<TResult>(sorter: AnyPredicate<number>, selector?: Converter<TElement, TResult>, comparer?: ComparisonOrComparer<TResult>) {
const iterator = this.iterator();
let next = iterator.next();
@@ -413,9 +418,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
selector = identity as Converter<TElement, TResult>;
}
if (!comparer) {
comparer = operatorCompare;
}
comparer = comparer ? asComparer(comparer) : defaultComparer;
let result = next.value;
let convertedResult = selector(result);
@@ -430,7 +433,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
const value = next.value;
const convertedValue = selector(value);
if (sorter(comparer(convertedResult, convertedValue))) {
if (sorter(comparer.compare(convertedResult, convertedValue))) {
result = value;
convertedResult = convertedValue;
}
@@ -439,23 +442,23 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return result;
}
min(comparer?: Comparer<TElement>) {
min(comparer?: ComparisonOrComparer<TElement>) {
return this.#find(x => x > 0, undefined, comparer);
}
minBy<TBy>(converter: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
minBy<TBy>(converter: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>) {
return this.#find(x => x > 0, converter, comparer);
}
max(comparer?: Comparer<TElement>) {
max(comparer?: ComparisonOrComparer<TElement>) {
return this.#find(x => x < 0, undefined, comparer);
}
maxBy<TBy>(converter: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
maxBy<TBy>(converter: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>) {
return this.#find(x => x < 0, converter, comparer);
}
#findBounds<TResult>(selector?: Converter<TElement, TResult>, comparer?: Comparer<TResult>) {
#findBounds<TResult>(selector?: Converter<TElement, TResult>, comparer?: ComparisonOrComparer<TResult>): [min: TElement, max: TElement] {
const iterator = this.iterator();
let next = iterator.next();
@@ -468,9 +471,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
selector = identity as Converter<TElement, TResult>;
}
if (!comparer) {
comparer = operatorCompare;
}
comparer = comparer ? asComparer(comparer) : defaultComparer;
let minBound = next.value, maxBound = minBound;
let convertedMinBound = selector(minBound), convertedMaxBound = convertedMinBound;
@@ -485,82 +486,82 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
const value = next.value;
const convertedValue = selector(value);
if (comparer(convertedMinBound, convertedValue) > 0) {
if (comparer.compare(convertedMinBound, convertedValue) > 0) {
minBound = value;
convertedMinBound = convertedValue;
}
if (comparer(convertedMaxBound, convertedValue) < 0) {
if (comparer.compare(convertedMaxBound, convertedValue) < 0) {
maxBound = value;
convertedMaxBound = convertedValue;
}
}
return { min: minBound, max: maxBound };
return [minBound, maxBound];
}
bounds(comparer?: Comparer<TElement>) {
bounds(comparer?: ComparisonOrComparer<TElement>) {
return this.#findBounds(undefined, comparer);
}
boundsBy<TBy>(converter: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
boundsBy<TBy>(converter: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>) {
return this.#findBounds(converter, comparer);
}
order(comparer?: Comparer<TElement>): OrderedSequence<TElement> {
order(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement> {
return new OrderSequence<TElement>(this, false, comparer);
}
orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement> {
orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement> {
return new OrderBySequence<TElement, TBy>(this, false, selector, comparer);
}
orderDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement> {
orderDescending(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement> {
return new OrderSequence<TElement>(this, true, comparer);
}
orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement> {
orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement> {
return new OrderBySequence<TElement, TBy>(this, true, selector, comparer);
}
partition(equater?: Equater<TElement>): Sequence<Sequence<TElement>> {
partition(equater?: EqualityComparison<TElement>): Sequence<Sequence<TElement>> {
return new PartitionSequence<TElement>(this, equater);
}
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<Sequence<TElement>> {
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<Sequence<TElement>> {
return new PartitionBySequence<TElement, TBy>(this, selector, equater);
}
distinct(equater?: Equater<TElement>): Sequence<TElement> {
distinct(equater?: EqualityComparison<TElement>): Sequence<TElement> {
return new DistinctSequence<TElement>(this, equater);
}
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement> {
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement> {
return new DistinctBySequence<TElement, TBy>(this, selector, equater);
}
union(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement> {
return new UnionSequence<TElement>(this, sequence, equater);
union(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement> {
return new UnionSequence<TElement>(this, wrap(sequence), equater);
}
unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement> {
return new UnionBySequence<TElement, TBy>(this, sequence, selector, equater);
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement> {
return new UnionBySequence<TElement, TBy>(this, wrap(sequence), selector, equater);
}
except(sequence: Sequence<TElement>): Sequence<TElement> {
return new ExceptSequence<TElement>(this, sequence);
except(sequence: Iterable<TElement>): Sequence<TElement> {
return new ExceptSequence<TElement>(this, wrap(sequence));
}
exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new ExceptBySequence<TElement, TBy>(this, sequence, selector);
exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new ExceptBySequence<TElement, TBy>(this, wrap(sequence), selector);
}
intersect(sequence: Sequence<TElement>): Sequence<TElement> {
return new IntersectSequence<TElement>(this, sequence);
intersect(sequence: Iterable<TElement>): Sequence<TElement> {
return new IntersectSequence<TElement>(this, wrap(sequence));
}
intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new IntersectBySequence<TElement, TBy>(this, sequence, selector);
intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new IntersectBySequence<TElement, TBy>(this, wrap(sequence), selector);
}
all(predicate: AnyPredicate<TElement>) {
@@ -669,8 +670,8 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
}
}
zip<TOther>(sequence: Sequence<TOther>): Sequence<[TElement, TOther]> {
return new ZippedSequence<TElement, TOther>(this, sequence);
zip<TOther>(sequence: Iterable<TOther>): Sequence<[TElement, TOther]> {
return new ZippedSequence<TElement, TOther>(this, wrap(sequence));
}
indexed(): Sequence<[number, TElement]> {
@@ -682,14 +683,19 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
}
chunked(size: number): Sequence<Sequence<TElement>>;
chunked(size: number, asArray: true): 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> {
chunked<TResult>(size: number, transformerOrAsArray?: true | SequencePipeline<TElement, TResult>): Sequence<Sequence<TElement>> | Sequence<TElement[]> | Sequence<TResult> {
if (size <= 0) {
throw new Error("Chunk size must be positive.");
}
if (transformerOrAsArray === true) {
return new ChunkedArraySequence<TElement>(this, size);
}
const result = new ChunkedSequence<TElement>(this, size);
return transformer ? result.select(transformer) : result;
return transformerOrAsArray ? result.select(transformerOrAsArray) : result;
}
random(options?: RandomOptions<TElement>) {
@@ -814,39 +820,39 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.select(selector);
}
selectMany<TResult>(selector: Converter<TElement, Sequence<TResult>>) {
selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>) {
return this.#sequence.selectMany(selector);
}
where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
where<TFiltered extends TElement>(predicate: TypePredicate<TElement, TFiltered>): Sequence<TFiltered>;
where(predicate: AnyPredicate<TElement>): Sequence<TElement>;
where(predicate: any): Sequence<any> {
return this.#sequence.where(predicate);
}
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<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<GroupedSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<GroupedSequence<TKey, TResult>>;
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
return this.#sequence.groupBy(keySelector, elementSelector, 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<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparison<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>(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<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<GroupedSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparison<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>) {
contains(obj: TElement, equater?: EqualityComparison<TElement>) {
return this.#sequence.contains(obj, equater);
}
sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
return this.#sequence.sequenceEquals(sequence, equater);
}
@@ -858,11 +864,11 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.prepend(obj);
}
remove(obj: TElement, all?: boolean, equater?: Equater<TElement>) {
remove(obj: TElement, all?: boolean, equater?: EqualityComparison<TElement>) {
return this.#sequence.remove(obj, all, equater);
}
concat(...sequences: Sequence<TElement>[]) {
concat(...sequences: Iterable<TElement>[]) {
return this.#sequence.concat(...sequences);
}
@@ -902,83 +908,83 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.aggregate(accumulator, seed, resultSelector);
}
min(comparer?: Comparer<TElement>) {
min(comparer?: ComparisonOrComparer<TElement>) {
return this.#sequence.min(comparer);
}
minBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
minBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>) {
return this.#sequence.minBy(selector, comparer);
}
max(comparer?: Comparer<TElement>) {
max(comparer?: ComparisonOrComparer<TElement>) {
return this.#sequence.max(comparer);
}
maxBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
maxBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>) {
return this.#sequence.maxBy(selector, comparer);
}
bounds(comparer?: Comparer<TElement>) {
bounds(comparer?: ComparisonOrComparer<TElement>) {
return this.#sequence.bounds(comparer);
}
boundsBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
boundsBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>) {
return this.#sequence.boundsBy(selector, comparer);
}
order(comparer?: Comparer<TElement>) {
order(comparer?: ComparisonOrComparer<TElement>) {
return this.#sequence.order(comparer);
}
orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>) {
return this.#sequence.orderBy(selector, comparer);
}
orderDescending(comparer?: Comparer<TElement>) {
orderDescending(comparer?: ComparisonOrComparer<TElement>) {
return this.#sequence.orderDescending(comparer);
}
orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>) {
return this.#sequence.orderByDescending(selector, comparer);
}
partition(equater?: Equater<TElement> | undefined): Sequence<Sequence<TElement>> {
partition(equater?: EqualityComparison<TElement> | undefined): Sequence<Sequence<TElement>> {
return this.#sequence.partition(equater);
}
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy> | undefined): Sequence<Sequence<TElement>> {
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy> | undefined): Sequence<Sequence<TElement>> {
return this.#sequence.partitionBy(selector, equater);
}
distinct(equater?: Equater<TElement>) {
distinct(equater?: EqualityComparison<TElement>) {
return this.#sequence.distinct(equater);
}
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) {
return this.#sequence.distinctBy(selector, equater);
}
union(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
union(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
return this.#sequence.union(sequence, equater);
}
unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) {
return this.#sequence.unionBy(sequence, selector, equater);
}
except(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
except(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
return this.#sequence.except(sequence, equater);
}
exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) {
return this.#sequence.exceptBy(sequence, selector, equater);
}
intersect(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
intersect(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
return this.#sequence.intersect(sequence, equater);
}
intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) {
return this.#sequence.intersectBy(sequence, selector, equater);
}
@@ -1030,7 +1036,7 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
this.#sequence.forEach(action);
}
zip<TOther>(sequence: Sequence<TOther>) {
zip<TOther>(sequence: Iterable<TOther>) {
return this.#sequence.zip(sequence);
}
@@ -1043,9 +1049,10 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
}
chunked(size: number): Sequence<Sequence<TElement>>;
chunked(size: number, asArray: true): Sequence<TElement[]>;
chunked<TResult>(size: number, transformer: SequencePipeline<TElement, TResult>): Sequence<TResult>;
chunked(size: number, transformer?: any): any {
return this.#sequence.chunked(size, transformer);
chunked(size: number, transformerOrAsArray?: any): any {
return this.#sequence.chunked(size, transformerOrAsArray);
}
random(options?: RandomOptions<TElement>) {
@@ -1107,17 +1114,16 @@ export class GroupedSequenceImpl<TKey, TElement> extends DelegatedSequence<TElem
}
}
//# TODO
export abstract class BaseOrderedSequence<TElement> extends BaseSequence<TElement> implements OrderedSequence<TElement> {
readonly #sequence: Sequence<TElement>;
readonly #sorter: Comparer<TElement> | undefined;
readonly #sorter: Comparer<TElement>;
readonly #descending: boolean;
constructor(sequence: Sequence<TElement>, sorter: Comparer<TElement> | undefined, descending: boolean) {
constructor(sequence: Sequence<TElement>, sorter: ComparisonOrComparer<TElement> | undefined, descending: boolean) {
super();
this.#sequence = sequence;
this.#sorter = sorter;
this.#sorter = sorter ? asComparer(sorter) : defaultComparer;
this.#descending = descending;
}
@@ -1141,19 +1147,19 @@ export abstract class BaseOrderedSequence<TElement> extends BaseSequence<TElemen
return this.#descending;
}
thenSelf(comparer?: Comparer<TElement>): OrderedSequence<TElement> {
thenSelf(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement> {
return new ThenOrderSequence(this, false, comparer);
}
thenBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement> {
thenBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement> {
return new ThenOrderBySequence<TElement, TBy>(this, false, selector, comparer);
}
thenSelfDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement> {
thenSelfDescending(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement> {
return new ThenOrderSequence(this, true, comparer);
}
thenByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement> {
thenByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement> {
return new ThenOrderBySequence<TElement, TBy>(this, true, selector, comparer);
}
@@ -1165,7 +1171,7 @@ export abstract class BaseOrderedSequence<TElement> extends BaseSequence<TElemen
}
if (this.#sorter) {
arr.sort(this.#descending ? reverseComparer(this.#sorter) : this.#sorter);
arr.sort((this.#descending ? this.#sorter.reverse() : this.#sorter).comparison());
} else {
arr.sort();
@@ -1361,7 +1367,11 @@ export class WrappedArray<T> extends BaseSequence<T> {
return this.#array.length;
}
override contains(obj: T, equater?: Equater<T>): boolean {
override _countWithoutPredicate() {
return this.#array.length;
}
override contains(obj: T, equater?: EqualityComparison<T>): boolean {
if (equater) {
return this.#array.some(x => equater(x, obj));
}
@@ -1457,7 +1467,7 @@ export class WrappedSet<T> extends BaseSequence<T> {
return this.#set.size;
}
override contains(obj: T, equater?: Equater<T>) {
override contains(obj: T, equater?: EqualityComparison<T>) {
if (equater) {
return super.contains(obj, equater);
}
@@ -1487,7 +1497,7 @@ export class WrappedMap<K, V> extends BaseSequence<[K, V]> {
return this.#map.size;
}
override contains(obj: [K, V], equater?: Equater<[K, V]>) {
override contains(obj: [K, V], equater?: EqualityComparison<[K, V]>) {
if (equater) {
return super.contains(obj, equater);
}
@@ -1596,9 +1606,9 @@ export class ConcatSequence<T> extends BaseSequence<T> {
class DistinctSequence<T> extends BaseSequence<T> {
readonly #sequence: Sequence<T>;
readonly #equater: Equater<T> | undefined;
readonly #equater: EqualityComparison<T> | undefined;
constructor(sequence: Sequence<T>, equater?: Equater<T>) {
constructor(sequence: Sequence<T>, equater?: EqualityComparison<T>) {
super();
this.#sequence = sequence;
@@ -1623,9 +1633,9 @@ class DistinctSequence<T> extends BaseSequence<T> {
class DistinctBySequence<T, U> extends BaseSequence<T> {
readonly #sequence: Sequence<T>;
readonly #converter: Converter<T, U>;
readonly #equater: Equater<U> | undefined;
readonly #equater: EqualityComparison<U> | undefined;
constructor(sequence: Sequence<T>, converter: Converter<T, U>, equater?: Equater<U>) {
constructor(sequence: Sequence<T>, converter: Converter<T, U>, equater?: EqualityComparison<U>) {
super();
this.#sequence = sequence;
@@ -1650,9 +1660,9 @@ class DistinctBySequence<T, U> extends BaseSequence<T> {
class WhereSequence<TElement, TFiltered extends TElement> extends BaseSequence<TFiltered> {
readonly #sequence: Sequence<TElement>;
readonly #predicate: FilterPredicate<TElement, TFiltered>;
readonly #predicate: TypePredicate<TElement, TFiltered>;
constructor(sequence: Sequence<TElement>, predicate: FilterPredicate<TElement, TFiltered>) {
constructor(sequence: Sequence<TElement>, predicate: TypePredicate<TElement, TFiltered>) {
super();
this.#sequence = sequence;
@@ -1674,9 +1684,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, Sequence<U>>;
readonly #converter: Converter<T, Iterable<U>>;
constructor(sequence: Sequence<T>, converter: Converter<T, Sequence<U>>) {
constructor(sequence: Sequence<T>, converter: Converter<T, Iterable<U>>) {
super();
this.#sequence = sequence;
@@ -1758,7 +1768,7 @@ class SkipWhileSequence<T> extends BaseSequence<T> {
}
override *iterator() {
const e = asIterable(this.#sequence.iterator());
const e = Iterator.from(this.#sequence);
for (const obj of e) {
if (!this.#predicate(obj)) {
@@ -1792,7 +1802,7 @@ class SkipLastSequence<T> extends BaseSequence<T> {
}
override *iterator() {
const iterator = this.#sequence.iterator();
const iterator = Iterator.from(this.#sequence);
const buffer = new Array<T>(this.#n); // n > 0
let i = 0;
@@ -1808,7 +1818,7 @@ class SkipLastSequence<T> extends BaseSequence<T> {
i = 0;
for (const obj of asIterable(iterator)) {
for (const obj of iterator) {
yield buffer[i];
buffer[i] = obj;
i = (i + 1) % this.#n;
@@ -1837,7 +1847,7 @@ class SkipSequence<T> extends BaseSequence<T> {
}
override *iterator() {
const iterator = this.#sequence.iterator();
const iterator = Iterator.from(this.#sequence);
let i = 0;
do {
@@ -1848,7 +1858,7 @@ class SkipSequence<T> extends BaseSequence<T> {
i++;
} while (i < this.#n);
yield* asIterable(iterator);
yield* iterator;
}
}
@@ -1947,45 +1957,26 @@ class TakeSequence<T> extends BaseSequence<T> {
}
class OrderSequence<T> extends BaseOrderedSequence<T> {
constructor(sequence: Sequence<T>, descending: boolean, sorter?: Comparer<T>) {
constructor(sequence: Sequence<T>, descending: boolean, sorter?: ComparisonOrComparer<T>) {
super(sequence, sorter, descending);
}
}
class OrderBySequence<T, U> extends BaseOrderedSequence<T> {
readonly #selector: Converter<T, U>;
constructor(sequence: Sequence<T>, descending: boolean, selector: Converter<T, U>, sorter?: Comparer<U>) {
super(sequence, OrderBySequence.#createSorter(selector, sorter), descending);
this.#selector = selector;
}
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));
constructor(sequence: Sequence<T>, descending: boolean, selector: Converter<T, U>, sorter?: ComparisonOrComparer<U>) {
super(sequence, createComparerUsing(selector, sorter), descending);
}
}
class ThenOrderSequence<T> extends BaseOrderedSequence<T> {
constructor(sequence: OrderedSequence<T>, descending: boolean, sorter?: Comparer<T>) {
super(sequence, combineComparers(sequence.comparer ?? defaultArrayComparer, sorter ?? defaultArrayComparer), descending);
constructor(sequence: OrderedSequence<T>, descending: boolean, sorter?: ComparisonOrComparer<T>) {
super(sequence, combineNullableComparers([sequence.comparer, sorter]), descending);
}
}
class ThenOrderBySequence<T, U> extends BaseOrderedSequence<T> {
readonly #selector: Converter<T, U>;
constructor(sequence: OrderedSequence<T>, descending: boolean, selector: Converter<T, U>, sorter?: Comparer<U>) {
super(sequence, ThenOrderBySequence.#createCombinedSorter(sequence.comparer, selector, sorter), descending);
this.#selector = selector;
}
static #createCombinedSorter<T, U>(baseSorter: Comparer<T> | undefined, selector: Converter<T, U>, sorter?: Comparer<U>) {
const _baseSorter = baseSorter ?? defaultArrayComparer;
const _sorter = sorter ?? defaultArrayComparer;
return combineComparers(_baseSorter, (a: T, b: T) => _sorter(selector(a), selector(b)));
constructor(sequence: OrderedSequence<T>, descending: boolean, selector: Converter<T, U>, sorter?: ComparisonOrComparer<U>) {
super(sequence, combineNullableComparers([sequence.comparer, createComparerUsing(selector, sorter)]), descending);
}
}
@@ -2110,9 +2101,9 @@ export class ZippedSequence<T, U> extends BaseSequence<[T, U]> {
class UnionSequence<T> extends BaseSequence<T> {
readonly #first: Sequence<T>;
readonly #second: Sequence<T>;
readonly #equater: Equater<T> | undefined;
readonly #equater: EqualityComparison<T> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, equater?: Equater<T>) {
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparison<T>) {
super();
this.#first = first;
@@ -2144,9 +2135,9 @@ class UnionBySequence<T, U> extends BaseSequence<T> {
readonly #first: Sequence<T>;
readonly #second: Sequence<T>;
readonly #selector: Converter<T, U>;
readonly #equater: Equater<U> | undefined;
readonly #equater: EqualityComparison<U> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: Equater<U>) {
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparison<U>) {
super();
this.#first = first;
@@ -2178,9 +2169,9 @@ class UnionBySequence<T, U> extends BaseSequence<T> {
class ExceptSequence<T> extends BaseSequence<T> {
readonly #first: Sequence<T>;
readonly #second: Sequence<T>;
readonly #equater: Equater<T> | undefined;
readonly #equater: EqualityComparison<T> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, equater?: Equater<T>) {
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparison<T>) {
super();
this.#first = first;
@@ -2211,9 +2202,9 @@ class ExceptBySequence<T, U> extends BaseSequence<T> {
readonly #first: Sequence<T>;
readonly #second: Sequence<T>;
readonly #selector: Converter<T, U>;
readonly #equater: Equater<U> | undefined;
readonly #equater: EqualityComparison<U> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: Equater<U>) {
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparison<U>) {
super();
this.#first = first;
@@ -2244,9 +2235,9 @@ class ExceptBySequence<T, U> extends BaseSequence<T> {
class IntersectSequence<T> extends BaseSequence<T> {
readonly #first: Sequence<T>;
readonly #second: Sequence<T>;
readonly #equater: Equater<T> | undefined;
readonly #equater: EqualityComparison<T> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, equater?: Equater<T>) {
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparison<T>) {
super();
this.#first = first;
@@ -2261,9 +2252,7 @@ class IntersectSequence<T> extends BaseSequence<T> {
override *iterator() {
const set = createEqualitySet(this.#equater);
for (const obj of this.#second) {
set.add(obj);
}
set.addAll(this.#second);
for (const obj of this.#first) {
if (set.remove(obj)) {
@@ -2277,9 +2266,9 @@ class IntersectBySequence<T, U> extends BaseSequence<T> {
readonly #first: Sequence<T>;
readonly #second: Sequence<T>;
readonly #selector: Converter<T, U>;
readonly #equater: Equater<U> | undefined;
readonly #equater: EqualityComparison<U> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: Equater<U>) {
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparison<U>) {
super();
this.#first = first;
@@ -2341,9 +2330,9 @@ class GroupBySequence<TElement, TKey, TResult> extends BaseSequence<GroupedSeque
readonly #sequence: Sequence<TElement>;
readonly #keySelector: Converter<TElement, TKey>;
readonly #elementSelector: Converter<TElement, TResult>;
readonly #keyEquater: Equater<TKey> | undefined;
readonly #keyEquater: EqualityComparison<TKey> | undefined;
constructor(sequence: Sequence<TElement>, keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyEquater?: Equater<TKey>) {
constructor(sequence: Sequence<TElement>, keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyEquater?: EqualityComparison<TKey>) {
super();
this.#sequence = sequence;
@@ -2404,7 +2393,7 @@ class ChunkedSequence<T> extends BaseSequence<Sequence<T>> {
for (const obj of this.#sequence) {
chunk.push(obj);
if (chunk.length === this.#size) {
if (chunk.length >= this.#size) {
yield array(chunk);
chunk = [];
}
@@ -2416,15 +2405,53 @@ class ChunkedSequence<T> extends BaseSequence<Sequence<T>> {
}
}
class ChunkedArraySequence<T> extends BaseSequence<T[]> {
readonly #sequence: Sequence<T>;
readonly #size: number;
constructor(sequence: Sequence<T>, size: number) {
super();
this.#sequence = sequence;
this.#size = size;
}
override nonEnumeratedCount() {
const n = this.#sequence.nonEnumeratedCount();
return n < 0 ? super.nonEnumeratedCount() : Math.ceil(n / this.#size);
}
override maxCount() {
return Math.ceil(this.#sequence.maxCount() / this.#size);
}
override *iterator() {
let chunk: T[] = [];
for (const obj of this.#sequence) {
chunk.push(obj);
if (chunk.length >= this.#size) {
yield chunk;
chunk = [];
}
}
if (chunk.length > 0) {
yield chunk;
}
}
}
class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult> {
readonly #first: Sequence<TOuter>;
readonly #second: Sequence<TInner>;
readonly #firstKeySelector: Converter<TOuter, TKey>;
readonly #secondKeySelector: Converter<TInner, TKey>;
readonly #resultSelector: BiConverter<TOuter, TInner, TResult>;
readonly #keyEquater: Equater<TKey>;
readonly #keyEquater: EqualityComparison<TKey>;
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, TInner, TResult>, keyEquater?: Equater<TKey>) {
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, TInner, TResult>, keyEquater?: EqualityComparison<TKey>) {
super();
this.#first = first;
@@ -2464,9 +2491,9 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
readonly #firstKeySelector: Converter<TOuter, TKey>;
readonly #secondKeySelector: Converter<TInner, TKey>;
readonly #resultSelector: BiConverter<TOuter, Sequence<TInner>, TResult>;
readonly #keyEquater: Equater<TKey>;
readonly #keyEquater: EqualityComparison<TKey>;
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, Sequence<TInner>, TResult>, keyEquater?: Equater<TKey>) {
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, Sequence<TInner>, TResult>, keyEquater?: EqualityComparison<TKey>) {
super();
this.#first = first;
@@ -2511,9 +2538,9 @@ class RemoveSequence<T> extends BaseSequence<T> {
readonly #sequence: Sequence<T>;
readonly #obj: T;
readonly #all: boolean;
readonly #equater: Equater<T>;
readonly #equater: EqualityComparison<T>;
constructor(sequence: Sequence<T>, obj: T, all?: boolean, equater?: Equater<T>) {
constructor(sequence: Sequence<T>, obj: T, all?: boolean, equater?: EqualityComparison<T>) {
super();
this.#sequence = sequence;
@@ -2574,9 +2601,9 @@ class CacheSequence<T> extends BaseSequence<T> {
class PartitionSequence<T> extends BaseSequence<Sequence<T>> {
readonly #sequence: Sequence<T>;
readonly #equater: Equater<T>;
readonly #equater: EqualityComparison<T>;
constructor(sequence: Sequence<T>, equater: Equater<T> | undefined) {
constructor(sequence: Sequence<T>, equater: EqualityComparison<T> | undefined) {
super();
this.#sequence = sequence;
@@ -2605,9 +2632,9 @@ class PartitionSequence<T> extends BaseSequence<Sequence<T>> {
class PartitionBySequence<TElement, TBy> extends BaseSequence<Sequence<TElement>> {
readonly #sequence: Sequence<TElement>;
readonly #selector: Converter<TElement, TBy>;
readonly #equater: Equater<TBy>;
readonly #equater: EqualityComparison<TBy>;
constructor(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater: Equater<TBy> | undefined) {
constructor(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater: EqualityComparison<TBy> | undefined) {
super();
this.#sequence = sequence;