Implement Index and IndexMut traits for ArrayVec

src/arrayvec.rs

@@ -2,7 +2,7 @@
 use std::cmp;
 use std::iter;
 use std::mem;
-use std::ops::{Bound, Deref, DerefMut, RangeBounds};
+use std::ops::{Bound, Deref, DerefMut, Index, IndexMut, RangeBounds};
 use std::ptr;
 use std::slice;
 
@@ -373,7 +373,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
 
     /// Remove the element at `index` and swap the last element into its place.
     ///
-    /// This is a checked version of `.swap_remove`.  
+    /// This is a checked version of `.swap_remove`.
     /// This operation is O(1).
     ///
     /// Return `Some(` *element* `)` if the index is in bounds, else `None`.
@@ -989,11 +989,11 @@ impl<T, Data, F> Drop for ScopeExitGuard<T, Data, F>
 
 
 /// Extend the `ArrayVec` with an iterator.
-/// 
+///
 /// ***Panics*** if extending the vector exceeds its capacity.
 impl<T, const CAP: usize> Extend<T> for ArrayVec<T, CAP> {
     /// Extend the `ArrayVec` with an iterator.
-    /// 
+    ///
     /// ***Panics*** if extending the vector exceeds its capacity.
     fn extend<I: IntoIterator<Item=T>>(&mut self, iter: I) {
         unsafe {
@@ -1002,6 +1002,42 @@ impl<T, const CAP: usize> Extend<T> for ArrayVec<T, CAP> {
     }
 }
 
+/// Perform the indexing (`container[index]`) operation.
+///
+/// # Panics
+/// Panics if index is out of bounds.
+impl<I, T, const CAP: usize> Index<I> for ArrayVec<T, CAP>
+where
+    I: slice::SliceIndex<[T]>,
+{
+    type Output = <I as slice::SliceIndex<[T]>>::Output;
+
+    /// Performs the indexing (`container[index]`) operation.
+    ///
+    /// # Panics
+    /// Panics if index is out of bounds.
+    fn index(&self, index: I) -> &Self::Output {
+        self.deref().index(index)
+    }
+}
+
+/// Perform the mutable indexing (`container[index]`) operation.
+///
+/// # Panics
+/// Panics if index is out of bounds.
+impl<I, T, const CAP: usize> IndexMut<I> for ArrayVec<T, CAP>
+where
+    I: slice::SliceIndex<[T]>,
+{
+    /// Perform the mutable indexing (`container[index]`) operation.
+    ///
+    /// # Panics
+    /// Panics if index is out of bounds.
+    fn index_mut(&mut self, index: I) -> &mut Self::Output {
+        self.deref_mut().index_mut(index)
+    }
+}
+
 #[inline(never)]
 #[cold]
 fn extend_panic() {
@@ -1072,11 +1108,11 @@ unsafe fn raw_ptr_add<T>(ptr: *mut T, offset: usize) -> *mut T {
 }
 
 /// Create an `ArrayVec` from an iterator.
-/// 
+///
 /// ***Panics*** if the number of elements in the iterator exceeds the arrayvec's capacity.
 impl<T, const CAP: usize> iter::FromIterator<T> for ArrayVec<T, CAP> {
     /// Create an `ArrayVec` from an iterator.
-    /// 
+    ///
     /// ***Panics*** if the number of elements in the iterator exceeds the arrayvec's capacity.
     fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> Self {
         let mut array = ArrayVec::new();

tests/tests.rs

@@ -520,6 +520,46 @@ fn array_clone_from() {
     assert_eq!(&t, &reference[..]);
 }
 
+#[test]
+fn array_index_usize() {
+    let v = ArrayVec::from([1, 2, 3]);
+    assert_eq!(v[1], 2);
+}
+
+#[should_panic(expected="index out of bounds: the len is 3 but the index is 3")]
+#[test]
+fn array_index_usize_out_of_bounds() {
+    let v = ArrayVec::from([1, 2, 3]);
+    let _ = v[3]; // out of bounds
+}
+
+#[test]
+fn array_index_range() {
+    let v = ArrayVec::from([1, 2, 3]);
+    assert_eq!(&v[1..3], [2, 3].as_ref());
+}
+
+#[should_panic(expected="range end index 4 out of range for slice of length 3")]
+#[test]
+fn array_index_range_out_of_bounds() {
+    let v = ArrayVec::from([1, 2, 3]);
+    let _ = v[1..4]; // out of bounds
+}
+
+#[test]
+fn array_indexmut_usize() {
+    let mut v = ArrayVec::from([1, 2, 3]);
+    v[1] = 0;
+    assert_eq!(v, ArrayVec::from([1, 0, 3]));
+}
+
+#[should_panic(expected="index out of bounds: the len is 3 but the index is 3")]
+#[test]
+fn array_indexmut_usize_out_of_bounds() {
+    let mut v = ArrayVec::from([1, 2, 3]);
+    v[3] = 0; // out of bounds
+}
+
 #[cfg(feature="std")]
 #[test]
 fn test_string() {