Trait NumRef 

pub trait NumRef<'a>
where
    Self: Deref<Target = Self::Own>,
{
    type Own: Num;

    // Provided methods
    fn num_to_owned(&self) -> Result<Self::Own>
       where Self::Own: Clone { ... }
    fn num_set(&mut self, value: <Self::Own as Num>::Inner) -> Result<()>
       where Self: DerefMut<Target = Self::Own> { ... }
    fn num_set_ref(&mut self, value: &<Self::Own as Num>::Inner) -> Result<()>
       where Self: DerefMut<Target = Self::Own> { ... }
    fn num_is_zero(&self) -> Result<bool> { ... }
    fn num_get_zero() -> Result<Self::Own> { ... }
    fn num_set_zero(&mut self) -> Result<()>
       where Self: DerefMut<Target = Self::Own> { ... }
    fn num_is_one(&self) -> Result<bool> { ... }
    fn num_get_one() -> Result<Self::Own> { ... }
    fn num_set_one(&mut self) -> Result<()>
       where Self: DerefMut<Target = Self::Own> { ... }
    fn num_ref_add(
        &self,
        rhs: &<Self::Own as Num>::Rhs,
    ) -> Result<<Self::Own as Num>::Out> { ... }
    fn num_ref_add_assign(
        &mut self,
        rhs: &<Self::Own as Num>::Rhs,
    ) -> Result<()>
       where Self: DerefMut<Target = Self::Own> { ... }
    fn num_ref_sub(
        &self,
        rhs: &<Self::Own as Num>::Rhs,
    ) -> Result<<Self::Own as Num>::Out> { ... }
    fn num_ref_sub_assign(
        &mut self,
        rhs: &<Self::Own as Num>::Rhs,
    ) -> Result<()>
       where Self: DerefMut<Target = Self::Own> { ... }
    fn num_ref_mul(
        &self,
        rhs: &<Self::Own as Num>::Rhs,
    ) -> Result<<Self::Own as Num>::Out> { ... }
    fn num_ref_mul_assign(
        &mut self,
        rhs: &<Self::Own as Num>::Rhs,
    ) -> Result<()>
       where Self: DerefMut<Target = Self::Own> { ... }
    fn num_ref_div(
        &self,
        rhs: &<Self::Own as Num>::Rhs,
    ) -> Result<<Self::Own as Num>::Out> { ... }
    fn num_ref_div_assign(
        &mut self,
        rhs: &<Self::Own as Num>::Rhs,
    ) -> Result<()>
       where Self: DerefMut<Target = Self::Own> { ... }
    fn num_ref_rem(
        &self,
        rhs: &<Self::Own as Num>::Rhs,
    ) -> Result<<Self::Own as Num>::Out> { ... }
    fn num_ref_rem_assign(
        &mut self,
        rhs: &<Self::Own as Num>::Rhs,
    ) -> Result<()>
       where Self: DerefMut<Target = Self::Own> { ... }
    fn num_ref_neg(&self) -> Result<<Self::Own as Num>::Out> { ... }
    fn num_ref_abs(&self) -> Result<<Self::Own as Num>::Out> { ... }
}

Available on crate feature num only.

⅀ 🍃 Common auto-trait for referenced numeric types.

---

^{📍 num/dom}

---

It is automatically implemented for references of types implementing Num. Mutable operations are only available for exclusive (&mut) references.

Required Associated Types

type Own: Num

The owned version of this numeric type.

Provided Methods

fn num_to_owned(&self) -> Result<Self::Own>

where Self::Own: Clone,

Returns the owned version of self, if it can be cloned.

fn num_set(&mut self, value: <Self::Own as Num>::Inner) -> Result<()>

where Self: DerefMut<Target = Self::Own>,

Sets self to a valid value.

fn num_set_ref(&mut self, value: &<Self::Own as Num>::Inner) -> Result<()>

where Self: DerefMut<Target = Self::Own>,

Sets self to a valid &value.

fn num_is_zero(&self) -> Result<bool>

Returns true if self is zero.

fn num_get_zero() -> Result<Self::Own>

Returns the number zero.

fn num_set_zero(&mut self) -> Result<()>

where Self: DerefMut<Target = Self::Own>,

Sets self to zero.

fn num_is_one(&self) -> Result<bool>

Returns true if self is one.

fn num_get_one() -> Result<Self::Own>

Returns the number one.

fn num_set_one(&mut self) -> Result<()>

where Self: DerefMut<Target = Self::Own>,

Sets the number to one.

fn num_ref_add( &self, rhs: &<Self::Own as Num>::Rhs, ) -> Result<<Self::Own as Num>::Out>

Computes &self + &rhs.

fn num_ref_add_assign(&mut self, rhs: &<Self::Own as Num>::Rhs) -> Result<()>

where Self: DerefMut<Target = Self::Own>,

Computes &mut self += &rhs.

fn num_ref_sub( &self, rhs: &<Self::Own as Num>::Rhs, ) -> Result<<Self::Own as Num>::Out>

Computes &self - &rhs.

fn num_ref_sub_assign(&mut self, rhs: &<Self::Own as Num>::Rhs) -> Result<()>

where Self: DerefMut<Target = Self::Own>,

Computes &mut self -= &rhs.

fn num_ref_mul( &self, rhs: &<Self::Own as Num>::Rhs, ) -> Result<<Self::Own as Num>::Out>

Computes &self * &rhs.

fn num_ref_mul_assign(&mut self, rhs: &<Self::Own as Num>::Rhs) -> Result<()>

where Self: DerefMut<Target = Self::Own>,

Computes &mut self *= &rhs.

fn num_ref_div( &self, rhs: &<Self::Own as Num>::Rhs, ) -> Result<<Self::Own as Num>::Out>

Computes &self / &rhs.

fn num_ref_div_assign(&mut self, rhs: &<Self::Own as Num>::Rhs) -> Result<()>

where Self: DerefMut<Target = Self::Own>,

Computes &mut self /= &rhs.

fn num_ref_rem( &self, rhs: &<Self::Own as Num>::Rhs, ) -> Result<<Self::Own as Num>::Out>

Computes &self % &rhs.

fn num_ref_rem_assign(&mut self, rhs: &<Self::Own as Num>::Rhs) -> Result<()>

where Self: DerefMut<Target = Self::Own>,

Computes &mut self %= &rhs.

fn num_ref_neg(&self) -> Result<<Self::Own as Num>::Out>

Computes - &self.

fn num_ref_abs(&self) -> Result<<Self::Own as Num>::Out>

Computes the absolute value of &self.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T: Num> NumRef<'_> for &T

type Own = T

impl<T: Num> NumRef<'_> for &mut T

type Own = T

Implementors