Skip to main content

Index

Trait Index 

1.0.0 (const: unstable) · Source
pub trait Index<Idx>
where Idx: ?Sized,
{ type Output: ?Sized; // Required method fn index(&self, index: Idx) -> &Self::Output; }
Available on crate features mtls and std only.
Expand description

Used for indexing operations (container[index]) in immutable contexts.

container[index] is actually syntactic sugar for *container.index(index), but only when used as an immutable value. If a mutable value is requested, IndexMut is used instead. This allows nice things such as let value = v[index] if the type of value implements Copy.

§Examples

The following example implements Index on a read-only NucleotideCount container, enabling individual counts to be retrieved with index syntax.

use std::ops::Index;

enum Nucleotide {
    A,
    C,
    G,
    T,
}

struct NucleotideCount {
    a: usize,
    c: usize,
    g: usize,
    t: usize,
}

impl Index<Nucleotide> for NucleotideCount {
    type Output = usize;

    fn index(&self, nucleotide: Nucleotide) -> &Self::Output {
        match nucleotide {
            Nucleotide::A => &self.a,
            Nucleotide::C => &self.c,
            Nucleotide::G => &self.g,
            Nucleotide::T => &self.t,
        }
    }
}

let nucleotide_count = NucleotideCount {a: 14, c: 9, g: 10, t: 12};
assert_eq!(nucleotide_count[Nucleotide::A], 14);
assert_eq!(nucleotide_count[Nucleotide::C], 9);
assert_eq!(nucleotide_count[Nucleotide::G], 10);
assert_eq!(nucleotide_count[Nucleotide::T], 12);

Required Associated Types§

1.0.0 (const: unstable) · Source

type Output: ?Sized

The returned type after indexing.

Required Methods§

1.0.0 (const: unstable) · Source

fn index(&self, index: Idx) -> &Self::Output

Performs the indexing (container[index]) operation.

§Panics

May panic if the index is out of bounds.

Dyn Compatibility§

This trait is dyn compatible.

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

Implementors§

Source§

impl Index<ConnectionHandle> for Slab<ConnectionMeta>

Source§

type Output = ConnectionMeta

Source§

impl Index<Range<usize>> for BStr

Source§

impl Index<Range<usize>> for ByteString

Source§

impl Index<Range<usize>> for Bytes

Source§

impl Index<Range<usize>> for InlinableString

Source§

impl Index<Range<usize>> for InlineString

Source§

impl Index<Range<usize>> for UninitSlice

Source§

impl Index<RangeFrom<usize>> for BStr

Source§

impl Index<RangeFrom<usize>> for ByteString

Source§

impl Index<RangeFrom<usize>> for Bytes

1.47.0 · Source§

impl Index<RangeFrom<usize>> for CStr

1.96.0 · Source§

impl Index<RangeFrom<usize>> for CStr

Source§

impl Index<RangeFrom<usize>> for InlinableString

Source§

impl Index<RangeFrom<usize>> for InlineString

Source§

impl Index<RangeFrom<usize>> for UninitSlice

Source§

impl Index<RangeFull> for BStr

Source§

impl Index<RangeFull> for ByteString

Source§

impl Index<RangeFull> for Bytes

1.7.0 · Source§

impl Index<RangeFull> for CString

Source§

impl Index<RangeFull> for InlinableString

Source§

impl Index<RangeFull> for InlineString

1.0.0 · Source§

impl Index<RangeFull> for OsString

Source§

impl Index<RangeFull> for UninitSlice

Source§

impl Index<RangeInclusive<usize>> for BStr

Source§

impl Index<RangeInclusive<usize>> for ByteString

Source§

impl Index<RangeInclusive<usize>> for Bytes

Source§

impl Index<RangeInclusive<usize>> for UninitSlice

Source§

impl Index<RangeTo<usize>> for BStr

Source§

impl Index<RangeTo<usize>> for ByteString

Source§

impl Index<RangeTo<usize>> for Bytes

Source§

impl Index<RangeTo<usize>> for InlinableString

Source§

impl Index<RangeTo<usize>> for InlineString

Source§

impl Index<RangeTo<usize>> for UninitSlice

Source§

impl Index<RangeToInclusive<usize>> for BStr

Source§

impl Index<RangeToInclusive<usize>> for ByteString

Source§

impl Index<RangeToInclusive<usize>> for Bytes

Source§

impl Index<RangeToInclusive<usize>> for UninitSlice

Source§

impl Index<SpaceId> for [PacketSpace; 3]

Source§

type Output = PacketSpace

Source§

impl Index<usize> for BStr

Source§

impl Index<usize> for ByteString

Source§

impl Index<usize> for Bytes

Source§

impl<'a> Index<usize> for BerObject<'a>

Source§

impl<'s, T, I> Index<I> for SliceVec<'s, T>
where I: SliceIndex<[T]>,

Source§

impl<'s> Index<&'s str> for DocumentMut

Source§

impl<'s> Index<&'s str> for InlineTable

Source§

impl<'s> Index<&'s str> for Table

Source§

impl<A, I> Index<I> for ArrayVec<A>
where A: Array, I: SliceIndex<[<A as Array>::Item]>,

Source§

type Output = <I as SliceIndex<[<A as Array>::Item]>>::Output

Source§

impl<A, I> Index<I> for SmallVec<A>
where A: Array, I: SliceIndex<[<A as Array>::Item]>,

Source§

type Output = <I as SliceIndex<[<A as Array>::Item]>>::Output

Source§

impl<A, I> Index<I> for TinyVec<A>
where A: Array, I: SliceIndex<[<A as Array>::Item]>,

Source§

type Output = <I as SliceIndex<[<A as Array>::Item]>>::Output

Source§

impl<I, T, const N: usize> Index<I> for Simd<T, N>
where T: SimdElement, I: SliceIndex<[T]>,

Source§

impl<I: SliceIndex<str, Output = str>> Index<I> for Key

Source§

impl<I: SliceIndex<str, Output = str>> Index<I> for Name

Source§

impl<I> Index<I> for ByteStr
where I: SliceIndex<ByteStr>,

Source§

impl<I> Index<I> for Item
where I: Index,

§

impl<I> Index<I> for RawStr
where I: SliceIndex<str, Output = str>,

1.0.0 · Source§

impl<I> Index<I> for String
where I: SliceIndex<str>,

Source§

impl<I> Index<I> for UncasedStr
where I: SliceIndex<str, Output = str>,

Source§

impl<I> Index<I> for toml::value::Value
where I: Index,

Source§

impl<I> Index<I> for rocket::serde::json::Value
where I: Index,

1.0.0 (const: unstable) · Source§

impl<I> Index<I> for str
where I: SliceIndex<str>,

1.0.0 · Source§

impl<K, Q, V, A> Index<&Q> for BTreeMap<K, V, A>
where A: AllocatorClone, K: Borrow<Q> + Ord, Q: Ord + ?Sized,

1.0.0 · Source§

impl<K, Q, V, S, A> Index<&Q> for rocket::mtls::oid::asn1_rs::nom::lib::std::collections::HashMap<K, V, S, A>
where K: Eq + Hash + Borrow<Q>, Q: Eq + Hash + ?Sized, S: BuildHasher, A: Allocator,

Source§

impl<K, Q, V, S, A> Index<&Q> for hashbrown::map::HashMap<K, V, S, A>
where K: Eq + Hash, Q: Hash + Equivalent<K> + ?Sized, S: BuildHasher, A: Allocator,

Source§

impl<K, T> Index<K> for HeaderMap<T>
where K: AsHeaderName,

Source§

impl<K, V, Q, S> Index<&Q> for IndexMap<K, V, S>
where Q: Hash + Equivalent<K> + ?Sized, S: BuildHasher,

Access IndexMap values corresponding to a key.

§Examples

use indexmap::IndexMap;

let mut map = IndexMap::new();
for word in "Lorem ipsum dolor sit amet".split_whitespace() {
    map.insert(word.to_lowercase(), word.to_uppercase());
}
assert_eq!(map["lorem"], "LOREM");
assert_eq!(map["ipsum"], "IPSUM");
ⓘ
use indexmap::IndexMap;

let mut map = IndexMap::new();
map.insert("foo", 1);
println!("{:?}", map["bar"]); // panics!
Source§

impl<K, V, S> Index<(Bound<usize>, Bound<usize>)> for IndexMap<K, V, S>

Source§

type Output = Slice<K, V>

Source§

impl<K, V, S> Index<Range<usize>> for IndexMap<K, V, S>

Source§

type Output = Slice<K, V>

Source§

impl<K, V, S> Index<RangeFrom<usize>> for IndexMap<K, V, S>

Source§

type Output = Slice<K, V>

Source§

impl<K, V, S> Index<RangeFull> for IndexMap<K, V, S>

Source§

type Output = Slice<K, V>

Source§

impl<K, V, S> Index<RangeInclusive<usize>> for IndexMap<K, V, S>

Source§

type Output = Slice<K, V>

Source§

impl<K, V, S> Index<RangeTo<usize>> for IndexMap<K, V, S>

Source§

type Output = Slice<K, V>

Source§

impl<K, V, S> Index<RangeToInclusive<usize>> for IndexMap<K, V, S>

Source§

type Output = Slice<K, V>

Source§

impl<K, V, S> Index<usize> for IndexMap<K, V, S>

Access IndexMap values at indexed positions.

See Index<usize> for Keys to access a map’s keys instead.

§Examples

use indexmap::IndexMap;

let mut map = IndexMap::new();
for word in "Lorem ipsum dolor sit amet".split_whitespace() {
    map.insert(word.to_lowercase(), word.to_uppercase());
}
assert_eq!(map[0], "LOREM");
assert_eq!(map[1], "IPSUM");
map.reverse();
assert_eq!(map[0], "AMET");
assert_eq!(map[1], "SIT");
map.sort_keys();
assert_eq!(map[0], "AMET");
assert_eq!(map[1], "DOLOR");
ⓘ
use indexmap::IndexMap;

let mut map = IndexMap::new();
map.insert("foo", 1);
println!("{:?}", map[10]); // panics!
Source§

impl<K, V> Index<(Bound<usize>, Bound<usize>)> for indexmap::map::slice::Slice<K, V>

Source§

type Output = Slice<K, V>

Source§

impl<K, V> Index<Range<usize>> for indexmap::map::slice::Slice<K, V>

Source§

type Output = Slice<K, V>

Source§

impl<K, V> Index<RangeFrom<usize>> for indexmap::map::slice::Slice<K, V>

Source§

type Output = Slice<K, V>

Source§

impl<K, V> Index<RangeFull> for indexmap::map::slice::Slice<K, V>

Source§

type Output = Slice<K, V>

Source§

impl<K, V> Index<RangeInclusive<usize>> for indexmap::map::slice::Slice<K, V>

Source§

type Output = Slice<K, V>

Source§

impl<K, V> Index<RangeTo<usize>> for indexmap::map::slice::Slice<K, V>

Source§

type Output = Slice<K, V>

Source§

impl<K, V> Index<RangeToInclusive<usize>> for indexmap::map::slice::Slice<K, V>

Source§

type Output = Slice<K, V>

Source§

impl<K, V> Index<usize> for Keys<'_, K, V>

Access IndexMap keys at indexed positions.

While Index<usize> for IndexMap accesses a map’s values, indexing through IndexMap::keys offers an alternative to access a map’s keys instead.

Since Keys is also an iterator, consuming items from the iterator will offset the effective indices. Similarly, if Keys is obtained from Slice::keys, indices will be interpreted relative to the position of that slice.

§Examples

use indexmap::IndexMap;

let mut map = IndexMap::new();
for word in "Lorem ipsum dolor sit amet".split_whitespace() {
    map.insert(word.to_lowercase(), word.to_uppercase());
}

assert_eq!(map[0], "LOREM");
assert_eq!(map.keys()[0], "lorem");
assert_eq!(map[1], "IPSUM");
assert_eq!(map.keys()[1], "ipsum");

map.reverse();
assert_eq!(map.keys()[0], "amet");
assert_eq!(map.keys()[1], "sit");

map.sort_keys();
assert_eq!(map.keys()[0], "amet");
assert_eq!(map.keys()[1], "dolor");

// Advancing the iterator will offset the indexing
let mut keys = map.keys();
assert_eq!(keys[0], "amet");
assert_eq!(keys.next().map(|s| &**s), Some("amet"));
assert_eq!(keys[0], "dolor");
assert_eq!(keys[1], "ipsum");

// Slices may have an offset as well
let slice = &map[2..];
assert_eq!(slice[0], "IPSUM");
assert_eq!(slice.keys()[0], "ipsum");
ⓘ
use indexmap::IndexMap;

let mut map = IndexMap::new();
map.insert("foo", 1);
println!("{:?}", map.keys()[10]); // panics!
Source§

impl<K, V> Index<usize> for indexmap::map::slice::Slice<K, V>

Source§

impl<Q> Index<&Q> for toml::map::Map<String, Value>
where String: Borrow<Q>, Q: Ord + Eq + Hash + ?Sized,

Access an element of this map. Panics if the given key is not present in the map.

Source§

impl<Q> Index<&Q> for serde_json::map::Map<String, Value>
where String: Borrow<Q>, Q: Ord + Eq + Hash + ?Sized,

Access an element of this map. Panics if the given key is not present in the map.

match val {
    Value::String(s) => Some(s.as_str()),
    Value::Array(arr) => arr[0].as_str(),
    Value::Object(map) => map["type"].as_str(),
    _ => None,
}
Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Index<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Source§

type Output = T8

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Index<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Source§

type Output = T9

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Index<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Source§

type Output = T10

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Index<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Source§

type Output = T11

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Source§

type Output = T4

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Source§

type Output = T5

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Index<UInt<UInt<UInt<UTerm, B1>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Source§

type Output = T6

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Index<UInt<UInt<UInt<UTerm, B1>, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Source§

type Output = T7

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Index<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Source§

type Output = T2

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Index<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Source§

type Output = T3

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Index<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Source§

type Output = T1

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Index<UTerm> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Source§

type Output = T0

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Index<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

Source§

type Output = T8

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Index<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

Source§

type Output = T9

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Index<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

Source§

type Output = T10

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

Source§

type Output = T4

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

Source§

type Output = T5

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Index<UInt<UInt<UInt<UTerm, B1>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

Source§

type Output = T6

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Index<UInt<UInt<UInt<UTerm, B1>, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

Source§

type Output = T7

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Index<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

Source§

type Output = T2

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Index<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

Source§

type Output = T3

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Index<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

Source§

type Output = T1

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Index<UTerm> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

Source§

type Output = T0

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Index<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

Source§

type Output = T8

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Index<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

Source§

type Output = T9

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

Source§

type Output = T4

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

Source§

type Output = T5

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Index<UInt<UInt<UInt<UTerm, B1>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

Source§

type Output = T6

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Index<UInt<UInt<UInt<UTerm, B1>, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

Source§

type Output = T7

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Index<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

Source§

type Output = T2

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Index<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

Source§

type Output = T3

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Index<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

Source§

type Output = T1

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Index<UTerm> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

Source§

type Output = T0

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Index<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

Source§

type Output = T8

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

Source§

type Output = T4

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

Source§

type Output = T5

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Index<UInt<UInt<UInt<UTerm, B1>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

Source§

type Output = T6

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Index<UInt<UInt<UInt<UTerm, B1>, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

Source§

type Output = T7

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Index<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

Source§

type Output = T2

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Index<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

Source§

type Output = T3

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Index<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

Source§

type Output = T1

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Index<UTerm> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

Source§

type Output = T0

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7)

Source§

type Output = T4

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7)

Source§

type Output = T5

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7> Index<UInt<UInt<UInt<UTerm, B1>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7)

Source§

type Output = T6

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7> Index<UInt<UInt<UInt<UTerm, B1>, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7)

Source§

type Output = T7

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7> Index<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7)

Source§

type Output = T2

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7> Index<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7)

Source§

type Output = T3

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7> Index<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7)

Source§

type Output = T1

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7> Index<UTerm> for (T0, T1, T2, T3, T4, T5, T6, T7)

Source§

type Output = T0

Source§

impl<T0, T1, T2, T3, T4, T5, T6> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6)

Source§

type Output = T4

Source§

impl<T0, T1, T2, T3, T4, T5, T6> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6)

Source§

type Output = T5

Source§

impl<T0, T1, T2, T3, T4, T5, T6> Index<UInt<UInt<UInt<UTerm, B1>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6)

Source§

type Output = T6

Source§

impl<T0, T1, T2, T3, T4, T5, T6> Index<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6)

Source§

type Output = T2

Source§

impl<T0, T1, T2, T3, T4, T5, T6> Index<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6)

Source§

type Output = T3

Source§

impl<T0, T1, T2, T3, T4, T5, T6> Index<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5, T6)

Source§

type Output = T1

Source§

impl<T0, T1, T2, T3, T4, T5, T6> Index<UTerm> for (T0, T1, T2, T3, T4, T5, T6)

Source§

type Output = T0

Source§

impl<T0, T1, T2, T3, T4, T5> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5)

Source§

type Output = T4

Source§

impl<T0, T1, T2, T3, T4, T5> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5)

Source§

type Output = T5

Source§

impl<T0, T1, T2, T3, T4, T5> Index<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5)

Source§

type Output = T2

Source§

impl<T0, T1, T2, T3, T4, T5> Index<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5)

Source§

type Output = T3

Source§

impl<T0, T1, T2, T3, T4, T5> Index<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5)

Source§

type Output = T1

Source§

impl<T0, T1, T2, T3, T4, T5> Index<UTerm> for (T0, T1, T2, T3, T4, T5)

Source§

type Output = T0

Source§

impl<T0, T1, T2, T3, T4> Index<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4)

Source§

type Output = T4

Source§

impl<T0, T1, T2, T3, T4> Index<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4)

Source§

type Output = T2

Source§

impl<T0, T1, T2, T3, T4> Index<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4)

Source§

type Output = T3

Source§

impl<T0, T1, T2, T3, T4> Index<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4)

Source§

type Output = T1

Source§

impl<T0, T1, T2, T3, T4> Index<UTerm> for (T0, T1, T2, T3, T4)

Source§

type Output = T0

Source§

impl<T0, T1, T2, T3> Index<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3)

Source§

type Output = T2

Source§

impl<T0, T1, T2, T3> Index<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3)

Source§

type Output = T3

Source§

impl<T0, T1, T2, T3> Index<UInt<UTerm, B1>> for (T0, T1, T2, T3)

Source§

type Output = T1

Source§

impl<T0, T1, T2, T3> Index<UTerm> for (T0, T1, T2, T3)

Source§

type Output = T0

Source§

impl<T0, T1, T2> Index<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2)

Source§

type Output = T2

Source§

impl<T0, T1, T2> Index<UInt<UTerm, B1>> for (T0, T1, T2)

Source§

type Output = T1

Source§

impl<T0, T1, T2> Index<UTerm> for (T0, T1, T2)

Source§

type Output = T0

Source§

impl<T0, T1> Index<UInt<UTerm, B1>> for (T0, T1)

Source§

type Output = T1

Source§

impl<T0, T1> Index<UTerm> for (T0, T1)

Source§

type Output = T0

Source§

impl<T0> Index<UTerm> for (T0,)

Source§

type Output = T0

1.0.0 · Source§

impl<T, A> Index<usize> for VecDeque<T, A>
where A: Allocator,

1.0.0 (const: unstable) · Source§

impl<T, I, A> Index<I> for Vec<T, A>
where I: SliceIndex<[T]>, A: Allocator,

1.50.0 (const: unstable) · Source§

impl<T, I, const N: usize> Index<I> for [T; N]
where [T]: Index<I>,

Source§

type Output = <[T] as Index<I>>::Output

1.0.0 (const: unstable) · Source§

impl<T, I> Index<I> for [T]
where I: SliceIndex<[T]>,

Source§

impl<T, S> Index<(Bound<usize>, Bound<usize>)> for IndexSet<T, S>

Source§

impl<T, S> Index<Range<usize>> for IndexSet<T, S>

Source§

impl<T, S> Index<RangeFrom<usize>> for IndexSet<T, S>

Source§

impl<T, S> Index<RangeFull> for IndexSet<T, S>

Source§

impl<T, S> Index<RangeInclusive<usize>> for IndexSet<T, S>

Source§

impl<T, S> Index<RangeTo<usize>> for IndexSet<T, S>

Source§

impl<T, S> Index<RangeToInclusive<usize>> for IndexSet<T, S>

Source§

impl<T, S> Index<usize> for IndexSet<T, S>

Access IndexSet values at indexed positions.

§Examples

use indexmap::IndexSet;

let mut set = IndexSet::new();
for word in "Lorem ipsum dolor sit amet".split_whitespace() {
    set.insert(word.to_string());
}
assert_eq!(set[0], "Lorem");
assert_eq!(set[1], "ipsum");
set.reverse();
assert_eq!(set[0], "amet");
assert_eq!(set[1], "sit");
set.sort();
assert_eq!(set[0], "Lorem");
assert_eq!(set[1], "amet");
ⓘ
use indexmap::IndexSet;

let mut set = IndexSet::new();
set.insert("foo");
println!("{:?}", set[10]); // panics!
Source§

impl<T> Index<(Bound<usize>, Bound<usize>)> for indexmap::set::slice::Slice<T>

Source§

impl<T> Index<Range<usize>> for indexmap::set::slice::Slice<T>

Source§

impl<T> Index<RangeFrom<usize>> for indexmap::set::slice::Slice<T>

Source§

impl<T> Index<RangeFull> for indexmap::set::slice::Slice<T>

Source§

impl<T> Index<RangeInclusive<usize>> for indexmap::set::slice::Slice<T>

Source§

impl<T> Index<RangeTo<usize>> for indexmap::set::slice::Slice<T>

Source§

impl<T> Index<RangeToInclusive<usize>> for indexmap::set::slice::Slice<T>

Source§

impl<T> Index<usize> for Slab<T>

Source§

impl<T> Index<usize> for indexmap::set::slice::Slice<T>