Struct brassfibre::prelude::Indexer

pub struct Indexer<U: Clone + Hash> {
    pub values: Vec<U>,
    // some fields omitted
}

Hash index

Fields

values: Vec<U>

Methods

impl<U> Indexer<U> where
    U: Clone + Eq + Hash + Ord, 

fn argsort(&self) -> (Vec<usize>, Self)

fn sort(&self) -> Self

impl<U> Indexer<U> where
    U: Clone + Eq + Hash, 

///////////////////////////////////////////////////////////////////////////// Constructor /////////////////////////////////////////////////////////////////////////////

fn from_len(len: usize) -> Indexer<usize>

fn new(values: Vec<U>) -> Self

impl<U> Indexer<U> where
    U: Clone + Eq + Hash, 

fn iter(&self) -> Iter<U>

Trait Implementations

impl<T: Clone + Eq + Hash> From<Vec<T>> for Indexer<T>

///////////////////////////////////////////////////////////////////////////// From / Into /////////////////////////////////////////////////////////////////////////////

fn from(values: Vec<T>) -> Self

Performs the conversion.

impl<T: Clone + Hash> Into<Vec<T>> for Indexer<T>

fn into(self) -> Vec<T>

Performs the conversion.

impl<'a, T: Clone + Hash> Into<Cow<'a, Indexer<T>>> for Indexer<T>

///////////////////////////////////////////////////////////////////////////// Clone on Write /////////////////////////////////////////////////////////////////////////////

fn into(self) -> Cow<'a, Self>

Performs the conversion.

impl<U> Display for Indexer<U> where
    U: Clone + Eq + Hash + Debug, 

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

Formats the value using the given formatter.

impl<U> Debug for Indexer<U> where
    U: Clone + Eq + Hash + Debug, 

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

Formats the value using the given formatter.

impl<U> Index<usize> for Indexer<U> where
    U: Clone + Eq + Hash, 

type Output = U

The returned type after indexing

fn index(&self, index: usize) -> &U

The method for the indexing (container[index]) operation

impl<U, O> Add<U> for Indexer<U> where
    U: Clone + Eq + Hash + Add<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the + operator

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

The method for the + operator

impl<'a, U, O> Add<&'a U> for Indexer<U> where
    U: Clone + Eq + Hash + Add<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the + operator

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

The method for the + operator

impl<'b, U, O> Add<U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Add<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the + operator

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

The method for the + operator

impl<'a, 'b, U, O> Add<&'a U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Add<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the + operator

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

The method for the + operator

impl<U, O> Add<Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + Add<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the + operator

fn add(self, _rhs: Self) -> Self::Output

The method for the + operator

impl<'a, U, O> Add<&'a Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + Add<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the + operator

fn add(self, _rhs: &Self) -> Self::Output

The method for the + operator

impl<'b, U, O> Add<Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Add<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the + operator

fn add(self, _rhs: Indexer<U>) -> Self::Output

The method for the + operator

impl<'a, 'b, U, O> Add<&'a Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Add<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the + operator

fn add(self, _rhs: &Indexer<U>) -> Self::Output

The method for the + operator

impl<U, O> Mul<U> for Indexer<U> where
    U: Clone + Eq + Hash + Mul<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the * operator

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

The method for the * operator

impl<'a, U, O> Mul<&'a U> for Indexer<U> where
    U: Clone + Eq + Hash + Mul<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the * operator

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

The method for the * operator

impl<'b, U, O> Mul<U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Mul<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the * operator

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

The method for the * operator

impl<'a, 'b, U, O> Mul<&'a U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Mul<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the * operator

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

The method for the * operator

impl<U, O> Mul<Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + Mul<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the * operator

fn mul(self, _rhs: Self) -> Self::Output

The method for the * operator

impl<'a, U, O> Mul<&'a Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + Mul<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the * operator

fn mul(self, _rhs: &Self) -> Self::Output

The method for the * operator

impl<'b, U, O> Mul<Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Mul<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the * operator

fn mul(self, _rhs: Indexer<U>) -> Self::Output

The method for the * operator

impl<'a, 'b, U, O> Mul<&'a Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Mul<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the * operator

fn mul(self, _rhs: &Indexer<U>) -> Self::Output

The method for the * operator

impl<U, O> Sub<U> for Indexer<U> where
    U: Clone + Eq + Hash + Sub<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the - operator

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

The method for the - operator

impl<'a, U, O> Sub<&'a U> for Indexer<U> where
    U: Clone + Eq + Hash + Sub<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the - operator

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

The method for the - operator

impl<'b, U, O> Sub<U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Sub<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the - operator

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

The method for the - operator

impl<'a, 'b, U, O> Sub<&'a U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Sub<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the - operator

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

The method for the - operator

impl<U, O> Sub<Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + Sub<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the - operator

fn sub(self, _rhs: Self) -> Self::Output

The method for the - operator

impl<'a, U, O> Sub<&'a Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + Sub<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the - operator

fn sub(self, _rhs: &Self) -> Self::Output

The method for the - operator

impl<'b, U, O> Sub<Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Sub<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the - operator

fn sub(self, _rhs: Indexer<U>) -> Self::Output

The method for the - operator

impl<'a, 'b, U, O> Sub<&'a Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Sub<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the - operator

fn sub(self, _rhs: &Indexer<U>) -> Self::Output

The method for the - operator

impl<U, O> Div<U> for Indexer<U> where
    U: Clone + Eq + Hash + Div<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the / operator

fn div(self, _rhs: U) -> Self::Output

The method for the / operator

impl<'a, U, O> Div<&'a U> for Indexer<U> where
    U: Clone + Eq + Hash + Div<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the / operator

fn div(self, _rhs: &U) -> Self::Output

The method for the / operator

impl<'b, U, O> Div<U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Div<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the / operator

fn div(self, _rhs: U) -> Self::Output

The method for the / operator

impl<'a, 'b, U, O> Div<&'a U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Div<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the / operator

fn div(self, _rhs: &U) -> Self::Output

The method for the / operator

impl<U, O> Div<Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + Div<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the / operator

fn div(self, _rhs: Self) -> Self::Output

The method for the / operator

impl<'a, U, O> Div<&'a Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + Div<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the / operator

fn div(self, _rhs: &Self) -> Self::Output

The method for the / operator

impl<'b, U, O> Div<Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Div<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the / operator

fn div(self, _rhs: Indexer<U>) -> Self::Output

The method for the / operator

impl<'a, 'b, U, O> Div<&'a Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Div<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the / operator

fn div(self, _rhs: &Indexer<U>) -> Self::Output

The method for the / operator

impl<U, O> Rem<U> for Indexer<U> where
    U: Clone + Eq + Hash + Rem<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the % operator

fn rem(self, _rhs: U) -> Self::Output

The method for the % operator

impl<'a, U, O> Rem<&'a U> for Indexer<U> where
    U: Clone + Eq + Hash + Rem<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the % operator

fn rem(self, _rhs: &U) -> Self::Output

The method for the % operator

impl<'b, U, O> Rem<U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Rem<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the % operator

fn rem(self, _rhs: U) -> Self::Output

The method for the % operator

impl<'a, 'b, U, O> Rem<&'a U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Rem<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the % operator

fn rem(self, _rhs: &U) -> Self::Output

The method for the % operator

impl<U, O> Rem<Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + Rem<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the % operator

fn rem(self, _rhs: Self) -> Self::Output

The method for the % operator

impl<'a, U, O> Rem<&'a Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + Rem<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the % operator

fn rem(self, _rhs: &Self) -> Self::Output

The method for the % operator

impl<'b, U, O> Rem<Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Rem<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the % operator

fn rem(self, _rhs: Indexer<U>) -> Self::Output

The method for the % operator

impl<'a, 'b, U, O> Rem<&'a Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + Rem<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the % operator

fn rem(self, _rhs: &Indexer<U>) -> Self::Output

The method for the % operator

impl<U, O> BitAnd<U> for Indexer<U> where
    U: Clone + Eq + Hash + BitAnd<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the & operator

fn bitand(self, _rhs: U) -> Self::Output

The method for the & operator

impl<'a, U, O> BitAnd<&'a U> for Indexer<U> where
    U: Clone + Eq + Hash + BitAnd<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the & operator

fn bitand(self, _rhs: &U) -> Self::Output

The method for the & operator

impl<'b, U, O> BitAnd<U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + BitAnd<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the & operator

fn bitand(self, _rhs: U) -> Self::Output

The method for the & operator

impl<'a, 'b, U, O> BitAnd<&'a U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + BitAnd<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the & operator

fn bitand(self, _rhs: &U) -> Self::Output

The method for the & operator

impl<U, O> BitAnd<Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + BitAnd<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the & operator

fn bitand(self, _rhs: Self) -> Self::Output

The method for the & operator

impl<'a, U, O> BitAnd<&'a Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + BitAnd<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the & operator

fn bitand(self, _rhs: &Self) -> Self::Output

The method for the & operator

impl<'b, U, O> BitAnd<Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + BitAnd<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the & operator

fn bitand(self, _rhs: Indexer<U>) -> Self::Output

The method for the & operator

impl<'a, 'b, U, O> BitAnd<&'a Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + BitAnd<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the & operator

fn bitand(self, _rhs: &Indexer<U>) -> Self::Output

The method for the & operator

impl<U, O> BitOr<U> for Indexer<U> where
    U: Clone + Eq + Hash + BitOr<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the | operator

fn bitor(self, _rhs: U) -> Self::Output

The method for the | operator

impl<'a, U, O> BitOr<&'a U> for Indexer<U> where
    U: Clone + Eq + Hash + BitOr<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the | operator

fn bitor(self, _rhs: &U) -> Self::Output

The method for the | operator

impl<'b, U, O> BitOr<U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + BitOr<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the | operator

fn bitor(self, _rhs: U) -> Self::Output

The method for the | operator

impl<'a, 'b, U, O> BitOr<&'a U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + BitOr<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the | operator

fn bitor(self, _rhs: &U) -> Self::Output

The method for the | operator

impl<U, O> BitOr<Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + BitOr<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the | operator

fn bitor(self, _rhs: Self) -> Self::Output

The method for the | operator

impl<'a, U, O> BitOr<&'a Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + BitOr<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the | operator

fn bitor(self, _rhs: &Self) -> Self::Output

The method for the | operator

impl<'b, U, O> BitOr<Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + BitOr<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the | operator

fn bitor(self, _rhs: Indexer<U>) -> Self::Output

The method for the | operator

impl<'a, 'b, U, O> BitOr<&'a Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + BitOr<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the | operator

fn bitor(self, _rhs: &Indexer<U>) -> Self::Output

The method for the | operator

impl<U, O> BitXor<U> for Indexer<U> where
    U: Clone + Eq + Hash + BitXor<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the ^ operator

fn bitxor(self, _rhs: U) -> Self::Output

The method for the ^ operator

impl<'a, U, O> BitXor<&'a U> for Indexer<U> where
    U: Clone + Eq + Hash + BitXor<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the ^ operator

fn bitxor(self, _rhs: &U) -> Self::Output

The method for the ^ operator

impl<'b, U, O> BitXor<U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + BitXor<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the ^ operator

fn bitxor(self, _rhs: U) -> Self::Output

The method for the ^ operator

impl<'a, 'b, U, O> BitXor<&'a U> for &'b Indexer<U> where
    U: Clone + Eq + Hash + BitXor<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the ^ operator

fn bitxor(self, _rhs: &U) -> Self::Output

The method for the ^ operator

impl<U, O> BitXor<Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + BitXor<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the ^ operator

fn bitxor(self, _rhs: Self) -> Self::Output

The method for the ^ operator

impl<'a, U, O> BitXor<&'a Indexer<U>> for Indexer<U> where
    U: Clone + Eq + Hash + BitXor<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the ^ operator

fn bitxor(self, _rhs: &Self) -> Self::Output

The method for the ^ operator

impl<'b, U, O> BitXor<Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + BitXor<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the ^ operator

fn bitxor(self, _rhs: Indexer<U>) -> Self::Output

The method for the ^ operator

impl<'a, 'b, U, O> BitXor<&'a Indexer<U>> for &'b Indexer<U> where
    U: Clone + Eq + Hash + BitXor<Output = O>,
    O: Clone + Eq + Hash, 

type Output = Indexer<O>

The resulting type after applying the ^ operator

fn bitxor(self, _rhs: &Indexer<U>) -> Self::Output

The method for the ^ operator

impl<U: Clone + Clone + Hash> Clone for Indexer<U>

fn clone(&self) -> Indexer<U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<U> Slicer for Indexer<U> where
    U: Clone + Eq + Hash, 

///////////////////////////////////////////////////////////////////////////// Indexing /////////////////////////////////////////////////////////////////////////////

type Scalar = U

fn len(&self) -> usize

Return the length of myself

fn iloc(&self, location: &usize) -> Self::Scalar

Return a single element specified with the location

unsafe fn iloc_unchecked(&self, location: &usize) -> Self::Scalar

Return a single element specified with the location

fn ilocs(&self, locations: &[usize]) -> Self

Return multiple elements specified with the locations

unsafe fn ilocs_unchecked(&self, locations: &[usize]) -> Self

Return multiple elements specified with the locations

fn ilocs_forced(&self, locations: &[usize]) -> Self

Return multiple elements specified with the locations

fn blocs(&self, flags: &[bool]) -> Self

Return multilpe elements specified with bool flags

fn reindex(&self, locations: &[usize]) -> Self

Return multiple elements specified with the locations

unsafe fn reindex_unchecked(&self, locations: &[usize]) -> Self

Return multiple elements specified with the locations

fn reindex_forced(&self, locations: &[usize]) -> Self

Return multiple elements specified with the locations

impl<U> IndexerIndex for Indexer<U> where
    U: Clone + Eq + Hash, 

type Key = U

fn contains(&self, label: &U) -> bool

Whether Indexer contains label or not

fn push(&mut self, label: U)

fn get_loc(&self, label: &U) -> usize

Return label location (usize) corresponding to given label (Scalar)

fn get_locs(&self, labels: &[U]) -> Vec<usize>

Return label locations (Vector) corresponding to given labels (Vector)

fn init_state(&self)

impl<'a, T> Append<'a> for Indexer<T> where
    T: Clone + Eq + Hash, 

///////////////////////////////////////////////////////////////////////////// Append /////////////////////////////////////////////////////////////////////////////

fn append(&self, other: &Self) -> Self

impl<U> PartialEq for Indexer<U> where
    U: Clone + Eq + Hash, 

///////////////////////////////////////////////////////////////////////////// Eq /////////////////////////////////////////////////////////////////////////////

fn eq(&self, other: &Indexer<U>) -> bool

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

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

This method tests for !=.

impl<U> IntoIterator for Indexer<U> where
    U: Clone + Eq + Hash, 

///////////////////////////////////////////////////////////////////////////// Iterator /////////////////////////////////////////////////////////////////////////////

type Item = U

The type of the elements being iterated over.

type IntoIter = IntoIter<U>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<U> FromIterator<U> for Indexer<U> where
    U: Clone + Eq + Hash, 

fn from_iter<T>(iter: T) -> Self where
    T: IntoIterator<Item = U>, 

Creates a value from an iterator.