Struct gcollections::wrappers::optional::Optional

pub struct Optional<T> { /* fields omitted */ }

Methods

impl<T> Optional<T>

pub fn wrap(value: Option<T>) -> Optional<T>

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

Methods from Deref<Target = Option<T>>

pub fn is_some(&self) -> bool

Returns true if the option is a Some value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_some(), true);

let x: Option<u32> = None;
assert_eq!(x.is_some(), false);

pub fn is_none(&self) -> bool

Returns true if the option is a None value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_none(), false);

let x: Option<u32> = None;
assert_eq!(x.is_none(), true);

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

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

Examples

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

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

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

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

Examples

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

pub fn as_pin_mut(self: PinMut<'a, Option<T>>) -> Option<PinMut<'a, T>>

🔬 This is a nightly-only experimental API. (pin)

Converts from Option<T> to Option<PinMut<'_, T>>

Important traits for Iter<'a, A>

impl<'a, A> Iterator for Iter<'a, A> type Item = &'a A;

pub fn iter(&self) -> Iter<T>

Returns an iterator over the possibly contained value.

Examples

let x = Some(4);
assert_eq!(x.iter().next(), Some(&4));

let x: Option<u32> = None;
assert_eq!(x.iter().next(), None);

Important traits for IterMut<'a, A>

impl<'a, A> Iterator for IterMut<'a, A> type Item = &'a mut A;

pub fn iter_mut(&mut self) -> IterMut<T>

Returns a mutable iterator over the possibly contained value.

Examples

let mut x = Some(4);
match x.iter_mut().next() {
    Some(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));

let mut x: Option<u32> = None;
assert_eq!(x.iter_mut().next(), None);

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

Inserts v into the option if it is None, then returns a mutable reference to the contained value.

Examples

let mut x = None;

{
    let y: &mut u32 = x.get_or_insert(5);
    assert_eq!(y, &5);

    *y = 7;
}

assert_eq!(x, Some(7));

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn get_or_insert_with<F>(&mut self, f: F) -> &mut T where     F: FnOnce() -> T,

Inserts a value computed from f into the option if it is None, then returns a mutable reference to the contained value.

Examples

let mut x = None;

{
    let y: &mut u32 = x.get_or_insert_with(|| 5);
    assert_eq!(y, &5);

    *y = 7;
}

assert_eq!(x, Some(7));

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

Takes the value out of the option, leaving a None in its place.

Examples

let mut x = Some(2);
x.take();
assert_eq!(x, None);

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

Trait Implementations

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: Copy> Copy for Optional<T>

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

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

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

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

This method tests for !=.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

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

Formats the value using the given formatter.

impl<T> Collection for Optional<T>

type Item = T

impl<T> Deref for Optional<T>

type Target = Option<T>

The resulting type after dereferencing.

fn deref<'a>(&'a self) -> &'a Option<T>

Dereferences the value.

impl<T> DerefMut for Optional<T>

fn deref_mut<'a>(&'a mut self) -> &'a mut Option<T>

Mutably dereferences the value.

impl<T> Cardinality for Optional<T>

type Size = usize

fn size(&self) -> usize

impl<T> Singleton for Optional<T>

fn singleton(value: T) -> Optional<T>

impl<T> Empty for Optional<T>

fn empty() -> Optional<T>

impl<T> Intersection<Optional<T>> for Optional<T> where     T: Clone + PartialEq,

type Output = Optional<T>

fn intersection(&self, other: &Optional<T>) -> Self::Output

impl<T> Intersection<T> for Optional<T> where     T: Clone + PartialEq,

type Output = Optional<T>

fn intersection(&self, other: &T) -> Self::Output

impl Intersection<Optional<i8>> for i8

type Output = Optional<i8>

fn intersection(&self, other: &Optional<i8>) -> Self::Output

impl Intersection<Optional<u8>> for u8

type Output = Optional<u8>

fn intersection(&self, other: &Optional<u8>) -> Self::Output

impl Intersection<Optional<i16>> for i16

type Output = Optional<i16>

fn intersection(&self, other: &Optional<i16>) -> Self::Output

impl Intersection<Optional<u16>> for u16

type Output = Optional<u16>

fn intersection(&self, other: &Optional<u16>) -> Self::Output

impl Intersection<Optional<i32>> for i32

type Output = Optional<i32>

fn intersection(&self, other: &Optional<i32>) -> Self::Output

impl Intersection<Optional<u32>> for u32

type Output = Optional<u32>

fn intersection(&self, other: &Optional<u32>) -> Self::Output

impl Intersection<Optional<i64>> for i64

type Output = Optional<i64>

fn intersection(&self, other: &Optional<i64>) -> Self::Output

impl Intersection<Optional<u64>> for u64

type Output = Optional<u64>

fn intersection(&self, other: &Optional<u64>) -> Self::Output

impl Intersection<Optional<isize>> for isize

type Output = Optional<isize>

fn intersection(&self, other: &Optional<isize>) -> Self::Output

impl Intersection<Optional<usize>> for usize

type Output = Optional<usize>

fn intersection(&self, other: &Optional<usize>) -> Self::Output

impl Intersection<Optional<f32>> for f32

type Output = Optional<f32>

fn intersection(&self, other: &Optional<f32>) -> Self::Output

impl Intersection<Optional<f64>> for f64

type Output = Optional<f64>

fn intersection(&self, other: &Optional<f64>) -> Self::Output

impl Intersection<Optional<bool>> for bool

type Output = Optional<bool>

fn intersection(&self, other: &Optional<bool>) -> Self::Output

impl Intersection<Optional<char>> for char

type Output = Optional<char>

fn intersection(&self, other: &Optional<char>) -> Self::Output

impl<T> Difference<Optional<T>> for Optional<T> where     T: Clone + PartialEq,

type Output = Optional<T>

fn difference(&self, other: &Optional<T>) -> Self::Output

impl<T> Difference<T> for Optional<T> where     T: Clone + PartialEq,

type Output = Optional<T>

fn difference(&self, other: &T) -> Self::Output

impl Difference<Optional<i8>> for i8

type Output = Optional<i8>

fn difference(&self, other: &Optional<i8>) -> Self::Output

impl Difference<Optional<u8>> for u8

type Output = Optional<u8>

fn difference(&self, other: &Optional<u8>) -> Self::Output

impl Difference<Optional<i16>> for i16

type Output = Optional<i16>

fn difference(&self, other: &Optional<i16>) -> Self::Output

impl Difference<Optional<u16>> for u16

type Output = Optional<u16>

fn difference(&self, other: &Optional<u16>) -> Self::Output

impl Difference<Optional<i32>> for i32

type Output = Optional<i32>

fn difference(&self, other: &Optional<i32>) -> Self::Output

impl Difference<Optional<u32>> for u32

type Output = Optional<u32>

fn difference(&self, other: &Optional<u32>) -> Self::Output

impl Difference<Optional<i64>> for i64

type Output = Optional<i64>

fn difference(&self, other: &Optional<i64>) -> Self::Output

impl Difference<Optional<u64>> for u64

type Output = Optional<u64>

fn difference(&self, other: &Optional<u64>) -> Self::Output

impl Difference<Optional<isize>> for isize

type Output = Optional<isize>

fn difference(&self, other: &Optional<isize>) -> Self::Output

impl Difference<Optional<usize>> for usize

type Output = Optional<usize>

fn difference(&self, other: &Optional<usize>) -> Self::Output

impl Difference<Optional<f32>> for f32

type Output = Optional<f32>

fn difference(&self, other: &Optional<f32>) -> Self::Output

impl Difference<Optional<f64>> for f64

type Output = Optional<f64>

fn difference(&self, other: &Optional<f64>) -> Self::Output

impl Difference<Optional<bool>> for bool

type Output = Optional<bool>

fn difference(&self, other: &Optional<bool>) -> Self::Output

impl Difference<Optional<char>> for char

type Output = Optional<char>

fn difference(&self, other: &Optional<char>) -> Self::Output

impl<T, U> Disjoint<Optional<U>> for Optional<T> where     T: Disjoint<U>,

fn is_disjoint(&self, other: &Optional<U>) -> bool

impl<T, U> Disjoint<U> for Optional<T> where     T: Disjoint<U>,     U: GroundType,

fn is_disjoint(&self, other: &U) -> bool

impl<T> Disjoint<Optional<T>> for i8 where     T: Disjoint<i8>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for u8 where     T: Disjoint<u8>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for i16 where     T: Disjoint<i16>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for u16 where     T: Disjoint<u16>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for i32 where     T: Disjoint<i32>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for u32 where     T: Disjoint<u32>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for i64 where     T: Disjoint<i64>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for u64 where     T: Disjoint<u64>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for isize where     T: Disjoint<isize>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for usize where     T: Disjoint<usize>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for f32 where     T: Disjoint<f32>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for f64 where     T: Disjoint<f64>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for bool where     T: Disjoint<bool>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Disjoint<Optional<T>> for char where     T: Disjoint<char>,

fn is_disjoint(&self, other: &Optional<T>) -> bool

impl<T> Contains for Optional<T> where     T: Eq,

fn contains(&self, value: &T) -> bool

impl<T> Subset<Optional<T>> for Optional<T> where     T: Subset,

fn is_subset(&self, other: &Optional<T>) -> bool

impl<T> ProperSubset<Optional<T>> for Optional<T> where     T: Subset + PartialEq,

fn is_proper_subset(&self, other: &Optional<T>) -> bool

impl<T, U> Overlap<Optional<U>> for Optional<T> where     T: Overlap<U>,

fn overlap(&self, other: &Optional<U>) -> bool

impl<T, U> Overlap<U> for Optional<T> where     T: Overlap<U>,     U: GroundType,

fn overlap(&self, other: &U) -> bool

impl<T> Overlap<Optional<T>> for i8 where     T: Overlap<i8>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for u8 where     T: Overlap<u8>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for i16 where     T: Overlap<i16>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for u16 where     T: Overlap<u16>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for i32 where     T: Overlap<i32>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for u32 where     T: Overlap<u32>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for i64 where     T: Overlap<i64>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for u64 where     T: Overlap<u64>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for isize where     T: Overlap<isize>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for usize where     T: Overlap<usize>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for f32 where     T: Overlap<f32>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for f64 where     T: Overlap<f64>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for bool where     T: Overlap<bool>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for char where     T: Overlap<char>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T, U, R> Add<Optional<U>> for Optional<T> where     T: Add<U, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, other: Optional<U>) -> Self::Output

Performs the + operation.

impl<T, U, R> Add<U> for Optional<T> where     T: Add<U, Output = R>,     U: GroundType,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, other: U) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for i8 where     T: Add<i8, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for u8 where     T: Add<u8, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for i16 where     T: Add<i16, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for u16 where     T: Add<u16, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for i32 where     T: Add<i32, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for u32 where     T: Add<u32, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for i64 where     T: Add<i64, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for u64 where     T: Add<u64, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for isize where     T: Add<isize, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for usize where     T: Add<usize, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for f32 where     T: Add<f32, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for f64 where     T: Add<f64, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for bool where     T: Add<bool, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, R> Add<Optional<T>> for char where     T: Add<char, Output = R>,

type Output = Optional<R>

The resulting type after applying the + operator.

fn add(self, rhs: Optional<T>) -> Self::Output

Performs the + operation.

impl<T, U, R> Sub<Optional<U>> for Optional<T> where     T: Sub<U, Output = R>,

type Output = Optional<R>

The resulting type after applying the - operator.

fn sub(self, other: Optional<U>) -> Self::Output

Performs the - operation.

impl<T, U, R> Sub<U> for Optional<T> where     T: Sub<U, Output = R>,     U: GroundType,

type Output = Optional<R>

The resulting type after applying the - operator.

fn sub(self, other: U) -> Self::Output

Performs the - operation.

impl Sub<Optional<i8>> for i8

type Output = Optional<i8>

The resulting type after applying the - operator.

fn sub(self, other: Optional<i8>) -> Self::Output

Performs the - operation.

impl Sub<Optional<u8>> for u8

type Output = Optional<u8>

The resulting type after applying the - operator.

fn sub(self, other: Optional<u8>) -> Self::Output

Performs the - operation.

impl Sub<Optional<i16>> for i16

type Output = Optional<i16>

The resulting type after applying the - operator.

fn sub(self, other: Optional<i16>) -> Self::Output

Performs the - operation.

impl Sub<Optional<u16>> for u16

type Output = Optional<u16>

The resulting type after applying the - operator.

fn sub(self, other: Optional<u16>) -> Self::Output

Performs the - operation.

impl Sub<Optional<i32>> for i32

type Output = Optional<i32>

The resulting type after applying the - operator.

fn sub(self, other: Optional<i32>) -> Self::Output

Performs the - operation.

impl Sub<Optional<u32>> for u32

type Output = Optional<u32>

The resulting type after applying the - operator.

fn sub(self, other: Optional<u32>) -> Self::Output

Performs the - operation.

impl Sub<Optional<i64>> for i64

type Output = Optional<i64>

The resulting type after applying the - operator.

fn sub(self, other: Optional<i64>) -> Self::Output

Performs the - operation.

impl Sub<Optional<u64>> for u64

type Output = Optional<u64>

The resulting type after applying the - operator.

fn sub(self, other: Optional<u64>) -> Self::Output

Performs the - operation.

impl Sub<Optional<isize>> for isize

type Output = Optional<isize>

The resulting type after applying the - operator.

fn sub(self, other: Optional<isize>) -> Self::Output

Performs the - operation.

impl Sub<Optional<usize>> for usize

type Output = Optional<usize>

The resulting type after applying the - operator.

fn sub(self, other: Optional<usize>) -> Self::Output

Performs the - operation.

impl Sub<Optional<f32>> for f32

type Output = Optional<f32>

The resulting type after applying the - operator.

fn sub(self, other: Optional<f32>) -> Self::Output

Performs the - operation.

impl Sub<Optional<f64>> for f64

type Output = Optional<f64>

The resulting type after applying the - operator.

fn sub(self, other: Optional<f64>) -> Self::Output

Performs the - operation.

impl<T, U, R> Mul<Optional<U>> for Optional<T> where     T: Mul<U, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<U>) -> Self::Output

Performs the * operation.

impl<T, U, R> Mul<U> for Optional<T> where     T: Mul<U, Output = R>,     U: GroundType,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: U) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for i8 where     T: Mul<i8, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for u8 where     T: Mul<u8, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for i16 where     T: Mul<i16, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for u16 where     T: Mul<u16, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for i32 where     T: Mul<i32, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for u32 where     T: Mul<u32, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for i64 where     T: Mul<i64, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for u64 where     T: Mul<u64, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for isize where     T: Mul<isize, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for usize where     T: Mul<usize, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for f32 where     T: Mul<f32, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for f64 where     T: Mul<f64, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for bool where     T: Mul<bool, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.

impl<T, R> Mul<Optional<T>> for char where     T: Mul<char, Output = R>,

type Output = Optional<R>

The resulting type after applying the * operator.

fn mul(self, other: Optional<T>) -> Self::Output

Performs the * operation.