enum struct Result<T E> {
    T: Ok
    E: Err
    
impl:

    inline fn Result.Ok<T E>(T) -> [Result<T E>] cast(Result<T E>::Ok)

    inline fn Result.Err<T E>(E) -> [Result<T E>] cast(Result<T E>::Err)

    fn Result.is_ok<T E>(&Result<T E>) -> [bool] {
        @ match {
            Result::Ok  { true }
            Result::Err { false }
        }
    }
    
    inline fn Result.is_err<T E>(&Result<T E>) -> [bool] {
        Result.is_ok lnot 
    }

    inline fn Result.take_is_ok<T E>(Result<T E>: self) -> [bool] {
        &self Result.is_ok
    }

    inline fn Result.take_is_err<T E>(Result<T E>: self) -> [bool] {
        &self Result.is_err
    }

    fn Result.unwrap<T E>(Result<T E>) -> [T] match {
        Result::Ok as [t] { t }
        Result::Err { 
            "Tried to `unwrap` an Error result" println
            1 exit
        }
    }

    fn Result.unwrap_err<T E>(Result<T E>) -> [E] match {
        Result::Err as [e] { e }
        Result::Ok {
            "Tried to `unwrap_err` an Ok result" println
            1 exit
        }
    }
    

    fn Result.ok<T E>(Result<T E>) -> [Option<T>] match {
        Result::Ok as [t] { t Option.Some }
        Result::Err { Option.None::<T> }
    }
    

}