typescript-dotnet-es6 - npm Package Compare versions

Comparing version 4.2.0 to 4.3.0

package.json

 {
   "name": "typescript-dotnet-es6",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "license": "MIT",
@@ -5,0 +5,0 @@ "author": "electricessence <[e-mail]>",

System.Linq/Enumerable.d.ts

@@ -25,2 +25,3 @@ /*!
 import {IDisposable} from "../System/Disposable/IDisposable";
+import {Primitive} from "../System/Primitive";
 
@@ -32,5 +33,2 @@ export interface IInfiniteEnumerable<T> extends IEnumerable<T>, IDisposable
 	doAction(
-		action:Action<T> | Predicate<T> | Selector<T, number> | Selector<T, EnumerableAction>,
-		initializer?:Closure | null, isEndless?:boolean | null | undefined):this;
-	doAction(
 		action:ActionWithIndex<T> | PredicateWithIndex<T> | SelectorWithIndex<T, number> | SelectorWithIndex<T, EnumerableAction>,
@@ -56,11 +54,5 @@ initializer?:Closure | null, isEndless?:boolean | null | undefined):this;
 		childrenSelector:(element:T) => IEnumerableOrArray<T> | null | undefined,
-		resultSelector:Selector<T, TResult>):ILinqEnumerable<TResult>;
-	traverseBreadthFirst<TResult>(
-		childrenSelector:(element:T) => IEnumerableOrArray<T> | null | undefined,
 		resultSelector:SelectorWithIndex<T, TResult>):ILinqEnumerable<TResult>;
 	traverseBreadthFirst<TNode, TResult>(
 		childrenSelector:(element:T | TNode) => IEnumerableOrArray<TNode> | null | undefined,
-		resultSelector:Selector<T, TResult>):ILinqEnumerable<TResult>;
-	traverseBreadthFirst<TNode, TResult>(
-		childrenSelector:(element:T | TNode) => IEnumerableOrArray<TNode> | null | undefined,
 		resultSelector:SelectorWithIndex<T, TResult>):ILinqEnumerable<TResult>;
@@ -71,11 +63,5 @@ traverseDepthFirst(childrenSelector:(element:T) => IEnumerableOrArray<T> | null | undefined):ILinqEnumerable<T>;
 		childrenSelector:(element:T) => IEnumerableOrArray<T> | null | undefined,
-		resultSelector:Selector<T, TResult>):ILinqEnumerable<TResult>;
-	traverseDepthFirst<TResult>(
-		childrenSelector:(element:T) => IEnumerableOrArray<T> | null | undefined,
 		resultSelector:SelectorWithIndex<T, TResult>):ILinqEnumerable<TResult>;
 	traverseDepthFirst<TNode, TResult>(
 		childrenSelector:(element:T | TNode) => IEnumerableOrArray<TNode> | null | undefined,
-		resultSelector:Selector<T, TResult>):ILinqEnumerable<TResult>;
-	traverseDepthFirst<TNode, TResult>(
-		childrenSelector:(element:T | TNode) => IEnumerableOrArray<TNode> | null | undefined,
 		resultSelector:SelectorWithIndex<T, TResult>):ILinqEnumerable<TResult>;
@@ -85,8 +71,3 @@ flatten():ILinqEnumerable<any>;
 	scan(func:(a:T, b:T) => T, seed?:T):this;
-	select<TResult>(selector:Selector<T, TResult>):IInfiniteEnumerable<TResult>;
 	select<TResult>(selector:SelectorWithIndex<T, TResult>):IInfiniteEnumerable<TResult>;
-	selectMany<TResult>(collectionSelector:Selector<T, IEnumerableOrArray<TResult> | null | undefined>):IInfiniteEnumerable<TResult>;
-	selectMany<TElement, TResult>(
-		collectionSelector:Selector<T, IEnumerableOrArray<TElement> | null | undefined>,
-		resultSelector:(collection:T, element:TElement) => TResult):IInfiniteEnumerable<TResult>;
 	selectMany<TResult>(collectionSelector:SelectorWithIndex<T, IEnumerableOrArray<TResult> | null | undefined>):IInfiniteEnumerable<TResult>;
@@ -98,3 +79,2 @@ selectMany<TElement, TResult>(
 	choose<TResult>(selector?:Selector<T, TResult>):IInfiniteEnumerable<TResult>;
-	where(predicate:Predicate<T>):this;
 	where(predicate:PredicateWithIndex<T>):this;
@@ -106,22 +86,16 @@ ofType<TType>(
 	except<TCompare>(second:IEnumerableOrArray<T>, compareSelector?:Selector<T, TCompare>):this;
-	distinct(compareSelector?:(value:T) => T):this;
-	distinctUntilChanged<TCompare>(compareSelector?:Selector<T, TCompare>):this;
+	distinct(compareSelector?:Selector<T, string|number|symbol>):this
+	distinctUntilChanged(compareSelector?:Selector<T, any>):this
 	defaultIfEmpty(defaultValue?:T):this;
 	zip<TSecond, TResult>(
 		second:IEnumerableOrArray<TSecond>,
-		resultSelector:(first:T, second:TSecond) => TResult):ILinqEnumerable<TResult>;
-	zip<TSecond, TResult>(
-		second:IEnumerableOrArray<TSecond>,
 		resultSelector:(first:T, second:TSecond, index:number) => TResult):ILinqEnumerable<TResult>;
 	zipMultiple<TSecond, TResult>(
 		second:IArray<IEnumerableOrArray<TSecond>>,
-		resultSelector:(first:T, second:TSecond) => TResult):ILinqEnumerable<TResult>;
-	zipMultiple<TSecond, TResult>(
-		second:IArray<IEnumerableOrArray<TSecond>>,
 		resultSelector:(first:T, second:TSecond, index:number) => TResult):ILinqEnumerable<TResult>;
-	join<TInner, TKey, TResult, TCompare>(
+	join<TInner, TKey, TResult>(
 		inner:IEnumerableOrArray<TInner>,
 		outerKeySelector:Selector<T, TKey>, innerKeySelector:Selector<TInner, TKey>,
 		resultSelector:(outer:T, inner:TInner) => TResult,
-		compareSelector?:Selector<TKey, TCompare>):ILinqEnumerable<TResult>;
+		compareSelector?:Selector<TKey, string|number|symbol>):ILinqEnumerable<TResult>;
 	groupJoin<TInner, TKey, TResult, TCompare>(
@@ -147,47 +121,24 @@ inner:IEnumerableOrArray<TInner>,
 
-	skipWhile(predicate:Predicate<T>):this;
 	skipWhile(predicate:PredicateWithIndex<T>):this;
-	takeWhile(predicate:Predicate<T>):this;
 	takeWhile(predicate:PredicateWithIndex<T>):this;
-	takeUntil(predicate:Predicate<T>, includeUntilValue?:boolean):this;
 	takeUntil(predicate:PredicateWithIndex<T>, includeUntilValue?:boolean):this;
-	forEach(action:Action<T>, max?:number):number;
-	forEach(action:Predicate<T>, max?:number):number;
 	forEach(action:ActionWithIndex<T>, max?:number):number;
 	forEach(action:PredicateWithIndex<T>, max?:number):number;
-	toArray(predicate?:Predicate<T>):T[];
 	toArray(predicate?:PredicateWithIndex<T>):T[];
 	copyTo(target:T[], index?:number, count?:number):T[];
-	toLookup<TKey, TValue, TCompare>(
-		keySelector:Selector<T, TKey>,
-		elementSelector:Selector<T, TValue>,
-		compareSelector?:Selector<TKey, TCompare>):ILookup<TKey, TValue>;
-	toLookup<TKey, TValue, TCompare>(
-		keySelector:Selector<T, TKey>,
-		elementSelector:SelectorWithIndex<T, TValue>,
-		compareSelector?:Selector<TKey, TCompare>):ILookup<TKey, TValue>;
-	toLookup<TKey, TValue, TCompare>(
+	toLookup<TKey, TValue>(
 		keySelector:SelectorWithIndex<T, TKey>,
-		elementSelector:Selector<T, TValue>,
-		compareSelector?:Selector<TKey, TCompare>):ILookup<TKey, TValue>;
-	toLookup<TKey, TValue, TCompare>(
-		keySelector:SelectorWithIndex<T, TKey>,
 		elementSelector?:SelectorWithIndex<T, TValue>,
-		compareSelector?:Selector<TKey, TCompare>):ILookup<TKey, TValue>;
+		compareSelector?:Selector<TKey, string|number|symbol>):ILookup<TKey, TValue>;
 	toMap<TResult>(
-		keySelector:Selector<T, string>,
+		keySelector:Selector<T, string|number|symbol>,
 		elementSelector:Selector<T, TResult>):IMap<TResult>;
-	toDictionary<TKey, TValue, TCompare>(
+	toDictionary<TKey, TValue>(
 		keySelector:SelectorWithIndex<T, TKey> | Selector<T, TKey>,
 		elementSelector:SelectorWithIndex<T, TValue> | Selector<T, TValue>,
-		compareSelector?:Selector<TKey, TCompare>):IDictionary<TKey, TValue>;
+		compareSelector?:Selector<TKey, string|number|symbol>):IDictionary<TKey, TValue>;
 	toJoinedString(separator?:string, selector?:Selector<T, string>):string;
 	takeExceptLast(count?:number):this;
 	skipToLast(count:number):this;
-	select<TResult>(selector:Selector<T, TResult>):ILinqEnumerable<TResult>;
 	select<TResult>(selector:SelectorWithIndex<T, TResult>):ILinqEnumerable<TResult>;
-	selectMany<TResult>(collectionSelector:Selector<T, IEnumerableOrArray<TResult> | null | undefined>):ILinqEnumerable<TResult>;
-	selectMany<TElement, TResult>(
-		collectionSelector:Selector<T, IEnumerableOrArray<TElement> | null | undefined>,
-		resultSelector:(collection:T, element:TElement) => TResult):ILinqEnumerable<TResult>;
 	selectMany<TResult>(collectionSelector:SelectorWithIndex<T, IEnumerableOrArray<TResult> | null | undefined>):ILinqEnumerable<TResult>;
@@ -198,22 +149,14 @@ selectMany<TElement, TResult>(
 	choose():ILinqEnumerable<T>;
-	choose<TResult>(selector:Selector<T, TResult>):ILinqEnumerable<TResult>;
 	choose<TResult>(selector:SelectorWithIndex<T, TResult>):ILinqEnumerable<TResult>;
 	reverse():this;
 	shuffle():this;
-	count(predicate:Predicate<T>):number;
 	count(predicate?:PredicateWithIndex<T>):number;
-	all(predicate:Predicate<T>):boolean;
 	all(predicate:PredicateWithIndex<T>):boolean;
-	every(predicate:Predicate<T>):boolean;
 	every(predicate:PredicateWithIndex<T>):boolean;
-	any(predicate:Predicate<T>):boolean;
 	any(predicate?:PredicateWithIndex<T>):boolean;
-	some(predicate:Predicate<T>):boolean;
 	some(predicate?:PredicateWithIndex<T>):boolean;
-	contains<TCompare>(value:T, compareSelector?:Selector<T, TCompare>):boolean;
-	indexOf<TCompare>(value:T, compareSelector:Selector<T, TCompare>):number;
-	indexOf<TCompare>(value:T, compareSelector?:SelectorWithIndex<T, TCompare>):number;
-	lastIndexOf<TCompare>(value:T, compareSelector:Selector<T, TCompare>):number;
-	lastIndexOf<TCompare>(value:T, compareSelector?:SelectorWithIndex<T, TCompare>):number;
-	intersect<TCompare>(second:IEnumerableOrArray<T>, compareSelector?:Selector<T, TCompare>):this;
+	contains(value:T, compareSelector?:Selector<T, any>):boolean;
+	indexOf(value:T, compareSelector?:SelectorWithIndex<T, any>):number;
+	lastIndexOf(value:T, compareSelector?:SelectorWithIndex<T, any>):number;
+	intersect(second:IEnumerableOrArray<T>, compareSelector?:Selector<T, string|number|symbol>):this;
 	sequenceEqual(second:IEnumerableOrArray<T>, equalityComparer?:EqualityComparison<T>):boolean;
@@ -229,39 +172,17 @@ ofType<TType>(
 	buffer(size:number):ILinqEnumerable<T[]>;
-	groupBy<TKey>(keySelector:Selector<T, TKey>):ILinqEnumerable<IGrouping<TKey, T>>;
 	groupBy<TKey>(keySelector:SelectorWithIndex<T, TKey>):ILinqEnumerable<IGrouping<TKey, T>>;
-	groupBy<TKey, TCompare>(
-		keySelector:Selector<T, TKey>, elementSelector:Selector<T, T>,
-		compareSelector?:Selector<TKey, TCompare>):ILinqEnumerable<IGrouping<TKey, T>>;
-	groupBy<TKey, TCompare>(
-		keySelector:Selector<T, TKey>, elementSelector:SelectorWithIndex<T, T>,
-		compareSelector?:Selector<TKey, TCompare>):ILinqEnumerable<IGrouping<TKey, T>>;
-	groupBy<TKey, TCompare>(
-		keySelector:SelectorWithIndex<T, TKey>, elementSelector:Selector<T, T>,
-		compareSelector?:Selector<TKey, TCompare>):ILinqEnumerable<IGrouping<TKey, T>>;
-	groupBy<TKey, TCompare>(
+	groupBy<TKey>(
 		keySelector:SelectorWithIndex<T, TKey>,
 		elementSelector:SelectorWithIndex<T, T>,
-		compareSelector?:Selector<TKey, TCompare>):ILinqEnumerable<IGrouping<TKey, T>>;
-	groupBy<TKey, TElement, TCompare>(
-		keySelector:Selector<T, TKey>,
-		elementSelector:Selector<T, TElement>,
-		compareSelector?:Selector<TKey, TCompare>):ILinqEnumerable<IGrouping<TKey, TElement>>;
-	groupBy<TKey, TElement, TCompare>(
-		keySelector:Selector<T, TKey>,
-		elementSelector:SelectorWithIndex<T, TElement>,
-		compareSelector?:Selector<TKey, TCompare>):ILinqEnumerable<IGrouping<TKey, TElement>>;
-	groupBy<TKey, TElement, TCompare>(
+		compareSelector?:Selector<TKey, string|number|symbol>):ILinqEnumerable<IGrouping<TKey, T>>;
+	groupBy<TKey, TElement>(
 		keySelector:SelectorWithIndex<T, TKey>,
-		elementSelector:Selector<T, TElement>,
-		compareSelector?:Selector<TKey, TCompare>):ILinqEnumerable<IGrouping<TKey, TElement>>;
-	groupBy<TKey, TElement, TCompare>(
-		keySelector:SelectorWithIndex<T, TKey>,
 		elementSelector:SelectorWithIndex<T, TElement>,
-		compareSelector?:Selector<TKey, TCompare>):ILinqEnumerable<IGrouping<TKey, TElement>>;
+		compareSelector?:Selector<TKey, string|number|symbol>):ILinqEnumerable<IGrouping<TKey, TElement>>;
 	partitionBy<TKey>(keySelector:Selector<T, TKey>):ILinqEnumerable<IGrouping<TKey, T>>;
-	partitionBy<TKey, TElement, TCompare>(
-		keySelector:Selector<T, TKey>,
-		elementSelector?:Selector<T, TElement>,
+	partitionBy<TKey, TElement>(
+		keySelector:Selector<T,TKey>,
+		elementSelector?:Selector<T,TElement>,
 		resultSelector?:(key:TKey, element:TElement[]) => IGrouping<TKey, TElement>,
-		compareSelector?:Selector<TKey, TCompare>):ILinqEnumerable<IGrouping<TKey, TElement>>;
+		compareSelector?:Selector<TKey, any>):ILinqEnumerable<IGrouping<TKey, TElement>>;
 	aggregate(func:(a:T, b:T) => T, seed?:T):T | undefined;
@@ -272,9 +193,6 @@ average(selector:Selector<T, number>):number;
 	min():T | undefined;
-	maxBy<TCompare>(keySelector?:Selector<T, TCompare>):T | undefined;
-	minBy<TCompare>(keySelector?:Selector<T, TCompare>):T | undefined;
-	sum(selector:Selector<T, number>):number;
+	maxBy(keySelector?:Selector<T, Primitive>):T | undefined;
+	minBy(keySelector?:Selector<T, Primitive>):T | undefined;
 	sum(selector?:SelectorWithIndex<T, number>):number;
-	product(selector:Selector<T, number>):number;
 	product(selector?:SelectorWithIndex<T, number>):number;
-	quotient(selector:Selector<T, number>):number;
 	quotient(selector?:SelectorWithIndex<T, number>):number;
@@ -281,0 +199,0 @@ last():T;

System.Linq/Linq.d.ts

@@ -8,3 +8,3 @@ /*!
 import { IEnumerator } from "../System/Collections/Enumeration/IEnumerator";
-import { Action, Predicate, Selector, EqualityComparison, Comparison, Closure, ActionWithIndex, PredicateWithIndex, SelectorWithIndex } from "../System/FunctionTypes";
+import { Action, Selector, EqualityComparison, Comparison, Closure, ActionWithIndex, PredicateWithIndex, SelectorWithIndex } from "../System/FunctionTypes";
 import { IEnumerableOrArray } from "../System/Collections/IEnumerableOrArray";
@@ -16,2 +16,3 @@ import { IArray } from "../System/Collections/Array/IArray";
 import { EnumerableAction } from "./EnumerableAction";
+import { Primitive } from "../System/Primitive";
 export declare class InfiniteEnumerable<T> extends DisposableBase implements IInfiniteEnumerable<T> {
@@ -25,3 +26,2 @@ protected _enumeratorFactory: () => IEnumerator<T>;
     asEnumerable(): this;
-    doAction(action: Action<T> | Predicate<T> | Selector<T, number> | Selector<T, EnumerableAction>, initializer?: Closure | null, isEndless?: boolean | null | undefined): this;
     doAction(action: ActionWithIndex<T> | PredicateWithIndex<T> | SelectorWithIndex<T, number> | SelectorWithIndex<T, EnumerableAction>, initializer?: Closure | null, isEndless?: boolean | null | undefined): this;
@@ -44,11 +44,7 @@ force(): void;
     traverseBreadthFirst<TNode>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode> | null | undefined): Enumerable<TNode>;
-    traverseBreadthFirst<TResult>(childrenSelector: (element: T) => IEnumerableOrArray<T> | null | undefined, resultSelector: Selector<T, TResult>): Enumerable<TResult>;
     traverseBreadthFirst<TResult>(childrenSelector: (element: T) => IEnumerableOrArray<T> | null | undefined, resultSelector: SelectorWithIndex<T, TResult>): Enumerable<TResult>;
-    traverseBreadthFirst<TNode, TResult>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode> | null | undefined, resultSelector: Selector<T, TResult>): Enumerable<TResult>;
     traverseBreadthFirst<TNode, TResult>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode> | null | undefined, resultSelector: SelectorWithIndex<T, TResult>): Enumerable<TResult>;
     traverseDepthFirst(childrenSelector: (element: T) => IEnumerableOrArray<T> | null | undefined): Enumerable<T>;
     traverseDepthFirst<TNode>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode> | null | undefined): Enumerable<TNode>;
-    traverseDepthFirst<TResult>(childrenSelector: (element: T) => IEnumerableOrArray<T> | null | undefined, resultSelector: Selector<T, TResult>): Enumerable<TResult>;
     traverseDepthFirst<TResult>(childrenSelector: (element: T) => IEnumerableOrArray<T> | null | undefined, resultSelector: SelectorWithIndex<T, TResult>): Enumerable<TResult>;
-    traverseDepthFirst<TNode, TResult>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode> | null | undefined, resultSelector: Selector<T, TResult>): Enumerable<TResult>;
     traverseDepthFirst<TNode, TResult>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode> | null | undefined, resultSelector: SelectorWithIndex<T, TResult>): Enumerable<TResult>;
@@ -58,7 +54,4 @@ flatten(): Enumerable<any>;
     scan(func: (a: T, b: T) => T, seed?: T): this;
-    select<TResult>(selector: Selector<T, TResult>): InfiniteEnumerable<TResult>;
     select<TResult>(selector: SelectorWithIndex<T, TResult>): InfiniteEnumerable<TResult>;
     protected _selectMany<TElement, TResult>(collectionSelector: SelectorWithIndex<T, IEnumerableOrArray<TElement> | null | undefined>, resultSelector?: (collection: T, element: TElement) => TResult): Enumerable<TResult>;
-    selectMany<TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TResult> | null | undefined>): InfiniteEnumerable<TResult>;
-    selectMany<TElement, TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TElement> | null | undefined>, resultSelector: (collection: T, element: TElement) => TResult): InfiniteEnumerable<TResult>;
     selectMany<TResult>(collectionSelector: SelectorWithIndex<T, IEnumerableOrArray<TResult> | null | undefined>): InfiniteEnumerable<TResult>;
@@ -69,3 +62,2 @@ selectMany<TElement, TResult>(collectionSelector: SelectorWithIndex<T, IEnumerableOrArray<TElement> | null | undefined>, resultSelector: (collection: T, element: TElement) => TResult): InfiniteEnumerable<TResult>;
     choose<TResult>(selector?: Selector<T, TResult>): InfiniteEnumerable<TResult>;
-    where(predicate: Predicate<T>): this;
     where(predicate: PredicateWithIndex<T>): this;
@@ -75,15 +67,13 @@ ofType<TType>(type: {
     }): InfiniteEnumerable<TType>;
-    except<TCompare>(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, TCompare>): this;
-    distinct(compareSelector?: (value: T) => T): this;
-    distinctUntilChanged<TCompare>(compareSelector?: Selector<T, TCompare>): this;
+    except(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, string | number | symbol>): this;
+    distinct(compareSelector?: Selector<T, string | number | symbol>): this;
+    distinctUntilChanged(compareSelector?: Selector<T, any>): this;
     defaultIfEmpty(defaultValue?: T): this;
-    zip<TSecond, TResult>(second: IEnumerableOrArray<TSecond>, resultSelector: (first: T, second: TSecond) => TResult): Enumerable<TResult>;
     zip<TSecond, TResult>(second: IEnumerableOrArray<TSecond>, resultSelector: (first: T, second: TSecond, index: number) => TResult): Enumerable<TResult>;
-    zipMultiple<TSecond, TResult>(second: IArray<IEnumerableOrArray<TSecond>>, resultSelector: (first: T, second: TSecond) => TResult): Enumerable<TResult>;
     zipMultiple<TSecond, TResult>(second: IArray<IEnumerableOrArray<TSecond>>, resultSelector: (first: T, second: TSecond, index: number) => TResult): Enumerable<TResult>;
-    join<TInner, TKey, TResult, TCompare>(inner: IEnumerableOrArray<TInner>, outerKeySelector: Selector<T, TKey>, innerKeySelector: Selector<TInner, TKey>, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: Selector<TKey, TCompare>): Enumerable<TResult>;
-    groupJoin<TInner, TKey, TResult, TCompare>(inner: IEnumerableOrArray<TInner>, outerKeySelector: Selector<T, TKey>, innerKeySelector: Selector<TInner, TKey>, resultSelector: (outer: T, inner: TInner[] | null) => TResult, compareSelector?: Selector<TKey, TCompare>): Enumerable<TResult>;
+    join<TInner, TKey, TResult>(inner: IEnumerableOrArray<TInner>, outerKeySelector: Selector<T, TKey>, innerKeySelector: Selector<TInner, TKey>, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: Selector<TKey, string | number | symbol>): Enumerable<TResult>;
+    groupJoin<TInner, TKey, TResult>(inner: IEnumerableOrArray<TInner>, outerKeySelector: Selector<T, TKey>, innerKeySelector: Selector<TInner, TKey>, resultSelector: (outer: T, inner: TInner[] | null) => TResult, compareSelector?: Selector<TKey, string | number | symbol>): Enumerable<TResult>;
     merge(enumerables: IArray<IEnumerableOrArray<T>>): this;
     concat(...enumerables: Array<IEnumerableOrArray<T>>): this;
-    union<TCompare>(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, TCompare>): this;
+    union(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, string | number | symbol>): this;
     insertAt(index: number, other: IEnumerableOrArray<T>): this;
@@ -101,51 +91,31 @@ alternateMultiple(sequence: IEnumerableOrArray<T>): this;
     asEnumerable(): this;
-    skipWhile(predicate: Predicate<T>): this;
     skipWhile(predicate: PredicateWithIndex<T>): this;
-    takeWhile(predicate: Predicate<T>): this;
     takeWhile(predicate: PredicateWithIndex<T>): this;
-    takeUntil(predicate: Predicate<T>, includeUntilValue?: boolean): this;
     takeUntil(predicate: PredicateWithIndex<T>, includeUntilValue?: boolean): this;
-    forEach(action: Action<T>, max?: number): number;
-    forEach(action: Predicate<T>, max?: number): number;
     forEach(action: ActionWithIndex<T>, max?: number): number;
     forEach(action: PredicateWithIndex<T>, max?: number): number;
-    toArray(predicate?: Predicate<T>): T[];
     toArray(predicate?: PredicateWithIndex<T>): T[];
     copyTo(target: T[], index?: number, count?: number): T[];
-    toLookup<TKey, TValue, TCompare>(keySelector: Selector<T, TKey>, elementSelector: Selector<T, TValue>, compareSelector?: Selector<TKey, TCompare>): ILookup<TKey, TValue>;
-    toLookup<TKey, TValue, TCompare>(keySelector: Selector<T, TKey>, elementSelector: SelectorWithIndex<T, TValue>, compareSelector?: Selector<TKey, TCompare>): ILookup<TKey, TValue>;
-    toLookup<TKey, TValue, TCompare>(keySelector: SelectorWithIndex<T, TKey>, elementSelector: Selector<T, TValue>, compareSelector?: Selector<TKey, TCompare>): ILookup<TKey, TValue>;
-    toLookup<TKey, TValue, TCompare>(keySelector: SelectorWithIndex<T, TKey>, elementSelector?: SelectorWithIndex<T, TValue>, compareSelector?: Selector<TKey, TCompare>): ILookup<TKey, TValue>;
-    toMap<TResult>(keySelector: Selector<T, string>, elementSelector: Selector<T, TResult>): IMap<TResult>;
-    toDictionary<TKey, TValue, TCompare>(keySelector: SelectorWithIndex<T, TKey> | Selector<T, TKey>, elementSelector: SelectorWithIndex<T, TValue> | Selector<T, TValue>, compareSelector?: Selector<TKey, TCompare>): IDictionary<TKey, TValue>;
+    toLookup<TKey, TValue>(keySelector: SelectorWithIndex<T, TKey>, elementSelector?: SelectorWithIndex<T, TValue>, compareSelector?: Selector<TKey, string | number | symbol>): ILookup<TKey, TValue>;
+    toMap<TResult>(keySelector: SelectorWithIndex<T, string | number | symbol>, elementSelector: SelectorWithIndex<T, TResult>): IMap<TResult>;
+    toDictionary<TKey, TValue>(keySelector: SelectorWithIndex<T, TKey>, elementSelector: SelectorWithIndex<T, TValue>, compareSelector?: Selector<TKey, string | number | symbol>): IDictionary<TKey, TValue>;
     toJoinedString(separator?: string, selector?: Selector<T, string>): string;
     takeExceptLast(count?: number): this;
     skipToLast(count: number): this;
-    select<TResult>(selector: Selector<T, TResult>): Enumerable<TResult>;
     select<TResult>(selector: SelectorWithIndex<T, TResult>): Enumerable<TResult>;
-    selectMany<TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TResult> | null | undefined>): Enumerable<TResult>;
-    selectMany<TElement, TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TElement> | null | undefined>, resultSelector: (collection: T, element: TElement) => TResult): Enumerable<TResult>;
     selectMany<TResult>(collectionSelector: SelectorWithIndex<T, IEnumerableOrArray<TResult> | null | undefined>): Enumerable<TResult>;
     selectMany<TElement, TResult>(collectionSelector: SelectorWithIndex<T, IEnumerableOrArray<TElement> | null | undefined>, resultSelector: (collection: T, element: TElement) => TResult): Enumerable<TResult>;
     choose(): Enumerable<T>;
-    choose<TResult>(selector: Selector<T, TResult>): Enumerable<TResult>;
     choose<TResult>(selector: SelectorWithIndex<T, TResult>): Enumerable<TResult>;
     reverse(): this;
     shuffle(): this;
-    count(predicate: Predicate<T>): number;
     count(predicate?: PredicateWithIndex<T>): number;
-    all(predicate: Predicate<T>): boolean;
     all(predicate: PredicateWithIndex<T>): boolean;
-    every(predicate: Predicate<T>): boolean;
     every(predicate: PredicateWithIndex<T>): boolean;
-    any(predicate: Predicate<T>): boolean;
     any(predicate?: PredicateWithIndex<T>): boolean;
-    some(predicate: Predicate<T>): boolean;
     some(predicate?: PredicateWithIndex<T>): boolean;
-    contains<TCompare>(value: T, compareSelector?: Selector<T, TCompare>): boolean;
-    indexOf<TCompare>(value: T, compareSelector: Selector<T, TCompare>): number;
-    indexOf<TCompare>(value: T, compareSelector?: SelectorWithIndex<T, TCompare>): number;
-    lastIndexOf<TCompare>(value: T, compareSelector: Selector<T, TCompare>): number;
-    lastIndexOf<TCompare>(value: T, compareSelector?: SelectorWithIndex<T, TCompare>): number;
-    intersect<TCompare>(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, TCompare>): this;
+    contains(value: T, compareSelector?: Selector<T, any>): boolean;
+    indexOf(value: T, compareSelector?: SelectorWithIndex<T, any>): number;
+    lastIndexOf(value: T, compareSelector?: SelectorWithIndex<T, any>): number;
+    intersect(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, string | number | symbol>): this;
     sequenceEqual(second: IEnumerableOrArray<T>, equalityComparer?: EqualityComparison<T>): boolean;
@@ -160,26 +130,15 @@ ofType<TType>(type: {
     buffer(size: number): Enumerable<T[]>;
-    groupBy<TKey>(keySelector: Selector<T, TKey>): Enumerable<IGrouping<TKey, T>>;
     groupBy<TKey>(keySelector: SelectorWithIndex<T, TKey>): Enumerable<IGrouping<TKey, T>>;
-    groupBy<TKey, TCompare>(keySelector: Selector<T, TKey>, elementSelector: Selector<T, T>, compareSelector?: Selector<TKey, TCompare>): Enumerable<IGrouping<TKey, T>>;
-    groupBy<TKey, TCompare>(keySelector: Selector<T, TKey>, elementSelector: SelectorWithIndex<T, T>, compareSelector?: Selector<TKey, TCompare>): Enumerable<IGrouping<TKey, T>>;
-    groupBy<TKey, TCompare>(keySelector: SelectorWithIndex<T, TKey>, elementSelector: Selector<T, T>, compareSelector?: Selector<TKey, TCompare>): Enumerable<IGrouping<TKey, T>>;
-    groupBy<TKey, TCompare>(keySelector: SelectorWithIndex<T, TKey>, elementSelector: SelectorWithIndex<T, T>, compareSelector?: Selector<TKey, TCompare>): Enumerable<IGrouping<TKey, T>>;
-    groupBy<TKey, TElement, TCompare>(keySelector: Selector<T, TKey>, elementSelector: Selector<T, TElement>, compareSelector?: Selector<TKey, TCompare>): Enumerable<IGrouping<TKey, TElement>>;
-    groupBy<TKey, TElement, TCompare>(keySelector: Selector<T, TKey>, elementSelector: SelectorWithIndex<T, TElement>, compareSelector?: Selector<TKey, TCompare>): Enumerable<IGrouping<TKey, TElement>>;
-    groupBy<TKey, TElement, TCompare>(keySelector: SelectorWithIndex<T, TKey>, elementSelector: Selector<T, TElement>, compareSelector?: Selector<TKey, TCompare>): Enumerable<IGrouping<TKey, TElement>>;
-    groupBy<TKey, TElement, TCompare>(keySelector: SelectorWithIndex<T, TKey>, elementSelector: SelectorWithIndex<T, TElement>, compareSelector?: Selector<TKey, TCompare>): Enumerable<IGrouping<TKey, TElement>>;
+    groupBy<TKey>(keySelector: SelectorWithIndex<T, TKey>, elementSelector: SelectorWithIndex<T, T>, compareSelector?: Selector<TKey, string | number | symbol>): Enumerable<IGrouping<TKey, T>>;
+    groupBy<TKey, TElement>(keySelector: SelectorWithIndex<T, TKey>, elementSelector: SelectorWithIndex<T, TElement>, compareSelector?: Selector<TKey, string | number | symbol>): Enumerable<IGrouping<TKey, TElement>>;
     partitionBy<TKey>(keySelector: Selector<T, TKey>): Enumerable<IGrouping<TKey, T>>;
-    partitionBy<TKey, TElement, TCompare>(keySelector: Selector<T, TKey>, elementSelector?: Selector<T, TElement>, resultSelector?: (key: TKey, element: TElement[]) => IGrouping<TKey, TElement>, compareSelector?: Selector<TKey, TCompare>): Enumerable<IGrouping<TKey, TElement>>;
+    partitionBy<TKey, TElement>(keySelector: Selector<T, TKey>, elementSelector?: Selector<T, TElement>, resultSelector?: (key: TKey, element: TElement[]) => IGrouping<TKey, TElement>, compareSelector?: Selector<TKey, any>): Enumerable<IGrouping<TKey, TElement>>;
     aggregate(func: (a: T, b: T) => T, seed?: T): T | undefined;
-    average(selector: Selector<T, number>): number;
     average(selector?: SelectorWithIndex<T, number>): number;
     max(): T | undefined;
     min(): T | undefined;
-    maxBy<TCompare>(keySelector?: Selector<T, TCompare>): T | undefined;
-    minBy<TCompare>(keySelector?: Selector<T, TCompare>): T | undefined;
-    sum(selector: Selector<T, number>): number;
+    maxBy(keySelector?: Selector<T, Primitive>): T | undefined;
+    minBy(keySelector?: Selector<T, Primitive>): T | undefined;
     sum(selector?: SelectorWithIndex<T, number>): number;
-    product(selector: Selector<T, number>): number;
     product(selector?: SelectorWithIndex<T, number>): number;
-    quotient(selector: Selector<T, number>): number;
     quotient(selector?: SelectorWithIndex<T, number>): number;
@@ -222,9 +181,6 @@ last(): T;
     function generate<T>(factory: (index: number) => T, count: number): FiniteEnumerable<T>;
-    function unfold<T>(seed: T, valueFactory: Selector<T, T>, skipSeed?: Boolean): InfiniteEnumerable<T>;
     function unfold<T>(seed: T, valueFactory: SelectorWithIndex<T, T>, skipSeed?: Boolean): InfiniteEnumerable<T>;
-    function forEach<T>(e: IEnumerableOrArray<T>, action: Action<T>, max?: number): number;
     function forEach<T>(e: IEnumerableOrArray<T>, action: ActionWithIndex<T>, max?: number): number;
     function forEach<T>(e: IEnumerableOrArray<T>, action: PredicateWithIndex<T>, max?: number): number;
-    function forEach<T>(e: IEnumerableOrArray<T>, action: PredicateWithIndex<T>, max?: number): number;
-    function map<T, TResult>(enumerable: IEnumerableOrArray<T>, selector: Selector<T, TResult>): TResult[];
+    function map<T, TResult>(enumerable: IEnumerableOrArray<T>, selector: SelectorWithIndex<T, TResult>): TResult[];
     function max(values: FiniteEnumerable<number>): number;
@@ -231,0 +187,0 @@ function min(values: FiniteEnumerable<number>): number;

System/Collections/CollectionBase.d.ts

@@ -9,3 +9,3 @@ /*!
 import { IEnumerateEach } from "./Enumeration/IEnumerateEach";
-import { EqualityComparison, Predicate, Action, PredicateWithIndex, ActionWithIndex } from "../FunctionTypes";
+import { EqualityComparison, Action, PredicateWithIndex, ActionWithIndex } from "../FunctionTypes";
 import { IEnumerableOrArray } from "./IEnumerableOrArray";
@@ -42,4 +42,2 @@ import { IArray } from "./Array/IArray";
     contains(entry: T): boolean;
-    forEach(action: Action<T>, useCopy?: boolean): number;
-    forEach(action: Predicate<T>, useCopy?: boolean): number;
     forEach(action: ActionWithIndex<T>, useCopy?: boolean): number;
@@ -46,0 +44,0 @@ forEach(action: PredicateWithIndex<T>, useCopy?: boolean): number;

System/Collections/Dictionaries/Dictionary.d.ts

@@ -14,6 +14,6 @@ /*!
 export declare class Dictionary<TKey, TValue> extends DictionaryBase<TKey, TValue> {
-    private _keyComparer;
     private readonly _entries;
     private readonly _buckets;
-    constructor(_keyComparer?: Selector<TKey, any>);
+    private readonly _keyGenerator;
+    constructor(keyGenerator?: Selector<TKey, string | number | symbol>);
     protected _onDispose(): void;
@@ -20,0 +20,0 @@ protected getCount(): number;

System/Collections/Dictionaries/Dictionary.js

@@ -8,6 +8,6 @@ /*!
 import { Type } from "../../Types";
-import { Functions } from "../../Functions";
 import { EnumeratorBase } from "../Enumeration/EnumeratorBase";
 import { LinkedNodeList } from "../LinkedNodeList";
 import { ObjectPool } from "../../Disposable/ObjectPool";
+import { getIdentifier } from "./getIdentifier";
 import DictionaryBase from "./DictionaryBase";
@@ -34,22 +34,6 @@ import __extendsImport from "../../../extends";
 }
-function callHasOwnProperty(target, key) {
-    return Object.prototype.hasOwnProperty.call(target, key);
-}
-const NULL = "null", GET_HASH_CODE = "getHashCode";
-function getHashString(obj) {
-    if (obj === null)
-        return NULL;
-    if (obj === VOID0)
-        return Type.UNDEFINED;
-    if (Type.hasMemberOfType(obj, GET_HASH_CODE, Type.FUNCTION)) {
-        return obj.getHashCode();
-    }
-    return (typeof obj.toString == Type.FUNCTION)
-        ? obj.toString()
-        : Object.prototype.toString.call(obj);
-}
 export class Dictionary extends DictionaryBase {
-    constructor(_keyComparer = Functions.Identity) {
+    constructor(keyGenerator) {
         super();
-        this._keyComparer = _keyComparer;
+        this._keyGenerator = keyGenerator;
         this._entries = linkedNodeList();
@@ -60,4 +44,6 @@ this._buckets = {};
         super._onDispose();
-        this._entries = null;
-        this._buckets = null;
+        const _ = this;
+        _._entries = null;
+        _._buckets = null;
+        _._hashGenerator = null;
     }
@@ -70,4 +56,6 @@ getCount() {
             return null;
+        if (!Type.isPrimitiveOrSymbol(hash))
+            console.warn("Key type not indexable and could cause Dictionary to be extremely slow.");
         var buckets = this._buckets;
-        var bucket = callHasOwnProperty(buckets, hash) ? buckets[hash] : VOID0;
+        var bucket = buckets[hash];
         if (createIfMissing && !bucket)
@@ -82,7 +70,9 @@ buckets[hash]
             return null;
-        var _ = this, comparer = _._keyComparer, compareKey = comparer(key);
+        var _ = this, comparer = _._keyGenerator, compareKey = comparer ? comparer(key) : key;
         if (!bucket)
-            bucket = _._getBucket(hash || getHashString(compareKey));
+            bucket = _._getBucket(hash || getIdentifier(compareKey));
         return bucket
-            && bucket.find(e => comparer(e.key) === compareKey);
+            && (comparer
+                ? bucket.find(e => comparer(e.key) === compareKey)
+                : bucket.find(e => e.key === compareKey));
     }
@@ -99,3 +89,3 @@ _getEntry(key) {
         const _ = this;
-        var buckets = _._buckets, entries = _._entries, comparer = _._keyComparer, compareKey = comparer(key), hash = getHashString(compareKey), bucket = _._getBucket(hash), bucketEntry = bucket && _._getBucketEntry(key, hash, bucket);
+        var buckets = _._buckets, entries = _._entries, compareKey = _._keyGenerator ? _._keyGenerator(key) : key, hash = getIdentifier(compareKey), bucket = _._getBucket(hash), bucketEntry = bucket && _._getBucketEntry(key, hash, bucket);
         if (bucketEntry) {
@@ -102,0 +92,0 @@ var b = bucket;

System/Collections/Dictionaries/IDictionary.d.ts

@@ -16,5 +16,10 @@ /*!
 {
-	getHashCode():string;
+	getHashCode():string|number;
 }
 
+export interface ISymbolizable
+{
+	getSymbol():symbol;
+}
+
 export interface IMap<TValue>
@@ -21,0 +26,0 @@ {

System/Collections/Enumeration/EmptyEnumerator.js

@@ -11,2 +11,3 @@ /*!
     moveNext: Functions.False,
+    tryMoveNext: Functions.False,
     nextValue: Functions.Blank,
@@ -13,0 +14,0 @@ next: IteratorResult.GetDone,

System/Collections/Enumeration/Enumerator.d.ts

@@ -5,3 +5,3 @@ /*!
  */
-import { Selector, SelectorWithIndex, Action, Predicate, ActionWithIndex, PredicateWithIndex } from "../../FunctionTypes";
+import { SelectorWithIndex, ActionWithIndex, PredicateWithIndex } from "../../FunctionTypes";
 import { IEnumerator } from "./IEnumerator";
@@ -18,8 +18,5 @@ import { IEnumerable } from "./IEnumerable";
 export declare function isIterator<T>(instance: any): instance is IIterator<T>;
-export declare function forEach<T>(e: IEnumerableOrArray<T> | IEnumerator<T> | IIterator<T>, action: Action<T>, max?: number): number;
 export declare function forEach<T>(e: IEnumerableOrArray<T> | IEnumerator<T> | IIterator<T>, action: ActionWithIndex<T>, max?: number): number;
-export declare function forEach<T>(e: IEnumerableOrArray<T> | IEnumerator<T> | IIterator<T>, action: Predicate<T>, max?: number): number;
 export declare function forEach<T>(e: IEnumerableOrArray<T> | IEnumerator<T> | IIterator<T>, action: PredicateWithIndex<T>, max?: number): number;
 export declare function toArray<T>(source: IEnumerableOrArray<T> | IEnumerator<T>, max?: number): T[];
-export declare function map<T, TResult>(source: IEnumerableOrArray<T> | IEnumerator<T>, selector: Selector<T, TResult>, max?: number): TResult[];
 export declare function map<T, TResult>(source: IEnumerableOrArray<T> | IEnumerator<T>, selector: SelectorWithIndex<T, TResult>, max?: number): TResult[];

System/Collections/Enumeration/EnumeratorBase.d.ts

@@ -9,3 +9,3 @@ /*!
 import { IYield } from "./IYield";
-import { Closure } from "../../FunctionTypes";
+import { Closure, Action } from "../../FunctionTypes";
 export declare class EnumeratorBase<T> extends DisposableBase implements IEnumerator<T> {
@@ -25,3 +25,6 @@ private _initializer;
     private _assertBadState();
+    tryGetCurrent(out: Action<T>): boolean;
+    readonly canMoveNext: boolean;
     moveNext(): boolean;
+    tryMoveNext(out: Action<T>): boolean;
     nextValue(): T | undefined;
@@ -28,0 +31,0 @@ next(): IIteratorResult<T>;

System/Collections/Enumeration/EnumeratorBase.js

@@ -45,11 +45,2 @@ /*!
 }
-var EnumeratorState;
-(function (EnumeratorState) {
-    EnumeratorState[EnumeratorState["Before"] = 0] = "Before";
-    EnumeratorState[EnumeratorState["Running"] = 1] = "Running";
-    EnumeratorState[EnumeratorState["Completed"] = 2] = "Completed";
-    EnumeratorState[EnumeratorState["Faulted"] = 3] = "Faulted";
-    EnumeratorState[EnumeratorState["Interrupted"] = 4] = "Interrupted";
-    EnumeratorState[EnumeratorState["Disposed"] = 5] = "Disposed";
-})(EnumeratorState || (EnumeratorState = {}));
 export class EnumeratorBase extends DisposableBase {
@@ -74,3 +65,3 @@ constructor(_initializer, _tryGetNext, disposer, isEndless) {
         var y = this._yielder;
-        return y && y.index;
+        return y ? y.index : NaN;
     }
@@ -85,3 +76,3 @@ get isEndless() {
         _._yielder = null;
-        _._state = EnumeratorState.Before;
+        _._state = 0;
         if (y)
@@ -93,6 +84,6 @@ yielder(y);
         switch (_._state) {
-            case EnumeratorState.Faulted:
+            case 3:
                 _.throwIfDisposed("This enumerator caused a fault and was disposed.");
                 break;
-            case EnumeratorState.Disposed:
+            case 5:
                 _.throwIfDisposed("This enumerator was manually disposed.");
@@ -102,2 +93,13 @@ break;
     }
+    tryGetCurrent(out) {
+        this._assertBadState();
+        if (this._state === 1) {
+            out(this.current);
+            return true;
+        }
+        return false;
+    }
+    get canMoveNext() {
+        return this._state < 2;
+    }
     moveNext() {
@@ -108,9 +110,9 @@ const _ = this;
             switch (_._state) {
-                case EnumeratorState.Before:
+                case 0:
                     _._yielder = _._yielder || yielder();
-                    _._state = EnumeratorState.Running;
+                    _._state = 1;
                     var initializer = _._initializer;
                     if (initializer)
                         initializer();
-                case EnumeratorState.Running:
+                case 1:
                     if (_._tryGetNext(_._yielder)) {
@@ -121,3 +123,3 @@ return true;
                         this.dispose();
-                        _._state = EnumeratorState.Completed;
+                        _._state = 2;
                         return false;
@@ -131,6 +133,13 @@ }
             this.dispose();
-            _._state = EnumeratorState.Faulted;
+            _._state = 3;
             throw e;
         }
     }
+    tryMoveNext(out) {
+        if (this.moveNext()) {
+            out(this.current);
+            return true;
+        }
+        return false;
+    }
     nextValue() {
@@ -147,3 +156,3 @@ return this.moveNext()
     end() {
-        this._ensureDisposeState(EnumeratorState.Interrupted);
+        this._ensureDisposeState(4);
     }
@@ -154,3 +163,3 @@ 'return'(value) {
         try {
-            return value === VOID0 || _._state === EnumeratorState.Completed || _._state === EnumeratorState.Interrupted
+            return value === VOID0 || _._state === 2 || _._state === 4
                 ? IteratorResult.Done
@@ -178,3 +187,3 @@ : new IteratorResult(value, VOID0, true);
         _._yielder = null;
-        this._state = EnumeratorState.Disposed;
+        this._state = 5;
         if (y)
@@ -181,0 +190,0 @@ yielder(y);

System/Collections/Enumeration/IEnumerateEach.d.ts

@@ -11,4 +11,2 @@ /*!
 	// Enforcing an interface that allows operating on a copy can prevent changing underlying data while enumerating.
-	forEach(action:Action<T>, useCopy?:boolean):number;
-	forEach(action:Predicate<T>, useCopy?:boolean):number;
 	forEach(action:ActionWithIndex<T>, useCopy?:boolean):number;
@@ -15,0 +13,0 @@ forEach(action:PredicateWithIndex<T>, useCopy?:boolean):number;

System/Collections/Enumeration/IEnumerator.d.ts

@@ -20,2 +20,7 @@ /*!
 	/**
+	 * Will indicate if moveNext is safe.
+	 */
+	canMoveNext?:boolean;
+
+	/**
 	 * Safely moves to the next entry and returns true if there is one.
@@ -26,2 +31,7 @@ */
 	/**
+	 * Moves to the next entry and emits the value through the out callback.
+	 */
+	tryMoveNext(out:(value:T)=>void):boolean;
+
+	/**
 	 * Restarts the enumeration.
@@ -28,0 +38,0 @@ */

System/Collections/Enumeration/InfiniteEnumerator.d.ts

@@ -12,3 +12,3 @@ /*!
     constructor(_factory: InfiniteValueFactory<T>);
-    protected canMoveNext(): boolean;
+    protected _canMoveNext(): boolean;
     moveNext(): boolean;
@@ -15,0 +15,0 @@ dispose(): void;

System/Collections/Enumeration/InfiniteEnumerator.js

@@ -13,3 +13,3 @@ /*!
     }
-    canMoveNext() {
+    _canMoveNext() {
         return this._factory != null;
@@ -16,0 +16,0 @@ }

System/Collections/Enumeration/IteratorEnumerator.d.ts

@@ -11,3 +11,3 @@ /*!
     constructor(_iterator: IIterator<T>, _isEndless?: boolean);
-    protected canMoveNext(): boolean;
+    protected _canMoveNext(): boolean;
     moveNext(value?: any): boolean;
@@ -14,0 +14,0 @@ dispose(): void;

System/Collections/Enumeration/IteratorEnumerator.js

@@ -14,3 +14,3 @@ /*!
     }
-    canMoveNext() {
+    _canMoveNext() {
         return this._iterator != null;
@@ -17,0 +17,0 @@ }

System/Collections/Enumeration/SimpleEnumerableBase.d.ts

@@ -7,2 +7,3 @@ /*!
 import { IEnumerator } from "./IEnumerator";
+import { Action } from "../../FunctionTypes";
 export declare abstract class SimpleEnumerableBase<T> implements IEnumerator<T> {
@@ -13,4 +14,6 @@ protected _current: T | undefined;
     readonly current: T | undefined;
-    protected abstract canMoveNext(): boolean;
+    protected abstract _canMoveNext(): boolean;
+    readonly canMoveNext: boolean;
     abstract moveNext(): boolean;
+    tryMoveNext(out: Action<T>): boolean;
     protected incrementIndex(): number;
@@ -17,0 +20,0 @@ nextValue(): T | undefined;

System/Collections/Enumeration/SimpleEnumerableBase.js

@@ -14,2 +14,12 @@ /*!
     }
+    get canMoveNext() {
+        return this._canMoveNext();
+    }
+    tryMoveNext(out) {
+        if (this.moveNext()) {
+            out(this._current);
+            return true;
+        }
+        return false;
+    }
     incrementIndex() {
@@ -34,3 +44,3 @@ let i = this._index;
         try {
-            return value !== VOID0 && this.canMoveNext()
+            return value !== VOID0 && this._canMoveNext()
                 ? new IteratorResult(value, VOID0, true)
@@ -51,3 +61,3 @@ : IteratorResult.Done;
     getIsEndless() {
-        return this.canMoveNext();
+        return this._canMoveNext();
     }
@@ -54,0 +64,0 @@ get isEndless() {

System/Collections/List.d.ts

@@ -6,3 +6,3 @@ /*!
 import { CollectionBase } from "./CollectionBase";
-import { Predicate, Action, EqualityComparison, ActionWithIndex, PredicateWithIndex } from "../FunctionTypes";
+import { EqualityComparison, ActionWithIndex, PredicateWithIndex } from "../FunctionTypes";
 import { IEnumerator } from "./Enumeration/IEnumerator";
@@ -30,4 +30,2 @@ import { IList } from "./IList";
     getEnumerator(): IEnumerator<T>;
-    forEach(action: Action<T>, useCopy?: boolean): number;
-    forEach(action: Predicate<T>, useCopy?: boolean): number;
     forEach(action: ActionWithIndex<T>, useCopy?: boolean): number;
@@ -34,0 +32,0 @@ forEach(action: PredicateWithIndex<T>, useCopy?: boolean): number;

System/Collections/Set.d.ts

@@ -5,15 +5,9 @@ /*!
  */
-import { SetBase } from "./SetBase";
-import { ILinkedNodeWithValue } from "./ILinkedListNode";
+import { ISymbolizable } from "./Dictionaries/IDictionary";
+import { HashSet } from "./HashSet";
 import { Primitive } from "../Primitive";
 import { IEnumerableOrArray } from "./IEnumerableOrArray";
-export declare class Set<T extends Primitive> extends SetBase<T> {
-    protected newUsing(source?: IEnumerableOrArray<T>): Set<T>;
-    private _registry;
-    protected _addInternal(item: T): boolean;
-    protected _clearInternal(): number;
-    protected _onDispose(): void;
-    protected _getNode(item: T): ILinkedNodeWithValue<T>;
-    protected _removeInternal(item: T, max?: number): number;
+export declare class Set<T extends Primitive | ISymbolizable | symbol> extends HashSet<T> {
+    constructor(source?: IEnumerableOrArray<T>);
 }
 export default Set;

System/Collections/Set.js

@@ -6,59 +6,14 @@ /*!
 import { Type } from "../Types";
-import { ArgumentException } from "../Exceptions/ArgumentException";
-import { SetBase } from "./SetBase";
+import { getIdentifier } from "./Dictionaries/getIdentifier";
+import { HashSet } from "./HashSet";
 import __extendsImport from "../../extends";
 const __extends = __extendsImport;
 const OTHER = 'other';
-export class Set extends SetBase {
-    newUsing(source) {
-        return new Set(source);
-    }
-    _addInternal(item) {
-        const _ = this;
-        if (!_.contains(item)) {
-            var type = typeof item;
-            if (!Type.isPrimitive(type))
-                throw new ArgumentException("item", "A Set can only index primitives.  Complex objects require a HashSet.");
-            var r = _._registry || (_._registry = {});
-            var t = r[type] || (r[type] = {});
-            var node = { value: item };
-            _._getSet().addNode(node);
-            t[item] = node;
-            return true;
-        }
-        return false;
-    }
-    _clearInternal() {
-        wipe(this._registry, 2);
-        return super._clearInternal();
-    }
-    _onDispose() {
-        super._onDispose();
-        this._registry = null;
-    }
-    _getNode(item) {
-        var r = this._registry, t = r && r[typeof item];
-        return t && t[item];
-    }
-    _removeInternal(item, max = Infinity) {
-        if (max === 0)
-            return 0;
-        var r = this._registry, t = r && r[typeof item], node = t && t[item];
-        if (node) {
-            delete t[item];
-            var s = this._set;
-            if (s && s.removeNode(node)) {
-                return 1;
-            }
-        }
-        return 0;
-    }
+const VOID0 = void 0;
+function getId(obj) {
+    return getIdentifier(obj, typeof obj != Type.BOOLEAN);
 }
-function wipe(map, depth = 1) {
-    if (map && depth) {
-        for (var key of Object.keys(map)) {
-            var v = map[key];
-            delete map[key];
-            wipe(v, depth - 1);
-        }
+export class Set extends HashSet {
+    constructor(source) {
+        super(source, getId);
     }
@@ -65,0 +20,0 @@ }

System/Collections/SetBase.d.ts

@@ -9,3 +9,3 @@ /*!
 import { ILinkedNodeWithValue } from "./ILinkedListNode";
-import { Predicate, Action, ActionWithIndex, PredicateWithIndex } from "../FunctionTypes";
+import { ActionWithIndex, PredicateWithIndex } from "../FunctionTypes";
 import { IEnumerator } from "./Enumeration/IEnumerator";
@@ -32,7 +32,5 @@ import { IEnumerableOrArray } from "./IEnumerableOrArray";
     protected _onDispose(): void;
-    protected abstract _getNode(item: T): ILinkedNodeWithValue<T>;
+    protected abstract _getNode(item: T): ILinkedNodeWithValue<T> | undefined;
     contains(item: T): boolean;
     getEnumerator(): IEnumerator<T>;
-    forEach(action: Action<T>, useCopy?: boolean): number;
-    forEach(action: Predicate<T>, useCopy?: boolean): number;
     forEach(action: ActionWithIndex<T>, useCopy?: boolean): number;
@@ -39,0 +37,0 @@ forEach(action: PredicateWithIndex<T>, useCopy?: boolean): number;

System/Exceptions/ArgumentNullException.js

@@ -11,3 +11,3 @@ /*!
 export class ArgumentNullException extends ArgumentException {
-    constructor(paramName, message = '', innerException) {
+    constructor(paramName, message = `'${paramName}' is null (or undefined).`, innerException) {
         super(paramName, message, innerException);
@@ -14,0 +14,0 @@ }

System/Text/RegularExpressions.d.ts

@@ -8,3 +8,3 @@ /*!
 import { Primitive } from "../Primitive";
-import { Selector, SelectorWithIndex } from "../FunctionTypes";
+import { SelectorWithIndex } from "../FunctionTypes";
 export declare module RegexOptions {
@@ -31,6 +31,2 @@ const IGNORE_CASE: string;
 }
-export interface MatchEvaluator extends Selector<Match, Primitive> {
-}
-export interface MatchEvaluatorIndexed extends SelectorWithIndex<Match, Primitive> {
-}
 export declare class Regex {
@@ -43,8 +39,7 @@ private _re;
     replace(input: string, replacement: Primitive, count?: number): string;
-    replace(input: string, evaluator: MatchEvaluatorIndexed, count?: number): string;
-    replace(input: string, evaluator: MatchEvaluator, count?: number): string;
+    replace(input: string, evaluator: SelectorWithIndex<Match, Primitive>, count?: number): string;
     isMatch(input: string): boolean;
     static isMatch(input: string, pattern: string, options?: RegexOptions.Literal[]): boolean;
     static replace(input: string, pattern: string, replacement: string, options?: RegexOptions.Literal[]): string;
-    static replace(input: string, pattern: string, evaluator: MatchEvaluator, options?: RegexOptions.Literal[]): string;
+    static replace(input: string, pattern: string, evaluator: SelectorWithIndex<Match, Primitive>, options?: RegexOptions.Literal[]): string;
 }
@@ -51,0 +46,0 @@ export declare class Capture {

System/Types.d.ts

@@ -8,19 +8,20 @@ /*!
 export declare class TypeInfo {
-    protected target: any;
-    type: string;
-    isBoolean: boolean;
-    isNumber: boolean;
-    isFinite: boolean;
-    isValidNumber: boolean;
-    isString: boolean;
-    isTrueNaN: boolean;
-    isObject: boolean;
-    isArray: boolean;
-    isFunction: boolean;
-    isUndefined: boolean;
-    isNull: boolean;
-    isNullOrUndefined: boolean;
-    isPrimitive: boolean;
+    protected readonly target: any;
+    readonly type: string;
+    readonly isBoolean: boolean;
+    readonly isNumber: boolean;
+    readonly isFinite: boolean;
+    readonly isValidNumber: boolean;
+    readonly isString: boolean;
+    readonly isTrueNaN: boolean;
+    readonly isObject: boolean;
+    readonly isArray: boolean;
+    readonly isFunction: boolean;
+    readonly isUndefined: boolean;
+    readonly isNull: boolean;
+    readonly isNullOrUndefined: boolean;
+    readonly isPrimitive: boolean;
+    readonly isSymbol: boolean;
     constructor(target: any, onBeforeFreeze?: () => void);
-    member(name: string): TypeInfo;
+    member(name: string | number | symbol): TypeInfo;
     static getFor(target: any): TypeInfo;
@@ -33,2 +34,3 @@ }
     const OBJECT: string;
+    const SYMBOL: string;
     const UNDEFINED: string;
@@ -40,3 +42,5 @@ const FUNCTION: string;
     function isString(value: any): value is string;
-    function isPrimitive(value: any): value is Primitive;
+    function isPrimitive(value: any, allowUndefined?: boolean): value is Primitive;
+    function isPrimitiveOrSymbol(value: any, allowUndefined?: boolean): value is Primitive | symbol;
+    function isPropertyKey(value: any): value is string | number | symbol;
     function isFunction(value: any): value is Function;
@@ -46,6 +50,7 @@ function isObject(value: any, allowNull?: boolean): boolean;
     function of(target: any): TypeInfo;
-    function hasMember(value: any, property: string): boolean;
+    function hasMember(instance: any, property: string): boolean;
     function hasMemberOfType<T>(instance: any, property: string, type: string): instance is T;
+    function hasMethod<T>(instance: any, property: string): instance is T;
     function isArrayLike<T>(instance: any): instance is IArray<T>;
 }
 export default Type;

System/Types.js

@@ -5,59 +5,62 @@ /*!
  */
-const VOID0 = void (0), _BOOLEAN = typeof true, _NUMBER = typeof 0, _STRING = typeof "", _OBJECT = typeof {}, _UNDEFINED = typeof VOID0, _FUNCTION = typeof function () { }, LENGTH = "length";
+const VOID0 = void (0), _BOOLEAN = typeof true, _NUMBER = typeof 0, _STRING = typeof "", _SYMBOL = "symbol", _OBJECT = typeof {}, _UNDEFINED = typeof VOID0, _FUNCTION = typeof function () { }, LENGTH = "length";
 var typeInfoRegistry = {};
 export class TypeInfo {
     constructor(target, onBeforeFreeze) {
-        const _ = this;
-        _.isBoolean = false;
-        _.isNumber = false;
-        _.isString = false;
-        _.isTrueNaN = false;
-        _.isObject = false;
-        _.isFunction = false;
-        _.isUndefined = false;
-        _.isNull = false;
-        _.isPrimitive = false;
-        switch (_.type = typeof target) {
+        this.isBoolean = false;
+        this.isNumber = false;
+        this.isString = false;
+        this.isTrueNaN = false;
+        this.isObject = false;
+        this.isFunction = false;
+        this.isUndefined = false;
+        this.isNull = false;
+        this.isPrimitive = false;
+        this.isSymbol = false;
+        switch (this.type = typeof target) {
             case _BOOLEAN:
-                _.isBoolean = true;
-                _.isPrimitive = true;
+                this.isBoolean = true;
+                this.isPrimitive = true;
                 break;
             case _NUMBER:
-                _.isNumber = true;
-                _.isTrueNaN = isNaN(target);
-                _.isFinite = isFinite(target);
-                _.isValidNumber = !_.isTrueNaN;
-                _.isPrimitive = true;
+                this.isNumber = true;
+                this.isTrueNaN = isNaN(target);
+                this.isFinite = isFinite(target);
+                this.isValidNumber = !this.isTrueNaN;
+                this.isPrimitive = true;
                 break;
             case _STRING:
-                _.isString = true;
-                _.isPrimitive = true;
+                this.isString = true;
+                this.isPrimitive = true;
                 break;
+            case _SYMBOL:
+                this.isSymbol = true;
+                break;
             case _OBJECT:
-                _.target = target;
+                this.target = target;
                 if (target === null) {
-                    _.isNull = true;
-                    _.isNullOrUndefined = true;
-                    _.isPrimitive = true;
+                    this.isNull = true;
+                    this.isNullOrUndefined = true;
+                    this.isPrimitive = true;
                 }
                 else {
-                    _.isArray = Array.isArray(target);
-                    _.isObject = true;
+                    this.isArray = Array.isArray(target);
+                    this.isObject = true;
                 }
                 break;
             case _FUNCTION:
-                _.target = target;
-                _.isFunction = true;
+                this.target = target;
+                this.isFunction = true;
                 break;
             case _UNDEFINED:
-                _.isUndefined = true;
-                _.isNullOrUndefined = true;
-                _.isPrimitive = true;
+                this.isUndefined = true;
+                this.isNullOrUndefined = true;
+                this.isPrimitive = true;
                 break;
             default:
-                throw "Fatal type failure.  Unknown type: " + _.type;
+                throw "Fatal type failure.  Unknown type: " + this.type;
         }
         if (onBeforeFreeze)
             onBeforeFreeze();
-        Object.freeze(_);
+        Object.freeze(this);
     }
@@ -68,3 +71,3 @@ member(name) {
             ? t[name]
-            : undefined);
+            : VOID0);
     }
@@ -90,2 +93,3 @@ static getFor(target) {
     Type.OBJECT = _OBJECT;
+    Type.SYMBOL = _SYMBOL;
     Type.UNDEFINED = _UNDEFINED;
@@ -111,3 +115,3 @@ Type.FUNCTION = _FUNCTION;
     Type.isString = isString;
-    function isPrimitive(value) {
+    function isPrimitive(value, allowUndefined = false) {
         var t = typeof value;
@@ -118,4 +122,5 @@ switch (t) {
             case _NUMBER:
+                return true;
             case _UNDEFINED:
-                return true;
+                return allowUndefined;
             case _OBJECT:
@@ -127,2 +132,17 @@ return value === null;
     Type.isPrimitive = isPrimitive;
+    function isPrimitiveOrSymbol(value, allowUndefined = false) {
+        return typeof value === _SYMBOL ? true : isPrimitive(value, allowUndefined);
+    }
+    Type.isPrimitiveOrSymbol = isPrimitiveOrSymbol;
+    function isPropertyKey(value) {
+        var t = typeof value;
+        switch (t) {
+            case _STRING:
+            case _NUMBER:
+            case _SYMBOL:
+                return true;
+        }
+        return false;
+    }
+    Type.isPropertyKey = isPropertyKey;
     function isFunction(value) {
@@ -144,4 +164,4 @@ return typeof value === _FUNCTION;
     Type.of = of;
-    function hasMember(value, property) {
-        return value && !isPrimitive(value) && (property) in (value);
+    function hasMember(instance, property) {
+        return instance && !isPrimitive(instance) && (property) in (instance);
     }
@@ -153,2 +173,6 @@ Type.hasMember = hasMember;
     Type.hasMemberOfType = hasMemberOfType;
+    function hasMethod(instance, property) {
+        return hasMemberOfType(instance, property, _FUNCTION);
+    }
+    Type.hasMethod = hasMethod;
     function isArrayLike(instance) {
@@ -155,0 +179,0 @@ return instance instanceof Array

No alert changes

Improved metrics

Number of package files

391

1.56%

Lines of code

13939

0.02%

Worsened metrics

Total package byte prevSize

1360681

-0.5%

No dependency changes