2012-12-03 18:48:01 -06:00
|
|
|
// Copyright 2012 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.
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
2012-10-04 17:14:28 -05:00
|
|
|
|
|
|
|
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
|
2013-02-15 02:51:28 -06:00
|
|
|
let unwrapped_msg = match msg {
|
|
|
|
Some(m) => m,
|
2012-10-04 17:14:28 -05:00
|
|
|
None => ~"default message"
|
|
|
|
};
|
|
|
|
~~~
|
|
|
|
|
|
|
|
*/
|
2012-07-04 16:53:12 -05:00
|
|
|
|
2013-02-04 19:12:31 -06:00
|
|
|
use cmp::{Eq,Ord};
|
2013-01-08 21:37:25 -06:00
|
|
|
use kinds::Copy;
|
2012-12-23 16:41:37 -06:00
|
|
|
use option;
|
2012-12-27 19:53:04 -06:00
|
|
|
use ptr;
|
|
|
|
use str;
|
2012-12-23 16:41:37 -06:00
|
|
|
use util;
|
2013-01-03 17:36:23 -06:00
|
|
|
use num::Zero;
|
2012-08-27 19:24:15 -05:00
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// The option type
|
2012-12-11 17:16:36 -06:00
|
|
|
#[deriving_eq]
|
2012-10-01 16:08:34 -05:00
|
|
|
pub enum Option<T> {
|
2012-08-20 14:23:37 -05:00
|
|
|
None,
|
|
|
|
Some(T),
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2013-02-04 19:12:31 -06:00
|
|
|
pub impl<T:Ord> Ord for Option<T> {
|
|
|
|
pure fn lt(&self, other: &Option<T>) -> bool {
|
|
|
|
match (self, other) {
|
|
|
|
(&None, &None) => false,
|
|
|
|
(&None, &Some(_)) => true,
|
|
|
|
(&Some(_), &None) => false,
|
|
|
|
(&Some(ref a), &Some(ref b)) => *a < *b
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pure fn le(&self, other: &Option<T>) -> bool {
|
|
|
|
match (self, other) {
|
|
|
|
(&None, &None) => true,
|
|
|
|
(&None, &Some(_)) => true,
|
|
|
|
(&Some(_), &None) => false,
|
|
|
|
(&Some(ref a), &Some(ref b)) => *a <= *b
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pure fn ge(&self, other: &Option<T>) -> bool {
|
|
|
|
! (self < other)
|
|
|
|
}
|
|
|
|
|
|
|
|
pure fn gt(&self, other: &Option<T>) -> bool {
|
|
|
|
! (self <= other)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2012-10-19 13:37:00 -05:00
|
|
|
pub pure fn get<T: Copy>(opt: Option<T>) -> T {
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
2012-10-04 17:14:28 -05:00
|
|
|
Gets the value out of 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.
|
|
|
|
*/
|
2011-12-13 18:25:51 -06:00
|
|
|
|
2012-10-19 13:37:00 -05:00
|
|
|
match opt {
|
2012-09-28 15:00:07 -05:00
|
|
|
Some(copy x) => return x,
|
2013-02-11 21:26:38 -06:00
|
|
|
None => fail!(~"option::get none")
|
2012-08-03 21:59:04 -05:00
|
|
|
}
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2012-10-01 16:08:34 -05:00
|
|
|
pub pure fn get_ref<T>(opt: &r/Option<T>) -> &r/T {
|
2012-08-16 20:06:05 -05:00
|
|
|
/*!
|
2012-10-04 17:14:28 -05:00
|
|
|
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.
|
2012-08-16 20:06:05 -05:00
|
|
|
*/
|
|
|
|
match *opt {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(ref x) => x,
|
2013-02-11 21:26:38 -06:00
|
|
|
None => fail!(~"option::get_ref none")
|
2012-08-16 20:06:05 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2013-02-07 17:30:34 -06:00
|
|
|
pub pure fn map<T, U>(opt: &r/Option<T>, f: fn(x: &r/T) -> U) -> Option<U> {
|
2012-08-14 18:17:59 -05:00
|
|
|
//! Maps a `some` value by reference from one type to another
|
|
|
|
|
2012-08-20 14:23:37 -05:00
|
|
|
match *opt { Some(ref x) => Some(f(x)), None => None }
|
2012-08-14 18:17:59 -05:00
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2012-10-02 13:37:37 -05:00
|
|
|
pub pure fn map_consume<T, U>(opt: Option<T>,
|
|
|
|
f: fn(v: T) -> U) -> Option<U> {
|
2012-07-17 17:24:51 -05:00
|
|
|
/*!
|
|
|
|
* As `map`, but consumes the option and gives `f` ownership to avoid
|
|
|
|
* copying.
|
|
|
|
*/
|
2013-01-13 00:38:20 -06:00
|
|
|
match opt { None => None, Some(v) => Some(f(v)) }
|
2012-07-17 17:24:51 -05:00
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2012-10-02 13:37:37 -05:00
|
|
|
pub pure fn chain<T, U>(opt: Option<T>,
|
|
|
|
f: fn(t: T) -> Option<U>) -> Option<U> {
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
|
|
|
* Update an optional value by optionally running its content through a
|
|
|
|
* function that returns an option.
|
|
|
|
*/
|
2012-03-06 21:09:32 -06:00
|
|
|
|
2013-02-15 02:51:28 -06:00
|
|
|
match opt {
|
|
|
|
Some(t) => f(t),
|
2012-10-11 16:14:46 -05:00
|
|
|
None => None
|
2012-09-27 19:01:28 -05:00
|
|
|
}
|
2012-02-22 06:18:15 -06:00
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2012-10-01 16:08:34 -05:00
|
|
|
pub pure fn chain_ref<T, U>(opt: &Option<T>,
|
|
|
|
f: fn(x: &T) -> Option<U>) -> Option<U> {
|
2012-08-14 18:17:59 -05:00
|
|
|
/*!
|
|
|
|
* Update an optional value by optionally running its content by reference
|
|
|
|
* through a function that returns an option.
|
|
|
|
*/
|
|
|
|
|
2012-08-20 14:23:37 -05:00
|
|
|
match *opt { Some(ref x) => f(x), None => None }
|
2012-08-14 18:17:59 -05:00
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2012-10-02 13:37:37 -05:00
|
|
|
pub pure fn or<T>(opta: Option<T>, optb: Option<T>) -> Option<T> {
|
2012-08-20 19:01:06 -05:00
|
|
|
/*!
|
2013-01-25 13:29:51 -06:00
|
|
|
* Returns the leftmost Some() value, or None if both are None.
|
2012-08-20 19:01:06 -05:00
|
|
|
*/
|
2013-02-15 02:51:28 -06:00
|
|
|
match opta {
|
|
|
|
Some(opta) => Some(opta),
|
|
|
|
_ => optb
|
2012-08-20 19:01:06 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-17 12:54:24 -05:00
|
|
|
#[inline(always)]
|
2012-10-02 13:37:37 -05:00
|
|
|
pub pure fn while_some<T>(x: Option<T>, blk: fn(v: T) -> Option<T>) {
|
2012-07-17 12:54:24 -05:00
|
|
|
//! Applies a function zero or more times until the result is none.
|
|
|
|
|
2013-02-15 02:51:28 -06:00
|
|
|
let mut opt = x;
|
2012-07-17 12:54:24 -05:00
|
|
|
while opt.is_some() {
|
2013-02-15 02:51:28 -06:00
|
|
|
opt = blk(unwrap(opt));
|
2012-07-17 12:54:24 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2012-10-01 16:08:34 -05:00
|
|
|
pub pure fn is_none<T>(opt: &Option<T>) -> bool {
|
2012-07-04 16:53:12 -05:00
|
|
|
//! Returns true if the option equals `none`
|
2012-03-06 21:09:32 -06:00
|
|
|
|
2012-09-21 21:37:57 -05:00
|
|
|
match *opt { None => true, Some(_) => false }
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2012-10-01 16:08:34 -05:00
|
|
|
pub pure fn is_some<T>(opt: &Option<T>) -> bool {
|
2012-07-04 16:53:12 -05:00
|
|
|
//! Returns true if the option contains some value
|
2011-12-13 18:25:51 -06:00
|
|
|
|
2012-03-06 21:09:32 -06:00
|
|
|
!is_none(opt)
|
|
|
|
}
|
2011-12-13 18:25:51 -06:00
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2013-01-04 18:01:26 -06:00
|
|
|
pub pure fn get_or_zero<T: Copy Zero>(opt: Option<T>) -> T {
|
2013-01-03 17:36:23 -06:00
|
|
|
//! Returns the contained value or zero (for this type)
|
|
|
|
|
|
|
|
match opt { Some(copy x) => x, None => Zero::zero() }
|
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2013-01-04 18:01:26 -06:00
|
|
|
pub pure fn get_or_default<T: Copy>(opt: Option<T>, def: T) -> T {
|
2012-07-04 16:53:12 -05:00
|
|
|
//! Returns the contained value or a default
|
2012-03-06 21:09:32 -06:00
|
|
|
|
2012-10-19 13:37:00 -05:00
|
|
|
match opt { Some(copy x) => x, None => def }
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2013-02-07 17:30:34 -06:00
|
|
|
pub pure fn map_default<T, U>(opt: &r/Option<T>, def: U,
|
|
|
|
f: fn(&r/T) -> U) -> U {
|
2012-08-14 18:17:59 -05:00
|
|
|
//! Applies a function to the contained value or returns a default
|
|
|
|
|
2013-02-15 02:51:28 -06:00
|
|
|
match *opt { None => def, Some(ref t) => f(t) }
|
2012-08-14 18:17:59 -05:00
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2013-02-10 15:30:17 -06:00
|
|
|
pub pure fn iter<T>(opt: &r/Option<T>, f: fn(x: &r/T)) {
|
2012-08-14 18:17:59 -05:00
|
|
|
//! Performs an operation on the contained value by reference
|
2012-08-20 14:23:37 -05:00
|
|
|
match *opt { None => (), Some(ref t) => f(t) }
|
2012-08-14 18:17:59 -05:00
|
|
|
}
|
|
|
|
|
2012-07-11 17:00:40 -05:00
|
|
|
#[inline(always)]
|
2012-10-02 13:37:37 -05:00
|
|
|
pub pure fn unwrap<T>(opt: Option<T>) -> T {
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
2012-10-04 17:14:28 -05:00
|
|
|
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.
|
2012-07-04 16:53:12 -05:00
|
|
|
*/
|
2013-02-15 02:51:28 -06:00
|
|
|
match opt {
|
|
|
|
Some(x) => x,
|
2013-02-11 21:26:38 -06:00
|
|
|
None => fail!(~"option::unwrap none")
|
2012-06-24 22:18:18 -05:00
|
|
|
}
|
2012-02-21 01:06:47 -06:00
|
|
|
}
|
|
|
|
|
2012-08-02 13:40:42 -05:00
|
|
|
#[inline(always)]
|
2012-10-01 16:08:34 -05:00
|
|
|
pub fn swap_unwrap<T>(opt: &mut Option<T>) -> T {
|
2012-10-04 17:14:28 -05:00
|
|
|
/*!
|
|
|
|
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`.
|
|
|
|
*/
|
2013-02-11 21:26:38 -06:00
|
|
|
if opt.is_none() { fail!(~"option::swap_unwrap none") }
|
2012-08-20 14:23:37 -05:00
|
|
|
unwrap(util::replace(opt, None))
|
2012-08-02 13:40:42 -05:00
|
|
|
}
|
|
|
|
|
2013-01-13 08:37:30 -06:00
|
|
|
#[inline(always)]
|
2012-12-18 20:55:19 -06:00
|
|
|
pub pure fn expect<T>(opt: Option<T>, reason: &str) -> T {
|
2012-07-24 14:46:40 -05:00
|
|
|
//! As unwrap, but with a specified failure message.
|
2013-02-15 02:51:28 -06:00
|
|
|
match opt {
|
|
|
|
Some(val) => val,
|
2013-02-11 21:26:38 -06:00
|
|
|
None => fail!(reason.to_owned()),
|
2012-12-18 20:55:19 -06:00
|
|
|
}
|
2012-07-24 14:46:40 -05:00
|
|
|
}
|
|
|
|
|
2012-08-20 14:23:37 -05:00
|
|
|
impl<T> Option<T> {
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Returns true if the option equals `none`
|
2012-12-18 20:55:19 -06:00
|
|
|
#[inline(always)]
|
|
|
|
pure fn is_none(&self) -> bool { is_none(self) }
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Returns true if the option contains some value
|
2012-12-18 20:55:19 -06:00
|
|
|
#[inline(always)]
|
|
|
|
pure fn is_some(&self) -> bool { is_some(self) }
|
2012-04-11 18:27:11 -05:00
|
|
|
|
2012-08-14 18:17:59 -05:00
|
|
|
/**
|
|
|
|
* Update an optional value by optionally running its content by reference
|
|
|
|
* through a function that returns an option.
|
|
|
|
*/
|
2012-12-18 20:55:19 -06:00
|
|
|
#[inline(always)]
|
|
|
|
pure fn chain_ref<U>(&self, f: fn(x: &T) -> Option<U>) -> Option<U> {
|
2012-08-14 18:17:59 -05:00
|
|
|
chain_ref(self, f)
|
|
|
|
}
|
2012-12-18 20:55:19 -06:00
|
|
|
|
|
|
|
/// Maps a `some` value from one type to another by reference
|
|
|
|
#[inline(always)]
|
2013-02-07 17:30:34 -06:00
|
|
|
pure fn map<U>(&self, f: fn(&self/T) -> U) -> Option<U> { map(self, f) }
|
2012-12-18 20:55:19 -06:00
|
|
|
|
2013-01-12 23:47:00 -06:00
|
|
|
/// As `map`, but consumes the option and gives `f` ownership to avoid
|
|
|
|
/// copying.
|
|
|
|
#[inline(always)]
|
|
|
|
pure fn map_consume<U>(self, f: fn(v: T) -> U) -> Option<U> {
|
|
|
|
map_consume(self, f)
|
|
|
|
}
|
|
|
|
|
2012-08-14 18:17:59 -05:00
|
|
|
/// Applies a function to the contained value or returns a default
|
2012-12-18 20:55:19 -06:00
|
|
|
#[inline(always)]
|
2013-02-07 17:30:34 -06:00
|
|
|
pure fn map_default<U>(&self, def: U, f: fn(&self/T) -> U) -> U {
|
2013-02-15 02:51:28 -06:00
|
|
|
map_default(self, def, f)
|
2012-12-18 20:55:19 -06:00
|
|
|
}
|
|
|
|
|
2013-01-12 23:56:50 -06:00
|
|
|
/// As `map_default`, but consumes the option and gives `f`
|
|
|
|
/// ownership to avoid copying.
|
|
|
|
#[inline(always)]
|
|
|
|
pure fn map_consume_default<U>(self, def: U, f: fn(v: T) -> U) -> U {
|
|
|
|
match self { None => def, Some(v) => f(v) }
|
|
|
|
}
|
|
|
|
|
2013-01-13 10:09:09 -06:00
|
|
|
/// Apply a function to the contained value or do nothing
|
|
|
|
fn mutate(&mut self, f: fn(T) -> T) {
|
|
|
|
if self.is_some() {
|
|
|
|
*self = Some(f(self.swap_unwrap()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Apply a function to the contained value or set it to a default
|
|
|
|
fn mutate_default(&mut self, def: T, f: fn(T) -> T) {
|
|
|
|
if self.is_some() {
|
|
|
|
*self = Some(f(self.swap_unwrap()));
|
|
|
|
} else {
|
|
|
|
*self = Some(def);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-14 18:17:59 -05:00
|
|
|
/// Performs an operation on the contained value by reference
|
2012-12-18 20:55:19 -06:00
|
|
|
#[inline(always)]
|
2013-02-10 15:30:17 -06:00
|
|
|
pure fn iter(&self, f: fn(x: &self/T)) { iter(self, f) }
|
2012-12-18 20:55:19 -06:00
|
|
|
|
2012-10-04 17:14:28 -05:00
|
|
|
/**
|
|
|
|
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.
|
|
|
|
*/
|
2012-12-18 20:55:19 -06:00
|
|
|
#[inline(always)]
|
|
|
|
pure fn get_ref(&self) -> &self/T { get_ref(self) }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets the value out of an option without copying.
|
|
|
|
*
|
|
|
|
* # Failure
|
|
|
|
*
|
|
|
|
* Fails if the value equals `none`
|
|
|
|
*/
|
|
|
|
#[inline(always)]
|
|
|
|
pure fn unwrap(self) -> T { unwrap(self) }
|
|
|
|
|
2013-01-12 23:47:00 -06:00
|
|
|
/**
|
|
|
|
* 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(always)]
|
|
|
|
fn swap_unwrap(&mut self) -> T { swap_unwrap(self) }
|
|
|
|
|
2012-12-18 20:55:19 -06:00
|
|
|
/**
|
|
|
|
* Gets the value out of an option, printing a specified message on
|
|
|
|
* failure
|
|
|
|
*
|
|
|
|
* # Failure
|
|
|
|
*
|
|
|
|
* Fails if the value equals `none`
|
|
|
|
*/
|
|
|
|
#[inline(always)]
|
|
|
|
pure fn expect(self, reason: &str) -> T { expect(self, reason) }
|
2012-08-14 18:17:59 -05:00
|
|
|
}
|
|
|
|
|
2012-09-07 16:52:28 -05:00
|
|
|
impl<T: Copy> Option<T> {
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
2012-10-04 17:14:28 -05:00
|
|
|
Gets the value out of 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.
|
|
|
|
*/
|
2012-12-18 20:55:19 -06:00
|
|
|
#[inline(always)]
|
|
|
|
pure fn get(self) -> T { get(self) }
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-01-04 18:01:26 -06:00
|
|
|
pure fn get_or_default(self, def: T) -> T { get_or_default(self, def) }
|
2012-12-18 20:55:19 -06:00
|
|
|
|
2012-07-17 12:54:24 -05:00
|
|
|
/// Applies a function zero or more times until the result is none.
|
2012-12-18 20:55:19 -06:00
|
|
|
#[inline(always)]
|
|
|
|
pure fn while_some(self, blk: fn(v: T) -> Option<T>) {
|
|
|
|
while_some(self, blk)
|
|
|
|
}
|
2012-03-16 19:49:58 -05:00
|
|
|
}
|
|
|
|
|
2013-01-03 17:36:23 -06:00
|
|
|
impl<T: Copy Zero> Option<T> {
|
|
|
|
#[inline(always)]
|
2013-01-04 18:01:26 -06:00
|
|
|
pure fn get_or_zero(self) -> T { get_or_zero(self) }
|
2013-01-03 17:36:23 -06:00
|
|
|
}
|
|
|
|
|
2012-02-21 01:06:47 -06:00
|
|
|
#[test]
|
|
|
|
fn test_unwrap_ptr() {
|
|
|
|
let x = ~0;
|
2012-10-03 16:38:01 -05:00
|
|
|
let addr_x = ptr::addr_of(&(*x));
|
2013-02-15 02:51:28 -06:00
|
|
|
let opt = Some(x);
|
|
|
|
let y = unwrap(opt);
|
2012-10-03 16:38:01 -05:00
|
|
|
let addr_y = ptr::addr_of(&(*y));
|
2012-02-21 01:06:47 -06:00
|
|
|
assert addr_x == addr_y;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_unwrap_str() {
|
2012-07-14 00:57:48 -05:00
|
|
|
let x = ~"test";
|
2012-10-01 18:06:28 -05:00
|
|
|
let addr_x = str::as_buf(x, |buf, _len| buf);
|
2013-02-15 02:51:28 -06:00
|
|
|
let opt = Some(x);
|
|
|
|
let y = unwrap(opt);
|
2012-10-01 18:06:28 -05:00
|
|
|
let addr_y = str::as_buf(y, |buf, _len| buf);
|
2012-02-21 01:06:47 -06:00
|
|
|
assert addr_x == addr_y;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_unwrap_resource() {
|
2012-09-02 17:39:37 -05:00
|
|
|
struct R {
|
2012-09-06 21:40:15 -05:00
|
|
|
i: @mut int,
|
2012-06-21 23:30:16 -05:00
|
|
|
drop { *(self.i) += 1; }
|
2012-02-21 01:06:47 -06:00
|
|
|
}
|
2012-09-04 17:23:28 -05:00
|
|
|
|
|
|
|
fn R(i: @mut int) -> R {
|
|
|
|
R {
|
|
|
|
i: i
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-26 20:35:18 -05:00
|
|
|
let i = @mut 0;
|
2012-02-21 01:06:47 -06:00
|
|
|
{
|
2012-09-02 17:39:37 -05:00
|
|
|
let x = R(i);
|
2013-02-15 02:51:28 -06:00
|
|
|
let opt = Some(x);
|
|
|
|
let _y = unwrap(opt);
|
2012-02-21 01:06:47 -06:00
|
|
|
}
|
|
|
|
assert *i == 1;
|
|
|
|
}
|
|
|
|
|
2012-08-02 13:40:42 -05:00
|
|
|
#[test]
|
|
|
|
fn test_option_dance() {
|
2012-08-20 14:23:37 -05:00
|
|
|
let x = Some(());
|
|
|
|
let mut y = Some(5);
|
2012-08-02 13:40:42 -05:00
|
|
|
let mut y2 = 0;
|
|
|
|
do x.iter |_x| {
|
|
|
|
y2 = swap_unwrap(&mut y);
|
|
|
|
}
|
|
|
|
assert y2 == 5;
|
|
|
|
assert y.is_none();
|
|
|
|
}
|
|
|
|
#[test] #[should_fail] #[ignore(cfg(windows))]
|
|
|
|
fn test_option_too_much_dance() {
|
2012-08-20 14:23:37 -05:00
|
|
|
let mut y = Some(util::NonCopyable());
|
2012-08-02 13:40:42 -05:00
|
|
|
let _y2 = swap_unwrap(&mut y);
|
|
|
|
let _y3 = swap_unwrap(&mut y);
|
|
|
|
}
|
|
|
|
|
2012-07-17 12:54:24 -05:00
|
|
|
#[test]
|
|
|
|
fn test_option_while_some() {
|
|
|
|
let mut i = 0;
|
2012-08-20 14:23:37 -05:00
|
|
|
do Some(10).while_some |j| {
|
2012-07-17 12:54:24 -05:00
|
|
|
i += 1;
|
|
|
|
if (j > 0) {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(j-1)
|
2012-07-17 12:54:24 -05:00
|
|
|
} else {
|
2012-08-20 14:23:37 -05:00
|
|
|
None
|
2012-07-17 12:54:24 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
assert i == 11;
|
|
|
|
}
|
|
|
|
|
2013-01-03 17:36:23 -06:00
|
|
|
#[test]
|
2013-01-04 18:01:26 -06:00
|
|
|
fn test_get_or_zero() {
|
2013-01-03 17:36:23 -06:00
|
|
|
let some_stuff = Some(42);
|
2013-01-04 18:01:26 -06:00
|
|
|
assert some_stuff.get_or_zero() == 42;
|
2013-01-03 17:36:23 -06:00
|
|
|
let no_stuff: Option<int> = None;
|
2013-01-04 18:01:26 -06:00
|
|
|
assert no_stuff.get_or_zero() == 0;
|
2013-01-03 17:36:23 -06:00
|
|
|
}
|
|
|
|
|
2011-12-13 18:25:51 -06:00
|
|
|
// Local Variables:
|
|
|
|
// mode: rust;
|
|
|
|
// fill-column: 78;
|
|
|
|
// indent-tabs-mode: nil
|
|
|
|
// c-basic-offset: 4
|
|
|
|
// buffer-file-coding-system: utf-8-unix
|
|
|
|
// End:
|