rust/src/libcore/result.rs

432 lines
10 KiB
Rust
Raw Normal View History

//! A type representing either success or failure
2012-09-04 13:12:17 -05:00
use cmp::Eq;
use either::Either;
/// The result type
2012-08-26 18:54:31 -05:00
enum Result<T, U> {
/// Contains the successful result value
2012-08-26 18:54:31 -05:00
Ok(T),
/// Contains the error value
2012-08-26 18:54:31 -05:00
Err(U)
}
/**
* Get the value out of a successful result
*
* # Failure
*
* If the result is an error
*/
2012-08-26 18:54:31 -05:00
pure fn get<T: copy, U>(res: Result<T, U>) -> T {
2012-08-06 14:34:08 -05:00
match res {
2012-08-26 18:54:31 -05:00
Ok(t) => t,
Err(the_err) => unchecked {
2012-08-22 19:24:52 -05:00
fail fmt!("get called on error result: %?", the_err)
}
}
}
/**
* Get a reference to the value out of a successful result
*
* # Failure
*
* If the result is an error
*/
2012-08-26 18:54:31 -05:00
pure fn get_ref<T, U>(res: &a/Result<T, U>) -> &a/T {
match *res {
2012-08-26 18:54:31 -05:00
Ok(ref t) => t,
Err(ref the_err) => unchecked {
fail fmt!("get_ref called on error result: %?", the_err)
}
}
}
/**
* Get the value out of an error result
*
* # Failure
*
* If the result is not an error
*/
2012-08-26 18:54:31 -05:00
pure fn get_err<T, U: copy>(res: Result<T, U>) -> U {
2012-08-06 14:34:08 -05:00
match res {
2012-08-26 18:54:31 -05:00
Err(u) => u,
2012-08-30 15:05:52 -05:00
Ok(_) => fail ~"get_err called on ok result"
}
}
/// Returns true if the result is `ok`
2012-08-26 18:54:31 -05:00
pure fn is_ok<T, U>(res: Result<T, U>) -> bool {
2012-08-06 14:34:08 -05:00
match res {
2012-08-26 18:54:31 -05:00
Ok(_) => true,
Err(_) => false
}
}
/// Returns true if the result is `err`
2012-08-26 18:54:31 -05:00
pure fn is_err<T, U>(res: Result<T, U>) -> bool {
!is_ok(res)
}
/**
* Convert to the `either` type
*
* `ok` result variants are converted to `either::right` variants, `err`
* result variants are converted to `either::left`.
*/
2012-08-26 18:54:31 -05:00
pure fn to_either<T: copy, U: copy>(res: Result<U, T>) -> Either<T, U> {
2012-08-06 14:34:08 -05:00
match res {
2012-08-26 18:54:31 -05:00
Ok(res) => either::Right(res),
Err(fail_) => either::Left(fail_)
}
}
/**
* 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-08-26 18:54:31 -05:00
fn chain<T, U: copy, V: copy>(res: Result<T, V>, op: fn(T) -> Result<U, V>)
-> Result<U, V> {
2012-08-06 14:34:08 -05:00
match res {
2012-08-26 18:54:31 -05:00
Ok(t) => op(t),
Err(e) => Err(e)
}
}
2012-01-17 19:28:21 -06:00
/**
* Call a function based on a previous result
*
* If `res` is `err` then the value is extracted and passed to `op`
* whereupon `op`s result is returned. if `res` is `ok` then it is
* immediately returned. This function can be used to pass through a
* successful result while handling an error.
*/
2012-03-22 22:06:01 -05:00
fn chain_err<T: copy, U: copy, V: copy>(
2012-08-26 18:54:31 -05:00
res: Result<T, V>,
op: fn(V) -> Result<T, U>)
-> Result<T, U> {
2012-08-06 14:34:08 -05:00
match res {
2012-08-26 18:54:31 -05:00
Ok(t) => Ok(t),
Err(v) => op(v)
2012-03-22 22:06:01 -05:00
}
}
/**
* 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:
*
* iter(read_file(file)) { |buf|
* print_buf(buf)
* }
*/
2012-08-26 18:54:31 -05:00
fn iter<T, E>(res: Result<T, E>, f: fn(T)) {
2012-08-06 14:34:08 -05:00
match res {
2012-08-26 18:54:31 -05:00
Ok(t) => f(t),
Err(_) => ()
}
}
/**
* Call a function based on a previous result
*
* If `res` is `err` then the value is extracted and passed to `op` whereupon
* `op`s result is returned. if `res` is `ok` then it is immediately returned.
* This function can be used to pass through a successful result while
* handling an error.
*/
2012-08-26 18:54:31 -05:00
fn iter_err<T, E>(res: Result<T, E>, f: fn(E)) {
2012-08-06 14:34:08 -05:00
match res {
2012-08-26 18:54:31 -05:00
Ok(_) => (),
Err(e) => f(e)
}
}
/**
* 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 wrapped in `ok` and 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 = map(read_file(file)) { |buf|
* parse_buf(buf)
* }
*/
2012-08-26 18:54:31 -05:00
fn map<T, E: copy, U: copy>(res: Result<T, E>, op: fn(T) -> U)
-> Result<U, E> {
2012-08-06 14:34:08 -05:00
match res {
2012-08-26 18:54:31 -05:00
Ok(t) => Ok(op(t)),
Err(e) => Err(e)
}
}
/**
* Call a function based on a previous result
*
* If `res` is `err` then the value is extracted and passed to `op` whereupon
* `op`s result is wrapped in an `err` and returned. if `res` is `ok` then it
* is immediately returned. This function can be used to pass through a
* successful result while handling an error.
*/
2012-08-26 18:54:31 -05:00
fn map_err<T: copy, E, F: copy>(res: Result<T, E>, op: fn(E) -> F)
-> Result<T, F> {
2012-08-06 14:34:08 -05:00
match res {
2012-08-26 18:54:31 -05:00
Ok(t) => Ok(t),
Err(e) => Err(op(e))
}
}
2012-08-26 18:54:31 -05:00
impl<T, E> Result<T, E> {
fn is_ok() -> bool { is_ok(self) }
2012-04-01 17:44:01 -05:00
fn is_err() -> bool { is_err(self) }
2012-04-01 17:44:01 -05:00
fn iter(f: fn(T)) {
2012-08-06 14:34:08 -05:00
match self {
2012-08-26 18:54:31 -05:00
Ok(t) => f(t),
Err(_) => ()
}
}
fn iter_err(f: fn(E)) {
2012-08-06 14:34:08 -05:00
match self {
2012-08-26 18:54:31 -05:00
Ok(_) => (),
Err(e) => f(e)
}
}
}
2012-08-26 18:54:31 -05:00
impl<T: copy, E> Result<T, E> {
fn get() -> T { get(self) }
2012-08-26 18:54:31 -05:00
fn map_err<F:copy>(op: fn(E) -> F) -> Result<T,F> {
2012-08-06 14:34:08 -05:00
match self {
2012-08-26 18:54:31 -05:00
Ok(t) => Ok(t),
Err(e) => Err(op(e))
}
}
}
2012-08-26 18:54:31 -05:00
impl<T, E: copy> Result<T, E> {
fn get_err() -> E { get_err(self) }
2012-08-26 18:54:31 -05:00
fn map<U:copy>(op: fn(T) -> U) -> Result<U,E> {
2012-08-06 14:34:08 -05:00
match self {
2012-08-26 18:54:31 -05:00
Ok(t) => Ok(op(t)),
Err(e) => Err(e)
}
}
}
2012-08-26 18:54:31 -05:00
impl<T: copy, E: copy> Result<T, E> {
fn chain<U:copy>(op: fn(T) -> Result<U,E>) -> Result<U,E> {
chain(self, op)
}
2012-08-26 18:54:31 -05:00
fn chain_err<F:copy>(op: fn(E) -> Result<T,F>) -> Result<T,F> {
chain_err(self, op)
}
}
/**
* Maps each element in the vector `ts` using the operation `op`. Should an
* error occur, no further mappings are performed and the error is returned.
* Should no error occur, a vector containing the result of each map is
* returned.
*
* Here is an example which increments every integer in a vector,
* checking for overflow:
*
* fn inc_conditionally(x: uint) -> result<uint,str> {
2012-08-01 19:30:05 -05:00
* if x == uint::max_value { return err("overflow"); }
* else { return ok(x+1u); }
* }
* map(~[1u, 2u, 3u], inc_conditionally).chain {|incd|
* assert incd == ~[2u, 3u, 4u];
* }
*/
fn map_vec<T,U:copy,V:copy>(
2012-08-26 18:54:31 -05:00
ts: &[T], op: fn(T) -> Result<V,U>) -> Result<~[V],U> {
let mut vs: ~[V] = ~[];
vec::reserve(vs, vec::len(ts));
2012-06-30 18:19:07 -05:00
for vec::each(ts) |t| {
2012-08-06 14:34:08 -05:00
match op(t) {
2012-08-26 18:54:31 -05:00
Ok(v) => vec::push(vs, v),
Err(u) => return Err(u)
}
}
2012-08-26 18:54:31 -05:00
return Ok(vs);
}
fn map_opt<T,U:copy,V:copy>(
2012-08-26 18:54:31 -05:00
o_t: Option<T>, op: fn(T) -> Result<V,U>) -> Result<Option<V>,U> {
2012-08-06 14:34:08 -05:00
match o_t {
2012-08-26 18:54:31 -05:00
None => Ok(None),
2012-08-20 14:23:37 -05:00
Some(t) => match op(t) {
2012-08-26 18:54:31 -05:00
Ok(v) => Ok(Some(v)),
Err(e) => Err(e)
}
}
}
/**
* Same as map, but it operates over two parallel vectors.
*
* A precondition is used here to ensure that the vectors are the same
* length. While we do not often use preconditions in the standard
* library, a precondition is used here because result::t is generally
* used in 'careful' code contexts where it is both appropriate and easy
* to accommodate an error like the vectors being of different lengths.
*/
fn map_vec2<S,T,U:copy,V:copy>(ss: &[S], ts: &[T],
2012-08-26 18:54:31 -05:00
op: fn(S,T) -> Result<V,U>) -> Result<~[V],U> {
assert vec::same_length(ss, ts);
let n = vec::len(ts);
let mut vs = ~[];
vec::reserve(vs, n);
let mut i = 0u;
while i < n {
2012-08-06 14:34:08 -05:00
match op(ss[i],ts[i]) {
2012-08-26 18:54:31 -05:00
Ok(v) => vec::push(vs, v),
Err(u) => return Err(u)
}
i += 1u;
}
2012-08-26 18:54:31 -05:00
return Ok(vs);
}
/**
* Applies op to the pairwise elements from `ss` and `ts`, aborting on
* error. This could be implemented using `map2()` but it is more efficient
* on its own as no result vector is built.
*/
fn iter_vec2<S,T,U:copy>(ss: &[S], ts: &[T],
2012-08-26 18:54:31 -05:00
op: fn(S,T) -> Result<(),U>) -> Result<(),U> {
assert vec::same_length(ss, ts);
2012-03-22 22:06:01 -05:00
let n = vec::len(ts);
let mut i = 0u;
while i < n {
2012-08-06 14:34:08 -05:00
match op(ss[i],ts[i]) {
2012-08-26 18:54:31 -05:00
Ok(()) => (),
Err(u) => return Err(u)
2012-03-22 22:06:01 -05:00
}
i += 1u;
}
2012-08-26 18:54:31 -05:00
return Ok(());
2012-03-22 22:06:01 -05:00
}
/// Unwraps a result, assuming it is an `ok(T)`
fn unwrap<T, U>(+res: Result<T, U>) -> T {
match move res {
Ok(move t) => t,
Err(_) => fail ~"unwrap called on an err result"
}
}
2012-08-30 17:54:16 -05:00
/// Unwraps a result, assuming it is an `err(U)`
fn unwrap_err<T, U>(+res: Result<T, U>) -> U {
match move res {
Err(move u) => u,
Ok(_) => fail ~"unwrap called on an ok result"
}
}
2012-08-27 18:26:35 -05:00
impl<T:Eq,U:Eq> Result<T,U> : Eq {
pure fn eq(&&other: Result<T,U>) -> bool {
match self {
Ok(e0a) => {
match other {
Ok(e0b) => e0a == e0b,
_ => false
}
}
Err(e0a) => {
match other {
Err(e0b) => e0a == e0b,
_ => false
}
}
}
}
}
2012-01-17 19:28:21 -06:00
#[cfg(test)]
#[allow(non_implicitly_copyable_typarams)]
2012-01-17 19:28:21 -06:00
mod tests {
2012-08-26 18:54:31 -05:00
fn op1() -> result::Result<int, ~str> { result::Ok(666) }
2012-01-17 19:28:21 -06:00
2012-08-26 18:54:31 -05:00
fn op2(&&i: int) -> result::Result<uint, ~str> {
result::Ok(i as uint + 1u)
}
2012-01-17 19:28:21 -06:00
2012-08-26 18:54:31 -05:00
fn op3() -> result::Result<int, ~str> { result::Err(~"sadface") }
2012-01-17 19:28:21 -06:00
#[test]
fn chain_success() {
assert get(chain(op1(), op2)) == 667u;
}
#[test]
fn chain_failure() {
assert get_err(chain(op3(), op2)) == ~"sadface";
2012-01-17 19:28:21 -06:00
}
#[test]
fn test_impl_iter() {
let mut valid = false;
2012-08-26 18:54:31 -05:00
Ok::<~str, ~str>(~"a").iter(|_x| valid = true);
assert valid;
2012-08-26 18:54:31 -05:00
Err::<~str, ~str>(~"b").iter(|_x| valid = false);
assert valid;
}
#[test]
fn test_impl_iter_err() {
let mut valid = true;
2012-08-26 18:54:31 -05:00
Ok::<~str, ~str>(~"a").iter_err(|_x| valid = false);
assert valid;
valid = false;
2012-08-26 18:54:31 -05:00
Err::<~str, ~str>(~"b").iter_err(|_x| valid = true);
assert valid;
}
#[test]
fn test_impl_map() {
2012-08-26 18:54:31 -05:00
assert Ok::<~str, ~str>(~"a").map(|_x| ~"b") == Ok(~"b");
assert Err::<~str, ~str>(~"a").map(|_x| ~"b") == Err(~"a");
}
#[test]
fn test_impl_map_err() {
2012-08-26 18:54:31 -05:00
assert Ok::<~str, ~str>(~"a").map_err(|_x| ~"b") == Ok(~"a");
assert Err::<~str, ~str>(~"a").map_err(|_x| ~"b") == Err(~"b");
}
2012-01-17 19:28:21 -06:00
}