/**
* Convert to the `either` type
*
- * `ok` result variants are converted to `either::right` variants, `err`
- * result variants are converted to `either::left`.
+ * `Ok` result variants are converted to `either::Right` variants, `Err`
+ * result variants are converted to `either::Left`.
*/
#[inline]
pub fn to_either(self)-> Either<E, T>{
#[inline]
pub fn get_ref<'a>(&'a self) -> &'a T {
match *self {
- Ok(ref t) => t,
- Err(ref the_err) =>
- fail!("get_ref called on error result: %?", *the_err)
+ Ok(ref t) => t,
+ Err(ref e) => fail!("get_ref called on `Err` result: %?", *e),
}
}
- /// Returns true if the result is `ok`
+ /// Returns true if the result is `Ok`
#[inline]
pub fn is_ok(&self) -> bool {
match *self {
}
}
- /// Returns true if the result is `err`
+ /// Returns true if the result is `Err`
#[inline]
pub fn is_err(&self) -> bool {
!self.is_ok()
/**
* Call a method based on a previous result
*
- * If `*self` is `ok` then the value is extracted and passed to `op` whereupon
- * `op`s result is returned. if `*self` is `err` then it is immediately
- * returned. This function can be used to compose the results of two
- * functions.
+ * If `self` is `Ok` then the value is extracted and passed to `op`
+ * whereupon `op`s result is returned. if `self` is `Err` then it is
+ * immediately returned. This function can be used to compose the results
+ * of two functions.
*
* Example:
*
- * read_file(file).iter() { |buf|
+ * do read_file(file).iter |buf| {
* print_buf(buf)
* }
*/
pub fn iter(&self, f: &fn(&T)) {
match *self {
Ok(ref t) => f(t),
- Err(_) => ()
+ Err(_) => (),
}
}
/**
* Call a method based on a previous result
*
- * If `*self` is `err` then the value is extracted and passed to `op` whereupon
- * `op`s result is returned. if `*self` is `ok` then it is immediately returned.
- * This function can be used to pass through a successful result while
- * handling an error.
+ * If `self` is `Err` then the value is extracted and passed to `op`
+ * whereupon `op`s result is returned. if `self` is `Ok` then it is
+ * immediately returned. This function can be used to pass through a
+ * successful result while handling an error.
*/
#[inline]
pub fn iter_err(&self, f: &fn(&E)) {
match *self {
Ok(_) => (),
- Err(ref e) => f(e)
+ Err(ref e) => f(e),
}
}
- /// Unwraps a result, assuming it is an `ok(T)`
+ /// Unwraps a result, assuming it is an `Ok(T)`
#[inline]
pub fn unwrap(self) -> T {
match self {
Ok(t) => t,
- Err(_) => fail!("unwrap called on an err result")
+ Err(_) => fail!("unwrap called on an `Err` result"),
}
}
- /// Unwraps a result, assuming it is an `err(U)`
+ /// Unwraps a result, assuming it is an `Err(U)`
#[inline]
pub fn unwrap_err(self) -> E {
match self {
- Err(u) => u,
- Ok(_) => fail!("unwrap called on an ok result")
+ Err(e) => e,
+ Ok(_) => fail!("unwrap called on an `Ok` result"),
}
}
/**
* Call a method based on a previous result
*
- * If `self` is `ok` then the value is extracted and passed to `op` whereupon
- * `op`s result is returned. if `self` is `err` then it is immediately
- * returned. This function can be used to compose the results of two
- * functions.
+ * If `self` is `Ok` then the value is extracted and passed to `op`
+ * whereupon `op`s result is returned. if `self` is `Err` then it is
+ * immediately returned. This function can be used to compose the results
+ * of two functions.
*
* Example:
*
- * let res = do read_file(file).chain |buf| {
- * ok(parse_bytes(buf))
+ * let res = do read_file(file) |buf| {
+ * Ok(parse_bytes(buf))
* };
*/
#[inline]
- pub fn chain<U>(self, op: &fn(T) -> Result<U,E>) -> Result<U,E> {
+ pub fn chain<U>(self, op: &fn(T) -> Result<U, E>) -> Result<U, E> {
match self {
Ok(t) => op(t),
- Err(e) => Err(e)
+ Err(e) => Err(e),
}
}
/**
- * Call a method based on a previous result
- *
- * If `self` is `err` then the value is extracted and passed to `op`
- * whereupon `op`s result is returned. if `self` is `ok` then it is
- * immediately returned. This function can be used to pass through a
- * successful result while handling an error.
- */
+ * Call a function based on a previous result
+ *
+ * If `self` is `Err` then the value is extracted and passed to `op`
+ * whereupon `op`s result is returned. if `self` is `Ok` then it is
+ * immediately returned. This function can be used to pass through a
+ * successful result while handling an error.
+ */
#[inline]
- pub fn chain_err<F>(self, op: &fn(E) -> Result<T,F>) -> Result<T,F> {
+ pub fn chain_err<F>(self, op: &fn(E) -> Result<T, F>) -> Result<T, F> {
match self {
Ok(t) => Ok(t),
- Err(v) => op(v)
+ Err(e) => op(e),
}
}
}
-impl<T:Clone,E> Result<T, E> {
+impl<T: Clone, E> Result<T, E> {
/**
* Get the value out of a successful result
*
#[inline]
pub fn get(&self) -> T {
match *self {
- Ok(ref t) => (*t).clone(),
- Err(ref e) => fail!("get called on error result: %?", *e),
+ Ok(ref t) => t.clone(),
+ Err(ref e) => fail!("get called on `Err` result: %?", *e),
}
}
/**
* Call a method based on a previous result
*
- * If `*self` is `err` then the value is extracted and passed to `op` whereupon
- * `op`s result is wrapped in an `err` and returned. if `*self` is `ok` then it
- * is immediately returned. This function can be used to pass through a
- * successful result while handling an error.
+ * If `self` is `Err` then the value is extracted and passed to `op`
+ * whereupon `op`s result is wrapped in an `Err` and returned. if `self` is
+ * `Ok` then it is immediately returned. This function can be used to pass
+ * through a successful result while handling an error.
*/
#[inline]
pub fn map_err<F:Clone>(&self, op: &fn(&E) -> F) -> Result<T,F> {
}
}
-impl<T, E:Clone> Result<T, E> {
+impl<T, E: Clone> Result<T, E> {
/**
* Get the value out of an error result
*
#[inline]
pub fn get_err(&self) -> E {
match *self {
- Err(ref u) => (*u).clone(),
- Ok(_) => fail!("get_err called on ok result"),
+ Err(ref e) => e.clone(),
+ Ok(_) => fail!("get_err called on `Ok` result")
}
}
/**
* Call a method 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.
+ * If `self` is `Ok` then the value is extracted and passed to `op`
+ * whereupon `op`s result is wrapped in `Ok` and returned. if `self` is
+ * `Err` then it is immediately returned. This function can be used to
+ * compose the results of two functions.
*
* Example:
*
- * let res = read_file(file).map() { |buf|
+ * let res = do read_file(file).map |buf| {
* parse_bytes(buf)
- * });
+ * };
*/
#[inline]
pub fn map<U:Clone>(&self, op: &fn(&T) -> U) -> Result<U,E> {
* checking for overflow:
*
* fn inc_conditionally(x: uint) -> result<uint,str> {
- * if x == uint::max_value { return err("overflow"); }
- * else { return ok(x+1u); }
+ * 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]);
return Ok(());
}
-
#[cfg(test)]
mod tests {
use result::{Err, Ok, Result};