maybe.clay


/// @section  Maybe[T] 

variant Maybe[T] (Nothing, T);

record Nothing ();



/// @section  constructors 

[T]
forceinline overload Maybe(x:T) : Maybe[T] = Maybe[T](x);

[T]
forceinline overload Maybe[T]() : Maybe[T] = Maybe[T](Nothing());

forceinline nothing(T) = Maybe[T]();

[T]
define Maybe?(#T) : Bool;
overload Maybe?(T) : Bool = false;
[T] overload Maybe?(#Maybe[T]) : Bool = true;


/// @section  nothing? 

forceinline nothing?(x) : Bool = variantIs?(x, Nothing);
forceinline just?(x) : Bool = variantIs?(x, Type(just(x)));

define just;
[T]
forceinline overload just(forward m: Maybe[T]) = forward variantAs(m, T);
[T]
forceinline overload just(m: Maybe[T], dflt: T) = maybe(m, v => v, () => dflt);


/// @section  maybe function 

private define maybeValue;
forceinline default maybeValue(T, forward x, thenFn, ..elseFn) = forward ..thenFn(x);
forceinline default maybeValue(T, forward n: Nothing, thenFn, elseFn) = forward ..elseFn();


// if the thenFn returns Maybe[T]s, have the default else case return nothing(T)s
[T, F when allValues?(Maybe?, ..CallOutputTypes(call, F, T))]
forceinline overload maybeValue(#T, forward n: Nothing, thenFn:F)
    = ..mapValues(call, ..CallOutputTypes(call, F, T));

[T]
forceinline maybe(forward m:Maybe[T], thenFn, ..elseFn)
    = forward ..maybeValue(#T, *m, thenFn, ..elseFn);



/// @section  require function 

record ValueMissing ();
instance Exception (ValueMissing);

define require;

[T]
forceinline overload require(forward m:Maybe[T], fn) {
    if (nothing?(m))
        throw ValueMissing();
    return forward ..fn(variantAs(m, T));
}

[T]
forceinline overload require(forward m:Maybe[T]) {
    if (nothing?(m))
        throw ValueMissing();
    return forward variantAs(m, T);
}


/// @section  maybe as iterator value 

[T] forceinline overload hasValue?(m:Maybe[T]) : Bool = just?(m);
[T] forceinline overload getValue(forward m:Maybe[T]) = forward just(m);

forceinline getMaybeValue(v) {
    if (hasValue?(v))
        return Maybe(getValue(v));
    else
        return nothing(Type(getValue(v)));
}