Enum spaceapi::optional::Optional

pub enum Optional<T> {
    Value(T),
    Absent,
}

An Optional can contain either Value<T> or Absent. It is similar to an Option, but None will be serialized to null while Absent means that both the key and the value will be omitted when serialized.

An Optional implements the Default trait, it is Absent by default.

Variants

Value(T)Absent

Methods

impl<T> Optional<T>

fn unwrap(self) -> T

Moves the value v out of the Optional<T> if it is Value(v).

Panics

Panics if the self value equals Absent.

Safety note

In general, because this function may panic, its use is discouraged. Instead, prefer to use pattern matching and handle the Absent case explicitly.

Examples

let x = Value("air");
assert_eq!(x.unwrap(), "air");

let x: Optional<&str> = Absent;
assert_eq!(x.unwrap(), "air"); // fails

fn unwrap_or(self, def: T) -> T

Returns the contained value or a default.

Examples

assert_eq!(Value("car").unwrap_or("bike"), "car");
assert_eq!(Absent.unwrap_or("bike"), "bike");

fn unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T

Returns the contained value or computes it from a closure.

Examples

let k = 10;
assert_eq!(Value(4).unwrap_or_else(|| 2 * k), 4);
assert_eq!(Absent.unwrap_or_else(|| 2 * k), 20);

fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Optional<U>

Maps an Optional<T> to Optional<U> by applying a function to a contained value

Examples

Convert an Optional<String> into an Optional<usize>, consuming the original:

let num_as_str: Optional<String> = Value("10".to_string());
// `Optional::map` takes self *by value*, consuming `num_as_str`
let num_as_int: Optional<usize> = num_as_str.map(|n| n.len());

fn map_or<U, F: FnOnce(T) -> U>(self, def: U, f: F) -> U

Applies a function to the contained value or returns a default. see std::option::Option<T>::map_or

fn as_mut<'r>(&'r mut self) -> Optional<&'r mut T>

Converts from Optional<T> to Optional<&mut T>

fn as_ref<'r>(&'r self) -> Optional<&'r T>

Converts from Optional<T> to Optional<&T>

fn and_then<U, F: FnOnce(T) -> Optional<U>>(self, f: F) -> Optional<U>

Returns Absent if the optional is Absent, otherwise calls f with the wrapped value and returns the result.

Some languages call this operation flatmap.

Examples

fn sq(x: u32) -> Optional<u32> { Value(x * x) }
fn nope(_: u32) -> Optional<u32> { Absent }

assert_eq!(Value(2).and_then(sq).and_then(sq), Value(16));
assert_eq!(Value(2).and_then(sq).and_then(nope), Absent);
assert_eq!(Value(2).and_then(nope).and_then(sq), Absent);
assert_eq!(Absent.and_then(sq).and_then(sq), Absent);

fn is_absent(&self) -> bool

Returns true if the optional is a Absent value

Examples

let x: Optional<u32> = Value(2);
assert_eq!(x.is_absent(), false);

let x: Optional<u32> = Absent;
assert_eq!(x.is_absent(), true);

Trait Implementations

impl<T: Hash> Hash for Optional<T>

fn hash<__HT: Hasher>(&self, __arg_0: &mut __HT)

Feeds this value into the state given, updating the hasher as necessary.

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

Feeds a slice of this type into the state provided.

impl<T: Debug> Debug for Optional<T>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Ord> Ord for Optional<T>

fn cmp(&self, __arg_0: &Optional<T>) -> Ordering

This method returns an Ordering between self and other.

impl<T: Eq> Eq for Optional<T>

impl<T: PartialOrd> PartialOrd for Optional<T>

fn partial_cmp(&self, __arg_0: &Optional<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, __arg_0: &Optional<T>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, __arg_0: &Optional<T>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, __arg_0: &Optional<T>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, __arg_0: &Optional<T>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: PartialEq> PartialEq for Optional<T>

fn eq(&self, __arg_0: &Optional<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Optional<T>) -> bool

This method tests for !=.

impl<T: Copy> Copy for Optional<T>

impl<T: Clone> Clone for Optional<T>

fn clone(&self) -> Optional<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Default for Optional<T>

fn default() -> Optional<T>

An optional value is absent by default.

impl<T> Into<Option<T>> for Optional<T>

fn into(self) -> Option<T>

Convert Optional into Option

Examples

let x: Optional<u32> = Value(2);
assert_eq!(Some(2), x.into());

let x: Optional<u32> = Absent;
assert_eq!(None, x.into());

impl<T: Decodable> Decodable for Optional<T>

fn decode<D: Decoder>(d: &mut D) -> Result<Optional<T>, D::Error>