2012-07-04 16:53:12 -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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/// The option type
|
2012-03-13 16:39:28 -05:00
|
|
|
enum option<T> {
|
2012-01-19 19:55:34 -06:00
|
|
|
none,
|
|
|
|
some(T),
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-03-13 16:39:28 -05:00
|
|
|
pure fn get<T: copy>(opt: option<T>) -> T {
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
|
|
|
* Gets the value out of an option
|
|
|
|
*
|
|
|
|
* # Failure
|
|
|
|
*
|
|
|
|
* Fails if the value equals `none`
|
|
|
|
*/
|
2011-12-13 18:25:51 -06:00
|
|
|
|
2012-08-02 13:40:42 -05:00
|
|
|
alt opt { some(x) { return x; } none { fail ~"option::get none"; } }
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
pure fn expect<T: copy>(opt: option<T>, reason: ~str) -> T {
|
2012-07-03 19:28:44 -05:00
|
|
|
#[doc = "
|
|
|
|
Gets the value out of an option, printing a specified message on failure
|
|
|
|
|
|
|
|
# Failure
|
|
|
|
|
|
|
|
Fails if the value equals `none`
|
|
|
|
"];
|
|
|
|
alt opt { some(x) { x } none { fail reason; } }
|
|
|
|
}
|
|
|
|
|
2012-07-17 17:24:51 -05:00
|
|
|
pure fn map<T, U>(opt: option<T>, f: fn(T) -> U) -> option<U> {
|
2012-07-04 16:53:12 -05:00
|
|
|
//! Maps a `some` value from one type to another
|
2012-03-06 21:09:32 -06:00
|
|
|
|
2012-01-19 00:37:22 -06:00
|
|
|
alt opt { some(x) { some(f(x)) } none { none } }
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-07-17 17:24:51 -05:00
|
|
|
pure fn map_consume<T, U>(-opt: option<T>, f: fn(-T) -> U) -> option<U> {
|
|
|
|
/*!
|
|
|
|
* As `map`, but consumes the option and gives `f` ownership to avoid
|
|
|
|
* copying.
|
|
|
|
*/
|
|
|
|
if opt.is_some() { some(f(option::unwrap(opt))) } else { none }
|
|
|
|
}
|
|
|
|
|
2012-05-25 10:14:49 -05:00
|
|
|
pure fn chain<T, U>(opt: option<T>, f: fn(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
|
|
|
|
2012-02-22 06:18:15 -06:00
|
|
|
alt opt { some(x) { f(x) } none { none } }
|
|
|
|
}
|
|
|
|
|
2012-07-17 12:54:24 -05:00
|
|
|
#[inline(always)]
|
|
|
|
pure fn while_some<T>(+x: option<T>, blk: fn(+T) -> option<T>) {
|
|
|
|
//! Applies a function zero or more times until the result is none.
|
|
|
|
|
|
|
|
let mut opt <- x;
|
|
|
|
while opt.is_some() {
|
|
|
|
opt = blk(unwrap(opt));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-13 16:39:28 -05:00
|
|
|
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-01-19 00:37:22 -06:00
|
|
|
alt opt { none { true } some(_) { false } }
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-03-13 16:39:28 -05:00
|
|
|
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
|
|
|
|
2012-04-11 11:24:46 -05:00
|
|
|
pure fn get_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-01-19 00:37:22 -06:00
|
|
|
alt opt { some(x) { x } none { def } }
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-07-31 12:21:15 -05:00
|
|
|
pure fn map_default<T, U>(opt: option<T>, +def: U, f: fn(T) -> U) -> U {
|
2012-07-04 16:53:12 -05:00
|
|
|
//! Applies a function to the contained value or returns a default
|
2012-03-06 21:09:32 -06:00
|
|
|
|
2012-01-19 00:37:22 -06:00
|
|
|
alt opt { none { def } some(t) { f(t) } }
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-05-25 10:14:49 -05:00
|
|
|
pure fn iter<T>(opt: option<T>, f: fn(T)) {
|
2012-07-04 16:53:12 -05:00
|
|
|
//! Performs an operation on the contained value or does nothing
|
2011-12-13 18:25:51 -06:00
|
|
|
|
2012-03-06 21:09:32 -06:00
|
|
|
alt opt { none { } some(t) { f(t); } }
|
|
|
|
}
|
2012-02-21 01:06:47 -06:00
|
|
|
|
2012-07-11 17:00:40 -05:00
|
|
|
#[inline(always)]
|
2012-06-24 22:18:18 -05:00
|
|
|
pure fn unwrap<T>(-opt: option<T>) -> T {
|
2012-07-04 16:53:12 -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.
|
|
|
|
*/
|
2012-03-06 21:09:32 -06:00
|
|
|
|
2012-06-24 22:18:18 -05:00
|
|
|
unsafe {
|
|
|
|
let addr = alt opt {
|
|
|
|
some(x) { ptr::addr_of(x) }
|
2012-08-02 13:40:42 -05:00
|
|
|
none { fail ~"option::unwrap none" }
|
2012-06-24 22:18:18 -05:00
|
|
|
};
|
|
|
|
let liberated_value = unsafe::reinterpret_cast(*addr);
|
|
|
|
unsafe::forget(opt);
|
2012-08-01 19:30:05 -05:00
|
|
|
return liberated_value;
|
2012-06-24 22:18:18 -05:00
|
|
|
}
|
2012-02-21 01:06:47 -06:00
|
|
|
}
|
|
|
|
|
2012-08-02 13:40:42 -05:00
|
|
|
/// The ubiquitous option dance.
|
|
|
|
#[inline(always)]
|
|
|
|
fn swap_unwrap<T>(opt: &mut option<T>) -> T {
|
|
|
|
if opt.is_none() { fail ~"option::swap_unwrap none" }
|
|
|
|
unwrap(util::replace(opt, none))
|
|
|
|
}
|
|
|
|
|
2012-07-24 14:46:40 -05:00
|
|
|
pure fn unwrap_expect<T>(-opt: option<T>, reason: ~str) -> T {
|
|
|
|
//! As unwrap, but with a specified failure message.
|
|
|
|
if opt.is_none() { fail reason; }
|
|
|
|
unwrap(opt)
|
|
|
|
}
|
|
|
|
|
2012-06-18 14:57:06 -05:00
|
|
|
impl extensions<T> for option<T> {
|
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-07-17 12:54:24 -05:00
|
|
|
pure fn chain<U>(f: fn(T) -> option<U>) -> option<U> { chain(self, f) }
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Applies a function to the contained value or returns a default
|
2012-07-31 12:21:15 -05:00
|
|
|
pure fn map_default<U>(+def: U, f: fn(T) -> U) -> U
|
2012-04-06 14:14:09 -05:00
|
|
|
{ map_default(self, def, f) }
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Performs an operation on the contained value or does nothing
|
2012-07-17 12:54:24 -05:00
|
|
|
pure fn iter(f: fn(T)) { iter(self, f) }
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Returns true if the option equals `none`
|
2012-07-17 12:54:24 -05:00
|
|
|
pure fn is_none() -> bool { is_none(self) }
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Returns true if the option contains some value
|
2012-07-17 12:54:24 -05:00
|
|
|
pure fn is_some() -> bool { is_some(self) }
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Maps a `some` value from one type to another
|
2012-07-17 17:24:51 -05:00
|
|
|
pure fn map<U>(f: fn(T) -> U) -> option<U> { map(self, f) }
|
2012-06-18 14:57:06 -05:00
|
|
|
}
|
2012-04-11 18:27:11 -05:00
|
|
|
|
2012-06-18 14:57:06 -05:00
|
|
|
impl extensions<T: copy> for option<T> {
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* Gets the value out of an option
|
|
|
|
*
|
|
|
|
* # Failure
|
|
|
|
*
|
|
|
|
* Fails if the value equals `none`
|
|
|
|
*/
|
2012-07-17 12:54:24 -05:00
|
|
|
pure fn get() -> T { get(self) }
|
|
|
|
pure fn get_default(def: T) -> T { get_default(self, def) }
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* Gets the value out of an option, printing a specified message on
|
|
|
|
* failure
|
|
|
|
*
|
|
|
|
* # Failure
|
|
|
|
*
|
|
|
|
* Fails if the value equals `none`
|
|
|
|
*/
|
2012-07-14 00:57:48 -05:00
|
|
|
pure fn expect(reason: ~str) -> T { expect(self, reason) }
|
2012-07-17 12:54:24 -05:00
|
|
|
/// Applies a function zero or more times until the result is none.
|
|
|
|
pure fn while_some(blk: fn(+T) -> option<T>) { while_some(self, blk) }
|
2012-03-16 19:49:58 -05:00
|
|
|
}
|
|
|
|
|
2012-02-21 01:06:47 -06:00
|
|
|
#[test]
|
|
|
|
fn test_unwrap_ptr() {
|
|
|
|
let x = ~0;
|
|
|
|
let addr_x = ptr::addr_of(*x);
|
|
|
|
let opt = some(x);
|
|
|
|
let y = unwrap(opt);
|
|
|
|
let addr_y = ptr::addr_of(*y);
|
|
|
|
assert addr_x == addr_y;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_unwrap_str() {
|
2012-07-14 00:57:48 -05:00
|
|
|
let x = ~"test";
|
2012-07-24 14:35:34 -05:00
|
|
|
let addr_x = str::as_buf(x, |buf, _len| ptr::addr_of(buf));
|
2012-02-21 01:06:47 -06:00
|
|
|
let opt = some(x);
|
|
|
|
let y = unwrap(opt);
|
2012-07-24 14:35:34 -05:00
|
|
|
let addr_y = str::as_buf(y, |buf, _len| ptr::addr_of(buf));
|
2012-02-21 01:06:47 -06:00
|
|
|
assert addr_x == addr_y;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_unwrap_resource() {
|
2012-06-21 23:30:16 -05:00
|
|
|
class r {
|
|
|
|
let i: @mut int;
|
|
|
|
new(i: @mut int) { self.i = i; }
|
|
|
|
drop { *(self.i) += 1; }
|
2012-02-21 01:06:47 -06:00
|
|
|
}
|
2012-03-26 20:35:18 -05:00
|
|
|
let i = @mut 0;
|
2012-02-21 01:06:47 -06:00
|
|
|
{
|
|
|
|
let x = r(i);
|
|
|
|
let opt = some(x);
|
2012-02-21 16:25:51 -06:00
|
|
|
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() {
|
|
|
|
let x = some(());
|
|
|
|
let mut y = some(5);
|
|
|
|
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() {
|
|
|
|
let mut y = some(util::noncopyable());
|
|
|
|
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;
|
|
|
|
do some(10).while_some |j| {
|
|
|
|
i += 1;
|
|
|
|
if (j > 0) {
|
|
|
|
some(j-1)
|
|
|
|
} else {
|
|
|
|
none
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert i == 11;
|
|
|
|
}
|
|
|
|
|
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:
|