trjhtr

This is yet another Node.js Promise implementation, but this is written in TypeScript, and it strives for type safety and clarity. The full project is located here. Feel free to download it and test it out.

Please give your comments regarding any missing bits or errors, as well as any potential improvements (I'm only 5 days into Node/TypeScript/JavaScript).

function isPromiseLike<T>(x: any): x is PromiseLike<T> 
 return x != null && (<PromiseLike<T>>x).then != undefined;


function isPromiseX<T>(x: PromiseLike<T>): x is PromiseX<T> 
 return x != null && (<PromiseX<T>>x).type == PromiseX.symbolPromiseX;


enum State Pending, Fulfilled, Rejected 

export class PromiseX<T = any> implements PromiseLike<T> 
 static symbolPromiseX: symbol = Symbol('PromiseX');
 readonly type: symbol = PromiseX.symbolPromiseX;

 private _state: State = State.Pending;

 private _result: T;

 private _reason: any;

 private _continuations: [(x: T) => void, (e: any) => void] = ;

 constructor(executor?: (resolve: (value?: T 

First, a few notes from your GitHub project

1. The most important compiler option to turn on is strict. This protects you from many common errors and makes it much nicer when defining optional type parameters. After turning on strict mode, the | undefined part can be dropped from parameters. (Personally, I'd like to also drop null to enforce the use of a consistent. See null is bad)




2. Consider using a proper testing framework, tests should ideally be quick and easy to read to see exactly what the code should be doing. The current testing code prints out a bunch of numbers without telling me for sure if everything is working or not. I will recommend Ava (potentially along with ava-ts) for the convenience of how it is designed to be used with promises. You could also just use this project to test your implementation.

Now on to your code :) In no particular order...

1. Instead of defining a isPromiseX function, you might consider implementing the Symbol.hasInstance method and just using if (x instanceof PromiseX)




2. With the default promise implementation in Chrome at least, if the passed executor function throws an error, the promise will be rejected. (Does not seem to be covered by the spec). It might be worth duplicating this behavior.




3. setResult and setError should not be public. They are only used internally.




4. I prefer early returns to nested code, in every case where you wrap a function's body with if (this._state == State.Pending), I would prefer to check if the state is not pending and return.




5. The code is not fully spec compliant. See point 2.3.1 is not fulfilled.



6. 
   

   Instead of defining setResult and setError as prototype methods, since you pass them into functions it may be worth defining them with arrow functions as demonstrated here.

   
   
   

   private setResult = (result?: T | PromiseLike<T>): void => {
   

   
   

Good work on the implementation overall!