interface PromiseStatePending {
	type: 'pending';
}

interface PromiseStateFulfilled<T> {
	type: 'fulfilled';
	value: T;
}

interface PromiseStateRejected {
	type: 'rejected';
	error: any;
}

type PromiseState<T> = PromiseStatePending | PromiseStateFulfilled<T> | PromiseStateRejected;

namespace PromiseState {

	export function fromPromise<T>(promise : PromiseLike<T>, callback: (state : PromiseState<T>) => void) {
		callback({ type: 'pending' });
		promise.then(value => callback({ type: 'fulfilled', value }), error => callback({ type: 'rejected', error }));
	}

	export function isPending<T>(state : PromiseState<T>) : state is PromiseStatePending {
		return state.type === 'pending';
	}

	export function isFulfilled<T>(state : PromiseState<T>) : state is PromiseStateFulfilled<T> {
		return state.type === 'fulfilled';
	}

	export function isRejected<T>(state : PromiseState<T>) : state is PromiseStateRejected {
		return state.type === 'rejected';
	}
}

PromiseState.fromPromise<number>(null, state => {

	if(PromiseState.isPending(state)) {

	} else if(PromiseState.isFulfilled(state)) {

	} else if(PromiseState.isRejected(state)) {

	}

});