awhitty / monapt

Options, Trys, and Futures for JavaScript / TypeScript

Monapt

The most current version of Monapt uses TypeScript 2.x.

TypeScript 1.x support is in maintenance mode on version 0.5.x.
It lives on the typescript-1.x branch.

What the heck are options anyway?

They're the cure for all your null/undefined problems. Read this article to learn more!

And tries?

You can also read up on tries, which provide a flexible way to deal with exceptions.

Setup

With npm:

$ npm install monapt

With Bower:

$ bower install git://github.com/jiaweihli/monapt.git --save

APIs

monapt

Properties / Methods

• static flatten<T>(options: Array<Option<T>>): Array<T>

monapt.Option

var valueOption = map.get('key');
valueOption.getOrElse(() => 'defaultValue');

valueOption
    .map((v) => v * 2)
    .filter((v) => v > 10)
    .match({
        Some: (v)  => console.log(v),
        None: () => console.log('None!')
    })

monapt.Some / monapt.None

monapt.Option('value') // Some('value')
monapt.Option(null) // None
monapt.Option(undefined) // None
monapt.None // None
monapt.None.get() // monapt.NoSuchElementError
monapt.flatten([Monapt.None, new Monapt.Some(1)]) // [1]

Properties / Methods

• isDefined: boolean
• isEmpty: boolean
• get(): A
• getOrElse(defaultValue: () => A): A
• orElse(alternative: () => Option<A>): Option<A>
• match<B>(matcher: IOptionMatcher<A, B>): B
• map<B>(f: (value: A) => B): Option<B>
• flatMap<B>(f: (value: A) => Option<B>): Option<B>
• filter(predicate: (value: A) => boolean): Option<A>
• reject(predicate: (value: A) => boolean): Option<A>
• foreach(f: (value: A) => void): void
• equals(option: Option<A>): boolean

monapt.IOptionMatcher

interface IOptionMatcher<A, B> {
    Some(value: A): B;
    None(): B;
}

monapt.Try

var trier = monapt.Try(() => {
    return parse(aValue);
});
trier.getOrElse(() => 'defaultValue');

trier.match({
    Success: (v) => console.log(v),
    Failure: (e) => console.log(e.message)
});

monapt.Success / monapt.Failure

new monapt.Success('value')
new monapt.Failure<string>(new Error());

Properties / Methods

• exception: Error
• isSuccess: boolean
• isFailure: boolean
• get(): T
• getOrElse(defaultValue: () => T): T
• orElse(alternative: () => Try<T>): Try<T>
• match<U>(matcher: ITryMatcher<T, U>): U
• map<U>(f: (value: T) => U): Try<U>
• flatMap<U>(f: (value: T) => Try<U>): Try<U>
• filter(predicate: (value: T) => boolean): Try<T>
• reject(predicate: (value: T) => boolean): Try<T>
• foreach(f: (value: T) => void): void
• recover(fn: (error: Error) => T): Try<T>
• recoverWith(fn: (error: Error) => Try<T>): Try<T>
• toOption(): Option<T>

monapt.Future

monapt.future<string>((promise) => {
    api.get((error, value) => {
        if (error) {
            promise.failure(error);
        }
        else {
          promise.success(value);
        }
    });
}).onComplete({
    Success: (v) => console.log(v),
    Failure: (e) => console.log(e)
})

Mix futures:

var macbook = monapt.future<string>((promise) => {
    setTimeout(() => {
        promise.success('MacBook');
    }, 100);
});

var pro = monapt.future<string>((promise) => {
    setTimeout(() => {
        promise.success('Pro');
    }, 100);
});

var macbookPro = macbook.flatMap<string>((mb) => {
    return pro.map<string>((pro, promise) => {
        promise.success(mb + pro);
    });
});

macbookPro.onSuccess((v) => {
    console.log(v); // MacBookPro
});

Properties / Methods

• onComplete(callback: ICompleteFunction<T>): void
• onSuccess(callback: (value: T) => void): void
• onFailure(callback: (error: Error) => void): void
• map<U>(f: (value: T, promise: IFuturePromiseLike<U>) => void): Future<U>
• flatMap<U>(f: (value: T) => Future<U>): Future<U>
• filter(predicate: (value: T) => boolean): Future<T>
• reject(predicate: (value: T) => boolean): Future<T>
• recover(fn: (e: Error, promise: IFuturePromiseLike<T>) => T): Future<T>
• recoverWith(fn: (e: Error) => Future<T>): Future<T>

Credits

This repo couldn't have been possible without https://github.com/yaakaito/monapt. In his absence, I'll continue improving upon his hard work.