2011-12-13 18:25:51 -06:00
|
|
|
/*
|
|
|
|
Module: result
|
|
|
|
|
|
|
|
A type representing either success or failure
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Section: Types */
|
|
|
|
|
|
|
|
/*
|
|
|
|
Tag: t
|
|
|
|
|
|
|
|
The result type
|
|
|
|
*/
|
2012-01-19 17:56:54 -06:00
|
|
|
enum t<T, U> {
|
2011-12-13 18:25:51 -06:00
|
|
|
/*
|
|
|
|
Variant: ok
|
|
|
|
|
|
|
|
Contains the result value
|
|
|
|
*/
|
2012-01-19 21:08:08 -06:00
|
|
|
ok(T),
|
2011-12-13 18:25:51 -06:00
|
|
|
/*
|
|
|
|
Variant: err
|
|
|
|
|
|
|
|
Contains the error value
|
|
|
|
*/
|
2012-01-19 21:29:21 -06:00
|
|
|
err(U)
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Section: Operations */
|
|
|
|
|
|
|
|
/*
|
|
|
|
Function: get
|
|
|
|
|
|
|
|
Get the value out of a successful result
|
|
|
|
|
|
|
|
Failure:
|
|
|
|
|
|
|
|
If the result is an error
|
|
|
|
*/
|
2012-01-05 08:35:37 -06:00
|
|
|
fn get<T: copy, U>(res: t<T, U>) -> T {
|
2011-12-13 18:25:51 -06:00
|
|
|
alt res {
|
|
|
|
ok(t) { t }
|
|
|
|
err(_) {
|
|
|
|
// FIXME: Serialize the error value
|
2011-12-16 09:31:35 -06:00
|
|
|
// and include it in the fail message (maybe just note it)
|
2011-12-13 18:25:51 -06:00
|
|
|
fail "get called on error result";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Function: get_err
|
|
|
|
|
|
|
|
Get the value out of an error result
|
|
|
|
|
|
|
|
Failure:
|
|
|
|
|
|
|
|
If the result is not an error
|
|
|
|
*/
|
2012-01-05 08:35:37 -06:00
|
|
|
fn get_err<T, U: copy>(res: t<T, U>) -> U {
|
2011-12-13 18:25:51 -06:00
|
|
|
alt res {
|
|
|
|
err(u) { u }
|
|
|
|
ok(_) {
|
|
|
|
fail "get_error called on ok result";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Function: success
|
|
|
|
|
|
|
|
Returns true if the result is <ok>
|
|
|
|
*/
|
2011-12-16 09:31:35 -06:00
|
|
|
pure fn success<T, U>(res: t<T, U>) -> bool {
|
2011-12-13 18:25:51 -06:00
|
|
|
alt res {
|
|
|
|
ok(_) { true }
|
|
|
|
err(_) { false }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Function: failure
|
|
|
|
|
|
|
|
Returns true if the result is <error>
|
|
|
|
*/
|
2011-12-16 09:31:35 -06:00
|
|
|
pure fn failure<T, U>(res: t<T, U>) -> bool {
|
2011-12-13 18:25:51 -06:00
|
|
|
!success(res)
|
|
|
|
}
|
|
|
|
|
2012-01-05 08:35:37 -06:00
|
|
|
pure fn to_either<T: copy, U: copy>(res: t<U, T>) -> either::t<T, U> {
|
2011-12-16 09:31:35 -06:00
|
|
|
alt res {
|
|
|
|
ok(res) { either::right(res) }
|
|
|
|
err(fail_) { either::left(fail_) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-13 18:25:51 -06:00
|
|
|
/*
|
|
|
|
Function: chain
|
|
|
|
|
|
|
|
Call a function based on a previous result
|
|
|
|
|
|
|
|
If `res` is <ok> then the value is extracted and passed to `op` whereupon
|
|
|
|
`op`s result is returned. if `res` is <err> then it is immediately returned.
|
|
|
|
This function can be used to compose the results of two functions.
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
|
|
|
> let res = chain(read_file(file), { |buf|
|
|
|
|
> ok(parse_buf(buf))
|
|
|
|
> })
|
|
|
|
|
|
|
|
*/
|
2012-01-05 08:35:37 -06:00
|
|
|
fn chain<T, U: copy, V: copy>(res: t<T, V>, op: block(T) -> t<U, V>)
|
2011-12-13 18:25:51 -06:00
|
|
|
-> t<U, V> {
|
|
|
|
alt res {
|
|
|
|
ok(t) { op(t) }
|
|
|
|
err(e) { err(e) }
|
|
|
|
}
|
|
|
|
}
|
2012-01-17 19:28:21 -06:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
fn op1() -> result::t<int, str> { result::ok(666) }
|
|
|
|
|
|
|
|
fn op2(&&i: int) -> result::t<uint, str> { result::ok(i as uint + 1u) }
|
|
|
|
|
|
|
|
fn op3() -> result::t<int, str> { result::err("sadface") }
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn chain_success() {
|
|
|
|
assert get(chain(op1(), op2)) == 667u;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn chain_failure() {
|
|
|
|
assert get_err(chain(op3(), op2)) == "sadface";
|
|
|
|
}
|
|
|
|
}
|