// Look to std/prelude.moc for `dup` and `drop` implementations
// Note: MyResult is defined in the stdlib, so we use MyMyResult... here.

enum MyResultTag { Ok Err }

union MyResultValue<T E> {
    T: ok 
    E: err
}

struct MyResult<T E> {
    MyResultValue<T E>: value
    MyResultTag       : tag
impl:
    fn MyResult.Ok<T E>(T: value) -> [MyResult<T E>] {
        value cast(MyResultValue) MyResultTag::Ok cast(MyResult)
    }
    fn MyResult.Err<T E>(E) -> [MyResult<T E>] {
        cast(MyResultValue) MyResultTag::Err cast(MyResult)
    } 
    fn MyResult.is_ok<T E>(MyResult<T E>: r)  -> [bool] { r::tag MyResultTag::Ok == }
    fn MyResult.is_err<T E>(MyResult<T E>: r) -> [bool] { r::tag MyResultTag::Err == }
    fn MyResult.unwrap<T E>(MyResult<T E>: r) -> [T] {
        r MyResult.is_err if {
            "Tried to unrwap a MyResult in an Error state. Exiting program" println
            1 exit
        }
        r::value::ok
    }
    fn MyResult.unwrap_err<T E>(MyResult<T E>: r) -> [E] {
        r MyResult.is_ok if {
            "Tried to unrwap_err a MyResult in an Ok state. Exiting program" println
            1 exit
        }
        r::value::err
    }
}

fn might_fail(u64: n) -> [MyResult<u64 Str>] {

    n 2 % 0 == if {
        "Woah didn't expect to see an even number here"
        MyResult.Err::<u64 Str>
    } else {
        n 2 * 1 + MyResult.Ok::<u64 Str>
    }
}

fn main() {

    12345 
    // uncomment this to see the compiler error
    // MyResult.Ok

    MyResult.Ok::<u64 char>  as [ok]

    // Notice that you can put any type here!
    "Uh Oh! Something went wrong!"
    MyResult.Err::<bool Str> as [err]

    "ok is in ok state:   " print ok  MyResult.is_ok  println
    "ok is in err state:  " print ok  MyResult.is_err println 
    "err is in ok state:  " print err MyResult.is_ok  println
    "err is in err state: " print err MyResult.is_err println

    ok MyResult.is_ok if {
        "unwrapped ok value: " print ok MyResult.unwrap println
    }

    err MyResult.is_err if {
        "Unwrapped err value: " print err MyResult.unwrap_err println 
    }

    0 while dup 10 < do {
        as [i]
        i might_fail as [r] {
            r MyResult.is_ok if {
                "Didn't fail: " print 
                r MyResult.unwrap println
            } else {
                "Did fail:    " print
                r MyResult.unwrap_err println
            }
        }
        i 1 + 
    } drop

}