Struct signal_processing :: Rpk Copy item path

impl<T, R, P, RP, K> Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>,

pub fn new(rp: RP, k: K) -> Self

pub type Owned = Rpk<T, R, P, <RP as MaybeContainer<(R, P)>>::Owned, <K as MaybeContainer<T>>::Owned> where RP::Owned: MaybeList<(R, P)>, K::Owned: MaybeList<T>

pub type View<'a> = Rpk<T, R, P, <RP as MaybeContainer<(R, P)>>::View<'a>, <K as MaybeContainer<T>>::View<'a>> where Self: 'a, RP::View<'a>: MaybeList<(R, P)>, K::View<'a>: MaybeList<T>

pub fn as_view<'a>(&'a self) -> Rpk<T, R, P, RP::View<'a>, K::View<'a>>
where Self: 'a, RP::View<'a>: MaybeList<(R, P)>, K::View<'a>: MaybeList<T>,

pub fn to_owned(&self) -> Rpk<T, R, P, RP::Owned, K::Owned>
where RP::Owned: MaybeList<(R, P)>, K::Owned: MaybeList<T>,

pub fn into_owned(self) -> Rpk<T, R, P, RP::Owned, K::Owned>
where RP::Owned: MaybeList<(R, P)>, K::Owned: MaybeList<T>,

Trait Implementations§

impl<'a, 'b, T1, R1, P1, RP1, K1, T2, R2, P2, RP2, K2, O> Add<&'b Rpk<T2, R2, P2, RP2, K2>> for &'a Rpk<T1, R1, P1, RP1, K1>
where T1: ComplexFloat, T2: ComplexFloat, R1: ComplexFloat<Real = T1::Real>, R2: ComplexFloat<Real = T2::Real>, P1: ComplexFloat<Real = T1::Real>, P2: ComplexFloat<Real = T2::Real>, RP1: MaybeList<(R1, P1)>, RP2: MaybeList<(R2, P2)>, K1: MaybeList<T1>, K2: MaybeList<T2>, RP1::View<'a>: MaybeList<(R1, P1)>, K1::View<'a>: MaybeList<T1>, RP2::View<'b>: MaybeList<(R2, P2)>, K2::View<'b>: MaybeList<T2>, Rpk<T1, R1, P1, RP1::View<'a>, K1::View<'a>>: Add<Rpk<T2, R2, P2, RP2::View<'b>, K2::View<'b>>, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: &'b Rpk<T2, R2, P2, RP2, K2>) -> Self::Output

Performs the + operation. Read more

impl<'b, T1, R1, P1, RP1, K1, T2, R2, P2, RP2, K2, O> Add<&'b Rpk<T2, R2, P2, RP2, K2>> for Rpk<T1, R1, P1, RP1, K1>
where T1: ComplexFloat, T2: ComplexFloat, R1: ComplexFloat<Real = T1::Real>, R2: ComplexFloat<Real = T2::Real>, P1: ComplexFloat<Real = T1::Real>, P2: ComplexFloat<Real = T2::Real>, RP1: MaybeList<(R1, P1)>, RP2: MaybeList<(R2, P2)>, K1: MaybeList<T1>, K2: MaybeList<T2>, RP2::View<'b>: MaybeList<(R2, P2)>, K2::View<'b>: MaybeList<T2>, Rpk<T1, R1, P1, RP1, K1>: Add<Rpk<T2, R2, P2, RP2::View<'b>, K2::View<'b>>, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: &'b Rpk<T2, R2, P2, RP2, K2>) -> Self::Output

Performs the + operation. Read more

impl<'a, 'b, T, R, P, RP, K, O> Add<&'b T> for &'a Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>, RP::View<'a>: MaybeList<(R, P)>, K::View<'a>: MaybeList<T>, Rpk<T, R, P, RP::View<'a>, K::View<'a>>: Add<Rpk<T, R, P, (), &'b [T; 1]>, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: &'b T) -> Self::Output

Performs the + operation. Read more

impl<'b, T, R, P, RP, K, O> Add<&'b T> for Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>, Rpk<T, R, P, RP, K>: Add<Rpk<T, R, P, (), &'b [T; 1]>, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: &'b T) -> Self::Output

Performs the + operation. Read more

impl<'a, T1, R1, P1, RP1, K1, T2, R2, P2, RP2, K2, O> Add<Rpk<T2, R2, P2, RP2, K2>> for &'a Rpk<T1, R1, P1, RP1, K1>
where T1: ComplexFloat, T2: ComplexFloat, R1: ComplexFloat<Real = T1::Real>, R2: ComplexFloat<Real = T2::Real>, P1: ComplexFloat<Real = T1::Real>, P2: ComplexFloat<Real = T2::Real>, RP1: MaybeList<(R1, P1)>, RP2: MaybeList<(R2, P2)>, K1: MaybeList<T1>, K2: MaybeList<T2>, RP1::View<'a>: MaybeList<(R1, P1)>, K1::View<'a>: MaybeList<T1>, Rpk<T1, R1, P1, RP1::View<'a>, K1::View<'a>>: Add<Rpk<T2, R2, P2, RP2, K2>, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: Rpk<T2, R2, P2, RP2, K2>) -> Self::Output

Performs the + operation. Read more

impl<T1, T2, T3, R1, R2, R3, P1, P2, P3, RP1, RP2, K1, K2, K3> Add<Rpk<T2, R2, P2, RP2, K2>> for Rpk<T1, R1, P1, RP1, K1>
where T1: ComplexOp<T2, Output = T3>, T2: ComplexFloat + Into<T3>, T3: ComplexFloat<Real: TotalOrder>, R1: ComplexFloat<Real = T1::Real> + ComplexOp<R2, Output = R3>, R2: ComplexFloat<Real = T2::Real> + Into<R3>, R3: ComplexFloat<Real = T3::Real> + AddAssign, P1: ComplexFloat<Real = T1::Real> + ComplexOp<P2, Output = P3>, P2: ComplexFloat<Real = T2::Real> + Into<P3>, P3: ComplexFloat<Real = T3::Real>, RP1: MaybeList<(R1, P1)>, RP2: MaybeList<(R2, P2)>, RP1::MaybeMapped<(R3, P3)>: MaybeList<(R3, P3)>, RP2::MaybeMapped<(R3, P3)>: MaybeList<(R3, P3)>, K1: MaybeList<T1>, K2: MaybeList<T2>, K3: MaybeList<T3>, K1::MaybeMapped<T3>: MaybeList<T3>, K2::MaybeMapped<T3>: MaybeList<T3>, SumSequence<(R3, P3), RP1::MaybeMapped<(R3, P3)>>: Into<SumSequence<(R3, P3), Vec<(R3, P3)>>>, SumSequence<(R3, P3), RP2::MaybeMapped<(R3, P3)>>: Into<SumSequence<(R3, P3), Vec<(R3, P3)>>>, Polynomial<T3, K1::MaybeMapped<T3>>: Add<Polynomial<T3, K2::MaybeMapped<T3>>, Output = Polynomial<T3, K3>>,

type Output = Rpk<T3, R3, P3, Vec<(R3, P3)>, K3>

The resulting type after applying the + operator.

fn add(self, rhs: Rpk<T2, R2, P2, RP2, K2>) -> Self::Output

Performs the + operation. Read more

impl<'a, T, R, P, RP, K, O> Add<T> for &'a Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>, RP::View<'a>: MaybeList<(R, P)>, K::View<'a>: MaybeList<T>, Rpk<T, R, P, RP::View<'a>, K::View<'a>>: Add<Rpk<T, R, P, (), [T; 1]>, Output = O>,

type Output = O

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl<T, R, P, RP, K, O> Add<T> for Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>, Rpk<T, R, P, RP, K>: Add<Rpk<T, R, P, (), [T; 1]>, Output = O>,

type Output = O

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl<T, R, P, RP, K> Clone for Rpk<T, R, P, RP, K>
where T: ComplexFloat + Clone, R: ComplexFloat<Real = T::Real> + Clone, P: ComplexFloat<Real = T::Real> + Clone, RP: MaybeList<(R, P)> + Clone, K: MaybeList<T> + Clone,

fn clone(&self) -> Rpk<T, R, P, RP, K>

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl<T, R, P, RP, K> Debug for Rpk<T, R, P, RP, K>
where T: ComplexFloat + Debug, R: ComplexFloat<Real = T::Real> + Debug, P: ComplexFloat<Real = T::Real> + Debug, RP: MaybeList<(R, P)> + Debug, K: MaybeList<T> + Debug,

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

Formats the value using the given formatter. Read more

impl<'a, T, R, P, RP, K, O> Neg for &'a Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>, RP::View<'a>: MaybeList<(R, P)>, K::View<'a>: MaybeList<T>, Rpk<T, R, P, RP::View<'a>, K::View<'a>>: Neg<Output = O>,

type Output = O

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation. Read more

impl<T, T2, R, P, RP, K, K2> Neg for Rpk<T, R, P, RP, K>
where T: ComplexFloat, T2: ComplexFloat<Real = T::Real>, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, RP::MaybeMapped<(R, P)>: MaybeList<(R, P)>, K: MaybeList<T>, K2: MaybeList<T2>, Polynomial<T, K>: Neg<Output = Polynomial<T2, K2>>,

type Output = Rpk<T2, R, P, <RP as MaybeContainer<(R, P)>>::MaybeMapped<(R, P)>, K2>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation. Read more

impl<T, R, P, RP, K> Residue for Rpk<T, R, P, RP, K>
where T: ComplexFloat<Real: Into<T> + TotalOrder> + Into<Complex<T::Real>> + 'static, R: ComplexFloat<Real = T::Real> + Into<Complex<T::Real>>, P: ComplexFloat<Real = T::Real> + Into<Complex<T::Real>>, RP: MaybeList<(R, P)>, K: MaybeList<T, MaybeMapped<Complex<T::Real>>: MaybeList<Complex<T::Real>>>, Polynomial<Complex<T::Real>, <K as MaybeContainer<T>>::MaybeMapped<Complex<T::Real>>>: Mul<Polynomial<Complex<T::Real>, Vec<Complex<T::Real>>>, Output = Polynomial<Complex<T::Real>, Vec<Complex<T::Real>>>>, Complex<T::Real>: AddAssign, Tf<T, Vec<T>, Vec<T>>: Normalize + System<Domain = T>,

type Output = <Tf<T, Vec<T>, Vec<T>> as Normalize>::Output

fn residue<TOL>(self, tol: TOL) -> Self::Output
where TOL: Maybe<T::Real>,

impl<T, R, P, RP, K, B, A> ResidueZ for Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real> + Mul<P, Output = R>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>, RP::Owned: MaybeOwnedList<(R, P)>, K::Owned: MaybeOwnedList<T>, Rpk<T, R, P, RP::Owned, K::Owned>: Residue<Output = Tf<T, B, A>> + System<Domain = T>, B: MaybeOwnedList<T>, A: MaybeOwnedList<T>, Tf<T, B, A>: Normalize + System<Domain = T>,

type Output = <Tf<T, B, A> as Normalize>::Output

fn residuez<TOL>(self, tol: TOL) -> Self::Output
where TOL: Maybe<<Self::Domain as ComplexFloat>::Real>,

impl<T, R, P, RP, K> RtfOrSystem for Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>,

type Domain = T

impl<'a, 'b, T1, R1, P1, RP1, K1, T2, R2, P2, RP2, K2, O> Sub<&'b Rpk<T2, R2, P2, RP2, K2>> for &'a Rpk<T1, R1, P1, RP1, K1>
where T1: ComplexFloat, T2: ComplexFloat, R1: ComplexFloat<Real = T1::Real>, R2: ComplexFloat<Real = T2::Real>, P1: ComplexFloat<Real = T1::Real>, P2: ComplexFloat<Real = T2::Real>, RP1: MaybeList<(R1, P1)>, RP2: MaybeList<(R2, P2)>, K1: MaybeList<T1>, K2: MaybeList<T2>, RP1::View<'a>: MaybeList<(R1, P1)>, K1::View<'a>: MaybeList<T1>, RP2::View<'b>: MaybeList<(R2, P2)>, K2::View<'b>: MaybeList<T2>, Rpk<T1, R1, P1, RP1::View<'a>, K1::View<'a>>: Sub<Rpk<T2, R2, P2, RP2::View<'b>, K2::View<'b>>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rpk<T2, R2, P2, RP2, K2>) -> Self::Output

Performs the - operation. Read more

impl<'b, T1, R1, P1, RP1, K1, T2, R2, P2, RP2, K2, O> Sub<&'b Rpk<T2, R2, P2, RP2, K2>> for Rpk<T1, R1, P1, RP1, K1>
where T1: ComplexFloat, T2: ComplexFloat, R1: ComplexFloat<Real = T1::Real>, R2: ComplexFloat<Real = T2::Real>, P1: ComplexFloat<Real = T1::Real>, P2: ComplexFloat<Real = T2::Real>, RP1: MaybeList<(R1, P1)>, RP2: MaybeList<(R2, P2)>, K1: MaybeList<T1>, K2: MaybeList<T2>, RP2::View<'b>: MaybeList<(R2, P2)>, K2::View<'b>: MaybeList<T2>, Rpk<T1, R1, P1, RP1, K1>: Sub<Rpk<T2, R2, P2, RP2::View<'b>, K2::View<'b>>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rpk<T2, R2, P2, RP2, K2>) -> Self::Output

Performs the - operation. Read more

impl<'a, 'b, T, R, P, RP, K, O> Sub<&'b T> for &'a Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>, RP::View<'a>: MaybeList<(R, P)>, K::View<'a>: MaybeList<T>, Rpk<T, R, P, RP::View<'a>, K::View<'a>>: Sub<Rpk<T, R, P, (), &'b [T; 1]>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: &'b T) -> Self::Output

Performs the - operation. Read more

impl<'b, T, R, P, RP, K, O> Sub<&'b T> for Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>, Rpk<T, R, P, RP, K>: Sub<Rpk<T, R, P, (), &'b [T; 1]>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: &'b T) -> Self::Output

Performs the - operation. Read more

impl<'a, T1, R1, P1, RP1, K1, T2, R2, P2, RP2, K2, O> Sub<Rpk<T2, R2, P2, RP2, K2>> for &'a Rpk<T1, R1, P1, RP1, K1>
where T1: ComplexFloat, T2: ComplexFloat, R1: ComplexFloat<Real = T1::Real>, R2: ComplexFloat<Real = T2::Real>, P1: ComplexFloat<Real = T1::Real>, P2: ComplexFloat<Real = T2::Real>, RP1: MaybeList<(R1, P1)>, RP2: MaybeList<(R2, P2)>, K1: MaybeList<T1>, K2: MaybeList<T2>, RP1::View<'a>: MaybeList<(R1, P1)>, K1::View<'a>: MaybeList<T1>, Rpk<T1, R1, P1, RP1::View<'a>, K1::View<'a>>: Sub<Rpk<T2, R2, P2, RP2, K2>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: Rpk<T2, R2, P2, RP2, K2>) -> Self::Output

Performs the - operation. Read more

impl<T1, T2, R1, R2, P1, P2, RP1, RP2, K1, K2> Sub<Rpk<T2, R2, P2, RP2, K2>> for Rpk<T1, R1, P1, RP1, K1>
where T1: ComplexFloat, T2: ComplexFloat, R1: ComplexFloat<Real = T1::Real>, R2: ComplexFloat<Real = T2::Real>, P1: ComplexFloat<Real = T1::Real>, P2: ComplexFloat<Real = T2::Real>, RP1: MaybeList<(R1, P1)>, RP2: MaybeList<(R2, P2)>, K1: MaybeList<T1>, K2: MaybeList<T2>, Rpk<T2, R2, P2, RP2, K2>: Neg, Self: Add<<Rpk<T2, R2, P2, RP2, K2> as Neg>::Output>,

type Output = <Rpk<T1, R1, P1, RP1, K1> as Add<<Rpk<T2, R2, P2, RP2, K2> as Neg>::Output>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Rpk<T2, R2, P2, RP2, K2>) -> Self::Output

Performs the - operation. Read more

impl<'a, T, R, P, RP, K, O> Sub<T> for &'a Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>, RP::View<'a>: MaybeList<(R, P)>, K::View<'a>: MaybeList<T>, Rpk<T, R, P, RP::View<'a>, K::View<'a>>: Sub<Rpk<T, R, P, (), [T; 1]>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation. Read more

impl<T, R, P, RP, K, O> Sub<T> for Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>, Rpk<T, R, P, RP, K>: Sub<Rpk<T, R, P, (), [T; 1]>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation. Read more

impl<T, R, P, RP, K> Copy for Rpk<T, R, P, RP, K>
where T: ComplexFloat + Copy, R: ComplexFloat<Real = T::Real> + Copy, P: ComplexFloat<Real = T::Real> + Copy, RP: MaybeList<(R, P)> + Copy, K: MaybeList<T> + Copy,

impl<T, R, P, RP, K> System for Rpk<T, R, P, RP, K>
where T: ComplexFloat, R: ComplexFloat<Real = T::Real>, P: ComplexFloat<Real = T::Real>, RP: MaybeList<(R, P)>, K: MaybeList<T>,

Auto Trait Implementations§

impl<T, R, P, RP, K> Freeze for Rpk<T, R, P, RP, K>
where RP: Freeze, K: Freeze,

impl<T, R, P, RP, K> !NotPolynomial for Rpk<T, R, P, RP, K>

impl<T, R, P, RP, K> NotRange for Rpk<T, R, P, RP, K>
where RP: NotRange, K: NotRange, T: NotRange, R: NotRange, P: NotRange,

impl<T, R, P, RP, K> NotVoid for Rpk<T, R, P, RP, K>

impl<T, R, P, RP, K> RefUnwindSafe for Rpk<T, R, P, RP, K>
where RP: RefUnwindSafe, K: RefUnwindSafe, T: RefUnwindSafe, R: RefUnwindSafe, P: RefUnwindSafe,

impl<T, R, P, RP, K> Send for Rpk<T, R, P, RP, K>
where RP: Send, K: Send, T: Send, R: Send, P: Send,

impl<T, R, P, RP, K> Sync for Rpk<T, R, P, RP, K>
where RP: Sync, K: Sync, T: Sync, R: Sync, P: Sync,

impl<T, R, P, RP, K> Unpin for Rpk<T, R, P, RP, K>
where RP: Unpin, K: Unpin, T: Unpin, R: Unpin, P: Unpin,

impl<T, R, P, RP, K> UnwindSafe for Rpk<T, R, P, RP, K>
where RP: UnwindSafe, K: UnwindSafe, T: UnwindSafe, R: UnwindSafe, P: UnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

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

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

type Output = T

Should always be Self

impl<Some> StaticMaybe<Some> for Some
where Some: NotVoid + ?Sized,

const IS_SOME: bool = true

const IS_NONE: bool = false

type None = ()

type Some = Some

type Opposite = ()

type Maybe<M: StaticMaybe<M> + ?Sized> = <M as StaticMaybe<M>>::Some

type MaybeOr<M: ?Sized, O: ?Sized> = M

fn maybe_from_fn<F>(func: F) -> Some
where F: FnOnce() -> Some,

fn maybe_or_from_fn<M, O>( maybe: M, _or: O ) -> <Some as StaticMaybe<Some>>::MaybeOr<<M as FnOnce()>::Output, <O as FnOnce()>::Output>
where M: FnOnce(), O: FnOnce(),

fn maybe_map<F>( self, map: F ) -> <Some as StaticMaybe<Some>>::Maybe<<F as FnOnce(Some)>::Output>
where F: FnOnce(Some), <F as FnOnce(Some)>::Output: StaticMaybe<<F as FnOnce(Some)>::Output>, <Some as StaticMaybe<Some>>::Maybe<<F as FnOnce(Some)>::Output>: Sized,

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V