Monadic Maybes using Promises! (In TypeScript)

maybe.ts

interface Maybe<T> {
    isJust: Boolean;
    isNothing: Boolean;
}

class Just<T> implements Maybe<T> {
    constructor(private value: T) {
    }
    isJust: true;
    isNothing: false;
    getValue(): T {
        return this.value;
    }
}

class Nothing<T> implements Maybe<T> {
    isJust: false;
    isNothing: true;
}

function safeGet<V, K>(dict: { [key: string]: V }, key: K): Maybe<V> {
    const val = dict[key.toString()];
    return val ? new Just<V>(val) : new Nothing<V>();
}

function toPromise<T>(v: Maybe<T>): Promise<T> {
    return new Promise((resolve, reject) => {
        if (v instanceof Just) {
            resolve(v.getValue());
        } else {
            reject("Was nothing");
        }
    });
}

const dict = { a: 'foo', b: 'bar', c: 'baz' };

const promises = ['a', 'b', 'c'].map(x => toPromise(safeGet(dict, x)));

Promise.all(promises).then(all => {
    console.log(all);
}).catch(err => {
    console.error(err);
});