maybe.ts

export interface MonadI<T> {
	lift<U>(transform: (v: T) => U): MonadI<U>;
	bind<U>(transform: (v: T) => MonadI<U>): MonadI<U>;
}

export interface MaybeI<T> extends MonadI<T> {
	isEmpty: boolean;
	toString(): string;
	get(): any;
}

export interface MaybeCase<T, U> {
	just: (v: T) => U;
	nothing: () => U;
}	

export class Just<T> implements MaybeI<T> {
	isEmpty: boolean = false;
	private value: T;

	constructor(value: T) {	
		this.value = value;
	}
	toString():string {
		return 'Just -> {}'.replace('{}', this.value.toString());
	}
	get():T {
		return this.value;
	}
	lift<U>(transform: (v: T) => U): MaybeI<U> {
		return maybe<U>(transform(this.value)); // We don't know...
	}
	bind<U>(transform: (v: T) => Just<U>): Just<U> {
		return transform(this.value);
	}
	caseOf<U>(branches: MaybeCase<T, U>) {
		return branches.just(this.value);
	}
}

export class Nothing<T> implements MaybeI<T> {
	isEmpty: boolean = true;

	toString():string {
		return 'Nothing';
	}
	get():void {
		throw "Can't get() from Nothing<T>";
	}
	lift<U>(transform: (v: T) => U): MaybeI<U> {
		return new Nothing<U>();
	}
	bind<U>(transform: (v: T) => Just<U>): Nothing<U> {
		return new Nothing<U>();
	}
	caseOf<U>(branches: MaybeCase<T, U>) {
		return branches.nothing();
	}
}

export function just<T>(v: T) {
	return new Just<T>(v);
}

export function nothing<T>() {
	return new Nothing<T>();
}

export function maybe<T>(v?: T) {
	if (v === null || v === undefined) return nothing<T>();
	return just<T>(v);
}