// Implementation of Result Monad in Java, by Chuck Liang, Hofstra University.
// V is the type of values and E is the type of errors
package ResultMonad;

import java.util.function.*;

public abstract class Result<V,E>
{   
    // Abstract methods
    
    public abstract boolean is_ok();
    
    public abstract V orElse(V Default);

    public abstract V getOr(Function<? super E,? extends V> errfun);
    
    public abstract <U> Result<U,E> map(Function<? super V, ? extends U> f);
    
    // aka "flatMap"
    public abstract <U> Result<U,E> bind(Function<? super V, Result<U,E>> f);
    
    public abstract void ifOk(Consumer<? super V> c);

    public abstract <U> U match(Function<? super V, ? extends U> okfun,
                Function<? super E, ? extends U> errfun);

    public abstract void match_do(Consumer<? super V> okfun,
                  Consumer<? super E> errfun);

    public abstract Result<V,E> map_mutate(Function<? super V,? extends V> mut);
    
    // Non-abstract methods

    //provided functions:
    public <U> Result<U,E> flatMap(Function<? super V, Result<U,E>> f) {
	return bind(f);
    }  // flatMap is alias for bind
    
    public static <A,B> Result<A,B> Ok(A v) {
	return new OkResult<A,B>(v);
    }//static, polymorphic Ok
    public static <A,B> Result<A,B> Err(B e) {
	return new ErrResult<A,B>(e);
    }//static, polymorphic Err

    // apply a function W*V -> U on two results
    @SuppressWarnings("unchecked")
    public <U,W> Result<U,E> chain(Result<W,E> other, BiFunction<? super V, ? super W, ? extends U> binop) {
      return this.match(
	_ok1 -> other.map(_ok2 -> binop.apply(_ok1,_ok2)),
	_err -> (ErrResult<U,E>)this  //new ErrResult<U,E>(_err)
      );
    }//chain

    // if other result is Err, do not change current result
    public <W> Result<V,E> if_and(Result<W,E> other, BiFunction<? super V, ? super W, ? extends V> binop) {
	return other.match(
			   _ok -> this.map(_ok1 -> binop.apply(_ok1,_ok)),
			   _err -> this
			   );
    }//if_and

    // combine two results into one for a pair (see pair.java in package)
    public <U> Result<pair<V,U>,E> zip(Result<U,E> second) {
        return this.bind(x -> second.bind(y -> Ok(new pair<V,U>(x,y))));
    }//zip (non-abstract) function

    // transform into java.util.Optional
    public java.util.Optional<V> toOptional() {
        return 
            this.match(_ok -> java.util.Optional.of(_ok),  //ok
                       err -> java.util.Optional.empty() //err
                       );
    }//toOptional
    
}//Result abstract class