Getting closer to merging Task<T> with Promise<T>.

Tweaks to leverage ObjectPools better.
Fixed LinkedNodeList removeNode method: Wasn't clearing previous and next if removed.

dist/commonjs/System/Disposable/ObjectPool.d.ts

@@ -8,13 +8,14 @@ import { DisposableBase } from "./DisposableBase";
 export declare class ObjectPool<T> extends DisposableBase {
     private _maxSize;
     private _generator;
+    private _recycler;
     private _pool;
     private _trimmer;
     private _flusher;
     private _autoFlusher;
     private _localAbsMaxSize;
     autoClearTimeout: number;
-    constructor(_maxSize: number, _generator: () => T);
+    constructor(_maxSize: number, _generator: (...args: any[]) => T, _recycler?: (o: T) => void);
     maxSize: number;
     count: number;
     protected _trim(): void;

dist/commonjs/System/Promises/Promise.d.ts

@@ -52,7 +52,7 @@ export declare class Promise<T> extends Resolvable<T> {
     resolve(result?: T, throwIfSettled?: boolean): void;
     reject(error: any, throwIfSettled?: boolean): void;
 }
-export declare class LazyResolved<T> extends Resolved<T> {
+export declare class Task<T> extends Resolved<T> {
     private _factory;
     constructor(_factory: Func<T>);
     protected _onDispose(): void;
@@ -61,8 +61,8 @@ export declare class LazyResolved<T> extends Resolved<T> {
     protected getError(): any;
     then<TResult>(onFulfilled: Promise.Fulfill<T, TResult>, onRejected?: Promise.Reject<TResult>): PromiseBase<TResult>;
     thenThis<TResult>(onFulfilled: Promise.Fulfill<T, TResult>, onRejected?: Promise.Reject<TResult>): PromiseBase<T>;
-    resolve(): PromiseBase<T>;
-    isResolved: boolean;
+    resolve(): Task<T>;
+    isCompleted: boolean;
 }
 export declare class LazyPromise<T> extends Promise<T> {
     private _resolver;
@@ -99,7 +99,7 @@ export declare module Promise {
     function resolve<T>(value: T | PromiseLike<T>): PromiseBase<T>;
     function reject<T>(reason: T): PromiseBase<T>;
     module lazy {
-        function resolve<T>(factory: Func<T>): LazyResolved<T>;
+        function resolve<T>(factory: Func<T>): Task<T>;
         function pending<T>(resolver: Promise.Executor<T>): LazyPromise<T>;
     }
     function wrap<T>(target: PromiseLike<T>): PromiseBase<T>;