2012-07-04 16:53:12 -05:00
|
|
|
//! A type representing either success or failure
|
2011-12-13 18:25:51 -06:00
|
|
|
|
2012-08-14 18:54:13 -05:00
|
|
|
import either::Either;
|
2012-03-16 17:14:37 -05:00
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// The result type
|
2012-03-13 16:39:28 -05:00
|
|
|
enum result<T, U> {
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Contains the successful result value
|
2012-01-19 21:08:08 -06:00
|
|
|
ok(T),
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Contains the error value
|
2012-01-19 21:29:21 -06:00
|
|
|
err(U)
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* Get the value out of a successful result
|
|
|
|
*
|
|
|
|
* # Failure
|
|
|
|
*
|
|
|
|
* If the result is an error
|
|
|
|
*/
|
2012-03-15 15:57:26 -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-03 21:59:04 -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)
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-26 13:50:21 -05:00
|
|
|
/**
|
|
|
|
* Get a reference to the value out of a successful result
|
|
|
|
*
|
|
|
|
* # Failure
|
|
|
|
*
|
|
|
|
* If the result is an error
|
|
|
|
*/
|
|
|
|
pure fn get_ref<T, U>(res: &a/result<T, U>) -> &a/T {
|
|
|
|
match *res {
|
|
|
|
ok(ref t) => t,
|
|
|
|
err(ref the_err) => unchecked {
|
|
|
|
fail fmt!("get_ref called on error result: %?", the_err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* Get the value out of an error result
|
|
|
|
*
|
|
|
|
* # Failure
|
|
|
|
*
|
|
|
|
* If the result is not an error
|
|
|
|
*/
|
2012-03-15 15:57:26 -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-03 21:59:04 -05:00
|
|
|
err(u) => u,
|
|
|
|
ok(_) => fail ~"get_error called on ok result"
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Returns true if the result is `ok`
|
2012-06-22 20:26:25 -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-03 21:59:04 -05:00
|
|
|
ok(_) => true,
|
|
|
|
err(_) => false
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Returns true if the result is `err`
|
2012-06-22 20:26:25 -05:00
|
|
|
pure fn is_err<T, U>(res: result<T, U>) -> bool {
|
|
|
|
!is_ok(res)
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* Convert to the `either` type
|
|
|
|
*
|
|
|
|
* `ok` result variants are converted to `either::right` variants, `err`
|
|
|
|
* result variants are converted to `either::left`.
|
|
|
|
*/
|
2012-08-14 18:54:13 -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-14 18:54:13 -05:00
|
|
|
ok(res) => either::Right(res),
|
|
|
|
err(fail_) => either::Left(fail_)
|
2011-12-16 09:31:35 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -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:
|
|
|
|
*
|
|
|
|
* let res = chain(read_file(file)) { |buf|
|
|
|
|
* ok(parse_buf(buf))
|
|
|
|
* }
|
|
|
|
*/
|
2012-03-13 16:39:28 -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-03 21:59:04 -05:00
|
|
|
ok(t) => op(t),
|
|
|
|
err(e) => err(e)
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
}
|
2012-01-17 19:28:21 -06:00
|
|
|
|
2012-07-04 16:53:12 -05: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>(
|
|
|
|
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-03 21:59:04 -05:00
|
|
|
ok(t) => ok(t),
|
|
|
|
err(v) => op(v)
|
2012-03-22 22:06:01 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -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-05-26 22:33:08 -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-03 21:59:04 -05:00
|
|
|
ok(t) => f(t),
|
|
|
|
err(_) => ()
|
2012-05-26 22:33:08 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05: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-05-26 22:33:08 -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-03 21:59:04 -05:00
|
|
|
ok(_) => (),
|
|
|
|
err(e) => f(e)
|
2012-05-26 22:33:08 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -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 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-05-26 22:33:08 -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-03 21:59:04 -05:00
|
|
|
ok(t) => ok(op(t)),
|
|
|
|
err(e) => err(e)
|
2012-05-26 22:33:08 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05: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 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-05-26 22:33:08 -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-03 21:59:04 -05:00
|
|
|
ok(t) => ok(t),
|
|
|
|
err(e) => err(op(e))
|
2012-05-26 22:33:08 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-07 20:10:06 -05:00
|
|
|
impl<T, E> result<T, E> {
|
2012-06-22 20:26:25 -05:00
|
|
|
fn is_ok() -> bool { is_ok(self) }
|
2012-04-01 17:44:01 -05:00
|
|
|
|
2012-06-22 20:26:25 -05:00
|
|
|
fn is_err() -> bool { is_err(self) }
|
2012-04-01 17:44:01 -05:00
|
|
|
|
2012-05-26 22:33:08 -05:00
|
|
|
fn iter(f: fn(T)) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self {
|
2012-08-03 21:59:04 -05:00
|
|
|
ok(t) => f(t),
|
|
|
|
err(_) => ()
|
2012-05-26 22:33:08 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn iter_err(f: fn(E)) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self {
|
2012-08-03 21:59:04 -05:00
|
|
|
ok(_) => (),
|
|
|
|
err(e) => f(e)
|
2012-05-26 22:33:08 -05:00
|
|
|
}
|
|
|
|
}
|
2012-06-22 19:32:52 -05:00
|
|
|
}
|
|
|
|
|
2012-08-07 20:10:06 -05:00
|
|
|
impl<T: copy, E> result<T, E> {
|
2012-06-22 19:32:52 -05:00
|
|
|
fn get() -> T { get(self) }
|
|
|
|
|
|
|
|
fn map_err<F:copy>(op: fn(E) -> F) -> result<T,F> {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self {
|
2012-08-03 21:59:04 -05:00
|
|
|
ok(t) => ok(t),
|
|
|
|
err(e) => err(op(e))
|
2012-06-22 19:32:52 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-07 20:10:06 -05:00
|
|
|
impl<T, E: copy> result<T, E> {
|
2012-06-22 19:32:52 -05:00
|
|
|
fn get_err() -> E { get_err(self) }
|
2012-05-26 22:33:08 -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-03 21:59:04 -05:00
|
|
|
ok(t) => ok(op(t)),
|
|
|
|
err(e) => err(e)
|
2012-05-26 22:33:08 -05:00
|
|
|
}
|
|
|
|
}
|
2012-06-22 19:32:52 -05:00
|
|
|
}
|
2012-05-26 22:33:08 -05:00
|
|
|
|
2012-08-07 20:10:06 -05:00
|
|
|
impl<T: copy, E: copy> result<T, E> {
|
2012-06-22 19:32:52 -05:00
|
|
|
fn chain<U:copy>(op: fn(T) -> result<U,E>) -> result<U,E> {
|
|
|
|
chain(self, op)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn chain_err<F:copy>(op: fn(E) -> result<T,F>) -> result<T,F> {
|
|
|
|
chain_err(self, op)
|
2012-05-26 22:33:08 -05:00
|
|
|
}
|
2012-03-25 15:54:05 -05:00
|
|
|
}
|
2012-03-13 19:46:16 -05:00
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* 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); }
|
2012-07-04 16:53:12 -05:00
|
|
|
* }
|
2012-07-11 18:49:02 -05:00
|
|
|
* map(~[1u, 2u, 3u], inc_conditionally).chain {|incd|
|
|
|
|
* assert incd == ~[2u, 3u, 4u];
|
2012-07-04 16:53:12 -05:00
|
|
|
* }
|
|
|
|
*/
|
2012-05-26 21:15:50 -05:00
|
|
|
fn map_vec<T,U:copy,V:copy>(
|
2012-08-08 14:58:22 -05:00
|
|
|
ts: &[T], op: fn(T) -> result<V,U>) -> result<~[V],U> {
|
2012-04-20 17:46:57 -05:00
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
let mut vs: ~[V] = ~[];
|
2012-03-13 19:46:16 -05:00
|
|
|
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-03 21:59:04 -05:00
|
|
|
ok(v) => vec::push(vs, v),
|
|
|
|
err(u) => return err(u)
|
2012-03-13 19:46:16 -05:00
|
|
|
}
|
|
|
|
}
|
2012-08-01 19:30:05 -05:00
|
|
|
return ok(vs);
|
2012-03-13 19:46:16 -05:00
|
|
|
}
|
|
|
|
|
2012-04-20 17:46:57 -05:00
|
|
|
fn map_opt<T,U:copy,V:copy>(
|
|
|
|
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-03 21:59:04 -05:00
|
|
|
none => ok(none),
|
2012-08-06 14:34:08 -05:00
|
|
|
some(t) => match op(t) {
|
2012-08-03 21:59:04 -05:00
|
|
|
ok(v) => ok(some(v)),
|
|
|
|
err(e) => err(e)
|
2012-04-20 17:46:57 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-08-08 14:58:22 -05:00
|
|
|
fn map_vec2<S,T,U:copy,V:copy>(ss: &[S], ts: &[T],
|
2012-07-13 20:43:52 -05:00
|
|
|
op: fn(S,T) -> result<V,U>) -> result<~[V],U> {
|
2012-03-25 15:54:05 -05:00
|
|
|
|
2012-07-13 20:43:52 -05:00
|
|
|
assert vec::same_length(ss, ts);
|
2012-03-13 19:46:16 -05:00
|
|
|
let n = vec::len(ts);
|
2012-06-29 18:26:56 -05:00
|
|
|
let mut vs = ~[];
|
2012-03-13 19:46:16 -05:00
|
|
|
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-03 21:59:04 -05:00
|
|
|
ok(v) => vec::push(vs, v),
|
|
|
|
err(u) => return err(u)
|
2012-03-13 19:46:16 -05:00
|
|
|
}
|
|
|
|
i += 1u;
|
|
|
|
}
|
2012-08-01 19:30:05 -05:00
|
|
|
return ok(vs);
|
2012-03-13 19:46:16 -05:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-08-08 14:58:22 -05:00
|
|
|
fn iter_vec2<S,T,U:copy>(ss: &[S], ts: &[T],
|
2012-07-13 20:43:52 -05:00
|
|
|
op: fn(S,T) -> result<(),U>) -> result<(),U> {
|
2012-03-25 15:54:05 -05:00
|
|
|
|
2012-07-13 20:43:52 -05:00
|
|
|
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-03 21:59:04 -05:00
|
|
|
ok(()) => (),
|
|
|
|
err(u) => return err(u)
|
2012-03-22 22:06:01 -05:00
|
|
|
}
|
|
|
|
i += 1u;
|
|
|
|
}
|
2012-08-01 19:30:05 -05:00
|
|
|
return ok(());
|
2012-03-22 22:06:01 -05:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Unwraps a result, assuming it is an `ok(T)`
|
2012-06-24 22:18:18 -05:00
|
|
|
fn unwrap<T, U>(-res: result<T, U>) -> T {
|
|
|
|
unsafe {
|
2012-08-06 14:34:08 -05:00
|
|
|
let addr = match res {
|
2012-08-03 21:59:04 -05:00
|
|
|
ok(x) => ptr::addr_of(x),
|
|
|
|
err(_) => fail ~"error result"
|
2012-06-24 22:18:18 -05:00
|
|
|
};
|
|
|
|
let liberated_value = unsafe::reinterpret_cast(*addr);
|
|
|
|
unsafe::forget(res);
|
2012-08-01 19:30:05 -05:00
|
|
|
return liberated_value;
|
2012-06-24 22:18:18 -05:00
|
|
|
}
|
2012-05-02 18:19:30 -05:00
|
|
|
}
|
|
|
|
|
2012-01-17 19:28:21 -06:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2012-07-14 00:57:48 -05:00
|
|
|
fn op1() -> result::result<int, ~str> { result::ok(666) }
|
2012-01-17 19:28:21 -06:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn op2(&&i: int) -> result::result<uint, ~str> {
|
2012-03-13 16:39:28 -05:00
|
|
|
result::ok(i as uint + 1u)
|
|
|
|
}
|
2012-01-17 19:28:21 -06:00
|
|
|
|
2012-07-14 00:57:48 -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() {
|
2012-07-14 00:57:48 -05:00
|
|
|
assert get_err(chain(op3(), op2)) == ~"sadface";
|
2012-01-17 19:28:21 -06:00
|
|
|
}
|
2012-05-26 22:33:08 -05:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_impl_iter() {
|
|
|
|
let mut valid = false;
|
2012-07-14 00:57:48 -05:00
|
|
|
ok::<~str, ~str>(~"a").iter(|_x| valid = true);
|
2012-05-26 22:33:08 -05:00
|
|
|
assert valid;
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
err::<~str, ~str>(~"b").iter(|_x| valid = false);
|
2012-05-26 22:33:08 -05:00
|
|
|
assert valid;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_impl_iter_err() {
|
|
|
|
let mut valid = true;
|
2012-07-14 00:57:48 -05:00
|
|
|
ok::<~str, ~str>(~"a").iter_err(|_x| valid = false);
|
2012-05-26 22:33:08 -05:00
|
|
|
assert valid;
|
|
|
|
|
|
|
|
valid = false;
|
2012-07-14 00:57:48 -05:00
|
|
|
err::<~str, ~str>(~"b").iter_err(|_x| valid = true);
|
2012-05-26 22:33:08 -05:00
|
|
|
assert valid;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_impl_map() {
|
2012-07-14 00:57:48 -05:00
|
|
|
assert ok::<~str, ~str>(~"a").map(|_x| ~"b") == ok(~"b");
|
|
|
|
assert err::<~str, ~str>(~"a").map(|_x| ~"b") == err(~"a");
|
2012-05-26 22:33:08 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_impl_map_err() {
|
2012-07-14 00:57:48 -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-05-26 22:33:08 -05:00
|
|
|
}
|
2012-01-17 19:28:21 -06:00
|
|
|
}
|