Trait PermFromSorting 

pub trait PermFromSorting<S, T>
where
    S: AsRef<[T]>,
    Self: Sized,
{
    type Output;

    // Required methods
    fn from_sort(vec: S) -> Self::Output
       where T: Ord;
    fn from_sort_by<F>(vec: S, compare: F) -> Self::Output
       where F: FnMut(&T, &T) -> Ordering;
    fn from_sort_by_key<B, F>(vec: S, f: F) -> Self::Output
       where B: Ord,
             F: FnMut(&T) -> B;
    fn from_sort_by_cached_key<B, F>(vec: S, f: F) -> Self::Output
       where B: Ord,
             F: FnMut(&T) -> B;
}

An operator that builds a permutation type by sorting slice-like types.

Required Associated Types

type Output

Required Methods

fn from_sort(vec: S) -> Self::Output

where T: Ord,

Builds a permutation by sorting a slice-like type.

fn from_sort_by<F>(vec: S, compare: F) -> Self::Output

where F: FnMut(&T, &T) -> Ordering,

Builds a permutation by sorting a slice-like type with a comparing function.

fn from_sort_by_key<B, F>(vec: S, f: F) -> Self::Output

where B: Ord, F: FnMut(&T) -> B,

Builds a permutation by sorting a slice-like type with a key function.

fn from_sort_by_cached_key<B, F>(vec: S, f: F) -> Self::Output

where B: Ord, F: FnMut(&T) -> B,

Builds a permutation by sorting a slice-like type with a key function. The key is not re-computed twice.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T> PermFromSorting<&[T], T> for PermD

type Output = Perm<Dynamic>

impl<T> PermFromSorting<Vec<T>, T> for PermD

type Output = Perm<Dynamic>

impl<T, const SIZE: usize> PermFromSorting<&[T; SIZE], T> for PermD

type Output = Perm<Dynamic>

impl<T, const SIZE: usize> PermFromSorting<&[T; SIZE], T> for PermS<SIZE>

type Output = Perm<Static<SIZE>>

impl<T, const SIZE: usize> PermFromSorting<&[T], T> for PermS<SIZE>

type Output = Option<Perm<Static<SIZE>>>

impl<T, const SIZE: usize> PermFromSorting<[T; SIZE], T> for PermD

type Output = Perm<Dynamic>

impl<T, const SIZE: usize> PermFromSorting<[T; SIZE], T> for PermS<SIZE>

type Output = Perm<Static<SIZE>>

impl<T, const SIZE: usize> PermFromSorting<Vec<T>, T> for PermS<SIZE>

type Output = Option<Perm<Static<SIZE>>>