src/libstd/option.rs - third_party/rust - Git at Google

 // Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.

 /*!

 Operations on the ubiquitous `Option` type.

 Type `Option` represents an optional value.

 Every `Option<T>` value can either be `Some(T)` or `None`. Where in other
 languages you might use a nullable type, in Rust you would use an option
 type.

 Options are most commonly used with pattern matching to query the presence
 of a value and take action, always accounting for the `None` case.

 # Example

  ```
 let msg = Some(~"howdy");

 // Take a reference to the contained string
 match msg {
     Some(ref m) => io::println(*m),
     None => ()
 }

 // Remove the contained string, destroying the Option
 let unwrapped_msg = match msg {
     Some(m) => m,
     None => ~"default message"
 };
  ```

 */

 use clone::Clone;
 use cmp::{Eq,Ord};
 use default::Default;
 use either;
 use util;
 use num::Zero;
 use iter;
 use iter::{Iterator, DoubleEndedIterator, ExactSize};
 use result;
 use str::{StrSlice, OwnedStr};
 use to_str::ToStr;
 use clone::DeepClone;

 /// The option type
 #[deriving(Clone, DeepClone, Eq)]
 pub enum Option<T> {
     None,
     Some(T),
 }

 impl<T: Eq + Ord> Ord for Option<T> {
     fn lt(&self, other: &Option<T>) -> bool {
         iter::order::lt(self.iter(), other.iter())
     }

     fn le(&self, other: &Option<T>) -> bool {
         iter::order::le(self.iter(), other.iter())
     }

     fn ge(&self, other: &Option<T>) -> bool {
         iter::order::ge(self.iter(), other.iter())
     }

     fn gt(&self, other: &Option<T>) -> bool {
         iter::order::gt(self.iter(), other.iter())
     }
 }

 // FIXME: #8242 implementing manually because deriving doesn't work for some reason
 impl<T: ToStr> ToStr for Option<T> {
     fn to_str(&self) -> ~str {
         match *self {
             Some(ref x) => {
                 let mut s = ~"Some(";
                 s.push_str(x.to_str());
                 s.push_str(")");
                 s
             }
             None => ~"None"
         }
     }
 }

 impl<T> Option<T> {
     /// Return an iterator over the possibly contained value
     #[inline]
     pub fn iter<'r>(&'r self) -> OptionIterator<&'r T> {
         match *self {
             Some(ref x) => OptionIterator{opt: Some(x)},
             None => OptionIterator{opt: None}
         }
     }

     /// Return a mutable iterator over the possibly contained value
     #[inline]
     pub fn mut_iter<'r>(&'r mut self) -> OptionIterator<&'r mut T> {
         match *self {
             Some(ref mut x) => OptionIterator{opt: Some(x)},
             None => OptionIterator{opt: None}
         }
     }

     /// Return a consuming iterator over the possibly contained value
     #[inline]
     pub fn move_iter(self) -> OptionIterator<T> {
         OptionIterator{opt: self}
     }

     /// Returns true if the option equals `None`
     #[inline]
     pub fn is_none(&self) -> bool {
         match *self { None => true, Some(_) => false }
     }

     /// Returns true if the option contains a `Some` value
     #[inline]
     pub fn is_some(&self) -> bool { !self.is_none() }

     /// Returns `None` if the option is `None`, otherwise returns `optb`.
     #[inline]
     pub fn and(self, optb: Option<T>) -> Option<T> {
         match self {
             Some(_) => optb,
             None => None,
         }
     }

     /// Returns `None` if the option is `None`, otherwise calls `f` with the
     /// wrapped value and returns the result.
     #[inline]
     pub fn and_then<U>(self, f: &fn(T) -> Option<U>) -> Option<U> {
         match self {
             Some(x) => f(x),
             None => None,
         }
     }

     /// Returns `None` if the option is `None`, otherwise calls `f` with a
     /// reference to the wrapped value and returns the result.
     #[inline]
     pub fn and_then_ref<'a, U>(&'a self, f: &fn(&'a T) -> Option<U>) -> Option<U> {
         match *self {
             Some(ref x) => f(x),
             None => None
         }
     }

     /// Returns `None` if the option is `None`, otherwise calls `f` with a
     /// mutable reference to the wrapped value and returns the result.
     #[inline]
     pub fn and_then_mut_ref<'a, U>(&'a mut self, f: &fn(&'a mut T) -> Option<U>) -> Option<U> {
         match *self {
             Some(ref mut x) => f(x),
             None => None
         }
     }

     /// Returns the option if it contains a value, otherwise returns `optb`.
     #[inline]
     pub fn or(self, optb: Option<T>) -> Option<T> {
         match self {
             Some(_) => self,
             None => optb
         }
     }

     /// Returns the option if it contains a value, otherwise calls `f` and
     /// returns the result.
     #[inline]
     pub fn or_else(self, f: &fn() -> Option<T>) -> Option<T> {
         match self {
             Some(_) => self,
             None => f(),
         }
     }

     /// Filters an optional value using given function.
     #[inline(always)]
     pub fn filtered(self, f: &fn(t: &T) -> bool) -> Option<T> {
         match self {
             Some(x) => if(f(&x)) {Some(x)} else {None},
             None => None
         }
     }

     /// Maps a `Some` value from one type to another by reference
     #[inline]
     pub fn map<'a, U>(&'a self, f: &fn(&'a T) -> U) -> Option<U> {
         match *self { Some(ref x) => Some(f(x)), None => None }
     }

     /// Maps a `Some` value from one type to another by a mutable reference
     #[inline]
     pub fn map_mut<'a, U>(&'a mut self, f: &fn(&'a mut T) -> U) -> Option<U> {
         match *self { Some(ref mut x) => Some(f(x)), None => None }
     }

     /// Applies a function to the contained value or returns a default
     #[inline]
     pub fn map_default<'a, U>(&'a self, def: U, f: &fn(&'a T) -> U) -> U {
         match *self { None => def, Some(ref t) => f(t) }
     }

     /// Maps a `Some` value from one type to another by a mutable reference,
     /// or returns a default value.
     #[inline]
     pub fn map_mut_default<'a, U>(&'a mut self, def: U, f: &fn(&'a mut T) -> U) -> U {
         match *self { Some(ref mut x) => f(x), None => def }
     }

     /// As `map`, but consumes the option and gives `f` ownership to avoid
     /// copying.
     #[inline]
     pub fn map_move<U>(self, f: &fn(T) -> U) -> Option<U> {
         match self { Some(x) => Some(f(x)), None => None }
     }

     /// As `map_default`, but consumes the option and gives `f`
     /// ownership to avoid copying.
     #[inline]
     pub fn map_move_default<U>(self, def: U, f: &fn(T) -> U) -> U {
         match self { None => def, Some(t) => f(t) }
     }

     /// Take the value out of the option, leaving a `None` in its place.
     #[inline]
     pub fn take(&mut self) -> Option<T> {
         util::replace(self, None)
     }

     /// Apply a function to the contained value or do nothing.
     /// Returns true if the contained value was mutated.
     pub fn mutate(&mut self, f: &fn(T) -> T) -> bool {
         if self.is_some() {
             *self = Some(f(self.take_unwrap()));
             true
         } else { false }
     }

     /// Apply a function to the contained value or set it to a default.
     /// Returns true if the contained value was mutated, or false if set to the default.
     pub fn mutate_default(&mut self, def: T, f: &fn(T) -> T) -> bool {
         if self.is_some() {
             *self = Some(f(self.take_unwrap()));
             true
         } else {
             *self = Some(def);
             false
         }
     }

     /// Gets an immutable reference to the value inside an option.
     ///
     /// # Failure
     ///
     /// Fails if the value equals `None`
     ///
     /// # Safety note
     ///
     /// In general, because this function may fail, its use is discouraged
     /// (calling `get` on `None` is akin to dereferencing a null pointer).
     /// Instead, prefer to use pattern matching and handle the `None`
     /// case explicitly.
     #[inline]
     pub fn get_ref<'a>(&'a self) -> &'a T {
         match *self {
             Some(ref x) => x,
             None => fail!("called `Option::get_ref()` on a `None` value"),
         }
     }

     /// Gets a mutable reference to the value inside an option.
     ///
     /// # Failure
     ///
     /// Fails if the value equals `None`
     ///
     /// # Safety note
     ///
     /// In general, because this function may fail, its use is discouraged
     /// (calling `get` on `None` is akin to dereferencing a null pointer).
     /// Instead, prefer to use pattern matching and handle the `None`
     /// case explicitly.
     #[inline]
     pub fn get_mut_ref<'a>(&'a mut self) -> &'a mut T {
         match *self {
             Some(ref mut x) => x,
             None => fail!("called `Option::get_mut_ref()` on a `None` value"),
         }
     }

     /// Moves a value out of an option type and returns it.
     ///
     /// Useful primarily for getting strings, vectors and unique pointers out
     /// of option types without copying them.
     ///
     /// # Failure
     ///
     /// Fails if the value equals `None`.
     ///
     /// # Safety note
     ///
     /// In general, because this function may fail, its use is discouraged.
     /// Instead, prefer to use pattern matching and handle the `None`
     /// case explicitly.
     #[inline]
     pub fn unwrap(self) -> T {
         match self {
             Some(x) => x,
             None => fail!("called `Option::unwrap()` on a `None` value"),
         }
     }

     /// The option dance. Moves a value out of an option type and returns it,
     /// replacing the original with `None`.
     ///
     /// # Failure
     ///
     /// Fails if the value equals `None`.
     #[inline]
     pub fn take_unwrap(&mut self) -> T {
         if self.is_none() {
             fail!("called `Option::take_unwrap()` on a `None` value")
         }
         self.take().unwrap()
     }

     ///  Gets the value out of an option, printing a specified message on
     ///  failure
     ///
     ///  # Failure
     ///
     ///  Fails if the value equals `None`
     #[inline]
     pub fn expect(self, reason: &str) -> T {
         match self {
             Some(val) => val,
             None => fail!(reason.to_owned()),
         }
     }

     /// Returns the contained value or a default
     #[inline]
     pub fn unwrap_or(self, def: T) -> T {
         match self {
             Some(x) => x,
             None => def
         }
     }

     /// Returns the contained value or computes it from a closure
     #[inline]
     pub fn unwrap_or_else(self, f: &fn() -> T) -> T {
         match self {
             Some(x) => x,
             None => f()
         }
     }

     /// Applies a function zero or more times until the result is `None`.
     #[inline]
     pub fn while_some(self, blk: &fn(v: T) -> Option<T>) {
         let mut opt = self;
         while opt.is_some() {
             opt = blk(opt.unwrap());
         }
     }
 }

 /// A generic trait for converting a value to a `Option`
 pub trait ToOption<T> {
     /// Convert to the `option` type
     fn to_option(&self) -> Option<T>;
 }

 /// A generic trait for converting a value to a `Option`
 pub trait IntoOption<T> {
     /// Convert to the `option` type
     fn into_option(self) -> Option<T>;
 }

 /// A generic trait for converting a value to a `Option`
 pub trait AsOption<T> {
     /// Convert to the `option` type
     fn as_option<'a>(&'a self) -> Option<&'a T>;
 }

 impl<T: Clone> ToOption<T> for Option<T> {
     #[inline]
     fn to_option(&self) -> Option<T> { self.clone() }
 }

 impl<T> IntoOption<T> for Option<T> {
     #[inline]
     fn into_option(self) -> Option<T> { self }
 }

 impl<T> AsOption<T> for Option<T> {
     #[inline]
     fn as_option<'a>(&'a self) -> Option<&'a T> {
         match *self {
             Some(ref x) => Some(x),
             None => None,
         }
     }
 }

 impl<T: Clone> result::ToResult<T, ()> for Option<T> {
     #[inline]
     fn to_result(&self) -> result::Result<T, ()> {
         match *self {
             Some(ref x) => result::Ok(x.clone()),
             None => result::Err(()),
         }
     }
 }

 impl<T> result::IntoResult<T, ()> for Option<T> {
     #[inline]
     fn into_result(self) -> result::Result<T, ()> {
         match self {
             Some(x) => result::Ok(x),
             None => result::Err(()),
         }
     }
 }

 impl<T: Clone> either::ToEither<(), T> for Option<T> {
     #[inline]
     fn to_either(&self) -> either::Either<(), T> {
         match *self {
             Some(ref x) => either::Right(x.clone()),
             None => either::Left(()),
         }
     }
 }

 impl<T> either::IntoEither<(), T> for Option<T> {
     #[inline]
     fn into_either(self) -> either::Either<(), T> {
         match self {
             Some(x) => either::Right(x),
             None => either::Left(()),
         }
     }
 }

 impl<T: Default> Option<T> {
     /// Returns the contained value or default (for this type)
     #[inline]
     pub fn unwrap_or_default(self) -> T {
         match self {
             Some(x) => x,
             None => Default::default()
         }
     }
 }

 impl<T> Default for Option<T> {
     #[inline]
     fn default() -> Option<T> { None }
 }

 impl<T: Zero> Option<T> {
     /// Returns the contained value or zero (for this type)
     #[inline]
     pub fn unwrap_or_zero(self) -> T {
         match self {
             Some(x) => x,
             None => Zero::zero()
         }
     }
 }

 /// An iterator that yields either one or zero elements
 #[deriving(Clone, DeepClone)]
 pub struct OptionIterator<A> {
     priv opt: Option<A>
 }

 impl<A> Iterator<A> for OptionIterator<A> {
     #[inline]
     fn next(&mut self) -> Option<A> {
         self.opt.take()
     }

     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) {
         match self.opt {
             Some(_) => (1, Some(1)),
             None => (0, Some(0)),
         }
     }
 }

 impl<A> DoubleEndedIterator<A> for OptionIterator<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
         self.opt.take()
     }
 }

 impl<A> ExactSize<A> for OptionIterator<A> {}

 #[cfg(test)]
 mod tests {
     use super::*;

     use either::{IntoEither, ToEither};
     use either;
     use result::{IntoResult, ToResult};
     use result;
     use util;

     #[test]
     fn test_get_ptr() {
         unsafe {
             let x = ~0;
             let addr_x: *int = ::cast::transmute(&*x);
             let opt = Some(x);
             let y = opt.unwrap();
             let addr_y: *int = ::cast::transmute(&*y);
             assert_eq!(addr_x, addr_y);
         }
     }

     #[test]
     fn test_get_str() {
         let x = ~"test";
         let addr_x = x.as_imm_buf(|buf, _len| buf);
         let opt = Some(x);
         let y = opt.unwrap();
         let addr_y = y.as_imm_buf(|buf, _len| buf);
         assert_eq!(addr_x, addr_y);
     }

     #[test]
     fn test_get_resource() {
         struct R {
            i: @mut int,
         }

         #[unsafe_destructor]
         impl ::ops::Drop for R {
            fn drop(&mut self) { *(self.i) += 1; }
         }

         fn R(i: @mut int) -> R {
             R {
                 i: i
             }
         }

         let i = @mut 0;
         {
             let x = R(i);
             let opt = Some(x);
             let _y = opt.unwrap();
         }
         assert_eq!(*i, 1);
     }

     #[test]
     fn test_option_dance() {
         let x = Some(());
         let mut y = Some(5);
         let mut y2 = 0;
         for _x in x.iter() {
             y2 = y.take_unwrap();
         }
         assert_eq!(y2, 5);
         assert!(y.is_none());
     }
     #[test] #[should_fail]
     fn test_option_too_much_dance() {
         let mut y = Some(util::NonCopyable);
         let _y2 = y.take_unwrap();
         let _y3 = y.take_unwrap();
     }

     #[test]
     fn test_and() {
         let x: Option<int> = Some(1);
         assert_eq!(x.and(Some(2)), Some(2));
         assert_eq!(x.and(None), None);

         let x: Option<int> = None;
         assert_eq!(x.and(Some(2)), None);
         assert_eq!(x.and(None), None);
     }

     #[test]
     fn test_and_then() {
         let x: Option<int> = Some(1);
         assert_eq!(x.and_then(|x| Some(x + 1)), Some(2));
         assert_eq!(x.and_then(|_| None::<int>), None);

         let x: Option<int> = None;
         assert_eq!(x.and_then(|x| Some(x + 1)), None);
         assert_eq!(x.and_then(|_| None::<int>), None);
     }

     #[test]
     fn test_or() {
         let x: Option<int> = Some(1);
         assert_eq!(x.or(Some(2)), Some(1));
         assert_eq!(x.or(None), Some(1));

         let x: Option<int> = None;
         assert_eq!(x.or(Some(2)), Some(2));
         assert_eq!(x.or(None), None);
     }

     #[test]
     fn test_or_else() {
         let x: Option<int> = Some(1);
         assert_eq!(x.or_else(|| Some(2)), Some(1));
         assert_eq!(x.or_else(|| None), Some(1));

         let x: Option<int> = None;
         assert_eq!(x.or_else(|| Some(2)), Some(2));
         assert_eq!(x.or_else(|| None), None);
     }

     #[test]
     fn test_option_while_some() {
         let mut i = 0;
         do Some(10).while_some |j| {
             i += 1;
             if (j > 0) {
                 Some(j-1)
             } else {
                 None
             }
         }
         assert_eq!(i, 11);
     }

     #[test]
     fn test_unwrap() {
         assert_eq!(Some(1).unwrap(), 1);
         assert_eq!(Some(~"hello").unwrap(), ~"hello");
     }

     #[test]
     #[should_fail]
     fn test_unwrap_fail1() {
         let x: Option<int> = None;
         x.unwrap();
     }

     #[test]
     #[should_fail]
     fn test_unwrap_fail2() {
         let x: Option<~str> = None;
         x.unwrap();
     }

     #[test]
     fn test_unwrap_or() {
         let x: Option<int> = Some(1);
         assert_eq!(x.unwrap_or(2), 1);

         let x: Option<int> = None;
         assert_eq!(x.unwrap_or(2), 2);
     }

     #[test]
     fn test_unwrap_or_else() {
         let x: Option<int> = Some(1);
         assert_eq!(x.unwrap_or_else(|| 2), 1);

         let x: Option<int> = None;
         assert_eq!(x.unwrap_or_else(|| 2), 2);
     }

     #[test]
     fn test_unwrap_or_zero() {
         let some_stuff = Some(42);
         assert_eq!(some_stuff.unwrap_or_zero(), 42);
         let no_stuff: Option<int> = None;
         assert_eq!(no_stuff.unwrap_or_zero(), 0);
     }

     #[test]
     fn test_filtered() {
         let some_stuff = Some(42);
         let modified_stuff = some_stuff.filtered(|&x| {x < 10});
         assert_eq!(some_stuff.unwrap(), 42);
         assert!(modified_stuff.is_none());
     }

     #[test]
     fn test_iter() {
         let val = 5;

         let x = Some(val);
         let mut it = x.iter();

         assert_eq!(it.size_hint(), (1, Some(1)));
         assert_eq!(it.next(), Some(&val));
         assert_eq!(it.size_hint(), (0, Some(0)));
         assert!(it.next().is_none());
     }

     #[test]
     fn test_mut_iter() {
         let val = 5;
         let new_val = 11;

         let mut x = Some(val);
         let mut it = x.mut_iter();

         assert_eq!(it.size_hint(), (1, Some(1)));

         match it.next() {
             Some(interior) => {
                 assert_eq!(*interior, val);
                 *interior = new_val;
                 assert_eq!(x, Some(new_val));
             }
             None => assert!(false),
         }

         assert_eq!(it.size_hint(), (0, Some(0)));
         assert!(it.next().is_none());
     }

     #[test]
     fn test_ord() {
         let small = Some(1.0);
         let big = Some(5.0);
         let nan = Some(0.0/0.0);
         assert!(!(nan < big));
         assert!(!(nan > big));
         assert!(small < big);
         assert!(None < big);
         assert!(big > None);
     }

     #[test]
     fn test_mutate() {
         let mut x = Some(3i);
         assert!(x.mutate(|i| i+1));
         assert_eq!(x, Some(4i));
         assert!(x.mutate_default(0, |i| i+1));
         assert_eq!(x, Some(5i));
         x = None;
         assert!(!x.mutate(|i| i+1));
         assert_eq!(x, None);
         assert!(!x.mutate_default(0i, |i| i+1));
         assert_eq!(x, Some(0i));
     }

     #[test]
     pub fn test_to_option() {
         let some: Option<int> = Some(100);
         let none: Option<int> = None;

         assert_eq!(some.to_option(), Some(100));
         assert_eq!(none.to_option(), None);
     }

     #[test]
     pub fn test_into_option() {
         let some: Option<int> = Some(100);
         let none: Option<int> = None;

         assert_eq!(some.into_option(), Some(100));
         assert_eq!(none.into_option(), None);
     }

     #[test]
     pub fn test_as_option() {
         let some: Option<int> = Some(100);
         let none: Option<int> = None;

         assert_eq!(some.as_option().unwrap(), &100);
         assert_eq!(none.as_option(), None);
     }

     #[test]
     pub fn test_to_result() {
         let some: Option<int> = Some(100);
         let none: Option<int> = None;

         assert_eq!(some.to_result(), result::Ok(100));
         assert_eq!(none.to_result(), result::Err(()));
     }

     #[test]
     pub fn test_into_result() {
         let some: Option<int> = Some(100);
         let none: Option<int> = None;

         assert_eq!(some.into_result(), result::Ok(100));
         assert_eq!(none.into_result(), result::Err(()));
     }

     #[test]
     pub fn test_to_either() {
         let some: Option<int> = Some(100);
         let none: Option<int> = None;

         assert_eq!(some.to_either(), either::Right(100));
         assert_eq!(none.to_either(), either::Left(()));
     }

     #[test]
     pub fn test_into_either() {
         let some: Option<int> = Some(100);
         let none: Option<int> = None;

         assert_eq!(some.into_either(), either::Right(100));
         assert_eq!(none.into_either(), either::Left(()));
     }
 }
	// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
	// file at the top-level directory of this distribution and at
	// http://rust-lang.org/COPYRIGHT.
	//
	// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
	// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
	// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
	// option. This file may not be copied, modified, or distributed
	// except according to those terms.

	/*!

	Operations on the ubiquitous `Option` type.

	Type `Option` represents an optional value.

	Every `Option<T>` value can either be `Some(T)` or `None`. Where in other
	languages you might use a nullable type, in Rust you would use an option
	type.

	Options are most commonly used with pattern matching to query the presence
	of a value and take action, always accounting for the `None` case.

	# Example

	```
	let msg = Some(~"howdy");

	// Take a reference to the contained string
	match msg {
	Some(ref m) => io::println(*m),
	None => ()
	}

	// Remove the contained string, destroying the Option
	let unwrapped_msg = match msg {
	Some(m) => m,
	None => ~"default message"
	};
	```

	*/

	use clone::Clone;
	use cmp::{Eq,Ord};
	use default::Default;
	use either;
	use util;
	use num::Zero;
	use iter;
	use iter::{Iterator, DoubleEndedIterator, ExactSize};
	use result;
	use str::{StrSlice, OwnedStr};
	use to_str::ToStr;
	use clone::DeepClone;

	/// The option type
	#[deriving(Clone, DeepClone, Eq)]
	pub enum Option<T> {
	None,
	Some(T),
	}

	impl<T: Eq + Ord> Ord for Option<T> {
	fn lt(&self, other: &Option<T>) -> bool {
	iter::order::lt(self.iter(), other.iter())
	}

	fn le(&self, other: &Option<T>) -> bool {
	iter::order::le(self.iter(), other.iter())
	}

	fn ge(&self, other: &Option<T>) -> bool {
	iter::order::ge(self.iter(), other.iter())
	}

	fn gt(&self, other: &Option<T>) -> bool {
	iter::order::gt(self.iter(), other.iter())
	}
	}

	// FIXME: #8242 implementing manually because deriving doesn't work for some reason
	impl<T: ToStr> ToStr for Option<T> {
	fn to_str(&self) -> ~str {
	match *self {
	Some(ref x) => {
	let mut s = ~"Some(";
	s.push_str(x.to_str());
	s.push_str(")");
	s
	}
	None => ~"None"
	}
	}
	}

	impl<T> Option<T> {
	/// Return an iterator over the possibly contained value
	#[inline]
	pub fn iter<'r>(&'r self) -> OptionIterator<&'r T> {
	match *self {
	Some(ref x) => OptionIterator{opt: Some(x)},
	None => OptionIterator{opt: None}
	}
	}

	/// Return a mutable iterator over the possibly contained value
	#[inline]
	pub fn mut_iter<'r>(&'r mut self) -> OptionIterator<&'r mut T> {
	match *self {
	Some(ref mut x) => OptionIterator{opt: Some(x)},
	None => OptionIterator{opt: None}
	}
	}

	/// Return a consuming iterator over the possibly contained value
	#[inline]
	pub fn move_iter(self) -> OptionIterator<T> {
	OptionIterator{opt: self}
	}

	/// Returns true if the option equals `None`
	#[inline]
	pub fn is_none(&self) -> bool {
	match *self { None => true, Some(_) => false }
	}

	/// Returns true if the option contains a `Some` value
	#[inline]
	pub fn is_some(&self) -> bool { !self.is_none() }

	/// Returns `None` if the option is `None`, otherwise returns `optb`.
	#[inline]
	pub fn and(self, optb: Option<T>) -> Option<T> {
	match self {
	Some(_) => optb,
	None => None,
	}
	}

	/// Returns `None` if the option is `None`, otherwise calls `f` with the
	/// wrapped value and returns the result.
	#[inline]
	pub fn and_then<U>(self, f: &fn(T) -> Option<U>) -> Option<U> {
	match self {
	Some(x) => f(x),
	None => None,
	}
	}

	/// Returns `None` if the option is `None`, otherwise calls `f` with a
	/// reference to the wrapped value and returns the result.
	#[inline]
	pub fn and_then_ref<'a, U>(&'a self, f: &fn(&'a T) -> Option<U>) -> Option<U> {
	match *self {
	Some(ref x) => f(x),
	None => None
	}
	}

	/// Returns `None` if the option is `None`, otherwise calls `f` with a
	/// mutable reference to the wrapped value and returns the result.
	#[inline]
	pub fn and_then_mut_ref<'a, U>(&'a mut self, f: &fn(&'a mut T) -> Option<U>) -> Option<U> {
	match *self {
	Some(ref mut x) => f(x),
	None => None
	}
	}

	/// Returns the option if it contains a value, otherwise returns `optb`.
	#[inline]
	pub fn or(self, optb: Option<T>) -> Option<T> {
	match self {
	Some(_) => self,
	None => optb
	}
	}

	/// Returns the option if it contains a value, otherwise calls `f` and
	/// returns the result.
	#[inline]
	pub fn or_else(self, f: &fn() -> Option<T>) -> Option<T> {
	match self {
	Some(_) => self,
	None => f(),
	}
	}

	/// Filters an optional value using given function.
	#[inline(always)]
	pub fn filtered(self, f: &fn(t: &T) -> bool) -> Option<T> {
	match self {
	Some(x) => if(f(&x)) {Some(x)} else {None},
	None => None
	}
	}

	/// Maps a `Some` value from one type to another by reference
	#[inline]
	pub fn map<'a, U>(&'a self, f: &fn(&'a T) -> U) -> Option<U> {
	match *self { Some(ref x) => Some(f(x)), None => None }
	}

	/// Maps a `Some` value from one type to another by a mutable reference
	#[inline]
	pub fn map_mut<'a, U>(&'a mut self, f: &fn(&'a mut T) -> U) -> Option<U> {
	match *self { Some(ref mut x) => Some(f(x)), None => None }
	}

	/// Applies a function to the contained value or returns a default
	#[inline]
	pub fn map_default<'a, U>(&'a self, def: U, f: &fn(&'a T) -> U) -> U {
	match *self { None => def, Some(ref t) => f(t) }
	}

	/// Maps a `Some` value from one type to another by a mutable reference,
	/// or returns a default value.
	#[inline]
	pub fn map_mut_default<'a, U>(&'a mut self, def: U, f: &fn(&'a mut T) -> U) -> U {
	match *self { Some(ref mut x) => f(x), None => def }
	}

	/// As `map`, but consumes the option and gives `f` ownership to avoid
	/// copying.
	#[inline]
	pub fn map_move<U>(self, f: &fn(T) -> U) -> Option<U> {
	match self { Some(x) => Some(f(x)), None => None }
	}

	/// As `map_default`, but consumes the option and gives `f`
	/// ownership to avoid copying.
	#[inline]
	pub fn map_move_default<U>(self, def: U, f: &fn(T) -> U) -> U {
	match self { None => def, Some(t) => f(t) }
	}

	/// Take the value out of the option, leaving a `None` in its place.
	#[inline]
	pub fn take(&mut self) -> Option<T> {
	util::replace(self, None)
	}

	/// Apply a function to the contained value or do nothing.
	/// Returns true if the contained value was mutated.
	pub fn mutate(&mut self, f: &fn(T) -> T) -> bool {
	if self.is_some() {
	*self = Some(f(self.take_unwrap()));
	true
	} else { false }
	}

	/// Apply a function to the contained value or set it to a default.
	/// Returns true if the contained value was mutated, or false if set to the default.
	pub fn mutate_default(&mut self, def: T, f: &fn(T) -> T) -> bool {
	if self.is_some() {
	*self = Some(f(self.take_unwrap()));
	true
	} else {
	*self = Some(def);
	false
	}
	}

	/// Gets an immutable reference to the value inside an option.
	///
	/// # Failure
	///
	/// Fails if the value equals `None`
	///
	/// # Safety note
	///
	/// In general, because this function may fail, its use is discouraged
	/// (calling `get` on `None` is akin to dereferencing a null pointer).
	/// Instead, prefer to use pattern matching and handle the `None`
	/// case explicitly.
	#[inline]
	pub fn get_ref<'a>(&'a self) -> &'a T {
	match *self {
	Some(ref x) => x,
	None => fail!("called `Option::get_ref()` on a `None` value"),
	}
	}

	/// Gets a mutable reference to the value inside an option.
	///
	/// # Failure
	///
	/// Fails if the value equals `None`
	///
	/// # Safety note
	///
	/// In general, because this function may fail, its use is discouraged
	/// (calling `get` on `None` is akin to dereferencing a null pointer).
	/// Instead, prefer to use pattern matching and handle the `None`
	/// case explicitly.
	#[inline]
	pub fn get_mut_ref<'a>(&'a mut self) -> &'a mut T {
	match *self {
	Some(ref mut x) => x,
	None => fail!("called `Option::get_mut_ref()` on a `None` value"),
	}
	}

	/// Moves a value out of an option type and returns it.
	///
	/// Useful primarily for getting strings, vectors and unique pointers out
	/// of option types without copying them.
	///
	/// # Failure
	///
	/// Fails if the value equals `None`.
	///
	/// # Safety note
	///
	/// In general, because this function may fail, its use is discouraged.
	/// Instead, prefer to use pattern matching and handle the `None`
	/// case explicitly.
	#[inline]
	pub fn unwrap(self) -> T {
	match self {
	Some(x) => x,
	None => fail!("called `Option::unwrap()` on a `None` value"),
	}
	}

	/// The option dance. Moves a value out of an option type and returns it,
	/// replacing the original with `None`.
	///
	/// # Failure
	///
	/// Fails if the value equals `None`.
	#[inline]
	pub fn take_unwrap(&mut self) -> T {
	if self.is_none() {
	fail!("called `Option::take_unwrap()` on a `None` value")
	}
	self.take().unwrap()
	}

	/// Gets the value out of an option, printing a specified message on
	/// failure
	///
	/// # Failure
	///
	/// Fails if the value equals `None`
	#[inline]
	pub fn expect(self, reason: &str) -> T {
	match self {
	Some(val) => val,
	None => fail!(reason.to_owned()),
	}
	}

	/// Returns the contained value or a default
	#[inline]
	pub fn unwrap_or(self, def: T) -> T {
	match self {
	Some(x) => x,
	None => def
	}
	}

	/// Returns the contained value or computes it from a closure
	#[inline]
	pub fn unwrap_or_else(self, f: &fn() -> T) -> T {
	match self {
	Some(x) => x,
	None => f()
	}
	}

	/// Applies a function zero or more times until the result is `None`.
	#[inline]
	pub fn while_some(self, blk: &fn(v: T) -> Option<T>) {
	let mut opt = self;
	while opt.is_some() {
	opt = blk(opt.unwrap());
	}
	}
	}

	/// A generic trait for converting a value to a `Option`
	pub trait ToOption<T> {
	/// Convert to the `option` type
	fn to_option(&self) -> Option<T>;
	}

	/// A generic trait for converting a value to a `Option`
	pub trait IntoOption<T> {
	/// Convert to the `option` type
	fn into_option(self) -> Option<T>;
	}

	/// A generic trait for converting a value to a `Option`
	pub trait AsOption<T> {
	/// Convert to the `option` type
	fn as_option<'a>(&'a self) -> Option<&'a T>;
	}

	impl<T: Clone> ToOption<T> for Option<T> {
	#[inline]
	fn to_option(&self) -> Option<T> { self.clone() }
	}

	impl<T> IntoOption<T> for Option<T> {
	#[inline]
	fn into_option(self) -> Option<T> { self }
	}

	impl<T> AsOption<T> for Option<T> {
	#[inline]
	fn as_option<'a>(&'a self) -> Option<&'a T> {
	match *self {
	Some(ref x) => Some(x),
	None => None,
	}
	}
	}

	impl<T: Clone> result::ToResult<T, ()> for Option<T> {
	#[inline]
	fn to_result(&self) -> result::Result<T, ()> {
	match *self {
	Some(ref x) => result::Ok(x.clone()),
	None => result::Err(()),
	}
	}
	}

	impl<T> result::IntoResult<T, ()> for Option<T> {
	#[inline]
	fn into_result(self) -> result::Result<T, ()> {
	match self {
	Some(x) => result::Ok(x),
	None => result::Err(()),
	}
	}
	}

	impl<T: Clone> either::ToEither<(), T> for Option<T> {
	#[inline]
	fn to_either(&self) -> either::Either<(), T> {
	match *self {
	Some(ref x) => either::Right(x.clone()),
	None => either::Left(()),
	}
	}
	}

	impl<T> either::IntoEither<(), T> for Option<T> {
	#[inline]
	fn into_either(self) -> either::Either<(), T> {
	match self {
	Some(x) => either::Right(x),
	None => either::Left(()),
	}
	}
	}

	impl<T: Default> Option<T> {
	/// Returns the contained value or default (for this type)
	#[inline]
	pub fn unwrap_or_default(self) -> T {
	match self {
	Some(x) => x,
	None => Default::default()
	}
	}
	}

	impl<T> Default for Option<T> {
	#[inline]
	fn default() -> Option<T> { None }
	}

	impl<T: Zero> Option<T> {
	/// Returns the contained value or zero (for this type)
	#[inline]
	pub fn unwrap_or_zero(self) -> T {
	match self {
	Some(x) => x,
	None => Zero::zero()
	}
	}
	}

	/// An iterator that yields either one or zero elements
	#[deriving(Clone, DeepClone)]
	pub struct OptionIterator<A> {
	priv opt: Option<A>
	}

	impl<A> Iterator<A> for OptionIterator<A> {
	#[inline]
	fn next(&mut self) -> Option<A> {
	self.opt.take()
	}

	#[inline]
	fn size_hint(&self) -> (uint, Option<uint>) {
	match self.opt {
	Some(_) => (1, Some(1)),
	None => (0, Some(0)),
	}
	}
	}

	impl<A> DoubleEndedIterator<A> for OptionIterator<A> {
	#[inline]
	fn next_back(&mut self) -> Option<A> {
	self.opt.take()
	}
	}

	impl<A> ExactSize<A> for OptionIterator<A> {}

	#[cfg(test)]
	mod tests {
	use super::*;

	use either::{IntoEither, ToEither};
	use either;
	use result::{IntoResult, ToResult};
	use result;
	use util;

	#[test]
	fn test_get_ptr() {
	unsafe {
	let x = ~0;
	let addr_x: int = ::cast::transmute(&x);
	let opt = Some(x);
	let y = opt.unwrap();
	let addr_y: int = ::cast::transmute(&y);
	assert_eq!(addr_x, addr_y);
	}
	}

	#[test]
	fn test_get_str() {
	let x = ~"test";
	let addr_x = x.as_imm_buf(\|buf, _len\| buf);
	let opt = Some(x);
	let y = opt.unwrap();
	let addr_y = y.as_imm_buf(\|buf, _len\| buf);
	assert_eq!(addr_x, addr_y);
	}

	#[test]
	fn test_get_resource() {
	struct R {
	i: @mut int,
	}

	#[unsafe_destructor]
	impl ::ops::Drop for R {
	fn drop(&mut self) { *(self.i) += 1; }
	}

	fn R(i: @mut int) -> R {
	R {
	i: i
	}
	}

	let i = @mut 0;
	{
	let x = R(i);
	let opt = Some(x);
	let _y = opt.unwrap();
	}
	assert_eq!(*i, 1);
	}

	#[test]
	fn test_option_dance() {
	let x = Some(());
	let mut y = Some(5);
	let mut y2 = 0;
	for _x in x.iter() {
	y2 = y.take_unwrap();
	}
	assert_eq!(y2, 5);
	assert!(y.is_none());
	}
	#[test] #[should_fail]
	fn test_option_too_much_dance() {
	let mut y = Some(util::NonCopyable);
	let _y2 = y.take_unwrap();
	let _y3 = y.take_unwrap();
	}

	#[test]
	fn test_and() {
	let x: Option<int> = Some(1);
	assert_eq!(x.and(Some(2)), Some(2));
	assert_eq!(x.and(None), None);

	let x: Option<int> = None;
	assert_eq!(x.and(Some(2)), None);
	assert_eq!(x.and(None), None);
	}

	#[test]
	fn test_and_then() {
	let x: Option<int> = Some(1);
	assert_eq!(x.and_then(\|x\| Some(x + 1)), Some(2));
	assert_eq!(x.and_then(\|_\| None::<int>), None);

	let x: Option<int> = None;
	assert_eq!(x.and_then(\|x\| Some(x + 1)), None);
	assert_eq!(x.and_then(\|_\| None::<int>), None);
	}

	#[test]
	fn test_or() {
	let x: Option<int> = Some(1);
	assert_eq!(x.or(Some(2)), Some(1));
	assert_eq!(x.or(None), Some(1));

	let x: Option<int> = None;
	assert_eq!(x.or(Some(2)), Some(2));
	assert_eq!(x.or(None), None);
	}

	#[test]
	fn test_or_else() {
	let x: Option<int> = Some(1);
	assert_eq!(x.or_else(\|\| Some(2)), Some(1));
	assert_eq!(x.or_else(\|\| None), Some(1));

	let x: Option<int> = None;
	assert_eq!(x.or_else(\|\| Some(2)), Some(2));
	assert_eq!(x.or_else(\|\| None), None);
	}

	#[test]
	fn test_option_while_some() {
	let mut i = 0;
	do Some(10).while_some \|j\| {
	i += 1;
	if (j > 0) {
	Some(j-1)
	} else {
	None
	}
	}
	assert_eq!(i, 11);
	}

	#[test]
	fn test_unwrap() {
	assert_eq!(Some(1).unwrap(), 1);
	assert_eq!(Some(~"hello").unwrap(), ~"hello");
	}

	#[test]
	#[should_fail]
	fn test_unwrap_fail1() {
	let x: Option<int> = None;
	x.unwrap();
	}

	#[test]
	#[should_fail]
	fn test_unwrap_fail2() {
	let x: Option<~str> = None;
	x.unwrap();
	}

	#[test]
	fn test_unwrap_or() {
	let x: Option<int> = Some(1);
	assert_eq!(x.unwrap_or(2), 1);

	let x: Option<int> = None;
	assert_eq!(x.unwrap_or(2), 2);
	}

	#[test]
	fn test_unwrap_or_else() {
	let x: Option<int> = Some(1);
	assert_eq!(x.unwrap_or_else(\|\| 2), 1);

	let x: Option<int> = None;
	assert_eq!(x.unwrap_or_else(\|\| 2), 2);
	}

	#[test]
	fn test_unwrap_or_zero() {
	let some_stuff = Some(42);
	assert_eq!(some_stuff.unwrap_or_zero(), 42);
	let no_stuff: Option<int> = None;
	assert_eq!(no_stuff.unwrap_or_zero(), 0);
	}

	#[test]
	fn test_filtered() {
	let some_stuff = Some(42);
	let modified_stuff = some_stuff.filtered(\|&x\| {x < 10});
	assert_eq!(some_stuff.unwrap(), 42);
	assert!(modified_stuff.is_none());
	}

	#[test]
	fn test_iter() {
	let val = 5;

	let x = Some(val);
	let mut it = x.iter();

	assert_eq!(it.size_hint(), (1, Some(1)));
	assert_eq!(it.next(), Some(&val));
	assert_eq!(it.size_hint(), (0, Some(0)));
	assert!(it.next().is_none());
	}

	#[test]
	fn test_mut_iter() {
	let val = 5;
	let new_val = 11;

	let mut x = Some(val);
	let mut it = x.mut_iter();

	assert_eq!(it.size_hint(), (1, Some(1)));

	match it.next() {
	Some(interior) => {
	assert_eq!(*interior, val);
	*interior = new_val;
	assert_eq!(x, Some(new_val));
	}
	None => assert!(false),
	}

	assert_eq!(it.size_hint(), (0, Some(0)));
	assert!(it.next().is_none());
	}

	#[test]
	fn test_ord() {
	let small = Some(1.0);
	let big = Some(5.0);
	let nan = Some(0.0/0.0);
	assert!(!(nan < big));
	assert!(!(nan > big));
	assert!(small < big);
	assert!(None < big);
	assert!(big > None);
	}

	#[test]
	fn test_mutate() {
	let mut x = Some(3i);
	assert!(x.mutate(\|i\| i+1));
	assert_eq!(x, Some(4i));
	assert!(x.mutate_default(0, \|i\| i+1));
	assert_eq!(x, Some(5i));
	x = None;
	assert!(!x.mutate(\|i\| i+1));
	assert_eq!(x, None);
	assert!(!x.mutate_default(0i, \|i\| i+1));
	assert_eq!(x, Some(0i));
	}

	#[test]
	pub fn test_to_option() {
	let some: Option<int> = Some(100);
	let none: Option<int> = None;

	assert_eq!(some.to_option(), Some(100));
	assert_eq!(none.to_option(), None);
	}

	#[test]
	pub fn test_into_option() {
	let some: Option<int> = Some(100);
	let none: Option<int> = None;

	assert_eq!(some.into_option(), Some(100));
	assert_eq!(none.into_option(), None);
	}

	#[test]
	pub fn test_as_option() {
	let some: Option<int> = Some(100);
	let none: Option<int> = None;

	assert_eq!(some.as_option().unwrap(), &100);
	assert_eq!(none.as_option(), None);
	}

	#[test]
	pub fn test_to_result() {
	let some: Option<int> = Some(100);
	let none: Option<int> = None;

	assert_eq!(some.to_result(), result::Ok(100));
	assert_eq!(none.to_result(), result::Err(()));
	}

	#[test]
	pub fn test_into_result() {
	let some: Option<int> = Some(100);
	let none: Option<int> = None;

	assert_eq!(some.into_result(), result::Ok(100));
	assert_eq!(none.into_result(), result::Err(()));
	}

	#[test]
	pub fn test_to_either() {
	let some: Option<int> = Some(100);
	let none: Option<int> = None;

	assert_eq!(some.to_either(), either::Right(100));
	assert_eq!(none.to_either(), either::Left(()));
	}

	#[test]
	pub fn test_into_either() {
	let some: Option<int> = Some(100);
	let none: Option<int> = None;

	assert_eq!(some.into_either(), either::Right(100));
	assert_eq!(none.into_either(), either::Left(()));
	}
	}