rust/src/libcore/option.rs

518 lines
13 KiB
Rust
Raw Normal View History

// 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-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"
};
~~~
*/
2013-02-04 19:12:31 -06:00
use cmp::{Eq,Ord};
use kinds::Copy;
use option;
use ptr;
use str;
use util;
use num::Zero;
/// The option type
2012-12-11 17:16:36 -06:00
#[deriving_eq]
pub enum Option<T> {
2012-08-20 14:23:37 -05:00
None,
Some(T),
}
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)
}
}
#[inline(always)]
pub pure fn get<T: Copy>(opt: Option<T>) -> T {
/*!
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.
*/
match opt {
2012-09-28 15:00:07 -05:00
Some(copy x) => return x,
None => fail!(~"option::get none")
2012-08-03 21:59:04 -05:00
}
}
#[inline(always)]
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,
None => fail!(~"option::get_ref none")
2012-08-16 20:06:05 -05:00
}
}
#[inline(always)]
pub pure fn map<T, U>(opt: &r/Option<T>, f: fn(x: &r/T) -> U) -> Option<U> {
//! 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 }
}
#[inline(always)]
pub pure fn map_consume<T, U>(opt: Option<T>,
f: fn(v: T) -> U) -> Option<U> {
/*!
* As `map`, but consumes the option and gives `f` ownership to avoid
* copying.
*/
match opt { None => None, Some(v) => Some(f(v)) }
}
#[inline(always)]
pub pure fn chain<T, U>(opt: Option<T>,
f: fn(t: T) -> Option<U>) -> Option<U> {
/*!
* 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),
None => None
2012-09-27 19:01:28 -05:00
}
}
#[inline(always)]
pub pure fn chain_ref<T, U>(opt: &Option<T>,
f: fn(x: &T) -> Option<U>) -> Option<U> {
/*!
* 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 }
}
#[inline(always)]
pub pure fn or<T>(opta: Option<T>, optb: Option<T>) -> Option<T> {
/*!
2013-01-25 13:29:51 -06:00
* Returns the leftmost Some() value, or None if both are None.
*/
2013-02-15 02:51:28 -06:00
match opta {
Some(opta) => Some(opta),
_ => optb
}
}
#[inline(always)]
pub pure fn while_some<T>(x: Option<T>, blk: fn(v: T) -> Option<T>) {
//! Applies a function zero or more times until the result is none.
2013-02-15 02:51:28 -06:00
let mut opt = x;
while opt.is_some() {
2013-02-15 02:51:28 -06:00
opt = blk(unwrap(opt));
}
}
#[inline(always)]
pub pure fn is_none<T>(opt: &Option<T>) -> bool {
//! 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 }
}
#[inline(always)]
pub pure fn is_some<T>(opt: &Option<T>) -> bool {
//! Returns true if the option contains some value
2012-03-06 21:09:32 -06:00
!is_none(opt)
}
#[inline(always)]
pub pure fn get_or_zero<T: Copy Zero>(opt: Option<T>) -> T {
//! Returns the contained value or zero (for this type)
match opt { Some(copy x) => x, None => Zero::zero() }
}
#[inline(always)]
pub pure fn get_or_default<T: Copy>(opt: Option<T>, def: T) -> T {
//! Returns the contained value or a default
2012-03-06 21:09:32 -06:00
match opt { Some(copy x) => x, None => def }
}
#[inline(always)]
pub pure fn map_default<T, U>(opt: &r/Option<T>, def: U,
f: fn(&r/T) -> U) -> U {
//! 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) }
}
#[inline(always)]
pub pure fn iter<T>(opt: &r/Option<T>, f: fn(x: &r/T)) {
//! 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) }
}
#[inline(always)]
pub pure fn unwrap<T>(opt: Option<T>) -> T {
/*!
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.
*/
2013-02-15 02:51:28 -06:00
match opt {
Some(x) => x,
None => fail!(~"option::unwrap none")
}
}
#[inline(always)]
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`.
*/
if opt.is_none() { fail!(~"option::swap_unwrap none") }
2012-08-20 14:23:37 -05:00
unwrap(util::replace(opt, None))
}
#[inline(always)]
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,
None => fail!(reason.to_owned()),
}
2012-07-24 14:46:40 -05:00
}
2012-08-20 14:23:37 -05:00
impl<T> Option<T> {
/// Returns true if the option equals `none`
#[inline(always)]
pure fn is_none(&self) -> bool { is_none(self) }
/// Returns true if the option contains some value
#[inline(always)]
pure fn is_some(&self) -> bool { is_some(self) }
/**
* Update an optional value by optionally running its content by reference
* through a function that returns an option.
*/
#[inline(always)]
pure fn chain_ref<U>(&self, f: fn(x: &T) -> Option<U>) -> Option<U> {
chain_ref(self, f)
}
/// Maps a `some` value from one type to another by reference
#[inline(always)]
pure fn map<U>(&self, f: fn(&self/T) -> U) -> Option<U> { map(self, f) }
/// 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)
}
/// Applies a function to the contained value or returns a default
#[inline(always)]
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)
}
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) }
}
/// 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);
}
}
/// Performs an operation on the contained value by reference
#[inline(always)]
pure fn iter(&self, f: fn(x: &self/T)) { iter(self, f) }
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.
*/
#[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) }
/**
* 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) }
/**
* 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) }
}
impl<T: Copy> Option<T> {
/**
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.
*/
#[inline(always)]
pure fn get(self) -> T { get(self) }
#[inline(always)]
pure fn get_or_default(self, def: T) -> T { get_or_default(self, def) }
/// Applies a function zero or more times until the result is none.
#[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
}
impl<T: Copy Zero> Option<T> {
#[inline(always)]
pure fn get_or_zero(self) -> T { get_or_zero(self) }
}
#[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));
assert addr_x == addr_y;
}
#[test]
fn test_unwrap_str() {
let x = ~"test";
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);
let addr_y = str::as_buf(y, |buf, _len| buf);
assert addr_x == addr_y;
}
#[test]
fn test_unwrap_resource() {
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-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;
{
let x = R(i);
2013-02-15 02:51:28 -06:00
let opt = Some(x);
let _y = unwrap(opt);
}
assert *i == 1;
}
#[test]
fn test_option_dance() {
2012-08-20 14:23:37 -05:00
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() {
2012-08-20 14:23:37 -05:00
let mut y = Some(util::NonCopyable());
let _y2 = swap_unwrap(&mut y);
let _y3 = swap_unwrap(&mut y);
}
#[test]
fn test_option_while_some() {
let mut i = 0;
2012-08-20 14:23:37 -05:00
do Some(10).while_some |j| {
i += 1;
if (j > 0) {
2012-08-20 14:23:37 -05:00
Some(j-1)
} else {
2012-08-20 14:23:37 -05:00
None
}
}
assert i == 11;
}
#[test]
fn test_get_or_zero() {
let some_stuff = Some(42);
assert some_stuff.get_or_zero() == 42;
let no_stuff: Option<int> = None;
assert no_stuff.get_or_zero() == 0;
}
// Local Variables:
// mode: rust;
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End: