Enum abi_stable::std_types::ROption

#[repr(u8)]
pub enum ROption<T> {
    RSome(T),
    RNone,
}

Ffi-safe equivalent of the std::option::Option type.

Option is also ffi-safe for NonNull/NonZero types, and references.

Variants

RSome(T)

RNone

Implementations

impl<T> ROption<T>

pub const fn as_ref(&self) -> ROption<&T>

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

Example

assert_eq!(RSome(10).as_ref(), RSome(&10));
assert_eq!(RNone::<u32>.as_ref(), RNone);

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

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

Example

assert_eq!(RSome(10).as_mut(), RSome(&mut 10));
assert_eq!(RNone::<u32>.as_mut(), RNone);

pub const fn is_rsome(&self) -> bool

Returns whether self is an RSome

Example

assert_eq!(RSome(10).is_rsome(), true);
assert_eq!(RNone::<u32>.is_rsome(), false);

pub const fn is_rnone(&self) -> bool

Returns whether self is an RNone

Example

assert_eq!(RSome(10).is_rnone(), false);
assert_eq!(RNone::<u32>.is_rnone(), true);

pub const fn is_some(&self) -> bool

Returns whether self is an RSome

Example

assert_eq!(RSome(10).is_some(), true);
assert_eq!(RNone::<u32>.is_some(), false);

pub const fn is_none(&self) -> bool

Returns whether self is an RNone

Example

assert_eq!(RSome(10).is_none(), false);
assert_eq!(RNone::<u32>.is_none(), true);

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

Converts from ROption<T> to Option<T>.

Example

assert_eq!(RSome(10).into_option(), Some(10));
assert_eq!(RNone::<u32>.into_option(), None);

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

Unwraps the ROption<T>, returning its contents.

Panics

Panics if self is RNone, with the msg message.

Example

assert_eq!(RSome(100).expect("must contain a value"), 100);

This one panics:

let _ = RNone::<()>.expect("Oh noooo!");

pub fn unwrap(self) -> T

Unwraps the ROption, returning its contents.

Panics

Panics if self is RNone.

Example

assert_eq!(RSome(500).unwrap(), 500);

This one panics:

let _ = RNone::<()>.unwrap();

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

Returns the value in the ROption<T>, or def if self is RNone.

Example

assert_eq!(RSome(10).unwrap_or(99), 10);
assert_eq!(RNone::<u32>.unwrap_or(99), 99);

pub fn unwrap_or_default(self) -> T

where T: Default,

Returns the value in the ROption<T>, or T::default() if self is RNone.

Example

assert_eq!(RSome(10).unwrap_or_default(), 10);
assert_eq!(RNone::<u32>.unwrap_or_default(), 0);

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

where F: FnOnce() -> T,

Returns the value in the ROption<T>, or the return value of calling f if self is RNone.

Example

assert_eq!(RSome(10).unwrap_or_else(|| 77), 10);
assert_eq!(RNone::<u32>.unwrap_or_else(|| 77), 77);

pub fn map<U, F>(self, f: F) -> ROption<U>

where F: FnOnce(T) -> U,

Converts the ROption<T> to a ROption<U>, transforming the contained value with the f closure.

Example

assert_eq!(RSome(10).map(|x| x * 2), RSome(20));
assert_eq!(RNone::<u32>.map(|x| x * 2), RNone);

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

where F: FnOnce(T) -> U,

Transforms (and returns) the contained value with the f closure, or returns default if self is RNone.

Example

assert_eq!(RSome(10).map_or(77, |x| x * 2), 20);
assert_eq!(RNone::<u32>.map_or(77, |x| x * 2), 77);

pub fn map_or_else<U, D, F>(self, otherwise: D, f: F) -> U

where D: FnOnce() -> U, F: FnOnce(T) -> U,

Transforms (and returns) the contained value with the f closure, or returns otherwise() if self is RNone..

Example

assert_eq!(RSome(10).map_or_else(|| 77, |x| x * 2), 20);
assert_eq!(RNone::<u32>.map_or_else(|| 77, |x| x * 2), 77);

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

Transforms the ROption<T> into a RResult<T, E>, mapping RSome(v) to ROk(v) and RNone to RErr(err).

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

Examples

let x = RSome("foo");
assert_eq!(x.ok_or(0), ROk("foo"));

let x: ROption<&str> = RNone;
assert_eq!(x.ok_or(0), RErr(0));

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

where F: FnOnce() -> E,

Transforms the ROption<T> into a RResult<T, E>, mapping RSome(v) to ROk(v) and RNone to RErr(err()).

Examples

let x = RSome("foo");
assert_eq!(x.ok_or_else(|| 0), ROk("foo"));

let x: ROption<&str> = RNone;
assert_eq!(x.ok_or_else(|| 0), RErr(0));

pub fn filter<P>(self, predicate: P) -> Self

where P: FnOnce(&T) -> bool,

Returns self if predicate(&self) is true, otherwise returns RNone.

Example

assert_eq!(RSome(10).filter(|x| (x % 2) == 0), RSome(10));
assert_eq!(RSome(10).filter(|x| (x % 2) == 1), RNone);
assert_eq!(RNone::<u32>.filter(|_| true), RNone);
assert_eq!(RNone::<u32>.filter(|_| false), RNone);

pub fn and(self, optb: ROption<T>) -> ROption<T>

Returns self if it is RNone, otherwise returns optb.

Example

assert_eq!(RSome(10).and(RSome(20)), RSome(20));
assert_eq!(RSome(10).and(RNone), RNone);
assert_eq!(RNone::<u32>.and(RSome(20)), RNone);
assert_eq!(RNone::<u32>.and(RNone), RNone);

pub fn and_then<F, U>(self, f: F) -> ROption<U>

where F: FnOnce(T) -> ROption<U>,

Returns self if it is RNone, otherwise returns the result of calling f with the value in RSome.

Example

assert_eq!(RSome(10).and_then(|x| RSome(x * 2)), RSome(20));
assert_eq!(RSome(10).and_then(|_| RNone::<u32>), RNone);
assert_eq!(RNone::<u32>.and_then(|x| RSome(x * 2)), RNone);
assert_eq!(RNone::<u32>.and_then(|_| RNone::<u32>), RNone);

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

Returns self if it contains a value, otherwise returns optb.

Example

assert_eq!(RSome(10).or(RSome(20)), RSome(10));
assert_eq!(RSome(10).or(RNone    ), RSome(10));
assert_eq!(RNone::<u32>.or(RSome(20)), RSome(20));
assert_eq!(RNone::<u32>.or(RNone    ), RNone);

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

where F: FnOnce() -> ROption<T>,

Returns self if it contains a value, otherwise calls optb and returns the value it evaluates to.

Example

assert_eq!(RSome(10).or_else(|| RSome(20)), RSome(10));
assert_eq!(RSome(10).or_else(|| RNone), RSome(10));
assert_eq!(RNone::<u32>.or_else(|| RSome(20)), RSome(20));
assert_eq!(RNone::<u32>.or_else(|| RNone), RNone);

pub fn xor(self, optb: ROption<T>) -> ROption<T>

Returns RNone if both values are RNone or RSome, otherwise returns the value that is anRSome.

Example

assert_eq!(RSome(10).xor(RSome(20)), RNone);
assert_eq!(RSome(10).xor(RNone), RSome(10));
assert_eq!(RNone::<u32>.xor(RSome(20)), RSome(20));
assert_eq!(RNone::<u32>.xor(RNone), RNone);

pub fn get_or_insert(&mut self, value: T) -> &mut T

Sets this ROption to RSome(value) if it was RNone. Returns a mutable reference to the inserted/pre-existing RSome.

Example

assert_eq!(RSome(10).get_or_insert(40), &mut 10);
assert_eq!(RSome(20).get_or_insert(55), &mut 20);
assert_eq!(RNone::<u32>.get_or_insert(77), &mut 77);

pub fn get_or_insert_with<F>(&mut self, func: F) -> &mut T

where F: FnOnce() -> T,

Sets this ROption to RSome(func()) if it was RNone. Returns a mutable reference to the inserted/pre-existing RSome.

Example

assert_eq!(RSome(10).get_or_insert_with(|| 40), &mut 10);
assert_eq!(RSome(20).get_or_insert_with(|| 55), &mut 20);
assert_eq!(RNone::<u32>.get_or_insert_with(|| 77), &mut 77);

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

Takes the value of self, replacing it with RNone

Example

let mut opt0 = RSome(10);
assert_eq!(opt0.take(), RSome(10));
assert_eq!(opt0, RNone);

let mut opt1 = RSome(20);
assert_eq!(opt1.take(), RSome(20));
assert_eq!(opt1, RNone);

let mut opt2 = RNone::<u32>;
assert_eq!(opt2.take(), RNone);
assert_eq!(opt2, RNone);

pub fn replace(&mut self, value: T) -> ROption<T>

Replaces the value of self with RSome(value).

Example

let mut opt0 = RSome(10);
assert_eq!(opt0.replace(55), RSome(10));
assert_eq!(opt0, RSome(55));

let mut opt1 = RSome(20);
assert_eq!(opt1.replace(88), RSome(20));
assert_eq!(opt1, RSome(88));

let mut opt2 = RNone::<u32>;
assert_eq!(opt2.replace(33), RNone);
assert_eq!(opt2, RSome(33));

impl<T> ROption<&T>

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

where T: Clone,

Converts an ROption<&T> to an ROption<T> by cloning its contents.

Example

assert_eq!(RSome(&vec![()]).cloned(), RSome(vec![()]));
assert_eq!(RNone::<&Vec<()>>.cloned(), RNone);

pub const fn copied(self) -> ROption<T>

where T: Copy,

Converts an ROption<&T> to an ROption<T> by Copy-ing its contents.

Example

assert_eq!(RSome(&7).copied(), RSome(7));
assert_eq!(RNone::<&u32>.copied(), RNone);

impl<T> ROption<&mut T>

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

where T: Clone,

Converts an ROption<&mut T> to a ROption<T> by cloning its contents.

Example

assert_eq!(RSome(&mut vec![()]).cloned(), RSome(vec![()]));
assert_eq!(RNone::<&mut Vec<()>>.cloned(), RNone);

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

where T: Copy,

Converts an ROption<&mut T> to a ROption<T> by Copy-ing its contents.

Example

assert_eq!(RSome(&mut 7).copied(), RSome(7));
assert_eq!(RNone::<&mut u32>.copied(), RNone);

impl<T: Deref> ROption<T>

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

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

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

Examples

let x: ROption<RString> = RSome(RString::from("hey"));
assert_eq!(x.as_deref(), RSome("hey"));

let x: ROption<RString> = RNone;
assert_eq!(x.as_deref(), RNone);

Trait Implementations

impl<T: Clone> Clone for ROption<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ROption<T>

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

Formats the value using the given formatter.

impl<T> Default for ROption<T>

The default value is RNone.

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for ROption<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<T>> for ROption<T>

fn from(this: Option<T>) -> ROption<T>

Converts to this type from the input type.

impl<T> From<ROption<T>> for Option<T>

fn from(this: ROption<T>) -> Option<T>

Converts to this type from the input type.

impl<T> GetStaticEquivalent_ for ROption<T>

where T: __StableAbi,

type StaticEquivalent = _static_ROption<<T as GetStaticEquivalent_>::StaticEquivalent>

The 'static equivalent of Self

impl<T: Hash> Hash for ROption<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> IntoReprRust for ROption<T>

type ReprRust = Option<T>

The #[repr(Rust)] equivalent.

fn into_rust(self) -> Self::ReprRust

Performs the conversion

impl<T: Ord> Ord for ROption<T>

fn cmp(&self, other: &ROption<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for ROption<T>

fn eq(&self, other: &ROption<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 ROption<T>

fn partial_cmp(&self, other: &ROption<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 ROption<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> StableAbi for ROption<T>

where T: __StableAbi,

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

const LAYOUT: &'static TypeLayout = _

The layout of the type provided by implementors.

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.

impl<T: Copy> Copy for ROption<T>

impl<T: Eq> Eq for ROption<T>

impl<T> StructuralPartialEq for ROption<T>