pub trait Index<Idx>where
Idx: ?Sized,{
type Output: ?Sized;
// Required method
fn index(&self, index: Idx) -> &Self::Output;
}
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§
Required Methods§
Implementors§
§impl<'h> Index<usize> for Captures<'h>
impl<'h> Index<usize> for Captures<'h>
Get a matching capture group’s haystack substring by index.
The haystack substring returned can’t outlive the Captures
object if this
method is used, because of how Index
is defined (normally a[i]
is part
of a
and can’t outlive it). To work around this limitation, do that, use
[Captures::get
] instead.
'h
is the lifetime of the matched haystack, but the lifetime of the
&str
returned by this implementation is the lifetime of the Captures
value itself.
§Panics
If there is no matching group at the given index.
§impl<'h> Index<usize> for Captures<'h>
impl<'h> Index<usize> for Captures<'h>
Get a matching capture group’s haystack substring by index.
The haystack substring returned can’t outlive the Captures
object if this
method is used, because of how Index
is defined (normally a[i]
is part
of a
and can’t outlive it). To work around this limitation, do that, use
[Captures::get
] instead.
'h
is the lifetime of the matched haystack, but the lifetime of the
&str
returned by this implementation is the lifetime of the Captures
value itself.
§Panics
If there is no matching group at the given index.
§impl<'h, 'n> Index<&'n str> for Captures<'h>
impl<'h, 'n> Index<&'n str> for Captures<'h>
Get a matching capture group’s haystack substring by name.
The haystack substring returned can’t outlive the Captures
object if this
method is used, because of how Index
is defined (normally a[i]
is part
of a
and can’t outlive it). To work around this limitation, do that, use
[Captures::get
] instead.
'h
is the lifetime of the matched haystack, but the lifetime of the
&str
returned by this implementation is the lifetime of the Captures
value itself.
'n
is the lifetime of the group name used to index the Captures
value.
§Panics
If there is no matching group at the given name.
§impl<'h, 'n> Index<&'n str> for Captures<'h>
impl<'h, 'n> Index<&'n str> for Captures<'h>
Get a matching capture group’s haystack substring by name.
The haystack substring returned can’t outlive the Captures
object if this
method is used, because of how Index
is defined (normally a[i]
is part
of a
and can’t outlive it). To work around this limitation, do that, use
[Captures::get
] instead.
'h
is the lifetime of the matched haystack, but the lifetime of the
&str
returned by this implementation is the lifetime of the Captures
value itself.
'n
is the lifetime of the group name used to index the Captures
value.
§Panics
If there is no matching group at the given name.
source§impl<I> Index<I> for strwhere
I: SliceIndex<str>,
impl<I> Index<I> for strwhere
I: SliceIndex<str>,
type Output = <I as SliceIndex<str>>::Output
§impl<I> Index<I> for p1_affineswhere
I: SliceIndex<[blst_p1_affine]>,
impl<I> Index<I> for p1_affineswhere
I: SliceIndex<[blst_p1_affine]>,
type Output = <I as SliceIndex<[blst_p1_affine]>>::Output
§impl<I> Index<I> for p2_affineswhere
I: SliceIndex<[blst_p2_affine]>,
impl<I> Index<I> for p2_affineswhere
I: SliceIndex<[blst_p2_affine]>,
type Output = <I as SliceIndex<[blst_p2_affine]>>::Output
source§impl<I, T, const N: usize> Index<I> for Simd<T, N>
impl<I, T, const N: usize> Index<I> for Simd<T, N>
type Output = <I as SliceIndex<[T]>>::Output
source§impl<K, Q, V, S> Index<&Q> for scrypto::prelude::radix_engine_common::prelude::hash_map::ext_HashMap<K, V, S>
impl<K, Q, V, S> Index<&Q> for scrypto::prelude::radix_engine_common::prelude::hash_map::ext_HashMap<K, V, S>
source§impl<K, V> Index<(Bound<usize>, Bound<usize>)> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
impl<K, V> Index<(Bound<usize>, Bound<usize>)> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
source§impl<K, V> Index<usize> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
impl<K, V> Index<usize> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
source§impl<K, V> Index<Range<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
impl<K, V> Index<Range<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
source§impl<K, V> Index<RangeFrom<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
impl<K, V> Index<RangeFrom<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
source§impl<K, V> Index<RangeFull> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
impl<K, V> Index<RangeFull> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
source§impl<K, V> Index<RangeInclusive<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
impl<K, V> Index<RangeInclusive<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
source§impl<K, V> Index<RangeTo<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
impl<K, V> Index<RangeTo<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
source§impl<K, V> Index<RangeToInclusive<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
impl<K, V> Index<RangeToInclusive<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::map::Slice<K, V>
source§impl<K, V, Q, S> Index<&Q> for IndexMap<K, V, S>
impl<K, V, Q, S> Index<&Q> for IndexMap<K, V, S>
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<usize> for IndexMap<K, V, S>
impl<K, V, S> Index<usize> for IndexMap<K, V, S>
Access IndexMap
values at indexed positions.
§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<T> Index<(Bound<usize>, Bound<usize>)> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
impl<T> Index<(Bound<usize>, Bound<usize>)> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
source§impl<T> Index<usize> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
impl<T> Index<usize> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
source§impl<T> Index<Range<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
impl<T> Index<Range<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
source§impl<T> Index<RangeFrom<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
impl<T> Index<RangeFrom<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
source§impl<T> Index<RangeFull> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
impl<T> Index<RangeFull> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
source§impl<T> Index<RangeInclusive<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
impl<T> Index<RangeInclusive<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
source§impl<T> Index<RangeTo<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
impl<T> Index<RangeTo<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
source§impl<T> Index<RangeToInclusive<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
impl<T> Index<RangeToInclusive<usize>> for scrypto::prelude::radix_engine_common::prelude::indexmap::set::Slice<T>
source§impl<T, I> Index<I> for [T]where
I: SliceIndex<[T]>,
impl<T, I> Index<I> for [T]where
I: SliceIndex<[T]>,
type Output = <I as SliceIndex<[T]>>::Output
source§impl<T, S> Index<usize> for IndexSet<T, S>
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!