hbecher/sequence-js
1
0
Fork 0
Code Activity

rename lib to sequence-js

Browse Source
This commit is contained in:
Hervé BECHER
2024-05-11 16:57:34 +02:00
parent 486abefba6
commit 05390027f8
9 changed files with 929 additions and 929 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
package-lock.json generated
View File

@@ -1,11 +1,11 @@
{ {
"name": "enumerable", "name": "sequence-js",
"version": "1.0.0", "version": "1.0.0",
"lockfileVersion": 3, "lockfileVersion": 3,
"requires": true, "requires": true,
"packages": { "packages": {
"": { "": {
"name": "enumerable", "name": "sequence-js",
"version": "1.0.0", "version": "1.0.0",
"license": "ISC", "license": "ISC",
"devDependencies": { "devDependencies": {
@@ -76,9 +76,9 @@
"dev": true "dev": true
}, },
"node_modules/@types/node": { "node_modules/@types/node": {
"version": "20.12.8", "version": "20.12.11",
"resolved": "https://registry.npmjs.org/@types/node/-/node-20.12.8.tgz", "resolved": "https://registry.npmjs.org/@types/node/-/node-20.12.11.tgz",
"integrity": "sha512-NU0rJLJnshZWdE/097cdCBbyW1h4hEg0xpovcoAQYHl8dnEyp/NAOiE45pvc+Bd1Dt+2r94v2eGFpQJ4R7g+2w==", "integrity": "sha512-vDg9PZ/zi+Nqp6boSOT7plNuthRugEKixDv5sFTIpkE89MmNtEArAShI4mxuX2+UrLEe9pxC1vm2cjm9YlWbJw==",
"dev": true, "dev": true,
"dependencies": { "dependencies": {
"undici-types": "~5.26.4" "undici-types": "~5.26.4"

4
package.json
View File

@@ -1,7 +1,7 @@
{ {
"name": "enumerable", "name": "sequence-js",
"version": "1.0.0", "version": "1.0.0",
"description": "Implementation of Enumerable API from .NET", "description": "Synchronous and asynchronous sequence manipulation library inspired by .NET Enumerables and Java Streams",
"main": "src/index.ts", "main": "src/index.ts",
"type": "module", "type": "module",
"scripts": { "scripts": {

780
src/async/impl.ts
View File

File diff suppressed because it is too large Load Diff

56
src/async/index.ts
View File

@@ -1,16 +1,16 @@
import { wrap as wrapSync } from "../sync/index.js"; import { wrap as wrapSync } from "../sync/index.js";
import { Enumerable } from "../sync/types.js"; import { Sequence } from "../sync/types.js";
import { MaybeAsyncIterable } from "../types.js"; import { MaybeAsyncIterable } from "../types.js";
import { isAsyncIterable } from "../utils.js"; import { isAsyncIterable } from "../utils.js";
import { WrappedEnumerable, WrappedAsyncIterable, EmptyAsyncEnumerable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncEnumerable, GeneratorAsyncEnumerable, RangeAsyncEnumerable, RepeatForeverAsyncEnumerable, RepeatAsyncEnumerable, AsyncEnumerableMarker } from "./impl.js"; import { WrappedSequence, WrappedAsyncIterable, EmptyAsyncSequence, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker } from "./impl.js";
import { AsyncEnumerable } from "./types.js"; import { AsyncSequence } from "./types.js";
export function asAsync<T>(enumerable: Enumerable<T>): AsyncEnumerable<T> { export function asAsync<T>(sequence: Sequence<T>): AsyncSequence<T> {
return new WrappedEnumerable(enumerable); return new WrappedSequence(sequence);
} }
export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncEnumerable<T> { export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncSequence<T> {
if (isAsyncEnumerable<T>(iterable)) { if (isAsyncSequence<T>(iterable)) {
return iterable; return iterable;
} }
@@ -21,27 +21,27 @@ export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncEnumerable<T> {
return asAsync(wrapSync(iterable)); return asAsync(wrapSync(iterable));
} }
export function sequence<T>(iterable: AsyncIterable<T>): AsyncEnumerable<T> { export function sequence<T>(iterable: AsyncIterable<T>): AsyncSequence<T> {
return new WrappedAsyncIterable(iterable); return new WrappedAsyncIterable(iterable);
} }
export function empty<T>(): AsyncEnumerable<T> { export function empty<T>(): AsyncSequence<T> {
return EmptyAsyncEnumerable.INSTANCE; return EmptyAsyncSequence.INSTANCE;
} }
export function single<T>(obj: T | PromiseLike<T>): AsyncEnumerable<T> { export function single<T>(obj: T | PromiseLike<T>): AsyncSequence<T> {
return new WrappedObjectAsync(obj); return new WrappedObjectAsync(obj);
} }
export function array<T>(array: (T | PromiseLike<T>)[]): AsyncEnumerable<T> { export function array<T>(array: (T | PromiseLike<T>)[]): AsyncSequence<T> {
return new WrappedArrayAsync(array); return new WrappedArrayAsync(array);
} }
export function arrayLike<T>(arrayLike: ArrayLike<(T | PromiseLike<T>)>): AsyncEnumerable<T> { export function arrayLike<T>(arrayLike: ArrayLike<(T | PromiseLike<T>)>): AsyncSequence<T> {
return new WrappedArrayLikeAsync(arrayLike); return new WrappedArrayLikeAsync(arrayLike);
} }
export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncEnumerable<T> { export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncSequence<T> {
switch (elements.length) { switch (elements.length) {
case 0: case 0:
return empty(); return empty();
@@ -52,18 +52,18 @@ export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncEnumerable<T> {
} }
} }
export function func<T>(f: () => Promise<T>): AsyncEnumerable<T> { export function func<T>(f: () => Promise<T>): AsyncSequence<T> {
return new FunctionAsyncEnumerable(f); return new FunctionAsyncSequence(f);
} }
export function generator<T>(generator: () => AsyncGenerator<T>): AsyncEnumerable<T> { export function generator<T>(generator: () => AsyncGenerator<T>): AsyncSequence<T> {
return new GeneratorAsyncEnumerable(generator); return new GeneratorAsyncSequence(generator);
} }
export function range(max: number): AsyncEnumerable<number> export function range(max: number): AsyncSequence<number>
export function range(min: number, max: number): AsyncEnumerable<number> export function range(min: number, max: number): AsyncSequence<number>
export function range(min: number, max: number, step: number): AsyncEnumerable<number> export function range(min: number, max: number, step: number): AsyncSequence<number>
export function range(a: number, b?: number, c?: number): AsyncEnumerable<number> { export function range(a: number, b?: number, c?: number): AsyncSequence<number> {
if (b === undefined) { if (b === undefined) {
b = a; b = a;
a = 0; a = 0;
@@ -73,12 +73,12 @@ export function range(a: number, b?: number, c?: number): AsyncEnumerable<number
c = 1; c = 1;
} }
return new RangeAsyncEnumerable(a, b, c); return new RangeAsyncSequence(a, b, c);
} }
export function repeat<T>(value: T, count?: number): AsyncEnumerable<T> { export function repeat<T>(value: T, count?: number): AsyncSequence<T> {
if (count == undefined) { if (count == undefined) {
return new RepeatForeverAsyncEnumerable(value); return new RepeatForeverAsyncSequence(value);
} }
if (count < 0) { if (count < 0) {
@@ -93,9 +93,9 @@ export function repeat<T>(value: T, count?: number): AsyncEnumerable<T> {
return new WrappedObjectAsync(value); return new WrappedObjectAsync(value);
} }
return new RepeatAsyncEnumerable(value, count); return new RepeatAsyncSequence(value, count);
} }
export function isAsyncEnumerable<T = any>(obj: any): obj is AsyncEnumerable<T> { export function isAsyncSequence<T = any>(obj: any): obj is AsyncSequence<T> {
return obj instanceof AsyncEnumerableMarker; return obj instanceof AsyncSequenceMarker;
} }

90
src/async/types.ts
View File

@@ -2,41 +2,41 @@ import { Collector } from "../collector/types.js";
import { AsyncRandomOptions } from "../random/types.js"; import { AsyncRandomOptions } from "../random/types.js";
import { MaybeAsyncPredicate, MaybeAsyncConverter, MaybeAsyncIterable, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, Predicate, MaybeAsyncAction } from "../types.js"; import { MaybeAsyncPredicate, MaybeAsyncConverter, MaybeAsyncIterable, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, Predicate, MaybeAsyncAction } from "../types.js";
export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElement>> { export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>> {
iterator(): AsyncIterator<Awaited<TElement>>; iterator(): AsyncIterator<Awaited<TElement>>;
apply<TResult>(pipeline: (enumerable: AsyncEnumerable<TElement>) => TResult): TResult; apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult;
count(predicate?: MaybeAsyncPredicate<TElement>): Promise<number>; count(predicate?: MaybeAsyncPredicate<TElement>): Promise<number>;
nonEnumeratedCount(): Promise<number>; nonEnumeratedCount(): Promise<number>;
fastCount(): Promise<number>; fastCount(): Promise<number>;
maxCount(): Promise<number>; maxCount(): Promise<number>;
select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncEnumerable<TResult>; select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult>;
selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncEnumerable<TResult>; selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult>;
where(predicate: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement>; where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TKey, TElement>>; groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TKey, TResult>>; groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
join<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<[Awaited<TElement>, Awaited<TOther>]>; join<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]>;
join<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<TResult>; join<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<TResult>;
groupJoin<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TElement, TOther>>; groupJoin<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncEnumerable<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<TResult>; groupJoin<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<TResult>;
contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>; contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>; sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
append(obj: TElement): AsyncEnumerable<TElement>; append(obj: TElement): AsyncSequence<TElement>;
prepend(obj: TElement): AsyncEnumerable<TElement>; prepend(obj: TElement): AsyncSequence<TElement>;
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>; remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncEnumerable<TElement>; concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>;
first(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>; first(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>; firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
@@ -60,23 +60,23 @@ export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElemen
max(): Promise<TElement>; max(): Promise<TElement>;
maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement>; maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement>;
order(comparer?: MaybeAsyncComparer<TElement>): AsyncEnumerable<TElement>; order(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncEnumerable<TElement>; orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncEnumerable<TElement>; orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncEnumerable<TElement>; orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
distinct(equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>; distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>; distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>; union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>; unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
except(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>; except(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>; exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
intersect(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>; intersect(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>; intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>; all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>; any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
@@ -84,29 +84,29 @@ export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElemen
none(predicate: Predicate<TElement>): Promise<boolean>; none(predicate: Predicate<TElement>): Promise<boolean>;
none(): Promise<boolean>; none(): Promise<boolean>;
skip(n: number): AsyncEnumerable<TElement>; skip(n: number): AsyncSequence<TElement>;
skipLast(n: number): AsyncEnumerable<TElement>; skipLast(n: number): AsyncSequence<TElement>;
skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement>; skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
take(n: number): AsyncEnumerable<TElement>; take(n: number): AsyncSequence<TElement>;
takeLast(n: number): AsyncEnumerable<TElement>; takeLast(n: number): AsyncSequence<TElement>;
takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement>; takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
peek(action: MaybeAsyncAction<TElement>): AsyncEnumerable<TElement>; peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement>;
forEach(action: MaybeAsyncAction<TElement>): Promise<void>; forEach(action: MaybeAsyncAction<TElement>): Promise<void>;
zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncEnumerable<[Awaited<TElement>, Awaited<TOther>]>; zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]>;
indexex(): AsyncEnumerable<[number, Awaited<TElement>]>; indexex(): AsyncSequence<[number, Awaited<TElement>]>;
reversed(): AsyncEnumerable<TElement>; reversed(): AsyncSequence<TElement>;
chunked(size: number): AsyncEnumerable<TElement[]>; chunked(size: number): AsyncSequence<TElement[]>;
random(options?: AsyncRandomOptions<TElement>): Promise<TElement | undefined>; random(options?: AsyncRandomOptions<TElement>): Promise<TElement | undefined>;
cached(): AsyncEnumerable<TElement>; cached(): AsyncSequence<TElement>;
toArray(): Promise<TElement[]>; toArray(): Promise<TElement[]>;
toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>; toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
@@ -116,18 +116,18 @@ export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElemen
collect<TResult>(collector: Collector<TElement, any, TResult>): Promise<TResult>; collect<TResult>(collector: Collector<TElement, any, TResult>): Promise<TResult>;
} }
export interface GroupedAsyncEnumerable<TKey, TElement> extends AsyncEnumerable<TElement> { export interface GroupedAsyncSequence<TKey, TElement> extends AsyncSequence<TElement> {
get key(): TKey; get key(): TKey;
} }
export interface OrderedAsyncEnumerable<TElement> extends AsyncEnumerable<TElement> { export interface OrderedAsyncSequence<TElement> extends AsyncSequence<TElement> {
get comparer(): MaybeAsyncComparer<TElement>; get comparer(): MaybeAsyncComparer<TElement>;
thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncEnumerable<TElement>; thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement>;
thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncEnumerable<TElement>; thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement>;
thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncEnumerable<TElement>; thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement>;
thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncEnumerable<TElement>; thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement>;
} }

8
src/index.ts
View File

@@ -1,8 +1,8 @@
export { BaseEnumerable, DelegatedEnumerable } from "./sync/impl.js"; export { BaseSequence, DelegatedSequence } from "./sync/impl.js";
export * as Enumerables from "./sync/index.js"; export * as Sequences from "./sync/index.js";
export * from "./sync/types.js"; export * from "./sync/types.js";
export { BaseAsyncEnumerable, DelegatedAsyncEnumerable } from "./async/impl.js"; export { BaseAsyncSequence, DelegatedAsyncSequence } from "./async/impl.js";
export * as AsyncEnumerables from "./async/index.js"; export * as AsyncSequences from "./async/index.js";
export * from "./async/types.js"; export * from "./async/types.js";
export * as Collectors from "./collector/index.js"; export * as Collectors from "./collector/index.js";
export * from "./collector/types.js"; export * from "./collector/types.js";

738
src/sync/impl.ts
View File

File diff suppressed because it is too large Load Diff

80
src/sync/index.ts
View File

@@ -1,10 +1,10 @@
import { mathRandom } from "../random/index.js"; import { mathRandom } from "../random/index.js";
import { RandomGenerator } from "../random/types.js"; import { RandomGenerator } from "../random/types.js";
import { BigIntRangeEnumerable, ConcatEnumerable, EmptyEnumerable, EnumerableMarker, FunctionEnumerable, GeneratorEnumerable, RangeEnumerable, RepeatEnumerable, RepeatForeverEnumerable, WrappedArray, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet } from "./impl.js"; import { BigIntRangeSequence, ConcatSequence, EmptySequence, SequenceMarker, FunctionSequence, GeneratorSequence, RangeSequence, RepeatSequence, RepeatForeverSequence, WrappedArray, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet } from "./impl.js";
import { Enumerable } from "./types.js"; import { Sequence } from "./types.js";
export function wrap<T>(iterable: Iterable<T>): Enumerable<T> { export function wrap<T>(iterable: Iterable<T>): Sequence<T> {
if (isEnumerable<T>(iterable)) { if (isSequence<T>(iterable)) {
return iterable; return iterable;
} }
@@ -17,41 +17,41 @@ export function wrap<T>(iterable: Iterable<T>): Enumerable<T> {
} }
if (iterable instanceof Map) { if (iterable instanceof Map) {
return map(iterable) as unknown as Enumerable<T>; return map(iterable) as unknown as Sequence<T>;
} }
return sequence(iterable); return sequence(iterable);
} }
export function sequence<T>(iterable: Iterable<T>): Enumerable<T> { export function sequence<T>(iterable: Iterable<T>): Sequence<T> {
return new WrappedIterable(iterable); return new WrappedIterable(iterable);
} }
export function empty<T>(): Enumerable<T> { export function empty<T>(): Sequence<T> {
return EmptyEnumerable.INSTANCE; return EmptySequence.INSTANCE;
} }
export function single<T>(obj: T): Enumerable<T> { export function single<T>(obj: T): Sequence<T> {
return new WrappedObject(obj); return new WrappedObject(obj);
} }
export function array<T>(array: T[]): Enumerable<T> { export function array<T>(array: T[]): Sequence<T> {
return new WrappedArray(array); return new WrappedArray(array);
} }
export function arrayLike<T>(arrayLike: ArrayLike<T>): Enumerable<T> { export function arrayLike<T>(arrayLike: ArrayLike<T>): Sequence<T> {
return new WrappedArrayLike(arrayLike); return new WrappedArrayLike(arrayLike);
} }
export function set<T>(set: Set<T>): Enumerable<T> { export function set<T>(set: Set<T>): Sequence<T> {
return new WrappedSet(set); return new WrappedSet(set);
} }
export function map<K, V>(map: Map<K, V>): Enumerable<[K, V]> { export function map<K, V>(map: Map<K, V>): Sequence<[K, V]> {
return new WrappedMap(map); return new WrappedMap(map);
} }
export function of<T>(...elements: T[]): Enumerable<T> { export function of<T>(...elements: T[]): Sequence<T> {
switch (elements.length) { switch (elements.length) {
case 0: case 0:
return empty(); return empty();
@@ -62,30 +62,30 @@ export function of<T>(...elements: T[]): Enumerable<T> {
} }
} }
export function ofPropertyKeys<T extends PropertyKey>(...elements: T[]): Enumerable<T> { export function ofPropertyKeys<T extends PropertyKey>(...elements: T[]): Sequence<T> {
return of(...elements); return of(...elements);
} }
export function entries<T>(o: Record<string, T> | ArrayLike<T>): Enumerable<[string, T]> { export function entries<T>(o: Record<string, T> | ArrayLike<T>): Sequence<[string, T]> {
return array(Object.entries(o)); return array(Object.entries(o));
} }
export function keys(o: object): Enumerable<string> { export function keys(o: object): Sequence<string> {
return array(Object.keys(o)); return array(Object.keys(o));
} }
export function func<T>(f: () => T): Enumerable<T> { export function func<T>(f: () => T): Sequence<T> {
return new FunctionEnumerable(f); return new FunctionSequence(f);
} }
export function generator<T>(generator: () => Iterable<T>): Enumerable<T> { export function generator<T>(generator: () => Iterable<T>): Sequence<T> {
return new GeneratorEnumerable(generator); return new GeneratorSequence(generator);
} }
export function range(max: number): Enumerable<number> export function range(max: number): Sequence<number>
export function range(min: number, max: number): Enumerable<number> export function range(min: number, max: number): Sequence<number>
export function range(min: number, max: number, step: number): Enumerable<number> export function range(min: number, max: number, step: number): Sequence<number>
export function range(a: number, b?: number, c?: number): Enumerable<number> { export function range(a: number, b?: number, c?: number): Sequence<number> {
if (b === undefined) { if (b === undefined) {
b = a; b = a;
a = 0; a = 0;
@@ -95,13 +95,13 @@ export function range(a: number, b?: number, c?: number): Enumerable<number> {
c = 1; c = 1;
} }
return new RangeEnumerable(a, b, c); return new RangeSequence(a, b, c);
} }
export function bigintRange(max: bigint): Enumerable<bigint> export function bigintRange(max: bigint): Sequence<bigint>
export function bigintRange(min: bigint, max: bigint): Enumerable<bigint> export function bigintRange(min: bigint, max: bigint): Sequence<bigint>
export function bigintRange(min: bigint, max: bigint, step: bigint): Enumerable<bigint> export function bigintRange(min: bigint, max: bigint, step: bigint): Sequence<bigint>
export function bigintRange(a: bigint, b?: bigint, c?: bigint): Enumerable<bigint> { export function bigintRange(a: bigint, b?: bigint, c?: bigint): Sequence<bigint> {
if (b === undefined) { if (b === undefined) {
b = a; b = a;
a = 0n; a = 0n;
@@ -111,12 +111,12 @@ export function bigintRange(a: bigint, b?: bigint, c?: bigint): Enumerable<bigin
c = 1n; c = 1n;
} }
return new BigIntRangeEnumerable(a, b, c); return new BigIntRangeSequence(a, b, c);
} }
export function repeat<T>(value: T, count?: number): Enumerable<T> { export function repeat<T>(value: T, count?: number): Sequence<T> {
if (count == undefined) { if (count == undefined) {
return new RepeatForeverEnumerable(value); return new RepeatForeverSequence(value);
} }
if (count < 0) { if (count < 0) {
@@ -131,17 +131,17 @@ export function repeat<T>(value: T, count?: number): Enumerable<T> {
return new WrappedObject(value); return new WrappedObject(value);
} }
return new RepeatEnumerable(value, count); return new RepeatSequence(value, count);
} }
export function randomSequence(random?: RandomGenerator): Enumerable<number> { export function randomSequence(random?: RandomGenerator): Sequence<number> {
return new FunctionEnumerable(random ?? mathRandom); return new FunctionSequence(random ?? mathRandom);
} }
export function concat<T>(...enumerables: Enumerable<T>[]): Enumerable<T> { export function concat<T>(...sequences: Sequence<T>[]): Sequence<T> {
return new ConcatEnumerable(enumerables); return new ConcatSequence(sequences);
} }
export function isEnumerable<T = any>(obj: any): obj is Enumerable<T> { export function isSequence<T = any>(obj: any): obj is Sequence<T> {
return obj instanceof EnumerableMarker; return obj instanceof SequenceMarker;
} }

92
src/sync/types.ts
View File

@@ -2,42 +2,42 @@ import { Collector } from "../collector/types.js";
import { RandomOptions } from "../random/types.js"; import { RandomOptions } from "../random/types.js";
import { Predicate, Converter, FilterPredicate, Equater, BiConverter, Accumulator, Comparer, Action } from "../types.js"; import { Predicate, Converter, FilterPredicate, Equater, BiConverter, Accumulator, Comparer, Action } from "../types.js";
export interface Enumerable<TElement> extends Iterable<TElement> { export interface Sequence<TElement> extends Iterable<TElement> {
iterator(): Iterator<TElement>; iterator(): Iterator<TElement>;
apply<TResult>(pipeline: (enumerable: Enumerable<TElement>) => TResult): TResult; apply<TResult>(pipeline: (sequence: Sequence<TElement>) => TResult): TResult;
count(predicate?: Predicate<TElement>): number; count(predicate?: Predicate<TElement>): number;
nonEnumeratedCount(): number; nonEnumeratedCount(): number;
fastCount(): number; fastCount(): number;
maxCount(): number; maxCount(): number;
select<TResult>(selector: Converter<TElement, TResult>): Enumerable<TResult>; select<TResult>(selector: Converter<TElement, TResult>): Sequence<TResult>;
selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>): Enumerable<TResult>; selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>): Sequence<TResult>;
where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Enumerable<TFiltered>; where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
where(predicate: Predicate<TElement>): Enumerable<TElement>; where(predicate: Predicate<TElement>): Sequence<TElement>;
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: Equater<TKey>): Enumerable<GroupedEnumerable<TKey, TElement>>; groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: Equater<TKey>): Enumerable<GroupedEnumerable<TKey, TResult>>; groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TResult>>;
join<TOther, TKey>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Enumerable<[TElement, TOther]>; join<TOther, TKey>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Enumerable<TResult>; 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>;
groupJoin<TOther, TKey>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Enumerable<GroupedEnumerable<TElement, TOther>>; groupJoin<TOther, TKey>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Enumerable<TOther>, TResult>, keyComparer?: Equater<TKey>): Enumerable<TResult>; 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>;
contains(obj: TElement, equater?: Equater<TElement>): boolean; contains(obj: TElement, equater?: Equater<TElement>): boolean;
sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>): boolean; sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>): boolean;
append(obj: TElement): Enumerable<TElement>; append(obj: TElement): Sequence<TElement>;
prepend(obj: TElement): Enumerable<TElement>; prepend(obj: TElement): Sequence<TElement>;
remove(obj: TElement, all?: boolean, equater?: Equater<TElement>): Enumerable<TElement>; remove(obj: TElement, all?: boolean, equater?: Equater<TElement>): Sequence<TElement>;
concat(...iterables: Iterable<TElement>[]): Enumerable<TElement>; concat(...iterables: Iterable<TElement>[]): Sequence<TElement>;
first(predicate?: Predicate<TElement>): TElement; first(predicate?: Predicate<TElement>): TElement;
firstOrDefault(predicate?: Predicate<TElement>, def?: TElement): TElement | undefined; firstOrDefault(predicate?: Predicate<TElement>, def?: TElement): TElement | undefined;
@@ -61,23 +61,23 @@ export interface Enumerable<TElement> extends Iterable<TElement> {
max(comparer?: Comparer<TElement>): TElement; max(comparer?: Comparer<TElement>): TElement;
maxBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): TElement; maxBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): TElement;
order(comparer?: Comparer<TElement>): OrderedEnumerable<TElement>; order(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedEnumerable<TElement>; orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
orderDescending(comparer?: Comparer<TElement>): OrderedEnumerable<TElement>; orderDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedEnumerable<TElement>; orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
distinct(equater?: Equater<TElement>): Enumerable<TElement>; distinct(equater?: Equater<TElement>): Sequence<TElement>;
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Enumerable<TElement>; distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
union(iterable: Iterable<TElement>, equater?: Equater<TElement>): Enumerable<TElement>; union(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Enumerable<TElement>; unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
except(iterable: Iterable<TElement>, equater?: Equater<TElement>): Enumerable<TElement>; except(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Enumerable<TElement>; exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
intersect(iterable: Iterable<TElement>, equater?: Equater<TElement>): Enumerable<TElement>; intersect(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Enumerable<TElement>; intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
all(predicate: Predicate<TElement>): boolean; all(predicate: Predicate<TElement>): boolean;
any(predicate: Predicate<TElement>): boolean; any(predicate: Predicate<TElement>): boolean;
@@ -85,29 +85,29 @@ export interface Enumerable<TElement> extends Iterable<TElement> {
none(predicate: Predicate<TElement>): boolean; none(predicate: Predicate<TElement>): boolean;
none(): boolean; none(): boolean;
skip(n: number): Enumerable<TElement>; skip(n: number): Sequence<TElement>;
skipLast(n: number): Enumerable<TElement>; skipLast(n: number): Sequence<TElement>;
skipWhile(condition: Predicate<TElement>): Enumerable<TElement>; skipWhile(condition: Predicate<TElement>): Sequence<TElement>;
take(n: number): Enumerable<TElement>; take(n: number): Sequence<TElement>;
takeLast(n: number): Enumerable<TElement>; takeLast(n: number): Sequence<TElement>;
takeWhile(condition: Predicate<TElement>): Enumerable<TElement>; takeWhile(condition: Predicate<TElement>): Sequence<TElement>;
peek(action: Action<TElement>): Enumerable<TElement>; peek(action: Action<TElement>): Sequence<TElement>;
forEach(action: Action<TElement>): void; forEach(action: Action<TElement>): void;
zip<TOther>(iterable: Iterable<TOther>): Enumerable<[TElement, TOther]>; zip<TOther>(iterable: Iterable<TOther>): Sequence<[TElement, TOther]>;
indexed(): Enumerable<[number, TElement]>; indexed(): Sequence<[number, TElement]>;
reversed(): Enumerable<TElement>; reversed(): Sequence<TElement>;
chunked(size: number): Enumerable<TElement[]>; chunked(size: number): Sequence<TElement[]>;
random(options?: RandomOptions<TElement>): TElement | undefined; random(options?: RandomOptions<TElement>): TElement | undefined;
cached(): Enumerable<TElement>; cached(): Sequence<TElement>;
asArray(): TElement[]; asArray(): TElement[];
toArray(): TElement[]; toArray(): TElement[];
@@ -118,18 +118,18 @@ export interface Enumerable<TElement> extends Iterable<TElement> {
collect<TResult>(collector: Collector<TElement, any, TResult>): TResult; collect<TResult>(collector: Collector<TElement, any, TResult>): TResult;
} }
export interface GroupedEnumerable<TKey, TElement> extends Enumerable<TElement> { export interface GroupedSequence<TKey, TElement> extends Sequence<TElement> {
get key(): TKey; get key(): TKey;
} }
export interface OrderedEnumerable<TElement> extends Enumerable<TElement> { export interface OrderedSequence<TElement> extends Sequence<TElement> {
get comparer(): Comparer<TElement> | undefined; get comparer(): Comparer<TElement> | undefined;
thenSelf(comparer?: Comparer<TElement>): OrderedEnumerable<TElement>; thenSelf(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
thenBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedEnumerable<TElement>; thenBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
thenSelfDescending(comparer?: Comparer<TElement>): OrderedEnumerable<TElement>; thenSelfDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
thenByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedEnumerable<TElement>; thenByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
} }