Rename

packages/jscorlib/src/linq/collect.ts

@@ -1,15 +1,15 @@
 import type { LinqWrapper } from "./linqWrapper";
-import { SequenceElementSelector } from "./typing";
+import { IndexedSequenceElementSelector } from "./typing";
 
 declare module "./linqWrapper" {
  export interface LinqWrapper<T> {
  toArray(): T[];
- toMap<TKey>(keySelector: SequenceElementSelector<T, TKey>): Map<TKey, T>;
- toMap<TKey, TValue>(keySelector: SequenceElementSelector<T, TKey>, valueSelector: SequenceElementSelector<T, TValue>): Map<TKey, TValue>;
- toMultiMap<TKey, TValue>(keySelector: SequenceElementSelector<T, TKey>): Map<TKey, TValue[]>;
- toMultiMap<TKey, TValue>(keySelector: SequenceElementSelector<T, TKey>, valueSelector: SequenceElementSelector<T, TValue>): Map<TKey, TValue[]>;
+ toMap<TKey>(keySelector: IndexedSequenceElementSelector<T, TKey>): Map<TKey, T>;
+ toMap<TKey, TValue>(keySelector: IndexedSequenceElementSelector<T, TKey>, valueSelector: IndexedSequenceElementSelector<T, TValue>): Map<TKey, TValue>;
+ toMultiMap<TKey, TValue>(keySelector: IndexedSequenceElementSelector<T, TKey>): Map<TKey, TValue[]>;
+ toMultiMap<TKey, TValue>(keySelector: IndexedSequenceElementSelector<T, TKey>, valueSelector: IndexedSequenceElementSelector<T, TValue>): Map<TKey, TValue[]>;
  toSet(): Set<T>;
- toSet<TValue>(valueSelector: SequenceElementSelector<T, TValue>): Set<TValue>;
+ toSet<TValue>(valueSelector: IndexedSequenceElementSelector<T, TValue>): Set<TValue>;
  }
 }
 
@@ -21,8 +21,8 @@ export function Linq$toArray<T>(this: LinqWrapper<T>): T[] {
 
 export function Linq$toMap<T, TKey, TValue>(
  this: LinqWrapper<T>,
- keySelector: SequenceElementSelector<T, TKey>,
- valueSelector?: SequenceElementSelector<T, TValue>,
+ keySelector: IndexedSequenceElementSelector<T, TKey>,
+ valueSelector?: IndexedSequenceElementSelector<T, TValue>,
 ): Map<TKey, TValue> {
  const map = new Map<TKey, TValue>();
  let i = 0;
@@ -43,8 +43,8 @@ export function Linq$toMap<T, TKey, TValue>(
 
 export function Linq$toMultiMap<T, TKey, TValue>(
  this: LinqWrapper<T>,
- keySelector: SequenceElementSelector<T, TKey>,
- valueSelector?: SequenceElementSelector<T, TValue>,
+ keySelector: IndexedSequenceElementSelector<T, TKey>,
+ valueSelector?: IndexedSequenceElementSelector<T, TValue>,
 ): Map<TKey, TValue[]> {
  const map = new Map<TKey, TValue[]>();
  let i = 0;
@@ -76,7 +76,7 @@ export function Linq$toMultiMap<T, TKey, TValue>(
 
 export function Linq$toSet<T, TValue = T>(
  this: LinqWrapper<T>,
- valueSelector?: SequenceElementSelector<T, TValue>,
+ valueSelector?: IndexedSequenceElementSelector<T, TValue>,
 ): Set<TValue> {
  const set = new Set<TValue>();
  if (valueSelector) {

packages/jscorlib/src/linq/collectHashMap.ts

@@ -1,19 +1,19 @@
 import { HashMap } from "../collections";
 import { EqualityComparer } from "../collections/equalityComparison";
 import type { LinqWrapper } from "./linqWrapper";
-import { SequenceElementSelector } from "./typing";
+import { IndexedSequenceElementSelector } from "./typing";
 
 declare module "./linqWrapper" {
  export interface LinqWrapper<T> {
- toHashMap<TKey>(keySelector: SequenceElementSelector<T, TKey>, comparer?: EqualityComparer<TKey>): HashMap<TKey, T>;
- toHashMap<TKey, TValue>(keySelector: SequenceElementSelector<T, TKey>, valueSelector: SequenceElementSelector<T, TValue>, comparer?: EqualityComparer<TKey>): HashMap<TKey, TValue>;
+ toHashMap<TKey>(keySelector: IndexedSequenceElementSelector<T, TKey>, comparer?: EqualityComparer<TKey>): HashMap<TKey, T>;
+ toHashMap<TKey, TValue>(keySelector: IndexedSequenceElementSelector<T, TKey>, valueSelector: IndexedSequenceElementSelector<T, TValue>, comparer?: EqualityComparer<TKey>): HashMap<TKey, TValue>;
  }
 }
 
 export function Linq$toHashMap<T, TKey, TValue>(
  this: LinqWrapper<T>,
- keySelector: SequenceElementSelector<T, TKey>,
- valueSelector?: SequenceElementSelector<T, TValue> | EqualityComparer<TKey>,
+ keySelector: IndexedSequenceElementSelector<T, TKey>,
+ valueSelector?: IndexedSequenceElementSelector<T, TValue> | EqualityComparer<TKey>,
  comparer?: EqualityComparer<TKey>,
 ): HashMap<TKey, TValue> {
  if (typeof valueSelector === "object") {

packages/jscorlib/src/linq/collectHashSet.ts

@@ -1,18 +1,18 @@
 import { HashSet } from "../collections";
 import { EqualityComparer } from "../collections/equalityComparison";
 import type { LinqWrapper } from "./linqWrapper";
-import { SequenceElementSelector } from "./typing";
+import { IndexedSequenceElementSelector } from "./typing";
 
 declare module "./linqWrapper" {
  export interface LinqWrapper<T> {
  toHashSet(comparer?: EqualityComparer<T>): HashSet<T>;
- toHashSet<TValue>(valueSelector: SequenceElementSelector<T, TValue>, comparer?: EqualityComparer<TValue>): HashSet<TValue>;
+ toHashSet<TValue>(valueSelector: IndexedSequenceElementSelector<T, TValue>, comparer?: EqualityComparer<TValue>): HashSet<TValue>;
  }
 }
 
 export function Linq$toHashSet<T, TValue = T>(
  this: LinqWrapper<T>,
- valueSelector?: SequenceElementSelector<T, TValue> | EqualityComparer<TValue>,
+ valueSelector?: IndexedSequenceElementSelector<T, TValue> | EqualityComparer<TValue>,
  comparer?: EqualityComparer<TValue>,
 ): HashSet<TValue> {
  if (typeof valueSelector === "object") {

packages/jscorlib/src/linq/distinct.ts

@@ -1,13 +1,13 @@
-import { HashSet } from "../collections/hashSet";
 import { EqualityComparer } from "../collections/equalityComparison";
+import { HashSet } from "../collections/hashSet";
 import type { LinqWrapper } from "./linqWrapper";
 import { IntermediateLinqWrapper } from "./linqWrapper.internal";
-import { SequenceElementSimpleSelector } from "./typing";
+import { SequenceElementSelector } from "./typing";
 
 declare module "./linqWrapper" {
  export interface LinqWrapper<T> {
  distinct(comparer?: EqualityComparer<T>): LinqWrapper<T>;
- distinctBy<TKey>(keySelector: SequenceElementSimpleSelector<T, TKey>, comparer?: EqualityComparer<TKey>): LinqWrapper<T>;
+ distinctBy<TKey>(keySelector: SequenceElementSelector<T, TKey>, comparer?: EqualityComparer<TKey>): LinqWrapper<T>;
  }
 }
 
@@ -23,7 +23,7 @@ export function Linq$distinct<T>(this: LinqWrapper<T>, comparer?: EqualityCompar
  }).asLinq();
 }
 
-export function Linq$distinctBy<T, TKey>(this: LinqWrapper<T>, keySelector: SequenceElementSimpleSelector<T, TKey>, comparer?: EqualityComparer<TKey>): LinqWrapper<T> {
+export function Linq$distinctBy<T, TKey>(this: LinqWrapper<T>, keySelector: SequenceElementSelector<T, TKey>, comparer?: EqualityComparer<TKey>): LinqWrapper<T> {
  if (this instanceof DistinctLinqWrapper) {
  const state = this.__state;
  // Trivial: distinct gets chained multiple times with the same keySelector (while almost impossible)
@@ -38,7 +38,7 @@ export function Linq$distinctBy<T, TKey>(this: LinqWrapper<T>, keySelector: Sequ
 
 interface DistinctIteratorInfo<T, TKey> {
  readonly iterable: Iterable<T>;
- keySelector?: SequenceElementSimpleSelector<T, TKey>;
+ keySelector?: SequenceElementSelector<T, TKey>;
  comparer?: EqualityComparer<TKey>
 }
 

packages/jscorlib/src/linq/forEach.ts

@@ -1,14 +1,14 @@
 import { isTypedArray } from "util/types";
 import { LinqWrapper } from "./linqWrapper";
-import { SequenceElementCallback } from "./typing";
+import { IndexedSequenceElementCallback } from "./typing";
 
 declare module "./linqWrapper" {
  export interface LinqWrapper<T> {
- forEach(callback: SequenceElementCallback<T>): void;
+ forEach(callback: IndexedSequenceElementCallback<T>): void;
  }
 }
 
-export function Linq$forEach<T>(this: LinqWrapper<T>, callback: SequenceElementCallback<T>): void {
+export function Linq$forEach<T>(this: LinqWrapper<T>, callback: IndexedSequenceElementCallback<T>): void {
  const unwrapped = this.unwrap();
 
  // Perf optimization for arrays

packages/jscorlib/src/linq/groupBy.ts

@@ -2,11 +2,11 @@ import { HashMap } from "../collections";
 import { EqualityComparer } from "../collections/equalityComparison";
 import { LinqWrapper } from "./linqWrapper";
 import { IntermediateLinqWrapper, IterableLinqWrapper } from "./linqWrapper.internal";
-import { SequenceElementSimpleSelector } from "./typing";
+import { SequenceElementSelector } from "./typing";
 
 declare module "./linqWrapper" {
  export interface LinqWrapper<T> {
- groupBy<TKey>(keySelector: SequenceElementSimpleSelector<T, TKey>, comparer?: EqualityComparer<T>): LinqWrapper<LinqGrouping<TKey, T>>;
+ groupBy<TKey>(keySelector: SequenceElementSelector<T, TKey>, comparer?: EqualityComparer<T>): LinqWrapper<LinqGrouping<TKey, T>>;
  }
 }
 
@@ -25,7 +25,7 @@ export interface LinqGrouping<TKey, TValue> {
 
 export function Linq$groupBy<T, TKey>(
  this: LinqWrapper<T>,
- keySelector: SequenceElementSimpleSelector<T, TKey>,
+ keySelector: SequenceElementSelector<T, TKey>,
  comparer?: EqualityComparer<TKey>,
 ): LinqWrapper<LinqGrouping<TKey, T>> {
  const unwrapped = this.unwrap();
@@ -38,7 +38,7 @@ export function Linq$groupBy<T, TKey>(
 
 interface GroupingIteratorInfo<T, TKey> {
  readonly iterable: Iterable<T>;
- keySelector: SequenceElementSimpleSelector<T, TKey>,
+ keySelector: SequenceElementSelector<T, TKey>,
  comparer?: EqualityComparer<TKey>,
 }
 

packages/jscorlib/src/linq/minmax.ts

@@ -3,40 +3,40 @@ import { ComparerFunction } from "../collections/comparison";
 import { fail } from "../diagnostics";
 import { InvalidOperationError } from "../errors";
 import type { LinqWrapper } from "./linqWrapper";
-import { SequenceElementSimpleSelector } from "./typing";
+import { SequenceElementSelector } from "./typing";
 import { unwrapUnorderedLinqWrapper } from "./utils.internal";
 
 export type AggregateAccumulator<T, TAccumulate> = (accumulate: TAccumulate, element: T) => TAccumulate;
 
 declare module "./linqWrapper" {
  export interface LinqWrapper<T> {
  min(comparer?: ComparerFunction<T>): T;
- minBy<TKey>(keySelector: SequenceElementSimpleSelector<T, TKey>, comparer?: ComparerFunction<TKey>): T;
+ minBy<TKey>(keySelector: SequenceElementSelector<T, TKey>, comparer?: ComparerFunction<TKey>): T;
  max(comparer?: ComparerFunction<T>): T;
- maxBy<TKey>(keySelector: SequenceElementSimpleSelector<T, TKey>, comparer?: ComparerFunction<TKey>): T;
+ maxBy<TKey>(keySelector: SequenceElementSelector<T, TKey>, comparer?: ComparerFunction<TKey>): T;
  }
 }
 
 export function Linq$min<T>(this: LinqWrapper<T>, comparer?: ComparerFunction<T>): T {
  return minMaxImpl(this, "min", undefined, comparer);
 }
 
-export function Linq$minBy<T, TKey>(this: LinqWrapper<T>, keySelector: SequenceElementSimpleSelector<T, TKey>, comparer?: ComparerFunction<TKey>): T {
+export function Linq$minBy<T, TKey>(this: LinqWrapper<T>, keySelector: SequenceElementSelector<T, TKey>, comparer?: ComparerFunction<TKey>): T {
  return minMaxImpl(this, "min", keySelector, comparer);
 }
 
 export function Linq$max<T>(this: LinqWrapper<T>, comparer?: ComparerFunction<T>): T {
  return minMaxImpl(this, "max", undefined, comparer);
 }
 
-export function Linq$maxBy<T, TKey>(this: LinqWrapper<T>, keySelector: SequenceElementSimpleSelector<T, TKey>, comparer?: ComparerFunction<TKey>): T {
+export function Linq$maxBy<T, TKey>(this: LinqWrapper<T>, keySelector: SequenceElementSelector<T, TKey>, comparer?: ComparerFunction<TKey>): T {
  return minMaxImpl(this, "max", keySelector, comparer);
 }
 
 function minMaxImpl<T, TKey = T>(
  wrapper: LinqWrapper<T>,
  mode: "min" | "max",
- keySelector?: SequenceElementSimpleSelector<T, TKey>,
+ keySelector?: SequenceElementSelector<T, TKey>,
  comparer?: ComparerFunction<TKey>,
 ): T {
  comparer ??= defaultArrayComparer;

packages/jscorlib/src/linq/pick.ts

@@ -3,21 +3,21 @@ import { assert } from "../diagnostics";
 import { ArgumentRangeError, InvalidOperationError } from "../errors";
 import { asSafeInteger } from "../numbers/asSafeInteger";
 import type { LinqWrapper } from "./linqWrapper";
-import { SequenceElementPredicate } from "./typing";
+import { IndexedSequenceElementPredicate } from "./typing";
 import { isArrayLikeStrict } from "./utils.internal";
 
 declare module "./linqWrapper" {
  export interface LinqWrapper<T> {
  first(): T;
- first(predicate?: SequenceElementPredicate<T>): T;
+ first(predicate?: IndexedSequenceElementPredicate<T>): T;
  last(): T;
- last(predicate?: SequenceElementPredicate<T>): T;
+ last(predicate?: IndexedSequenceElementPredicate<T>): T;
  firstOrDefault(): T | undefined;
- firstOrDefault(predicate: SequenceElementPredicate<T> | undefined, defaultValue: T): T;
- firstOrDefault(predicate?: SequenceElementPredicate<T>, defaultValue?: T): T | undefined;
+ firstOrDefault(predicate: IndexedSequenceElementPredicate<T> | undefined, defaultValue: T): T;
+ firstOrDefault(predicate?: IndexedSequenceElementPredicate<T>, defaultValue?: T): T | undefined;
  lastOrDefault(): T | undefined;
- lastOrDefault(predicate: SequenceElementPredicate<T> | undefined, defaultValue: T): T;
- lastOrDefault(predicate?: SequenceElementPredicate<T>, defaultValue?: T): T | undefined;
+ lastOrDefault(predicate: IndexedSequenceElementPredicate<T> | undefined, defaultValue: T): T;
+ lastOrDefault(predicate?: IndexedSequenceElementPredicate<T>, defaultValue?: T): T | undefined;
  elementAt(index: BidirectionalIndex): T;
  elementAtOrDefault(index: BidirectionalIndex): T;
  elementAtOrDefault(index: BidirectionalIndex, defaultValue: T): T;
@@ -27,29 +27,29 @@ declare module "./linqWrapper" {
 
 const NoMatch = Symbol("NoMatch");
 
-export function Linq$first<T>(this: LinqWrapper<T>, predicate?: SequenceElementPredicate<T>): T {
+export function Linq$first<T>(this: LinqWrapper<T>, predicate?: IndexedSequenceElementPredicate<T>): T {
  const e = getFirst(this.unwrap(), predicate);
  if (e !== NoMatch) return e;
 
  if (predicate) throw new InvalidOperationError("Sequence contains no matching element.");
  throw new InvalidOperationError("Sequence contains no element.");
 }
 
-export function Linq$last<T>(this: LinqWrapper<T>, predicate?: SequenceElementPredicate<T>): T {
+export function Linq$last<T>(this: LinqWrapper<T>, predicate?: IndexedSequenceElementPredicate<T>): T {
  const e = getLast(this.unwrap(), predicate);
  if (e !== NoMatch) return e;
 
  if (predicate) throw new InvalidOperationError("Sequence contains no matching element.");
  throw new InvalidOperationError("Sequence contains no element.");
 }
 
-export function Linq$firstOrDefault<T>(this: LinqWrapper<T>, predicate?: SequenceElementPredicate<T>, defaultValue?: T): T | undefined {
+export function Linq$firstOrDefault<T>(this: LinqWrapper<T>, predicate?: IndexedSequenceElementPredicate<T>, defaultValue?: T): T | undefined {
  const e = getFirst(this.unwrap(), predicate);
  if (e !== NoMatch) return e;
  return defaultValue;
 }
 
-export function Linq$lastOrDefault<T>(this: LinqWrapper<T>, predicate?: SequenceElementPredicate<T>, defaultValue?: T): T | undefined {
+export function Linq$lastOrDefault<T>(this: LinqWrapper<T>, predicate?: IndexedSequenceElementPredicate<T>, defaultValue?: T): T | undefined {
  const e = getLast(this.unwrap(), predicate);
  if (e !== NoMatch) return e;
  return defaultValue;
@@ -67,7 +67,7 @@ export function Linq$elementAtOrDefault<T>(this: LinqWrapper<T>, index: Bidirect
  return defaultValue;
 }
 
-function getFirst<T>(iterable: Iterable<T>, predicate?: SequenceElementPredicate<T>): T | typeof NoMatch {
+function getFirst<T>(iterable: Iterable<T>, predicate?: IndexedSequenceElementPredicate<T>): T | typeof NoMatch {
  if (predicate) {
  let index = 0;
  for (const i of iterable) {
@@ -82,7 +82,7 @@ function getFirst<T>(iterable: Iterable<T>, predicate?: SequenceElementPredicate
  return getElementAt(iterable, 0);
 }
 
-function getLast<T>(iterable: Iterable<T>, predicate?: SequenceElementPredicate<T>): T | typeof NoMatch {
+function getLast<T>(iterable: Iterable<T>, predicate?: IndexedSequenceElementPredicate<T>): T | typeof NoMatch {
  if (predicate) {
  if (isArrayLikeStrict(iterable)) {
  const length = iterable.length;

packages/jscorlib/src/linq/select.ts

@@ -2,39 +2,39 @@ import { Linq$tryGetCountDirect } from "./count";
 import { asLinq, LinqWrapper } from "./linqWrapper";
 import { IntermediateLinqWrapper, IterableFactoryLinqWrapper } from "./linqWrapper.internal";
 import { BuiltInLinqTraits, TryGetCountDirectSymbol } from "./traits";
-import { SequenceElementSelector } from "./typing";
+import { IndexedSequenceElementSelector } from "./typing";
 
 declare module "./linqWrapper" {
  export interface LinqWrapper<T> {
- select<TResult>(selector: SequenceElementSelector<T, TResult>): LinqWrapper<TResult>;
- selectMany<TResult>(selector: SequenceElementSelector<T, Iterable<TResult>>): LinqWrapper<TResult>;
+ select<TResult>(selector: IndexedSequenceElementSelector<T, TResult>): LinqWrapper<TResult>;
+ selectMany<TResult>(selector: IndexedSequenceElementSelector<T, Iterable<TResult>>): LinqWrapper<TResult>;
  }
 }
 
-export function Linq$select<T, TResult>(this: LinqWrapper<T>, selector: SequenceElementSelector<T, TResult>): LinqWrapper<TResult> {
+export function Linq$select<T, TResult>(this: LinqWrapper<T>, selector: IndexedSequenceElementSelector<T, TResult>): LinqWrapper<TResult> {
  if (this instanceof SelectLinqWrapper) {
  const state = this.__state;
  return new SelectLinqWrapper<T, TResult>({
  ...state,
  selectors: [
  ...state.selectors,
- { selector: selector as SequenceElementSelector<unknown, unknown> },
+ { selector: selector as IndexedSequenceElementSelector<unknown, unknown> },
  ],
  }).asLinq();
  }
 
  return new SelectLinqWrapper<T, TResult>({
  iterable: this.unwrap(),
- selectors: [{ selector: selector as SequenceElementSelector<unknown, unknown> }],
+ selectors: [{ selector: selector as IndexedSequenceElementSelector<unknown, unknown> }],
  }).asLinq();
 }
 
-export function Linq$selectMany<T, TResult>(this: LinqWrapper<T>, selector: SequenceElementSelector<T, Iterable<TResult>>): LinqWrapper<TResult> {
+export function Linq$selectMany<T, TResult>(this: LinqWrapper<T>, selector: IndexedSequenceElementSelector<T, Iterable<TResult>>): LinqWrapper<TResult> {
  const unwrapped = this.unwrap();
  return new IterableFactoryLinqWrapper(() => selectManyIterable(unwrapped, selector)).asLinq();
 }
 
-function* selectManyIterable<T, TResult>(iterable: Iterable<T>, selector: SequenceElementSelector<T, Iterable<TResult>>): Iterable<TResult> {
+function* selectManyIterable<T, TResult>(iterable: Iterable<T>, selector: IndexedSequenceElementSelector<T, Iterable<TResult>>): Iterable<TResult> {
  let index = 0;
  for (const e of iterable) {
  yield* selector(e, index);
@@ -43,7 +43,7 @@ function* selectManyIterable<T, TResult>(iterable: Iterable<T>, selector: Sequen
 }
 
 interface SelectorEntry {
- selector: SequenceElementSelector<unknown, unknown>;
+ selector: IndexedSequenceElementSelector<unknown, unknown>;
  // Reserved for future use.
  flatten?: false;
 }