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.
They're the cure for all your null
/undefined
problems. Read this article to learn more!
You can also read up on tries, which provide a flexible way to deal with exceptions.
With npm:
$ npm install monapt
With Bower:
$ bower install git://github.com/jiaweihli/monapt.git --save
static flatten<T>(options: Array<Option<T>>): Array<T>
var valueOption = Option(null);
var finalValue = valueOption.getOrElse(() => 'defaultValue'); // 'defaultValue'
valueOption
.map((v) => v * 2)
.filter((v) => v > 10)
.match({
Some: (v) => 'Value: ' + v,
None: () => 'Invalid value'
})
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, Monapt.Option(1)]) // [1]
isDefined: boolean
isEmpty: boolean
get(): T
getOrElse(defaultValue: () => T): T
orElse(alternative: () => Option<A>): Option<A>
match<B>(matcher: { Some: (T) => U, None: () => U }): U
map<B>(f: (value: T) => U): Option<U>
flatMap<B>(f: (value: T) => Option<U>): Option<B>
filter(predicate: (value: T) => boolean): Option<U>
reject(predicate: (value: T) => boolean): Option<U>
foreach(f: (value: T) => void): void
equals(option: Option<T>): boolean
var attempt = Monapt.Try(() => {
return parse(aValue);
});
attempt.getOrElse(() => 'defaultValue');
attempt.match({
Success: (v) => 'Awesome! ' + v,
Failure: (e) => 'Whoops!' + e.message
});
exception: Error
isSuccess: boolean
isFailure: boolean
get(): T
getOrElse(defaultValue: () => T): T
orElse(alternative: () => Try<T>): Try<T>
match<U>(matcher: { Success: (T) => U, Failure: () => 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((promise) => {
api.get((error, value) => {
if (error) {
promise.failure(error);
}
else {
promise.success(value);
}
});
})
.onComplete({
Success: (v) => 'Awesome! ' + v,
Failure: (e) => 'Whoops! ' + e.toString()
})
Mix futures:
var macbook = Monapt.future((promise) => {
setTimeout(() => {
promise.success('MacBook');
}, 100);
});
var pro = Monapt.future((promise) => {
setTimeout(() => {
promise.success('Pro');
}, 100);
});
var macbookPro = macbook.flatMap((mb) => {
return pro.map((pro) => {
return mb + pro;
});
});
macbookPro.onSuccess((v) => {
console.log(v); // MacBookPro
});
onComplete(callback: { Success: (T) => void, Failure: () => void } => void): void
onSuccess(callback: (value: T) => void): void
onFailure(callback: (error: Error) => void): void
map<U>(f: (value: T) => U): 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) => T): Future<T>
recoverWith(fn: (e: Error) => Future<T>): Future<T>
This repo couldn't have been possible without https://github.com/yaakaito/monapt. In his absence, I'll continue improving upon his hard work.