# Struct sp_runtime::Percent

`pub struct Percent(/* private fields */);`

## Expand description

Re-export top-level arithmetic stuff. A fixed point representation of a number in the range [0, 1].

*Percent*

## Implementations§

§### impl Percent

### impl Percent

#### pub const fn from_parts(parts: u8) -> Percent

#### pub const fn from_parts(parts: u8) -> Percent

From an explicitly defined number of parts per maximum of the type.

#### pub const fn from_percent(x: u8) -> Percent

#### pub const fn from_percent(x: u8) -> Percent

Converts a percent into `Self`

. Equal to `x / 100`

.

This can be created at compile time.

#### pub const fn one() -> Percent

#### pub const fn one() -> Percent

See `PerThing::one`

#### pub fn is_one(&self) -> bool

#### pub fn is_one(&self) -> bool

See `PerThing::is_one`

.

#### pub const fn zero() -> Percent

#### pub const fn zero() -> Percent

See `PerThing::zero`

.

#### pub fn is_zero(&self) -> bool

#### pub fn is_zero(&self) -> bool

See `PerThing::is_zero`

.

#### pub const fn deconstruct(self) -> u8

#### pub const fn deconstruct(self) -> u8

#### pub fn square(self) -> Percent

#### pub fn square(self) -> Percent

See `PerThing::square`

.

#### pub fn from_float(x: f64) -> Percent

#### pub fn from_float(x: f64) -> Percent

See `PerThing::from_float`

.

#### pub fn from_rational_approximation<N>(p: N, q: N) -> Percent

👎Deprecated: Use `PerThing::from_rational`

instead

#### pub fn from_rational_approximation<N>(p: N, q: N) -> Percent

`PerThing::from_rational`

instead#### pub fn from_rational<N>(p: N, q: N) -> Percent

#### pub fn from_rational<N>(p: N, q: N) -> Percent

#### pub fn mul_floor<N>(self, b: N) -> N

#### pub fn mul_floor<N>(self, b: N) -> N

See `PerThing::mul_floor`

.

#### pub fn mul_ceil<N>(self, b: N) -> N

#### pub fn mul_ceil<N>(self, b: N) -> N

See `PerThing::mul_ceil`

.

#### pub fn saturating_reciprocal_mul<N>(self, b: N) -> N

#### pub fn saturating_reciprocal_mul<N>(self, b: N) -> N

#### pub fn saturating_reciprocal_mul_floor<N>(self, b: N) -> N

#### pub fn saturating_reciprocal_mul_floor<N>(self, b: N) -> N

#### pub fn saturating_reciprocal_mul_ceil<N>(self, b: N) -> N

#### pub fn saturating_reciprocal_mul_ceil<N>(self, b: N) -> N

#### pub fn saturating_div(self, rhs: Percent, r: Rounding) -> Percent

#### pub fn saturating_div(self, rhs: Percent, r: Rounding) -> Percent

Saturating division. Compute `self / rhs`

, saturating at one if `rhs < self`

.

The `rounding`

method must be specified. e.g.:

```
let pc = |x| Percent::from_percent(x);
assert_eq!(
pc(2).saturating_div(pc(3), Down),
pc(66),
);
assert_eq!(
pc(1).saturating_div(pc(3), NearestPrefUp),
pc(33),
);
assert_eq!(
pc(2).saturating_div(pc(3), NearestPrefDown),
pc(67),
);
assert_eq!(
pc(1).saturating_div(pc(3), Up),
pc(34),
);
```

## Trait Implementations§

§### impl CheckedAdd for Percent

### impl CheckedAdd for Percent

§#### fn checked_add(&self, rhs: &Percent) -> Option<Percent>

#### fn checked_add(&self, rhs: &Percent) -> Option<Percent>

`None`

is
returned.§### impl CheckedMul for Percent

### impl CheckedMul for Percent

#### §Note

CheckedMul will never fail for PerThings.

§#### fn checked_mul(&self, rhs: &Percent) -> Option<Percent>

#### fn checked_mul(&self, rhs: &Percent) -> Option<Percent>

`None`

is returned.§### impl CheckedSub for Percent

### impl CheckedSub for Percent

§#### fn checked_sub(&self, v: &Percent) -> Option<Percent>

#### fn checked_sub(&self, v: &Percent) -> Option<Percent>

`None`

is returned.§### impl CompactAs for Percent

### impl CompactAs for Percent

Implementation makes any compact encoding of `PerThing::Inner`

valid,
when decoding it will saturate up to `PerThing::ACCURACY`

.

§### impl Decode for Percent

### impl Decode for Percent

§#### fn decode<I>(input: &mut I) -> Result<Percent, Error>where
I: Input,

#### fn decode<I>(input: &mut I) -> Result<Percent, Error>where
I: Input,

§#### fn decode_into<I>(
input: &mut I,
dst: &mut MaybeUninit<Self>,
) -> Result<DecodeFinished, Error>where
I: Input,

#### fn decode_into<I>(
input: &mut I,
dst: &mut MaybeUninit<Self>,
) -> Result<DecodeFinished, Error>where
I: Input,

§#### fn skip<I>(input: &mut I) -> Result<(), Error>where
I: Input,

#### fn skip<I>(input: &mut I) -> Result<(), Error>where
I: Input,

§#### fn encoded_fixed_size() -> Option<usize>

#### fn encoded_fixed_size() -> Option<usize>

§### impl<'de> Deserialize<'de> for Percent

### impl<'de> Deserialize<'de> for Percent

§#### fn deserialize<__D>(
__deserializer: __D,
) -> Result<Percent, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,

#### fn deserialize<__D>(
__deserializer: __D,
) -> Result<Percent, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,

§### impl Encode for Percent

### impl Encode for Percent

§#### fn encode_to<__CodecOutputEdqy>(
&self,
__codec_dest_edqy: &mut __CodecOutputEdqy,
)where
__CodecOutputEdqy: Output + ?Sized,

#### fn encode_to<__CodecOutputEdqy>(
&self,
__codec_dest_edqy: &mut __CodecOutputEdqy,
)where
__CodecOutputEdqy: Output + ?Sized,

§#### fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>(
&self,
f: __CodecUsingEncodedCallback,
) -> __CodecOutputReturn

#### fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

§#### fn encoded_size(&self) -> usize

#### fn encoded_size(&self) -> usize

§### impl MaxEncodedLen for Percent

### impl MaxEncodedLen for Percent

§#### fn max_encoded_len() -> usize

#### fn max_encoded_len() -> usize

§### impl<N> Mul<N> for Percent

### impl<N> Mul<N> for Percent

Non-overflow multiplication.

This is tailored to be used with a balance type.

§### impl Ord for Percent

### impl Ord for Percent

§### impl PartialOrd for Percent

### impl PartialOrd for Percent

§#### fn partial_cmp(&self, other: &Percent) -> Option<Ordering>

#### fn partial_cmp(&self, other: &Percent) -> Option<Ordering>

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read more§### impl PerThing for Percent

### impl PerThing for Percent

§#### fn deconstruct(self) -> <Percent as PerThing>::Inner

#### fn deconstruct(self) -> <Percent as PerThing>::Inner

Consume self and return the number of parts per thing.

§#### fn from_parts(parts: <Percent as PerThing>::Inner) -> Percent

#### fn from_parts(parts: <Percent as PerThing>::Inner) -> Percent

Build this type from a number of parts per thing.

§#### fn from_float(x: f64) -> Percent

#### fn from_float(x: f64) -> Percent

NOTE: saturate to 0 or 1 if x is beyond `[0, 1]`

§#### type Upper = u16

#### type Upper = u16

`Self::Inner`

, used to avoid overflow in some computations.
It must be able to compute `ACCURACY^2`

.§#### const ACCURACY: <Percent as PerThing>::Inner = {transmute(0x64): <sp_arithmetic::Percent as sp_arithmetic::PerThing>::Inner}

#### const ACCURACY: <Percent as PerThing>::Inner = {transmute(0x64): <sp_arithmetic::Percent as sp_arithmetic::PerThing>::Inner}

§#### fn from_rational_with_rounding<N>(
p: N,
q: N,
r: Rounding,
) -> Result<Percent, ()>

#### fn from_rational_with_rounding<N>( p: N, q: N, r: Rounding, ) -> Result<Percent, ()>

`p/q`

into a per-thing fraction. Read more§#### fn less_epsilon(self) -> Self

#### fn less_epsilon(self) -> Self

`self`

or `self`

if it is already zero.§#### fn try_less_epsilon(self) -> Result<Self, Self>

#### fn try_less_epsilon(self) -> Result<Self, Self>

`self`

or an error with the same value if `self`

is already
zero.§#### fn plus_epsilon(self) -> Self

#### fn plus_epsilon(self) -> Self

`self`

or `self`

if it is already one.§#### fn try_plus_epsilon(self) -> Result<Self, Self>

#### fn try_plus_epsilon(self) -> Result<Self, Self>

`self`

or an error with the same value if `self`

is already
one.§#### fn from_percent(x: Self::Inner) -> Self

#### fn from_percent(x: Self::Inner) -> Self

`Self::from_parts(x * Self::ACCURACY / 100)`

but more accurate and can cope with potential type overflows.§#### fn left_from_one(self) -> Self

#### fn left_from_one(self) -> Self

`self`

is saturating-subtracted from `Self::one()`

.§#### fn mul_floor<N>(self, b: N) -> N

#### fn mul_floor<N>(self, b: N) -> N

`Mul`

rounds to the
nearest whole number. Read more§#### fn mul_ceil<N>(self, b: N) -> N

#### fn mul_ceil<N>(self, b: N) -> N

`Mul`

rounds to the nearest whole number. Read more§#### fn saturating_reciprocal_mul<N>(self, b: N) -> N

#### fn saturating_reciprocal_mul<N>(self, b: N) -> N

`self`

. The result is rounded to the
nearest whole number and saturates at the numeric bounds instead of overflowing. Read more§#### fn saturating_reciprocal_mul_floor<N>(self, b: N) -> N

#### fn saturating_reciprocal_mul_floor<N>(self, b: N) -> N

`self`

. The result is rounded down to the
nearest whole number and saturates at the numeric bounds instead of overflowing. Read more§#### fn saturating_reciprocal_mul_ceil<N>(self, b: N) -> N

#### fn saturating_reciprocal_mul_ceil<N>(self, b: N) -> N

`self`

. The result is rounded up to the
nearest whole number and saturates at the numeric bounds instead of overflowing. Read more§#### fn from_rational<N>(p: N, q: N) -> Self

#### fn from_rational<N>(p: N, q: N) -> Self

`p/q`

into a per-thing fraction. This will never overflow. Read more§### impl Saturating for Percent

### impl Saturating for Percent

§#### fn saturating_add(self, rhs: Percent) -> Percent

#### fn saturating_add(self, rhs: Percent) -> Percent

Saturating addition. Compute `self + rhs`

, saturating at the numeric bounds instead of
overflowing. This operation is lossless if it does not saturate.

§#### fn saturating_sub(self, rhs: Percent) -> Percent

#### fn saturating_sub(self, rhs: Percent) -> Percent

Saturating subtraction. Compute `self - rhs`

, saturating at the numeric bounds instead of
overflowing. This operation is lossless if it does not saturate.

§#### fn saturating_mul(self, rhs: Percent) -> Percent

#### fn saturating_mul(self, rhs: Percent) -> Percent

Saturating multiply. Compute `self * rhs`

, saturating at the numeric bounds instead of
overflowing. This operation is lossy.

§#### fn saturating_pow(self, exp: usize) -> Percent

#### fn saturating_pow(self, exp: usize) -> Percent

Saturating exponentiation. Computes `self.pow(exp)`

, saturating at the numeric
bounds instead of overflowing. This operation is lossy.

§#### fn saturating_less_one(self) -> Selfwhere
Self: One,

#### fn saturating_less_one(self) -> Selfwhere
Self: One,

§#### fn saturating_plus_one(self) -> Selfwhere
Self: One,

#### fn saturating_plus_one(self) -> Selfwhere
Self: One,

§#### fn saturating_inc(&mut self)where
Self: One,

#### fn saturating_inc(&mut self)where
Self: One,

§#### fn saturating_dec(&mut self)where
Self: One,

#### fn saturating_dec(&mut self)where
Self: One,

§#### fn saturating_accrue(&mut self, amount: Self)where
Self: One,

#### fn saturating_accrue(&mut self, amount: Self)where
Self: One,

`amount`

, saturating.§#### fn saturating_reduce(&mut self, amount: Self)where
Self: One,

#### fn saturating_reduce(&mut self, amount: Self)where
Self: One,

`amount`

, saturating at zero.§### impl SaturatingAdd for Percent

### impl SaturatingAdd for Percent

§#### fn saturating_add(&self, v: &Percent) -> Percent

#### fn saturating_add(&self, v: &Percent) -> Percent

`self + other`

, saturating at the relevant high or low boundary of
the type.§### impl SaturatingSub for Percent

### impl SaturatingSub for Percent

§#### fn saturating_sub(&self, v: &Percent) -> Percent

#### fn saturating_sub(&self, v: &Percent) -> Percent

`self - other`

, saturating at the relevant high or low boundary of
the type.§### impl Serialize for Percent

### impl Serialize for Percent

§#### fn serialize<__S>(
&self,
__serializer: __S,
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,

#### fn serialize<__S>(
&self,
__serializer: __S,
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,

### impl Copy for Percent

### impl EncodeLike for Percent

### impl Eq for Percent

### impl StructuralPartialEq for Percent

## Auto Trait Implementations§

### impl Freeze for Percent

### impl RefUnwindSafe for Percent

### impl Send for Percent

### impl Sync for Percent

### impl Unpin for Percent

### impl UnwindSafe for Percent

## Blanket Implementations§

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

source§### impl<T> CheckedConversion for T

### impl<T> CheckedConversion for T

source§### impl<T> CloneToUninit for Twhere
T: Copy,

### impl<T> CloneToUninit for Twhere
T: Copy,

source§#### unsafe fn clone_to_uninit(&self, dst: *mut T)

#### unsafe fn clone_to_uninit(&self, dst: *mut T)

`clone_to_uninit`

)source§### impl<T> CloneToUninit for Twhere
T: Clone,

### impl<T> CloneToUninit for Twhere
T: Clone,

source§#### default unsafe fn clone_to_uninit(&self, dst: *mut T)

#### default unsafe fn clone_to_uninit(&self, dst: *mut T)

`clone_to_uninit`

)§### impl<Q, K> Comparable<K> for Q

### impl<Q, K> Comparable<K> for Q

§### impl<T> Conv for T

### impl<T> Conv for T

§### impl<T> DecodeAll for Twhere
T: Decode,

### impl<T> DecodeAll for Twhere
T: Decode,

§#### fn decode_all(input: &mut &[u8]) -> Result<T, Error>

#### fn decode_all(input: &mut &[u8]) -> Result<T, Error>

`Self`

and consume all of the given input data. Read more§### impl<T> DecodeLimit for Twhere
T: Decode,

### impl<T> DecodeLimit for Twhere
T: Decode,

§### impl<T> EnsureAdd for Twhere
T: EnsureAddAssign,

### impl<T> EnsureAdd for Twhere
T: EnsureAddAssign,

§#### fn ensure_add(self, v: Self) -> Result<Self, ArithmeticError>

#### fn ensure_add(self, v: Self) -> Result<Self, ArithmeticError>

§### impl<T> EnsureAddAssign for T

### impl<T> EnsureAddAssign for T

§#### fn ensure_add_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

#### fn ensure_add_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

§### impl<T, S> EnsureFrom<S> for T

### impl<T, S> EnsureFrom<S> for T

§#### fn ensure_from(other: T) -> Result<Self, ArithmeticError>

#### fn ensure_from(other: T) -> Result<Self, ArithmeticError>

`ArithmeticError`

if fails. Read more§### impl<T, S> EnsureInto<S> for T

### impl<T, S> EnsureInto<S> for T

§#### fn ensure_into(self) -> Result<T, ArithmeticError>

#### fn ensure_into(self) -> Result<T, ArithmeticError>

`ArithmeticError`

if fails. Read more§### impl<T> EnsureMul for Twhere
T: EnsureMulAssign,

### impl<T> EnsureMul for Twhere
T: EnsureMulAssign,

§#### fn ensure_mul(self, v: Self) -> Result<Self, ArithmeticError>

#### fn ensure_mul(self, v: Self) -> Result<Self, ArithmeticError>

§### impl<T> EnsureMulAssign for T

### impl<T> EnsureMulAssign for T

§#### fn ensure_mul_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

#### fn ensure_mul_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

§### impl<T> EnsureSub for Twhere
T: EnsureSubAssign,

### impl<T> EnsureSub for Twhere
T: EnsureSubAssign,

§#### fn ensure_sub(self, v: Self) -> Result<Self, ArithmeticError>

#### fn ensure_sub(self, v: Self) -> Result<Self, ArithmeticError>

§### impl<T> EnsureSubAssign for T

### impl<T> EnsureSubAssign for T

§#### fn ensure_sub_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

#### fn ensure_sub_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

source§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

source§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

`key`

and return `true`

if they are equal.§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

`key`

and return `true`

if they are equal.§### impl<T> FmtForward for T

### impl<T> FmtForward for T

§#### fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,

#### fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,

`self`

to use its `Binary`

implementation when `Debug`

-formatted.§#### fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,

#### fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,

`self`

to use its `Display`

implementation when
`Debug`

-formatted.§#### fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,

#### fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,

`self`

to use its `LowerExp`

implementation when
`Debug`

-formatted.§#### fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,

#### fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,

`self`

to use its `LowerHex`

implementation when
`Debug`

-formatted.§#### fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,

#### fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,

`self`

to use its `Octal`

implementation when `Debug`

-formatted.§#### fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,

#### fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,

`self`

to use its `Pointer`

implementation when
`Debug`

-formatted.§#### fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,

#### fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,

`self`

to use its `UpperExp`

implementation when
`Debug`

-formatted.§#### fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,

#### fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,

`self`

to use its `UpperHex`

implementation when
`Debug`

-formatted.§#### fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,

#### fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,

§### impl<T> HasCompact for T

### impl<T> HasCompact for T

§### impl<T> Instrument for T

### impl<T> Instrument for T

§#### fn instrument(self, span: Span) -> Instrumented<Self>

#### fn instrument(self, span: Span) -> Instrumented<Self>

§#### fn in_current_span(self) -> Instrumented<Self>

#### fn in_current_span(self) -> Instrumented<Self>

source§### impl<T> IntoEither for T

### impl<T> IntoEither for T

source§#### fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

#### fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left`

is `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read moresource§#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left(&self)`

returns `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read more§### impl<T, Outer> IsWrappedBy<Outer> for T

### impl<T, Outer> IsWrappedBy<Outer> for T

§### impl<T> KeyedVec for Twhere
T: Codec,

### impl<T> KeyedVec for Twhere
T: Codec,

source§### impl<T> LowerBounded for Twhere
T: Bounded,

### impl<T> LowerBounded for Twhere
T: Bounded,

§### impl<T> Pipe for Twhere
T: ?Sized,

### impl<T> Pipe for Twhere
T: ?Sized,

§#### fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,

#### fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,

§#### fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,

#### fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,

`self`

and passes that borrow into the pipe function. Read more§#### fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,

#### fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,

`self`

and passes that borrow into the pipe function. Read more§#### fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R

#### fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R

§#### fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R

#### fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R

§#### fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R

#### fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R

`self`

, then passes `self.as_ref()`

into the pipe function.§#### fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R

#### fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R

`self`

, then passes `self.as_mut()`

into the pipe
function.§#### fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R

#### fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R

`self`

, then passes `self.deref()`

into the pipe function.§### impl<T> Pointable for T

### impl<T> Pointable for T

§### impl<T> SaturatedConversion for T

### impl<T> SaturatedConversion for T

§#### fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,

#### fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,

§#### fn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,

#### fn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,

`T`

. Read more§### impl<T> Tap for T

### impl<T> Tap for T

§#### fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self

#### fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self

`Borrow<B>`

of a value. Read more§#### fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self

#### fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self

`BorrowMut<B>`

of a value. Read more§#### fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self

#### fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self

`AsRef<R>`

view of a value. Read more§#### fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self

#### fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self

`AsMut<R>`

view of a value. Read more§#### fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self

#### fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self

`Deref::Target`

of a value. Read more§#### fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self

#### fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self

`Deref::Target`

of a value. Read more§#### fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

#### fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

`.tap()`

only in debug builds, and is erased in release builds.§#### fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

#### fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

`.tap_mut()`

only in debug builds, and is erased in release
builds.§#### fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self

#### fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self

`.tap_borrow()`

only in debug builds, and is erased in release
builds.§#### fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self

#### fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self

`.tap_borrow_mut()`

only in debug builds, and is erased in release
builds.§#### fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self

#### fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self

`.tap_ref()`

only in debug builds, and is erased in release
builds.§#### fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self

#### fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self

`.tap_ref_mut()`

only in debug builds, and is erased in release
builds.§#### fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self

#### fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self

`.tap_deref()`

only in debug builds, and is erased in release
builds.§### impl<T> ThresholdOrd<T> for T

### impl<T> ThresholdOrd<T> for T

§### impl<T> TryConv for T

### impl<T> TryConv for T

§### impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,

### impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,

§#### fn unchecked_into(self) -> T

#### fn unchecked_into(self) -> T

`unchecked_from`

.§### impl<T, S> UniqueSaturatedFrom<T> for S

### impl<T, S> UniqueSaturatedFrom<T> for S

§#### fn unique_saturated_from(t: T) -> S

#### fn unique_saturated_from(t: T) -> S

`T`

into an equivalent instance of `Self`

.§### impl<T, S> UniqueSaturatedInto<T> for S

### impl<T, S> UniqueSaturatedInto<T> for S

§#### fn unique_saturated_into(self) -> T

#### fn unique_saturated_into(self) -> T

`T`

.