Enum optional_field::Field

pub enum Field<T> {
    Missing,
    Present(Option<T>),
}

Variants

Missing

Present(Option<T>)

Implementations

impl<T> Field<T>

pub fn is_missing(&self) -> bool

Is the value missing?

Examples

assert!(Missing::<u8>.is_missing());
assert!(!Present::<u8>(None).is_missing());
assert!(!Present(Some(1)).is_missing());

pub fn is_present(&self) -> bool

Is the value present?

Examples

assert!(!Missing::<u8>.is_present());
assert!(Present::<u8>(None).is_present());
assert!(Present(Some(1)).is_present());

pub fn has_value(&self) -> bool

Is present and the value is not None?

Examples

assert!(!Missing::<u8>.has_value());
assert!(!Present::<u8>(None).has_value());
assert!(Present(Some(1)).has_value());

pub fn contains<U>(&self, x: &U) -> bool where
    U: PartialEq<T>, 

Does the value contain the given value?

Examples

let x = 1;
assert!(!Missing::<u8>.contains(&x));
assert!(!Present::<u8>(None).contains(&x));
assert!(Present(Some(1)).contains(&x));

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

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

Examples

Converts a Field<String> into an Field<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 an Field to a reference to the value inside the original.

let text: Field<String> = Present(Some("Hello, world!".to_string()));
// First, cast `Field<String>` to `Field<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Field<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {:?}", text);

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

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

Examples

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

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

Maps a Field<T> to Field<U> by applying a function to the value contained in the inner Option.

Examples

Converts a Field<String> into an Field<usize>, consuming the original:

let maybe_some_string = Present(Some(String::from("Hello, World!")));
// `Field::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, Present(Some(13)));

pub fn map_present<U, F: FnOnce(Option<T>) -> Option<U>>(self, f: F) -> Field<U>

Maps a Field<T> to Field<U> by applying a function to the option contained in Present.

Examples

Converts a Field<String> into an Field<usize>, consuming the original:

let maybe_some_string = Present(Some(String::from("Hello, World!")));
// `Field::map_present` takes self *by value*, consuming `maybe_some_string`
let maybe_some_len = maybe_some_string.map_present(|s| None);

assert_eq!(maybe_some_len, Present::<usize>(None));

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

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

Arguments passed to map_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use map_or_else, which is lazily evaluated.

Examples

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

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

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

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

Examples

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

let x: Field<&str> = Missing;
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

Computes a default function result if the field is Missing or Present(None), or applies a different function to the contained value (if any).

Examples

let k = 21;

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

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

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

Computes a default function result (if missing), or applies a different function to the contained value (if any).

Examples

let k = 21;

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

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

pub fn unwrap(self) -> T

Returns the contained Some value, consuming the self value.

Panics

Panics if the self value equals Missing or Present(None).

Examples

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

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

pub fn unwrap_present(self) -> Option<T>

Returns the contained option, consuming the self value.

Panics

Panics if the self value equals Missing.

Examples

let x = Present(Some("air"));
assert_eq!(x.unwrap_present(), Some("air"));

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

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

Returns the contained Some value or a provided default.

Arguments passed to unwrap_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use unwrap_or_else, which is lazily evaluated.

Examples

assert_eq!(Present(Some("car")).unwrap_or("bike"), "car");
assert_eq!(Present(None).unwrap_or("bike"), "bike");
assert_eq!(Missing.unwrap_or("bike"), "bike");

pub fn unwrap_present_or(self, default: Option<T>) -> Option<T>

Returns the contained Present value or a provided default.

Examples

assert_eq!(Present(Some("car")).unwrap_present_or(Some("bike")), Some("car"));
assert_eq!(Present(None).unwrap_present_or(Some("bike")), None);
assert_eq!(Missing.unwrap_present_or(Some("bike")), Some("bike"));

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

Returns the contained Some value or computes it from a closure.

Examples

let k = 10;
assert_eq!(Present(Some(4)).unwrap_or_else(|| 2 * k), 4);
assert_eq!(Present(None).unwrap_or_else(|| 2 * k), 20);
assert_eq!(Missing.unwrap_or_else(|| 2 * k), 20);

pub fn unwrap_present_or_else<F: FnOnce() -> Option<T>>(self, f: F) -> Option<T>

Returns the contained Present value or computes it from a closure.

Examples

assert_eq!(Present(Some(4)).unwrap_present_or_else(|| Some(10)), Some(4));
assert_eq!(Present(None).unwrap_present_or_else(|| Some(20)), None);
assert_eq!(Missing.unwrap_present_or_else(|| Some(30)), Some(30));

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

Returns the contained Some value from within Present, consuming the self value.

Panics

Panics if the value is a Missing or [‘None’] with a custom panic message provided by msg.

Examples

let x = Present(Some("value"));
assert_eq!(x.expect("fruits are healthy"), "value");

let x: Field<Option<&str>> = Missing;
x.expect("fruits are healthy"); // panics with `fruits are healthy`

pub fn expect_present(self, msg: &str) -> Option<T>

Returns the contained Option in the Present, consuming the self value.

Panics

Panics if the value is a Missing with a custom panic message provided by msg.

Examples

let x: Field<Option<&str>> = Present(None);
assert_eq!(x.expect_present("fruits are healthy"), None);

let x: Field<Option<&str>> = Missing;
x.expect("fruits are healthy"); // panics with `fruits are healthy`

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

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

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

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

impl<T: Default> Field<T>

pub fn unwrap_or_default(self) -> T

pub fn unwrap_present_or_default(self) -> Option<T>

impl<T: Copy> Field<&T>

pub fn copied(self) -> Field<T>

Maps a Field<&T> to a Field<T> by copying the contents of the option.

Examples

let x = 12;
let opt_x = Some(&x);
assert_eq!(opt_x, Some(&12));
let copied = opt_x.copied();
assert_eq!(copied, Some(12));

impl<T: Copy> Field<&mut T>

pub fn copied(self) -> Field<T>

Maps a Field<&mut T> to an Field<T> by copying the contents of the option.

Examples

let mut x = 12;
let opt_x = Present(Some(&x));
assert_eq!(opt_x, Present(Some(&x)));
let copied = opt_x.copied();
assert_eq!(copied, Present(Some(12)));

impl<T: Clone> Field<&T>

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

Maps a Field<&T> to a Field<T> by cloning the contents .

Examples

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

impl<T: Clone> Field<&mut T>

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

Maps a Field<&mut T> to a Field<T> by cloning the contents.

Examples

let mut x = 12;
let opt_x = Present(Some(&mut x));
assert_eq!(opt_x, Present(Some(&mut 12)));
let cloned = opt_x.cloned();
assert_eq!(cloned, Present(Some(12)));

impl<T: Deref> Field<T>

pub fn as_deref(&self) -> Field<&T::Target>

Converts from Field<T> (or &Field<T>) to Field<&T::Target>.

Leaves the original Field in-place, creating a new one with a reference to the original one, additionally coercing the contents via Deref.

Examples

let x: Field<String> = Present(Some("hey".to_owned()));
assert_eq!(x.as_deref(), Present(Some("hey")));

let x: Field<String> = Present(None);
assert_eq!(x.as_deref(), Present(None));

impl<T: DerefMut> Field<T>

pub fn as_deref_mut(&mut self) -> Field<&mut T::Target>

Converts from Field<T> (or &mut Field<T>) to Field<&mut T::Target>.

Leaves the original Field in-place, creating a new one containing a mutable reference to the inner type’s Deref::Target type.

Examples

let mut x: Field<String> = Present(Some("hey".to_owned()));
assert_eq!(x.as_deref_mut().map(|x| {
    x.make_ascii_uppercase();
    x
}), Present(Some("HEY".to_owned().as_mut_str())));

Trait Implementations

impl<T: Clone> Clone for Field<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Field<T>

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

Formats the value using the given formatter.

impl<T> Default for Field<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Field<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> From<Option<Option<T>>> for Field<T>

fn from(opt: Option<Option<T>>) -> Field<T>

Performs the conversion.

impl<T> From<Option<T>> for Field<T>

fn from(opt: Option<T>) -> Field<T>

Performs the conversion.

impl<T> From<T> for Field<T>

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

Performs the conversion.

impl<T: PartialEq> PartialEq<Field<T>> for Field<T>

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

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

fn ne(&self, other: &Field<T>) -> bool

This method tests for !=.

impl<T> Serialize for Field<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> StructuralPartialEq for Field<T>