Enum Nullable

pub enum Nullable<T> {
    Null,
    Present(T),
}

The Nullable type. Represents a value which may be specified as null on an API. Note that this is distinct from a value that is optional and not present!

Nullable implements many of the same methods as the Option type (map, unwrap, etc).

Variants

Null

Null value

Present(T)

Value is present

Implementations

impl<T> Nullable<T>

pub fn is_present(&self) -> bool

Returns true if the Nullable is a Present value.

Examples

let x: Nullable<u32> = Nullable::Present(2);
assert_eq!(x.is_present(), true);

let x: Nullable<u32> = Nullable::Null;
assert_eq!(x.is_present(), false);

pub fn is_null(&self) -> bool

Returns true if the Nullable is a Null value.

Examples

let x: Nullable<u32> = Nullable::Present(2);
assert_eq!(x.is_null(), false);

let x: Nullable<u32> = Nullable::Null;
assert_eq!(x.is_null(), true);

pub fn as_ref(&self) -> Nullable<&T>

Converts from Nullable<T> to Nullable<&T>.

Examples

Convert an Nullable<String> into a Nullable<usize>, preserving the original. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take a Nullable to a reference to the value inside the original.

let num_as_str: Nullable<String> = Nullable::Present("10".to_string());
// First, cast `Nullable<String>` to `Nullable<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `num_as_str` on the stack.
let num_as_int: Nullable<usize> = num_as_str.as_ref().map(|n| n.len());
println!("still can print num_as_str: {:?}", num_as_str);

pub fn as_mut(&mut self) -> Nullable<&mut T>

Converts from Nullable<T> to Nullable<&mut T>.

Examples

let mut x = Nullable::Present(2);
match x.as_mut() {
    Nullable::Present(v) => *v = 42,
    Nullable::Null => {},
}
assert_eq!(x, Nullable::Present(42));

pub fn expect(self, msg: &str) -> T

Unwraps a Nullable, yielding the content of a Nullable::Present.

Panics

Panics if the value is a Nullable::Null with a custom panic message provided by msg.

Examples

let x = Nullable::Present("value");
assert_eq!(x.expect("the world is ending"), "value");

let x: Nullable<&str> = Nullable::Null;
x.expect("the world is ending"); // panics with `the world is ending`

pub fn unwrap(self) -> T

Moves the value v out of the Nullable<T> if it is Nullable::Present(v).

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

Panics

Panics if the self value equals Nullable::Null.

Examples

let x = Nullable::Present("air");
assert_eq!(x.unwrap(), "air");

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

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

Returns the contained value or a default.

Examples

assert_eq!(Nullable::Present("car").unwrap_or("bike"), "car");
assert_eq!(Nullable::Null.unwrap_or("bike"), "bike");

pub 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!(Nullable::Present(4).unwrap_or_else(|| 2 * k), 4);
assert_eq!(Nullable::Null.unwrap_or_else(|| 2 * k), 20);

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

Maps a Nullable<T> to Nullable<U> by applying a function to a contained value.

Examples

Convert a Nullable<String> into a Nullable<usize>, consuming the original:

let maybe_some_string = Nullable::Present(String::from("Hello, World!"));
// `Nullable::map` takes self *by value*, consuming `maybe_some_string`
let maybe_some_len = maybe_some_string.map(|s| s.len());

assert_eq!(maybe_some_len, Nullable::Present(13));

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

Applies a function to the contained value (if any), or returns a default (if not).

Examples

let x = Nullable::Present("foo");
assert_eq!(x.map_or(42, |v| v.len()), 3);

let x: Nullable<&str> = Nullable::Null;
assert_eq!(x.map_or(42, |v| v.len()), 42);

pub fn map_or_else<U, D: FnOnce() -> U, F: FnOnce(T) -> U>( self, default: D, f: F, ) -> U

Applies a function to the contained value (if any), or computes a default (if not).

Examples

let k = 21;

let x = Nullable::Present("foo");
assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 3);

let x: Nullable<&str> = Nullable::Null;
assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 42);

pub fn ok_or<E>(self, err: E) -> Result<T, E>

Transforms the Nullable<T> into a Result<T, E>, mapping Nullable::Present(v) to Ok(v) and Nullable::Null to Err(err).

Examples

let x = Nullable::Present("foo");
assert_eq!(x.ok_or(0), Ok("foo"));

let x: Nullable<&str> = Nullable::Null;
assert_eq!(x.ok_or(0), Err(0));

pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E>

Transforms the Nullable<T> into a Result<T, E>, mapping Nullable::Present(v) to Ok(v) and Nullable::Null to Err(err()).

Examples

let x = Nullable::Present("foo");
assert_eq!(x.ok_or_else(|| 0), Ok("foo"));

let x: Nullable<&str> = Nullable::Null;
assert_eq!(x.ok_or_else(|| 0), Err(0));

pub fn and<U>(self, optb: Nullable<U>) -> Nullable<U>

Returns Nullable::Null if the Nullable is Nullable::Null, otherwise returns optb.

Examples

let x = Nullable::Present(2);
let y: Nullable<&str> = Nullable::Null;
assert_eq!(x.and(y), Nullable::Null);

let x: Nullable<u32> = Nullable::Null;
let y = Nullable::Present("foo");
assert_eq!(x.and(y), Nullable::Null);

let x = Nullable::Present(2);
let y = Nullable::Present("foo");
assert_eq!(x.and(y), Nullable::Present("foo"));

let x: Nullable<u32> = Nullable::Null;
let y: Nullable<&str> = Nullable::Null;
assert_eq!(x.and(y), Nullable::Null);

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

Returns Nullable::Null if the Nullable is Nullable::Null, otherwise calls f with the wrapped value and returns the result.

Some languages call this operation flatmap.

Examples

fn sq(x: u32) -> Nullable<u32> { Nullable::Present(x * x) }
fn nope(_: u32) -> Nullable<u32> { Nullable::Null }

assert_eq!(Nullable::Present(2).and_then(sq).and_then(sq), Nullable::Present(16));
assert_eq!(Nullable::Present(2).and_then(sq).and_then(nope), Nullable::Null);
assert_eq!(Nullable::Present(2).and_then(nope).and_then(sq), Nullable::Null);
assert_eq!(Nullable::Null.and_then(sq).and_then(sq), Nullable::Null);

pub fn or(self, optb: Nullable<T>) -> Nullable<T>

Returns the Nullable if it contains a value, otherwise returns optb.

Examples

let x = Nullable::Present(2);
let y = Nullable::Null;
assert_eq!(x.or(y), Nullable::Present(2));

let x = Nullable::Null;
let y = Nullable::Present(100);
assert_eq!(x.or(y), Nullable::Present(100));

let x = Nullable::Present(2);
let y = Nullable::Present(100);
assert_eq!(x.or(y), Nullable::Present(2));

let x: Nullable<u32> = Nullable::Null;
let y = Nullable::Null;
assert_eq!(x.or(y), Nullable::Null);

pub fn or_else<F: FnOnce() -> Nullable<T>>(self, f: F) -> Nullable<T>

Returns the Nullable if it contains a value, otherwise calls f and returns the result.

Examples

fn nobody() -> Nullable<&'static str> { Nullable::Null }
fn vikings() -> Nullable<&'static str> { Nullable::Present("vikings") }

assert_eq!(Nullable::Present("barbarians").or_else(vikings),
           Nullable::Present("barbarians"));
assert_eq!(Nullable::Null.or_else(vikings), Nullable::Present("vikings"));
assert_eq!(Nullable::Null.or_else(nobody), Nullable::Null);

pub fn take(&mut self) -> Nullable<T>

Takes the value out of the Nullable, leaving a Nullable::Null in its place.

Examples

let mut x = Nullable::Present(2);
x.take();
assert_eq!(x, Nullable::Null);

let mut x: Nullable<u32> = Nullable::Null;
x.take();
assert_eq!(x, Nullable::Null);

impl<'a, T: Clone> Nullable<&'a T>

pub fn cloned(self) -> Nullable<T>

Maps an Nullable<&T> to an Nullable<T> by cloning the contents of the Nullable.

Examples

let x = 12;
let opt_x = Nullable::Present(&x);
assert_eq!(opt_x, Nullable::Present(&12));
let cloned = opt_x.cloned();
assert_eq!(cloned, Nullable::Present(12));

impl<T: Default> Nullable<T>

pub fn unwrap_or_default(self) -> T

Returns the contained value or a default

Consumes the self argument then, if Nullable::Present, returns the contained value, otherwise if Nullable::Null, returns the default value for that type.

Examples

let x = Nullable::Present(42);
assert_eq!(42, x.unwrap_or_default());

let y: Nullable<i32> = Nullable::Null;
assert_eq!(0, y.unwrap_or_default());

Trait Implementations

impl<T: Clone> Clone for Nullable<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Nullable<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for Nullable<T>

fn default() -> Nullable<T>

Returns None.

impl<'de, T> Deserialize<'de> for Nullable<T>

where T: DeserializeOwned,

fn deserialize<D>(deserializer: D) -> Result<Nullable<T>, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<T> for Nullable<T>

fn from(val: T) -> Nullable<T>

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for Nullable<T>

fn eq(&self, other: &Nullable<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd> PartialOrd for Nullable<T>

fn partial_cmp(&self, other: &Nullable<T>) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<T> Serialize for Nullable<T>

where T: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Copy> Copy for Nullable<T>

impl<T> StructuralPartialEq for Nullable<T>