sync local repositories

add booleanish predicates
enable custom inspection
default to sequence of any when sequence type is unknown

src/async/impl.ts

@@ -6,7 +6,7 @@ import { getRandomElementAsync } from "../random/index.js";
 import { AsyncRandomOptions } from "../random/types.js";
 import { selectionSorter } from "../sorting.js";
 import { Sequence } from "../sync/types.js";
-import { MaybeAsyncConverter, MaybeAsyncPredicate, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybeAsyncSequence } from "../types.js";
+import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybeAsyncSequence } from "../types.js";
 import { strictEquals, identity, operatorCompare, defaultArrayComparer, combineAsyncComparers, asAsyncIterable } from "../utils.js";
 import { array, empty, wrap } from "./index.js";
 import { AsyncSequence, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
@@ -25,15 +25,15 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
   }
 
   select<TResult>(converter: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult> {
-    return new MapperAsyncSequence<TElement, TResult>(this, converter);
+    return new SelectAsyncSequence<TElement, TResult>(this, converter);
   }
 
   selectMany<TResult>(converter: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult> {
-    return new FlatMapperAsyncSequence<TElement, TResult>(this, converter);
+    return new SelectManyAsyncSequence<TElement, TResult>(this, converter);
   }
 
-  where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
-    return new FilterAsyncSequence<TElement>(this, predicate);
+    return new WhereAsyncSequence<TElement>(this, predicate);
   }
 
   groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
@@ -133,7 +133,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new ConcatAsyncSequence(arr);
   }
 
-  async count(predicate?: MaybeAsyncPredicate<TElement>) {
+  async count(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     let count = 0;
 
     if (predicate) {
@@ -167,7 +167,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return n >= 0 ? n : Infinity;
   }
 
-  async #tryGetFirst(predicate?: MaybeAsyncPredicate<TElement>) {
+  async #tryGetFirst(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     if (predicate) {
       for await (const element of this) {
         if (await predicate(element)) {
@@ -193,7 +193,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     } as const;
   }
 
-  async first(predicate?: MaybeAsyncPredicate<TElement>) {
+  async first(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     const result = await this.#tryGetFirst(predicate);
 
     if (result.found) {
@@ -203,13 +203,13 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     throw new Error("No element was found.");
   }
 
-  async firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement) {
+  async firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement) {
     const result = await this.#tryGetFirst(predicate);
 
     return result.found ? result.element : def;
   }
 
-  async #tryGetLast(predicate?: MaybeAsyncPredicate<TElement>) {
+  async #tryGetLast(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     let found = false;
     let result: TElement | undefined = undefined;
 
@@ -233,7 +233,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     };
   }
 
-  async last(predicate?: MaybeAsyncPredicate<TElement>) {
+  async last(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     const result = await this.#tryGetLast(predicate);
 
     if (result.found) {
@@ -243,13 +243,13 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     throw new Error("No element was found.");
   }
 
-  async lastOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement) {
+  async lastOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement) {
     const result = await this.#tryGetLast(predicate);
 
     return result.found ? result.element : def;
   }
 
-  async #tryGetSingle(predicate?: MaybeAsyncPredicate<TElement>) {
+  async #tryGetSingle(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     if (predicate) {
       let result: { found: true; element: TElement; } | undefined = undefined;
 
@@ -297,7 +297,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     } as const;
   }
 
-  async single(predicate?: MaybeAsyncPredicate<TElement>) {
+  async single(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     const result = await this.#tryGetSingle(predicate);
 
     if (result.found == true) {
@@ -318,7 +318,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     throw new Error(reason);
   }
 
-  async singleOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement) {
+  async singleOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement) {
     const result = await this.#tryGetSingle(predicate);
 
     return result.found ? result.element : def;
@@ -391,7 +391,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return acc as unknown as TResult;
   }
 
-  async #find<TResult>(sorter: MaybeAsyncPredicate<number>, selector?: MaybeAsyncConverter<TElement, TResult>, comparer?: MaybeAsyncComparer<TResult>) {
+  async #find<TResult>(sorter: MaybeAsyncAnyPredicate<number>, selector?: MaybeAsyncConverter<TElement, TResult>, comparer?: MaybeAsyncComparer<TResult>) {
     const iterator = this.iterator();
 
     let next = await iterator.next();
@@ -462,11 +462,11 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new OrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
   }
 
-  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement[]> {
+  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<AsyncSequence<TElement>> {
     return new PartitionAsyncSequence<TElement>(this, equater);
   }
 
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement[]> {
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<AsyncSequence<TElement>> {
     return new PartitionByAsyncSequence<TElement, TBy>(this, selector, equater);
   }
 
@@ -502,7 +502,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new IntersectByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector);
   }
 
-  async all(predicate: MaybeAsyncPredicate<TElement>) {
+  async all(predicate: MaybeAsyncAnyPredicate<TElement>) {
     const n = await this.nonEnumeratedCount();
 
     if (n === 0) {
@@ -518,7 +518,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return true;
   }
 
-  async any(predicate?: MaybeAsyncPredicate<TElement>) {
+  async any(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     const n = await this.nonEnumeratedCount();
 
     if (n === 0) {
@@ -538,7 +538,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return n < 0 ? !(await this.iterator().next()).done : n > 0;
   }
 
-  async none(predicate?: MaybeAsyncPredicate<TElement>) {
+  async none(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     const n = await this.nonEnumeratedCount();
 
     if (n === 0) {
@@ -574,7 +574,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return n === 0 ? this : new SkipLastAsyncSequence<TElement>(this, n);
   }
 
-  skipWhile(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+  skipWhile(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
     return new SkipWhileAsyncSequence<TElement>(this, predicate);
   }
 
@@ -594,7 +594,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return n === 0 ? empty<TElement>() : new TakeLastAsyncSequence<TElement>(this, n);
   }
 
-  takeWhile(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+  takeWhile(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
     return new TakeWhileAsyncSequence<TElement>(this, predicate);
   }
 
@@ -612,7 +612,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new ZippedAsyncSequence<TElement, TOther>(this, wrap(sequence));
   }
 
-  indexex(): AsyncSequence<[number, TElement]> {
+  indexed(): AsyncSequence<[number, TElement]> {
     return new IndexedAsyncSequence<TElement>(this);
   }
 
@@ -620,12 +620,15 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new ReversedAsyncSequence<TElement>(this);
   }
 
-  chunked(size: number): AsyncSequence<AsyncSequence<TElement>> {
+  chunked(size: number, asArray?: false): AsyncSequence<AsyncSequence<TElement>>;
+  chunked(size: number, asArray: true): AsyncSequence<TElement[]>;
+  chunked(size: number, asArray?: boolean): AsyncSequence<AsyncSequence<TElement>> | AsyncSequence<TElement[]> {
     if (size <= 0) {
       throw new Error("Chunk size must be positive.");
     }
 
-    return new ChunkedAsyncSequence<TElement>(this, size);
+    const sequence = new ChunkedAsyncSequence<TElement>(this, size);
+    return asArray ? sequence : sequence.select(array);
   }
 
   async random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
@@ -636,6 +639,10 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new CacheAsyncSequence<TElement>(this);
   }
 
+  async asArray(): Promise<TElement[]> {
+    return await this.toArray();
+  }
+
   async toArray() {
     const array: TElement[] = [];
 
@@ -646,8 +653,12 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return array;
   }
 
-  async toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>) {
+  toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Map<TKey, TElement>>;
-    const map = new Map<TKey, TValue>();
+  toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
+  async toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector?: MaybeAsyncConverter<TElement, any>): Promise<Map<TKey, any>> {
+    valueSelector ??= identity;
+
+    const map = new Map<TKey, any>();
 
     for await (const element of this) {
       const key = await keySelector(element);
@@ -669,8 +680,12 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return set;
   }
 
-  async toObject<TValue>(keySelector: MaybeAsyncConverter<TElement, PropertyKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>) {
+  toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Record<TKey, TElement>>;
-    const obj: Record<PropertyKey, TValue> = {};
+  toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;
+  async toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector?: MaybeAsyncConverter<TElement, any>): Promise<Record<TKey, any>> {
+    valueSelector ??= identity;
+
+    const obj: Record<PropertyKey, any> = {};
 
     for await (const element of this) {
       const key = await keySelector(element);
@@ -722,7 +737,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.apply(pipeline);
   }
 
-  count(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<number> {
+  count(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<number> {
     return this.#sequence.count(predicate);
   }
 
@@ -746,7 +761,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.selectMany(selector);
   }
 
-  where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
     return this.#sequence.where(predicate);
   }
 
@@ -792,27 +807,27 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.concat(...sequences);
   }
 
-  first(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<TElement> {
+  first(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<TElement> {
     return this.#sequence.first(predicate);
   }
 
-  firstOrDefault(predicate?: MaybeAsyncPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
+  firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
     return this.#sequence.firstOrDefault(predicate, def);
   }
 
-  last(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<TElement> {
+  last(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<TElement> {
     return this.#sequence.last(predicate);
   }
 
-  lastOrDefault(predicate?: MaybeAsyncPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
+  lastOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
     return this.#sequence.lastOrDefault(predicate, def);
   }
 
-  single(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<TElement> {
+  single(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<TElement> {
     return this.#sequence.single(predicate);
   }
 
-  singleOrDefault(predicate?: MaybeAsyncPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
+  singleOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
     return this.#sequence.singleOrDefault(predicate, def);
   }
 
@@ -863,11 +878,11 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.orderByDescending(selector, comparer);
   }
 
-  partition(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement[]> {
+  partition(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<AsyncSequence<TElement>> {
     return this.#sequence.partition(equater);
   }
 
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement[]> {
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<AsyncSequence<TElement>> {
     return this.#sequence.partitionBy(selector, equater);
   }
 
@@ -903,17 +918,17 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.intersectBy(wrap(sequence), selector, equater);
   }
 
-  all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean> {
+  all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean> {
     return this.#sequence.all(predicate);
   }
 
-  any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
+  any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
   any(): Promise<boolean>;
   any(predicate?: any) {
     return this.#sequence.any(predicate);
   }
 
-  none(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
+  none(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
   none(): Promise<boolean>;
   none(predicate?: any) {
     return this.#sequence.none(predicate);
@@ -927,7 +942,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.skipLast(n);
   }
 
-  skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+  skipWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
     return this.#sequence.skipWhile(condition);
   }
 
@@ -939,7 +954,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.takeLast(n);
   }
 
-  takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+  takeWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
     return this.#sequence.takeWhile(condition);
   }
 
@@ -955,16 +970,18 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.zip(wrap(sequence));
   }
 
-  indexex(): AsyncSequence<[number, TElement]> {
+  indexed(): AsyncSequence<[number, TElement]> {
-    return this.#sequence.indexex();
+    return this.#sequence.indexed();
   }
 
   reversed(): AsyncSequence<TElement> {
     return this.#sequence.reversed();
   }
 
-  chunked(size: number): AsyncSequence<AsyncSequence<TElement>> {
+  chunked(size: number, asArray?: false): AsyncSequence<AsyncSequence<TElement>>;
-    return this.#sequence.chunked(size);
+  chunked(size: number, asArray: true): AsyncSequence<TElement[]>;
+  chunked(size: number, asArray?: any): AsyncSequence<AsyncSequence<TElement>> | AsyncSequence<TElement[]> {
+    return this.#sequence.chunked(size, asArray);
   }
 
   random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
@@ -975,11 +992,17 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.cached();
   }
 
+  asArray(): Promise<TElement[]> {
+    return this.#sequence.asArray();
+  }
+
   toArray(): Promise<TElement[]> {
     return this.#sequence.toArray();
   }
 
-  toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>> {
+  toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Map<TKey, TElement>>;
+  toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
+  toMap(keySelector: any, valueSelector?: any) {
     return this.#sequence.toMap(keySelector, valueSelector);
   }
 
@@ -987,7 +1010,9 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.toSet();
   }
 
-  toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>> {
+  toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Record<TKey, TElement>>;
+  toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;
+  toObject(keySelector: any, valueSelector?: any) {
     return this.#sequence.toObject(keySelector, valueSelector);
   }
 
@@ -1352,11 +1377,11 @@ class DistinctByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
   }
 }
 
-class FilterAsyncSequence<T> extends BaseAsyncSequence<T> {
+class WhereAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #sequence: AsyncSequence<T>;
-  readonly #predicate: MaybeAsyncPredicate<T>;
+  readonly #predicate: MaybeAsyncAnyPredicate<T>;
 
-  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncPredicate<T>) {
+  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncAnyPredicate<T>) {
     super();
 
     this.#sequence = sequence;
@@ -1372,7 +1397,7 @@ class FilterAsyncSequence<T> extends BaseAsyncSequence<T> {
   }
 }
 
-class FlatMapperAsyncSequence<T, U> extends BaseAsyncSequence<U> {
+class SelectManyAsyncSequence<T, U> extends BaseAsyncSequence<U> {
   readonly #sequence: AsyncSequence<T>;
   readonly #converter: MaybeAsyncConverter<T, MaybeAsyncSequence<U>>;
 
@@ -1408,7 +1433,7 @@ class IndexedAsyncSequence<T> extends BaseAsyncSequence<[number, T]> {
   }
 }
 
-class MapperAsyncSequence<T, U> extends BaseAsyncSequence<U> {
+class SelectAsyncSequence<T, U> extends BaseAsyncSequence<U> {
   readonly #sequence: AsyncSequence<T>;
   readonly #converter: MaybeAsyncConverter<T, U>;
 
@@ -1432,9 +1457,9 @@ class MapperAsyncSequence<T, U> extends BaseAsyncSequence<U> {
 
 class SkipWhileAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #sequence: AsyncSequence<T>;
-  readonly #predicate: MaybeAsyncPredicate<T>;
+  readonly #predicate: MaybeAsyncAnyPredicate<T>;
 
-  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncPredicate<T>) {
+  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncAnyPredicate<T>) {
     super();
 
     this.#sequence = sequence;
@@ -1538,9 +1563,9 @@ class SkipAsyncSequence<T> extends BaseAsyncSequence<T> {
 
 class TakeWhileAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #sequence: AsyncSequence<T>;
-  readonly #predicate: MaybeAsyncPredicate<T>;
+  readonly #predicate: MaybeAsyncAnyPredicate<T>;
 
-  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncPredicate<T>) {
+  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncAnyPredicate<T>) {
     super();
 
     this.#sequence = sequence;
@@ -1998,7 +2023,7 @@ class GroupByAsyncSequence<TElement, TKey, TResult> extends BaseAsyncSequence<Gr
   }
 }
 
-class ChunkedAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
+class ChunkedAsyncSequence<T> extends BaseAsyncSequence<T[]> {
   readonly #sequence: AsyncSequence<T>;
   readonly #size: number;
 
@@ -2021,13 +2046,13 @@ class ChunkedAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
       chunk.push(obj);
 
       if (chunk.length === this.#size) {
-        yield array(chunk);
+        yield chunk;
         chunk = [];
       }
     }
 
     if (chunk.length > 0) {
-      yield array(chunk);
+      yield chunk;
     }
   }
 }
@@ -2158,7 +2183,7 @@ class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
   }
 }
 
-class PartitionAsyncSequence<T> extends BaseAsyncSequence<T[]> {
+class PartitionAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
   readonly #sequence: AsyncSequence<T>;
   readonly #equater: MaybeAsyncEquater<T>;
 
@@ -2182,11 +2207,13 @@ class PartitionAsyncSequence<T> extends BaseAsyncSequence<T[]> {
       }
     }
 
-    yield* partitions.values();
+    for (const partition of partitions.values()) {
+      yield array(partition);
+    }
   }
 }
 
-class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<TElement[]> {
+class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<AsyncSequence<TElement>> {
   readonly #sequence: AsyncSequence<TElement>;
   readonly #selector: MaybeAsyncConverter<TElement, TBy>;
   readonly #equater: MaybeAsyncEquater<TBy>;
@@ -2213,6 +2240,8 @@ class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<TElement
       }
     }
 
-    yield* partitions.values();
+    for (const partition of partitions.values()) {
+      yield array(partition);
+    }
   }
 }

src/async/index.ts

@@ -2,7 +2,7 @@ import { wrap as wrapSync } from "../sync/index.js";
 import { Sequence } from "../sync/types.js";
 import { MaybeAsyncGenerator, MaybeAsyncIterable, MaybePromiseLike } from "../types.js";
 import { isAsyncIterable } from "../utils.js";
-import { WrappedSequence, WrappedAsyncIterable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker, EMPTY } from "./impl.js";
+import { WrappedSequence, WrappedAsyncIterable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker, EMPTY, ConcatAsyncSequence } from "./impl.js";
 import { AsyncSequence } from "./types.js";
 
 export function asAsync<T>(sequence: Sequence<MaybePromiseLike<T>>): AsyncSequence<T> {
@@ -52,6 +52,10 @@ export function of<T>(...elements: MaybePromiseLike<T>[]): AsyncSequence<T> {
   }
 }
 
+export function concat<T>(...sequences: AsyncSequence<T>[]): AsyncSequence<T> {
+  return new ConcatAsyncSequence<T>(sequences);
+}
+
 export function func<T>(f: () => MaybePromiseLike<T>): AsyncSequence<T> {
   return new FunctionAsyncSequence(f);
 }

src/async/types.ts

@@ -1,13 +1,13 @@
 import { Collector } from "../collector/types.js";
 import { AsyncRandomOptions } from "../random/types.js";
-import { MaybeAsyncPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybeAsyncSequence } from "../types.js";
+import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybeAsyncSequence } from "../types.js";
 
 export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
   iterator(): AsyncIterator<TElement>;
 
   apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult;
 
-  count(predicate?: MaybeAsyncPredicate<TElement>): Promise<number>;
+  count(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<number>;
   nonEnumeratedCount(): Promise<number>;
   fastCount(): Promise<number>;
   maxCount(): Promise<number>;
@@ -15,7 +15,7 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
   select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult>;
   selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult>;
 
-  where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
+  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<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>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
@@ -38,14 +38,14 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
 
   concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement>;
 
-  first(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
+  first(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<TElement>;
-  firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
+  firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
 
-  last(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
+  last(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<TElement>;
-  lastOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
+  lastOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
 
-  single(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
+  single(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<TElement>;
-  singleOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
+  singleOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
 
   elementAt(index: number): Promise<TElement>;
   elementAtOrDefault(index: number, def?: TElement): Promise<TElement | undefined>;
@@ -66,8 +66,8 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
   orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
   orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
 
-  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement[]>;
+  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<AsyncSequence<TElement>>;
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement[]>;
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<AsyncSequence<TElement>>;
 
   distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
   distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
@@ -81,19 +81,19 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
   intersect(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
   intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
 
-  all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
+  all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
-  any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
+  any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
   any(): Promise<boolean>;
-  none(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
+  none(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
   none(): Promise<boolean>;
 
   skip(n: number): AsyncSequence<TElement>;
   skipLast(n: number): AsyncSequence<TElement>;
-  skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
+  skipWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
 
   take(n: number): AsyncSequence<TElement>;
   takeLast(n: number): AsyncSequence<TElement>;
-  takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
+  takeWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
 
   peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement>;
 
@@ -101,19 +101,24 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
 
   zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]>;
 
-  indexex(): AsyncSequence<[number, TElement]>;
+  indexed(): AsyncSequence<[number, TElement]>;
 
   reversed(): AsyncSequence<TElement>;
 
-  chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
+  chunked(size: number, asArray?: false): AsyncSequence<AsyncSequence<TElement>>;
+  chunked(size: number, asArray: true): AsyncSequence<TElement[]>;
 
   random(options?: AsyncRandomOptions<TElement>): Promise<TElement | undefined>;
 
   cached(): AsyncSequence<TElement>;
 
+  asArray(): Promise<TElement[]>;
+
   toArray(): Promise<TElement[]>;
+  toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Map<TKey, TElement>>;
   toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
   toSet(): Promise<Set<TElement>>;
+  toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Record<TKey, TElement>>;
   toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;
 
   collect<TResult>(collector: Collector<TElement, any, TResult>): Promise<TResult>;

src/sync/index.ts

@@ -1,9 +1,9 @@
 import { mathRandom } from "../random/index.js";
 import { RandomGenerator } from "../random/types.js";
-import { BigIntRangeSequence, ConcatSequence, SequenceMarker, FunctionSequence, GeneratorSequence, RangeSequence, RepeatSequence, RepeatForeverSequence, WrappedArray, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet, EMPTY } from "./impl.js";
+import { BigIntRangeSequence, ConcatSequence, SequenceMarker, FunctionSequence, GeneratorSequence, RangeSequence, RepeatSequence, RepeatForeverSequence, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet, WrappedReadonlyArray, EMPTY } from "./impl.js";
 import { Sequence } from "./types.js";
 
-export function wrap<T>(iterable: Iterable<T>): Sequence<T> {
+export function wrap<T = any>(iterable: Iterable<T>): Sequence<T> {
   if (isSequence<T>(iterable)) {
     return iterable;
   }
@@ -23,11 +23,11 @@ export function wrap<T>(iterable: Iterable<T>): Sequence<T> {
   return sequence(iterable);
 }
 
-export function sequence<T>(iterable: Iterable<T>): Sequence<T> {
+export function sequence<T = any>(iterable: Iterable<T>): Sequence<T> {
   return new WrappedIterable(iterable);
 }
 
-export function empty<T>(): Sequence<T> {
+export function empty<T = any>(): Sequence<T> {
   return EMPTY;
 }
 
@@ -35,19 +35,19 @@ export function single<T>(obj: T): Sequence<T> {
   return new WrappedObject(obj);
 }
 
-export function array<T>(array: T[]): Sequence<T> {
+export function array<T = any>(array: ReadonlyArray<T>): Sequence<T> {
-  return new WrappedArray(array);
+  return new WrappedReadonlyArray(array);
 }
 
-export function arrayLike<T>(arrayLike: ArrayLike<T>): Sequence<T> {
+export function arrayLike<T = any>(arrayLike: ArrayLike<T>): Sequence<T> {
   return new WrappedArrayLike(arrayLike);
 }
 
-export function set<T>(set: Set<T>): Sequence<T> {
+export function set<T>(set: ReadonlySet<T>): Sequence<T> {
   return new WrappedSet(set);
 }
 
-export function map<K, V>(map: Map<K, V>): Sequence<[K, V]> {
+export function map<K, V>(map: ReadonlyMap<K, V>): Sequence<[K, V]> {
   return new WrappedMap(map);
 }
 

src/sync/types.ts

@@ -1,14 +1,18 @@
 import { AsyncSequence } from "../async/types.js";
 import { Collector } from "../collector/types.js";
 import { RandomOptions } from "../random/types.js";
-import { Predicate, Converter, FilterPredicate, Equater, BiConverter, Accumulator, Comparer, Action } from "../types.js";
+import { AnyPredicate, Converter, FilterPredicate, Equater, BiConverter, Accumulator, Comparer, Action } from "../types.js";
+
+export type SequencePipeline<TElement, TResult> = (sequence: Sequence<TElement>) => TResult;
 
 export interface Sequence<TElement> extends Iterable<TElement> {
   iterator(): Iterator<TElement>;
 
-  apply<TResult>(pipeline: (sequence: Sequence<TElement>) => TResult): TResult;
+  toJSON(): any;
 
-  count(predicate?: Predicate<TElement>): number;
+  apply<TResult>(pipeline: SequencePipeline<TElement, TResult>): TResult;
+
+  count(predicate?: AnyPredicate<TElement>): number;
   nonEnumeratedCount(): number;
   fastCount(): number;
   maxCount(): number;
@@ -17,7 +21,7 @@ export interface Sequence<TElement> extends Iterable<TElement> {
   selectMany<TResult>(selector: Converter<TElement, Sequence<TResult>>): Sequence<TResult>;
 
   where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
-  where(predicate: Predicate<TElement>): Sequence<TElement>;
+  where(predicate: AnyPredicate<TElement>): Sequence<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>): Sequence<GroupedSequence<TKey, TResult>>;
@@ -40,14 +44,14 @@ export interface Sequence<TElement> extends Iterable<TElement> {
 
   concat(...sequences: Sequence<TElement>[]): Sequence<TElement>;
 
-  first(predicate?: Predicate<TElement>): TElement;
+  first(predicate?: AnyPredicate<TElement>): TElement;
-  firstOrDefault(predicate?: Predicate<TElement>, def?: TElement): TElement | undefined;
+  firstOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement): TElement | undefined;
 
-  last(predicate?: Predicate<TElement>): TElement;
+  last(predicate?: AnyPredicate<TElement>): TElement;
-  lastOrDefault(predicate?: Predicate<TElement>, def?: TElement): TElement | undefined;
+  lastOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement): TElement | undefined;
 
-  single(predicate?: Predicate<TElement>): TElement;
+  single(predicate?: AnyPredicate<TElement>): TElement;
-  singleOrDefault(predicate?: Predicate<TElement>, def?: TElement): TElement | undefined;
+  singleOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement): TElement | undefined;
 
   elementAt(index: number): TElement;
   elementAtOrDefault(index: number, def?: TElement): TElement | undefined;
@@ -68,8 +72,8 @@ export interface Sequence<TElement> extends Iterable<TElement> {
   orderDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
   orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
 
-  partition(equater?: Equater<TElement>): Sequence<TElement[]>;
+  partition(equater?: Equater<TElement>): Sequence<Sequence<TElement>>;
-  partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement[]>;
+  partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<Sequence<TElement>>;
 
   distinct(equater?: Equater<TElement>): Sequence<TElement>;
   distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
@@ -83,19 +87,19 @@ export interface Sequence<TElement> extends Iterable<TElement> {
   intersect(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
   intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
 
-  all(predicate: Predicate<TElement>): boolean;
+  all(predicate: AnyPredicate<TElement>): boolean;
-  any(predicate: Predicate<TElement>): boolean;
+  any(predicate: AnyPredicate<TElement>): boolean;
   any(): boolean;
-  none(predicate: Predicate<TElement>): boolean;
+  none(predicate: AnyPredicate<TElement>): boolean;
   none(): boolean;
 
   skip(n: number): Sequence<TElement>;
   skipLast(n: number): Sequence<TElement>;
-  skipWhile(condition: Predicate<TElement>): Sequence<TElement>;
+  skipWhile(condition: AnyPredicate<TElement>): Sequence<TElement>;
 
   take(n: number): Sequence<TElement>;
   takeLast(n: number): Sequence<TElement>;
-  takeWhile(condition: Predicate<TElement>): Sequence<TElement>;
+  takeWhile(condition: AnyPredicate<TElement>): Sequence<TElement>;
 
   peek(action: Action<TElement>): Sequence<TElement>;
 
@@ -107,7 +111,8 @@ export interface Sequence<TElement> extends Iterable<TElement> {
 
   reversed(): Sequence<TElement>;
 
-  chunked(size: number): Sequence<Sequence<TElement>>;
+  chunked(size: number, asArray?: false): Sequence<Sequence<TElement>>;
+  chunked(size: number, asArray: true): Sequence<TElement[]>;
 
   random(options?: RandomOptions<TElement>): TElement | undefined;
 
@@ -115,9 +120,12 @@ export interface Sequence<TElement> extends Iterable<TElement> {
 
   awaited(): AsyncSequence<Awaited<TElement>>;
 
+  asArray(): TElement[];
   toArray(): TElement[];
+  toMap<TKey>(keySelector: Converter<TElement, TKey>): Map<TKey, TElement>;
   toMap<TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Map<TKey, TValue>;
   toSet(): Set<TElement>;
+  toObject<TKey extends PropertyKey>(keySelector: Converter<TElement, TKey>): Record<TKey, TElement>;
   toObject<TKey extends PropertyKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Record<TKey, TValue>;
 
   collect<TResult>(collector: Collector<TElement, any, TResult>): TResult;

src/types.ts

@@ -2,6 +2,7 @@ import { AsyncSequence } from "./async/types.js";
 import { Sequence } from "./sync/types.js";
 
 export type Predicate<T> = (obj: T) => boolean;
+export type AnyPredicate<T> = (obj: T) => unknown;
 export type FilterPredicate<TElement, TFiltered extends TElement> = (obj: TElement) => obj is TFiltered;
 export type Converter<TFrom, TTo> = (obj: TFrom) => TTo;
 export type BiConverter<TFromFirst, TFromSecond, TTo> = (first: TFromFirst, second: TFromSecond) => TTo;
@@ -20,7 +21,9 @@ export type MaybeAsyncFunction<TFunc extends (...args: any) => any> = TFunc exte
 export type MaybeAsyncSequence<T> = Sequence<T> | AsyncSequence<T>;
 
 export type AsyncPredicate<T> = AsyncFunction<Predicate<T>>;
+export type AsyncAnyPredicate<T> = AsyncFunction<AnyPredicate<T>>;
 export type MaybeAsyncPredicate<T> = MaybeAsyncFunction<Predicate<T>>;
+export type MaybeAsyncAnyPredicate<T> = MaybeAsyncFunction<AnyPredicate<T>>;
 export type AsyncConverter<TFrom, TTo> = AsyncFunction<Converter<TFrom, TTo>>;
 export type MaybeAsyncConverter<TFrom, TTo> = MaybeAsyncFunction<Converter<TFrom, TTo>>;
 export type AsyncBiConverter<TFromFirst, TFromSecond, TTo> = AsyncFunction<BiConverter<TFromFirst, TFromSecond, TTo>>;