diff --git a/README.md b/README.md
index 5b987aa..c49ca46 100644
--- a/README.md
+++ b/README.md
@@ -47,9 +47,9 @@ to look up a value. A region for slices has storage to remember slices of indexe
 where the index can be used to look up the datum's representation in an inner
 region.
 
-`flatcontainer` provides [`FlatStack`], an exemplary implementation of how to
+`flatcontainer` provides the [`FlatStack`] type, an exemplary implementation of how to
 implement a collection of items that supports pushing additional elements,
-and retrieval by offset of previously pushed elements. It can be used in many
+and retrieval by an index to previously pushed elements. It can be used in many
 places that simply want to use a flat data representation, but it leaves potential
 for optimization behind. Specifically, indexes, although opaque, follow a
 simple structure where a more efficient storage can save memory instead of blindly
@@ -101,10 +101,10 @@ we know more about the data, and can use a better approach to storing indexes.
   e.g., 0, 2, 4, 8, ..., which we can represent using constant memory by remembering the
   stride and length. We can extend this to storing a tail of elements equals to the last
   stride by adding another count. Such an index container uses 0 bits in the limit!
-* Consult the [offsets] module for types specialized to storing indexes using less bits.
+* Consult the [index] module for types specialized to storing indexes using less bits.
 
 Flatcontainer provides some implementations of these concepts. To merge adjacent start-end
-pairs, wrap a region in a [`ConsecutiveOffsetPairs`] region. It stores indexes and presents
+pairs, wrap a region in a [`ConsecutiveIndexPairs`] region. It stores indexes and presents
 outwards as a dense sequence of 0, 1, 2, ...
 
 A [`CollapseSequence`] region remembers the index of the last element, and if a new element
@@ -112,8 +112,8 @@ equals the last, it'll return the previous index again instead of storing the sa
 multiple times. This is limited to the direct predecessor, because otherwise storing
 indexes and scanning through previous elements would be too expensive.
 
-[offsets]: impls::offsets
-[`ConsecutiveOffsetPairs`]: impls::deduplicate::ConsecutiveOffsetPairs
+[index]: impls::index
+[`ConsecutiveIndexPairs`]: impls::deduplicate::ConsecutiveIndexPairs
 [`CollapseSequence`]: impls::deduplicate::CollapseSequence
 
 ## Comparison to columnation
diff --git a/benches/bench.rs b/benches/bench.rs
index 9903bab..da6c9b1 100644
--- a/benches/bench.rs
+++ b/benches/bench.rs
@@ -4,8 +4,8 @@
 
 extern crate test;
 
-use flatcontainer::impls::deduplicate::{CollapseSequence, ConsecutiveOffsetPairs};
-use flatcontainer::impls::offsets::OffsetOptimized;
+use flatcontainer::impls::deduplicate::{CollapseSequence, ConsecutiveIndexPairs};
+use flatcontainer::impls::index::IndexOptimized;
 use flatcontainer::impls::tuple::{TupleABCRegion, TupleABRegion};
 use flatcontainer::{
     ColumnsRegion, FlatStack, MirrorRegion, OwnedRegion, Push, Region, RegionPreference,
@@ -87,7 +87,7 @@ fn string10_copy_region(bencher: &mut Bencher) {
 #[bench]
 fn string10_copy_region_collapse(bencher: &mut Bencher) {
     _bench_copy_region::<
-        SliceRegion<CollapseSequence<ConsecutiveOffsetPairs<StringRegion>>, OffsetOptimized>,
+        SliceRegion<CollapseSequence<ConsecutiveIndexPairs<StringRegion>>, IndexOptimized>,
         _,
     >(bencher, vec![format!("grawwwwrr!"); 1024]);
 }
diff --git a/src/impls.rs b/src/impls.rs
index 519873c..3dbf004 100644
--- a/src/impls.rs
+++ b/src/impls.rs
@@ -4,8 +4,8 @@ pub mod codec;
 pub mod columns;
 pub mod deduplicate;
 pub mod huffman_container;
+pub mod index;
 pub mod mirror;
-pub mod offsets;
 pub mod option;
 pub mod result;
 pub mod slice;
diff --git a/src/impls/columns.rs b/src/impls/columns.rs
index 43366c7..5ccb772 100644
--- a/src/impls/columns.rs
+++ b/src/impls/columns.rs
@@ -7,8 +7,8 @@ use std::slice::Iter;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use crate::impls::deduplicate::ConsecutiveOffsetPairs;
-use crate::impls::offsets::{OffsetContainer, OffsetOptimized};
+use crate::impls::deduplicate::ConsecutiveIndexPairs;
+use crate::impls::index::{IndexContainer, IndexOptimized};
 use crate::{IntoOwned, PushIter};
 use crate::{OwnedRegion, Push, Region};
 
@@ -25,7 +25,7 @@ use crate::{OwnedRegion, Push, Region};
 ///
 /// Copy a table-like structure:
 /// ```
-/// # use flatcontainer::impls::deduplicate::ConsecutiveOffsetPairs;
+/// # use flatcontainer::impls::deduplicate::ConsecutiveIndexPairs;
 /// # use flatcontainer::{ColumnsRegion, Push, Region, StringRegion};
 /// let data = [
 ///     vec![],
@@ -37,7 +37,7 @@ use crate::{OwnedRegion, Push, Region};
 ///     vec![],
 /// ];
 ///
-/// let mut r = <ColumnsRegion<ConsecutiveOffsetPairs<StringRegion>>>::default();
+/// let mut r = <ColumnsRegion<ConsecutiveIndexPairs<StringRegion>>>::default();
 ///
 /// let mut indices = Vec::with_capacity(data.len());
 ///
@@ -60,13 +60,13 @@ use crate::{OwnedRegion, Push, Region};
             O: Serialize + for<'a> Deserialize<'a>,
             ")
 )]
-pub struct ColumnsRegion<R, O = OffsetOptimized>
+pub struct ColumnsRegion<R, O = IndexOptimized>
 where
     R: Region,
 {
     /// Indices to address rows in `inner`. For each row, we remember
     /// an index for each column.
-    indices: ConsecutiveOffsetPairs<OwnedRegion<R::Index>, O>,
+    indices: ConsecutiveIndexPairs<OwnedRegion<R::Index>, O>,
     /// Storage for columns.
     inner: Vec<R>,
 }
@@ -92,11 +92,11 @@ where
 impl<R, O> Region for ColumnsRegion<R, O>
 where
     R: Region,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
 {
     type Owned = Vec<R::Owned>;
     type ReadItem<'a> = ReadColumns<'a, R> where Self: 'a;
-    type Index = <ConsecutiveOffsetPairs<OwnedRegion<R::Index>, OffsetOptimized> as Region>::Index;
+    type Index = <ConsecutiveIndexPairs<OwnedRegion<R::Index>, IndexOptimized> as Region>::Index;
 
     fn merge_regions<'a>(regions: impl Iterator<Item = &'a Self> + Clone) -> Self
     where
@@ -112,7 +112,7 @@ where
         }
 
         Self {
-            indices: ConsecutiveOffsetPairs::merge_regions(regions.map(|r| &r.indices)),
+            indices: ConsecutiveIndexPairs::merge_regions(regions.map(|r| &r.indices)),
             inner,
         }
     }
@@ -169,11 +169,11 @@ where
 impl<R, O> Default for ColumnsRegion<R, O>
 where
     R: Region,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
 {
     fn default() -> Self {
         Self {
-            indices: ConsecutiveOffsetPairs::default(),
+            indices: ConsecutiveIndexPairs::default(),
             inner: Vec::default(),
         }
     }
@@ -376,7 +376,7 @@ where
 impl<R, O> Push<ReadColumns<'_, R>> for ColumnsRegion<R, O>
 where
     for<'a> R: Region + Push<<R as Region>::ReadItem<'a>>,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
 {
     fn push(&mut self, item: ReadColumns<'_, R>) -> <ColumnsRegion<R, O> as Region>::Index {
         // Ensure all required regions exist.
@@ -395,7 +395,7 @@ where
 impl<'a, R, O, T> Push<&'a [T]> for ColumnsRegion<R, O>
 where
     R: Region + Push<&'a T>,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
 {
     fn push(&mut self, item: &'a [T]) -> <ColumnsRegion<R, O> as Region>::Index {
         // Ensure all required regions exist.
@@ -414,7 +414,7 @@ where
 impl<R, O, T, const N: usize> Push<[T; N]> for ColumnsRegion<R, O>
 where
     R: Region + Push<T>,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
 {
     fn push(&mut self, item: [T; N]) -> <ColumnsRegion<R, O> as Region>::Index {
         // Ensure all required regions exist.
@@ -433,7 +433,7 @@ where
 impl<'a, R, O, T, const N: usize> Push<&'a [T; N]> for ColumnsRegion<R, O>
 where
     R: Region + Push<&'a T>,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
 {
     fn push(&mut self, item: &'a [T; N]) -> <ColumnsRegion<R, O> as Region>::Index {
         // Ensure all required regions exist.
@@ -452,7 +452,7 @@ where
 impl<R, O, T> Push<Vec<T>> for ColumnsRegion<R, O>
 where
     R: Region + Push<T>,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
 {
     fn push(&mut self, item: Vec<T>) -> <ColumnsRegion<R, O> as Region>::Index {
         // Ensure all required regions exist.
@@ -471,7 +471,7 @@ where
 impl<'a, R, O, T> Push<&'a Vec<T>> for ColumnsRegion<R, O>
 where
     R: Region + Push<&'a T>,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
 {
     fn push(&mut self, item: &'a Vec<T>) -> <ColumnsRegion<R, O> as Region>::Index {
         // Ensure all required regions exist.
@@ -490,7 +490,7 @@ where
 impl<R, O, T, I> Push<PushIter<I>> for ColumnsRegion<R, O>
 where
     R: Region + Push<T>,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
     I: IntoIterator<Item = T>,
     I::IntoIter: ExactSizeIterator,
 {
@@ -509,7 +509,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::impls::deduplicate::{CollapseSequence, ConsecutiveOffsetPairs};
+    use crate::impls::deduplicate::{CollapseSequence, ConsecutiveIndexPairs};
     use crate::{MirrorRegion, OwnedRegion, Push, PushIter, Region, StringRegion};
 
     use super::*;
@@ -573,7 +573,7 @@ mod tests {
         ];
 
         let mut r =
-            ColumnsRegion::<CollapseSequence<ConsecutiveOffsetPairs<StringRegion>>>::default();
+            ColumnsRegion::<CollapseSequence<ConsecutiveIndexPairs<StringRegion>>>::default();
 
         let mut indices = Vec::with_capacity(data.len());
 
@@ -601,7 +601,7 @@ mod tests {
             vec![],
         ];
 
-        let mut r = ColumnsRegion::<ConsecutiveOffsetPairs<StringRegion>>::default();
+        let mut r = ColumnsRegion::<ConsecutiveIndexPairs<StringRegion>>::default();
 
         let mut indices = Vec::with_capacity(data.len());
 
@@ -629,7 +629,7 @@ mod tests {
             vec![],
         ];
 
-        let mut r = ColumnsRegion::<ConsecutiveOffsetPairs<StringRegion>>::default();
+        let mut r = ColumnsRegion::<ConsecutiveIndexPairs<StringRegion>>::default();
 
         let mut indices = Vec::with_capacity(data.len());
 
@@ -713,7 +713,7 @@ mod tests {
             vec![],
         ];
 
-        let mut r = ColumnsRegion::<ConsecutiveOffsetPairs<StringRegion>>::default();
+        let mut r = ColumnsRegion::<ConsecutiveIndexPairs<StringRegion>>::default();
 
         for row in &data {
             let _ = r.push(PushIter(row.iter()));
diff --git a/src/impls/deduplicate.rs b/src/impls/deduplicate.rs
index 7c19bc6..c28bf5f 100644
--- a/src/impls/deduplicate.rs
+++ b/src/impls/deduplicate.rs
@@ -3,7 +3,7 @@
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use crate::impls::offsets::{OffsetContainer, OffsetOptimized};
+use crate::impls::index::{IndexContainer, IndexOptimized};
 use crate::{Push, Region, ReserveItems};
 
 /// A region to deduplicate consecutive equal items.
@@ -114,68 +114,68 @@ where
 /// Transform an index of `(usize, usize)` to a sequence of `0..`. Requires the pairs to
 /// be dense, i.e., `(i, j)` is followed by `(j, k)`.
 ///
-/// Defers to region `R` for storing items, and uses offset container `O` to
+/// Defers to region `R` for storing items, and uses index container `O` to
 /// remeber indices. By default, `O` is `Vec<usize>`.
 ///
 /// # Examples
 ///
 /// The following example shows that two inserts into a copy region have a collapsible index:
 /// ```
-/// use flatcontainer::impls::deduplicate::{CollapseSequence, ConsecutiveOffsetPairs};
+/// use flatcontainer::impls::deduplicate::{CollapseSequence, ConsecutiveIndexPairs};
 /// use flatcontainer::{Push, OwnedRegion, Region, StringRegion};
-/// let mut r = <ConsecutiveOffsetPairs<OwnedRegion<u8>>>::default();
+/// let mut r = <ConsecutiveIndexPairs<OwnedRegion<u8>>>::default();
 ///
 /// let index = r.push(&b"abc");
 /// assert_eq!(b"abc", r.index(index));
 /// ```
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct ConsecutiveOffsetPairs<R, O = OffsetOptimized> {
+pub struct ConsecutiveIndexPairs<R, O = IndexOptimized> {
     /// Wrapped region
     inner: R,
-    /// Storage for offsets. Always stores element 0.
-    offsets: O,
+    /// Storage for indices. Always stores element 0.
+    indices: O,
     /// The most recent end of the index pair of region `R`.
     last_index: usize,
 }
 
-impl<R: Clone, O: Clone> Clone for ConsecutiveOffsetPairs<R, O> {
+impl<R: Clone, O: Clone> Clone for ConsecutiveIndexPairs<R, O> {
     fn clone(&self) -> Self {
         Self {
             inner: self.inner.clone(),
-            offsets: self.offsets.clone(),
+            indices: self.indices.clone(),
             last_index: self.last_index,
         }
     }
 
     fn clone_from(&mut self, source: &Self) {
         self.inner.clone_from(&source.inner);
-        self.offsets.clone_from(&source.offsets);
+        self.indices.clone_from(&source.indices);
         self.last_index = source.last_index;
     }
 }
 
-impl<R, O> Default for ConsecutiveOffsetPairs<R, O>
+impl<R, O> Default for ConsecutiveIndexPairs<R, O>
 where
     R: Default,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
 {
     #[inline]
     fn default() -> Self {
         let mut d = Self {
             inner: Default::default(),
-            offsets: Default::default(),
+            indices: Default::default(),
             last_index: 0,
         };
-        d.offsets.push(0);
+        d.indices.push(0);
         d
     }
 }
 
-impl<R, O> Region for ConsecutiveOffsetPairs<R, O>
+impl<R, O> Region for ConsecutiveIndexPairs<R, O>
 where
     R: Region<Index = (usize, usize)>,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
 {
     type Owned = R::Owned;
     type ReadItem<'a> = R::ReadItem<'a>
@@ -189,11 +189,11 @@ where
     where
         Self: 'a,
     {
-        let mut offsets = O::default();
-        offsets.push(0);
+        let mut indices = O::default();
+        indices.push(0);
         Self {
             inner: R::merge_regions(regions.map(|r| &r.inner)),
-            offsets,
+            indices,
             last_index: 0,
         }
     }
@@ -201,7 +201,7 @@ where
     #[inline]
     fn index(&self, index: Self::Index) -> Self::ReadItem<'_> {
         self.inner
-            .index((self.offsets.index(index), self.offsets.index(index + 1)))
+            .index((self.indices.index(index), self.indices.index(index + 1)))
     }
 
     #[inline]
@@ -217,13 +217,13 @@ where
     fn clear(&mut self) {
         self.last_index = 0;
         self.inner.clear();
-        self.offsets.clear();
-        self.offsets.push(0);
+        self.indices.clear();
+        self.indices.push(0);
     }
 
     #[inline]
     fn heap_size<F: FnMut(usize, usize)>(&self, mut callback: F) {
-        self.offsets.heap_size(&mut callback);
+        self.indices.heap_size(&mut callback);
         self.inner.heap_size(callback);
     }
 
@@ -236,25 +236,25 @@ where
     }
 }
 
-impl<R, O, T> Push<T> for ConsecutiveOffsetPairs<R, O>
+impl<R, O, T> Push<T> for ConsecutiveIndexPairs<R, O>
 where
     R: Region<Index = (usize, usize)> + Push<T>,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
 {
     #[inline]
-    fn push(&mut self, item: T) -> <ConsecutiveOffsetPairs<R, O> as Region>::Index {
+    fn push(&mut self, item: T) -> <ConsecutiveIndexPairs<R, O> as Region>::Index {
         let index = self.inner.push(item);
         debug_assert_eq!(index.0, self.last_index);
         self.last_index = index.1;
-        self.offsets.push(index.1);
-        self.offsets.len() - 2
+        self.indices.push(index.1);
+        self.indices.len() - 2
     }
 }
 
-impl<R, O, T> ReserveItems<T> for ConsecutiveOffsetPairs<R, O>
+impl<R, O, T> ReserveItems<T> for ConsecutiveIndexPairs<R, O>
 where
     R: Region<Index = (usize, usize)> + ReserveItems<T>,
-    O: OffsetContainer<usize>,
+    O: IndexContainer<usize>,
 {
     fn reserve_items<I>(&mut self, items: I)
     where
@@ -266,8 +266,8 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::impls::deduplicate::{CollapseSequence, ConsecutiveOffsetPairs};
-    use crate::impls::offsets::OffsetOptimized;
+    use crate::impls::deduplicate::{CollapseSequence, ConsecutiveIndexPairs};
+    use crate::impls::index::IndexOptimized;
     use crate::{FlatStack, Push, StringRegion};
 
     #[test]
@@ -292,9 +292,9 @@ mod tests {
     }
 
     #[test]
-    fn test_offset_optimized() {
+    fn test_index_optimized() {
         let mut r =
-            CollapseSequence::<ConsecutiveOffsetPairs<StringRegion, OffsetOptimized>>::default();
+            CollapseSequence::<ConsecutiveIndexPairs<StringRegion, IndexOptimized>>::default();
 
         for _ in 0..1000 {
             let _ = r.push("abc");
diff --git a/src/impls/offsets.rs b/src/impls/index.rs
similarity index 75%
rename from src/impls/offsets.rs
rename to src/impls/index.rs
index c968c24..229e889 100644
--- a/src/impls/offsets.rs
+++ b/src/impls/index.rs
@@ -1,12 +1,12 @@
-//! Types to represent offsets.
+//! Types to store indexes.
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
 use crate::impls::storage::Storage;
 
-/// A container to store offsets.
-pub trait OffsetContainer<T>: Storage<T> {
+/// A container to store indices.
+pub trait IndexContainer<T>: Storage<T> {
     /// Iterator over the elements.
     type Iter<'a>: Iterator<Item = T> + Clone
     where
@@ -30,14 +30,14 @@ pub trait OffsetContainer<T>: Storage<T> {
 
 /// A container for offsets that can represent strides of offsets.
 ///
-/// Does not implement `OffsetContainer` because it cannot accept arbitrary pushes. Instead,
+/// Does not implement [`IndexContainer`] because it cannot accept arbitrary pushes. Instead,
 /// its `push` method returns a boolean to indicate whether the push was successful or not.
 ///
 /// This type can absorb sequences of the form `0, stride, 2 * stride, 3 * stride, ...` and
 /// saturates in a repeated last element.
 #[derive(Eq, PartialEq, Debug, Default, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub enum OffsetStride {
+pub enum Stride {
     /// No push has occurred.
     #[default]
     Empty,
@@ -50,36 +50,36 @@ pub enum OffsetStride {
     Saturated(usize, usize, usize),
 }
 
-impl OffsetStride {
+impl Stride {
     /// Accepts or rejects a newly pushed element.
     #[must_use]
     #[inline]
     pub fn push(&mut self, item: usize) -> bool {
         match self {
-            OffsetStride::Empty => {
+            Stride::Empty => {
                 if item == 0 {
-                    *self = OffsetStride::Zero;
+                    *self = Stride::Zero;
                     true
                 } else {
                     false
                 }
             }
-            OffsetStride::Zero => {
-                *self = OffsetStride::Striding(item, 2);
+            Stride::Zero => {
+                *self = Stride::Striding(item, 2);
                 true
             }
-            OffsetStride::Striding(stride, count) => {
+            Stride::Striding(stride, count) => {
                 if item == *stride * *count {
                     *count += 1;
                     true
                 } else if item == *stride * (*count - 1) {
-                    *self = OffsetStride::Saturated(*stride, *count, 1);
+                    *self = Stride::Saturated(*stride, *count, 1);
                     true
                 } else {
                     false
                 }
             }
-            OffsetStride::Saturated(stride, count, reps) => {
+            Stride::Saturated(stride, count, reps) => {
                 if item == *stride * (*count - 1) {
                     *reps += 1;
                     true
@@ -95,17 +95,17 @@ impl OffsetStride {
     /// # Panics
     ///
     /// Panics for out-of-bounds accesses, i.e., if `index` greater or equal to
-    /// [`len`][OffsetStride::len].
+    /// [`len`](Stride::len).
     #[must_use]
     #[inline]
     pub fn index(&self, index: usize) -> usize {
         match self {
-            OffsetStride::Empty => {
-                panic!("Empty OffsetStride")
+            Stride::Empty => {
+                panic!("Empty Stride")
             }
-            OffsetStride::Zero => 0,
-            OffsetStride::Striding(stride, _steps) => *stride * index,
-            OffsetStride::Saturated(stride, steps, _reps) => {
+            Stride::Zero => 0,
+            Stride::Striding(stride, _steps) => *stride * index,
+            Stride::Saturated(stride, steps, _reps) => {
                 if index < *steps {
                     *stride * index
                 } else {
@@ -120,10 +120,10 @@ impl OffsetStride {
     #[inline]
     pub fn len(&self) -> usize {
         match self {
-            OffsetStride::Empty => 0,
-            OffsetStride::Zero => 1,
-            OffsetStride::Striding(_stride, steps) => *steps,
-            OffsetStride::Saturated(_stride, steps, reps) => *steps + *reps,
+            Stride::Empty => 0,
+            Stride::Zero => 1,
+            Stride::Striding(_stride, steps) => *steps,
+            Stride::Saturated(_stride, steps, reps) => *steps + *reps,
         }
     }
 
@@ -131,7 +131,7 @@ impl OffsetStride {
     #[must_use]
     #[inline]
     pub fn is_empty(&self) -> bool {
-        matches!(self, OffsetStride::Empty)
+        matches!(self, Stride::Empty)
     }
 
     /// Removes all elements.
@@ -143,22 +143,22 @@ impl OffsetStride {
     /// Return an iterator over the elements.
     #[must_use]
     #[inline]
-    pub fn iter(&self) -> OffsetStrideIter {
-        OffsetStrideIter {
+    pub fn iter(&self) -> StrideIter {
+        StrideIter {
             strided: *self,
             index: 0,
         }
     }
 }
 
-/// An iterator over the elements of an [`OffsetStride`].
+/// An iterator over the elements of an [`Stride`].
 #[derive(Clone, Copy)]
-pub struct OffsetStrideIter {
-    strided: OffsetStride,
+pub struct StrideIter {
+    strided: Stride,
     index: usize,
 }
 
-impl Iterator for OffsetStrideIter {
+impl Iterator for StrideIter {
     type Item = usize;
 
     #[inline]
@@ -176,17 +176,17 @@ impl Iterator for OffsetStrideIter {
 /// A list of unsigned integers that uses `u32` elements as long as they are small enough, and switches to `u64` once they are not.
 #[derive(Eq, PartialEq, Clone, Debug, Default)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct OffsetList<S, L> {
-    /// Offsets that fit within a `u32`.
+pub struct IndexList<S, L> {
+    /// Indexes that fit within a `u32`.
     pub smol: S,
-    /// Offsets that either do not fit in a `u32`, or are inserted after some offset that did not fit.
+    /// Indexes that either do not fit in a `u32`, or are inserted after some offset that did not fit.
     pub chonk: L,
 }
 
-impl<S, L> OffsetList<S, L>
+impl<S, L> IndexList<S, L>
 where
-    S: OffsetContainer<u32>,
-    L: OffsetContainer<u64>,
+    S: IndexContainer<u32>,
+    L: IndexContainer<u64>,
 {
     /// Allocate a new list with a specified capacity.
     #[must_use]
@@ -198,21 +198,21 @@ where
         }
     }
 
-    /// Inserts the offset, as a `u32` if that is still on the table.
+    /// Inserts the index, as a `u32` if that is still on the table.
     ///
     /// # Panics
     ///
     /// Panics if `usize` does not fit in `u64`.
     #[inline]
-    pub fn push(&mut self, offset: usize) {
+    pub fn push(&mut self, index: usize) {
         if self.chonk.is_empty() {
-            if let Ok(smol) = offset.try_into() {
+            if let Ok(smol) = index.try_into() {
                 self.smol.push(smol);
             } else {
-                self.chonk.push(offset.try_into().unwrap());
+                self.chonk.push(index.try_into().unwrap());
             }
         } else {
-            self.chonk.push(offset.try_into().unwrap());
+            self.chonk.push(index.try_into().unwrap());
         }
     }
 
@@ -265,10 +265,10 @@ where
     }
 }
 
-impl<S, L> Storage<usize> for OffsetList<S, L>
+impl<S, L> Storage<usize> for IndexList<S, L>
 where
-    S: OffsetContainer<u32>,
-    L: OffsetContainer<u64>,
+    S: IndexContainer<u32>,
+    L: IndexContainer<u64>,
 {
     #[inline]
     fn with_capacity(capacity: usize) -> Self {
@@ -301,12 +301,12 @@ where
     }
 }
 
-impl<S, L> OffsetContainer<usize> for OffsetList<S, L>
+impl<S, L> IndexContainer<usize> for IndexList<S, L>
 where
-    S: OffsetContainer<u32>,
-    L: OffsetContainer<u64>,
+    S: IndexContainer<u32>,
+    L: IndexContainer<u64>,
 {
-    type Iter<'a> = OffsetListIter<S::Iter<'a>, L::Iter<'a>> where Self: 'a;
+    type Iter<'a> = IndexListIter<S::Iter<'a>, L::Iter<'a>> where Self: 'a;
 
     #[inline]
     fn index(&self, index: usize) -> usize {
@@ -330,21 +330,21 @@ where
 
     #[inline]
     fn iter(&self) -> Self::Iter<'_> {
-        OffsetListIter {
+        IndexListIter {
             smol: self.smol.iter(),
             chonk: self.chonk.iter(),
         }
     }
 }
 
-/// An iterator over the elements of an [`OffsetList`].
+/// An iterator over the elements of an [`IndexList`].
 #[derive(Clone, Copy)]
-pub struct OffsetListIter<S, L> {
+pub struct IndexListIter<S, L> {
     smol: S,
     chonk: L,
 }
 
-impl<S, L> Iterator for OffsetListIter<S, L>
+impl<S, L> Iterator for IndexListIter<S, L>
 where
     S: Iterator<Item = u32>,
     L: Iterator<Item = u64>,
@@ -364,15 +364,15 @@ where
 /// a regular offset list.
 #[derive(Eq, PartialEq, Default, Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct OffsetOptimized<S = Vec<u32>, L = Vec<u64>> {
-    strided: OffsetStride,
-    spilled: OffsetList<S, L>,
+pub struct IndexOptimized<S = Vec<u32>, L = Vec<u64>> {
+    strided: Stride,
+    spilled: IndexList<S, L>,
 }
 
-impl<S, L> Storage<usize> for OffsetOptimized<S, L>
+impl<S, L> Storage<usize> for IndexOptimized<S, L>
 where
-    S: OffsetContainer<u32>,
-    L: OffsetContainer<u64>,
+    S: IndexContainer<u32>,
+    L: IndexContainer<u64>,
 {
     #[inline]
     fn with_capacity(_capacity: usize) -> Self {
@@ -383,7 +383,7 @@ where
     #[inline]
     fn clear(&mut self) {
         self.spilled.clear();
-        self.strided = OffsetStride::default();
+        self.strided = Stride::default();
     }
 
     #[inline]
@@ -409,12 +409,12 @@ where
     }
 }
 
-impl<S, L> OffsetContainer<usize> for OffsetOptimized<S, L>
+impl<S, L> IndexContainer<usize> for IndexOptimized<S, L>
 where
-    S: OffsetContainer<u32>,
-    L: OffsetContainer<u64>,
+    S: IndexContainer<u32>,
+    L: IndexContainer<u64>,
 {
-    type Iter<'a> = OffsetOptimizedIter<S::Iter<'a>, L::Iter<'a>> where Self: 'a;
+    type Iter<'a> = IndexOptimizedIter<S::Iter<'a>, L::Iter<'a>> where Self: 'a;
 
     fn index(&self, index: usize) -> usize {
         if index < self.strided.len() {
@@ -445,21 +445,21 @@ where
     }
 
     fn iter(&self) -> Self::Iter<'_> {
-        OffsetOptimizedIter {
+        IndexOptimizedIter {
             strided: self.strided.iter(),
             spilled: self.spilled.iter(),
         }
     }
 }
 
-/// An iterator over the elements of an [`OffsetOptimized`].
+/// An iterator over the elements of an [`IndexOptimized`].
 #[derive(Clone, Copy)]
-pub struct OffsetOptimizedIter<S, L> {
-    strided: OffsetStrideIter,
-    spilled: OffsetListIter<S, L>,
+pub struct IndexOptimizedIter<S, L> {
+    strided: StrideIter,
+    spilled: IndexListIter<S, L>,
 }
 
-impl<S, L> Iterator for OffsetOptimizedIter<S, L>
+impl<S, L> Iterator for IndexOptimizedIter<S, L>
 where
     S: Iterator<Item = u32>,
     L: Iterator<Item = u64>,
@@ -471,7 +471,7 @@ where
     }
 }
 
-impl<T: Copy> OffsetContainer<T> for Vec<T> {
+impl<T: Copy> IndexContainer<T> for Vec<T> {
     type Iter<'a> = std::iter::Copied<std::slice::Iter<'a, T>> where Self: 'a;
 
     fn index(&self, index: usize) -> T {
@@ -497,28 +497,28 @@ impl<T: Copy> OffsetContainer<T> for Vec<T> {
 
 #[cfg(test)]
 mod tests {
-    use crate::impls::deduplicate::ConsecutiveOffsetPairs;
+    use crate::impls::deduplicate::ConsecutiveIndexPairs;
     use crate::{Push, Region, SliceRegion, StringRegion};
 
     use super::*;
 
     #[test]
-    fn test_offset_optimized() {
+    fn test_index_optimized() {
         fn copy<R: Region + Push<T>, T>(r: &mut R, item: T) -> R::Index {
             r.push(item)
         }
 
         let mut r = SliceRegion::<
-            ConsecutiveOffsetPairs<StringRegion, OffsetOptimized>,
-            OffsetOptimized,
+            ConsecutiveIndexPairs<StringRegion, IndexOptimized>,
+            IndexOptimized,
         >::default();
         let idx = copy(&mut r, ["abc"]);
         assert_eq!("abc", r.index(idx).get(0))
     }
 
     #[test]
-    fn test_offset_optimized_clear() {
-        let mut oo = <OffsetOptimized>::default();
+    fn test_index_optimized_clear() {
+        let mut oo = <IndexOptimized>::default();
         oo.push(0);
         assert_eq!(oo.len(), 1);
         oo.clear();
@@ -531,16 +531,16 @@ mod tests {
     }
 
     #[test]
-    fn test_offset_optimized_reserve() {
-        let mut oo = <OffsetOptimized>::default();
+    fn test_index_optimized_reserve() {
+        let mut oo = <IndexOptimized>::default();
         oo.push(9999999999);
         assert_eq!(oo.len(), 1);
         oo.reserve(1);
     }
 
     #[test]
-    fn test_offset_optimized_heap_size() {
-        let mut oo = <OffsetOptimized>::default();
+    fn test_index_optimized_heap_size() {
+        let mut oo = <IndexOptimized>::default();
         oo.push(9999999999);
         let mut cap = 0;
         oo.heap_size(|_, ca| {
@@ -550,8 +550,8 @@ mod tests {
     }
 
     #[test]
-    fn test_offset_stride_push() {
-        let mut os = OffsetStride::default();
+    fn test_index_stride_push() {
+        let mut os = Stride::default();
         assert_eq!(os.len(), 0);
         assert!(os.is_empty());
         assert!(os.push(0));
@@ -578,15 +578,15 @@ mod tests {
 
     #[test]
     fn test_chonk() {
-        let mut ol = <OffsetList<Vec<_>, Vec<_>>>::default();
+        let mut ol = <IndexList<Vec<_>, Vec<_>>>::default();
         ol.push(usize::MAX);
         assert_eq!(usize::MAX, ol.index(0));
     }
 
     #[test]
     #[should_panic]
-    fn test_offset_stride_index() {
-        let os = OffsetStride::default();
+    fn test_index_stride_index() {
+        let os = Stride::default();
         let _ = os.index(0);
     }
 }
diff --git a/src/impls/slice.rs b/src/impls/slice.rs
index 9fe04ad..34dda42 100644
--- a/src/impls/slice.rs
+++ b/src/impls/slice.rs
@@ -7,7 +7,7 @@ use std::ops::{Deref, Range};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use crate::impls::offsets::OffsetContainer;
+use crate::impls::index::IndexContainer;
 use crate::{IntoOwned, Push, Region, RegionPreference, ReserveItems};
 
 impl<T: RegionPreference> RegionPreference for Vec<T> {
@@ -81,7 +81,7 @@ where
     }
 }
 
-impl<R: Region, O: OffsetContainer<R::Index>> Region for SliceRegion<R, O> {
+impl<R: Region, O: IndexContainer<R::Index>> Region for SliceRegion<R, O> {
     type Owned = Vec<R::Owned>;
     type ReadItem<'a> = ReadSlice<'a, R, O> where Self: 'a;
     type Index = (usize, usize);
@@ -138,7 +138,7 @@ impl<R: Region, O: OffsetContainer<R::Index>> Region for SliceRegion<R, O> {
     }
 }
 
-impl<R: Region, O: OffsetContainer<R::Index>> Default for SliceRegion<R, O> {
+impl<R: Region, O: IndexContainer<R::Index>> Default for SliceRegion<R, O> {
     #[inline]
     fn default() -> Self {
         Self {
@@ -149,11 +149,11 @@ impl<R: Region, O: OffsetContainer<R::Index>> Default for SliceRegion<R, O> {
 }
 
 /// A helper to read data out of a slice region.
-pub struct ReadSlice<'a, R: Region, O: OffsetContainer<R::Index> = Vec<<R as Region>::Index>>(
+pub struct ReadSlice<'a, R: Region, O: IndexContainer<R::Index> = Vec<<R as Region>::Index>>(
     Result<ReadSliceInner<'a, R, O>, &'a [R::Owned]>,
 );
 
-impl<R: Region, O: OffsetContainer<R::Index>> ReadSlice<'_, R, O> {
+impl<R: Region, O: IndexContainer<R::Index>> ReadSlice<'_, R, O> {
     /// Read the n-th item from the underlying region.
     ///
     /// # Panics
@@ -194,7 +194,7 @@ impl<R: Region, O: OffsetContainer<R::Index>> ReadSlice<'_, R, O> {
     }
 }
 
-impl<R: Region, O: OffsetContainer<R::Index>> PartialEq for ReadSlice<'_, R, O>
+impl<R: Region, O: IndexContainer<R::Index>> PartialEq for ReadSlice<'_, R, O>
 where
     for<'a> R::ReadItem<'a>: PartialEq,
 {
@@ -203,12 +203,12 @@ where
     }
 }
 
-impl<R: Region, O: OffsetContainer<R::Index>> Eq for ReadSlice<'_, R, O> where
+impl<R: Region, O: IndexContainer<R::Index>> Eq for ReadSlice<'_, R, O> where
     for<'a> R::ReadItem<'a>: Eq
 {
 }
 
-impl<R: Region, O: OffsetContainer<R::Index>> PartialOrd for ReadSlice<'_, R, O>
+impl<R: Region, O: IndexContainer<R::Index>> PartialOrd for ReadSlice<'_, R, O>
 where
     for<'a> R::ReadItem<'a>: PartialOrd,
 {
@@ -217,7 +217,7 @@ where
     }
 }
 
-impl<R: Region, O: OffsetContainer<R::Index>> Ord for ReadSlice<'_, R, O>
+impl<R: Region, O: IndexContainer<R::Index>> Ord for ReadSlice<'_, R, O>
 where
     for<'a> R::ReadItem<'a>: Ord,
 {
@@ -226,13 +226,13 @@ where
     }
 }
 
-struct ReadSliceInner<'a, R: Region, O: OffsetContainer<R::Index> = Vec<<R as Region>::Index>> {
+struct ReadSliceInner<'a, R: Region, O: IndexContainer<R::Index> = Vec<<R as Region>::Index>> {
     region: &'a SliceRegion<R, O>,
     start: usize,
     end: usize,
 }
 
-impl<R: Region, O: OffsetContainer<R::Index>> ReadSliceInner<'_, R, O> {
+impl<R: Region, O: IndexContainer<R::Index>> ReadSliceInner<'_, R, O> {
     /// Read the n-th item from the underlying region.
     ///
     /// # Panics
@@ -267,7 +267,7 @@ impl<R: Region, O: OffsetContainer<R::Index>> ReadSliceInner<'_, R, O> {
     }
 }
 
-impl<R: Region, O: OffsetContainer<R::Index>> Debug for ReadSlice<'_, R, O>
+impl<R: Region, O: IndexContainer<R::Index>> Debug for ReadSlice<'_, R, O>
 where
     for<'a> R::ReadItem<'a>: Debug,
 {
@@ -276,27 +276,27 @@ where
     }
 }
 
-impl<R: Region, O: OffsetContainer<R::Index>> Clone for ReadSlice<'_, R, O> {
+impl<R: Region, O: IndexContainer<R::Index>> Clone for ReadSlice<'_, R, O> {
     #[inline]
     fn clone(&self) -> Self {
         *self
     }
 }
 
-impl<R: Region, O: OffsetContainer<R::Index>> Clone for ReadSliceInner<'_, R, O> {
+impl<R: Region, O: IndexContainer<R::Index>> Clone for ReadSliceInner<'_, R, O> {
     #[inline]
     fn clone(&self) -> Self {
         *self
     }
 }
 
-impl<R: Region, O: OffsetContainer<R::Index>> Copy for ReadSlice<'_, R, O> {}
-impl<R: Region, O: OffsetContainer<R::Index>> Copy for ReadSliceInner<'_, R, O> {}
+impl<R: Region, O: IndexContainer<R::Index>> Copy for ReadSlice<'_, R, O> {}
+impl<R: Region, O: IndexContainer<R::Index>> Copy for ReadSliceInner<'_, R, O> {}
 
 impl<'a, R, O> IntoOwned<'a> for ReadSlice<'a, R, O>
 where
     R: Region,
-    O: OffsetContainer<R::Index>,
+    O: IndexContainer<R::Index>,
 {
     type Owned = Vec<R::Owned>;
 
@@ -321,7 +321,7 @@ where
     }
 }
 
-impl<'a, R: Region, O: OffsetContainer<R::Index>> IntoIterator for ReadSlice<'a, R, O> {
+impl<'a, R: Region, O: IndexContainer<R::Index>> IntoIterator for ReadSlice<'a, R, O> {
     type Item = R::ReadItem<'a>;
     type IntoIter = ReadSliceIter<'a, R, O>;
 
@@ -338,11 +338,11 @@ impl<'a, R: Region, O: OffsetContainer<R::Index>> IntoIterator for ReadSlice<'a,
 
 /// An iterator over the items read from a slice region.
 #[derive(Debug)]
-pub struct ReadSliceIter<'a, C: Region, O: OffsetContainer<C::Index>>(
+pub struct ReadSliceIter<'a, C: Region, O: IndexContainer<C::Index>>(
     Result<ReadSliceIterInner<'a, C, O>, std::slice::Iter<'a, C::Owned>>,
 );
 
-impl<'a, C: Region, O: OffsetContainer<C::Index>> Clone for ReadSliceIter<'a, C, O> {
+impl<'a, C: Region, O: IndexContainer<C::Index>> Clone for ReadSliceIter<'a, C, O> {
     #[inline]
     fn clone(&self) -> Self {
         Self(self.0.clone())
@@ -351,19 +351,19 @@ impl<'a, C: Region, O: OffsetContainer<C::Index>> Clone for ReadSliceIter<'a, C,
 
 /// An iterator over the items read from a slice region.
 #[derive(Debug)]
-pub struct ReadSliceIterInner<'a, C: Region, O: OffsetContainer<C::Index>>(
+pub struct ReadSliceIterInner<'a, C: Region, O: IndexContainer<C::Index>>(
     &'a SliceRegion<C, O>,
     Range<usize>,
 );
 
-impl<'a, C: Region, O: OffsetContainer<C::Index>> Clone for ReadSliceIterInner<'a, C, O> {
+impl<'a, C: Region, O: IndexContainer<C::Index>> Clone for ReadSliceIterInner<'a, C, O> {
     #[inline]
     fn clone(&self) -> Self {
         Self(self.0, self.1.clone())
     }
 }
 
-impl<'a, C: Region, O: OffsetContainer<C::Index>> Iterator for ReadSliceIter<'a, C, O> {
+impl<'a, C: Region, O: IndexContainer<C::Index>> Iterator for ReadSliceIter<'a, C, O> {
     type Item = C::ReadItem<'a>;
 
     #[inline]
@@ -378,13 +378,13 @@ impl<'a, C: Region, O: OffsetContainer<C::Index>> Iterator for ReadSliceIter<'a,
 impl<'a, R, O> ExactSizeIterator for ReadSliceIter<'a, R, O>
 where
     R: Region,
-    O: OffsetContainer<R::Index>,
+    O: IndexContainer<R::Index>,
     std::slice::Iter<'a, R::Owned>: ExactSizeIterator,
     ReadSliceIterInner<'a, R, O>: ExactSizeIterator,
 {
 }
 
-impl<'a, C: Region, O: OffsetContainer<C::Index>> Iterator for ReadSliceIterInner<'a, C, O> {
+impl<'a, C: Region, O: IndexContainer<C::Index>> Iterator for ReadSliceIterInner<'a, C, O> {
     type Item = C::ReadItem<'a>;
 
     #[inline]
@@ -398,7 +398,7 @@ impl<'a, C: Region, O: OffsetContainer<C::Index>> Iterator for ReadSliceIterInne
 impl<'a, R, O> ExactSizeIterator for ReadSliceIterInner<'a, R, O>
 where
     R: Region,
-    O: OffsetContainer<R::Index>,
+    O: IndexContainer<R::Index>,
     Range<usize>: ExactSizeIterator,
 {
 }
@@ -406,7 +406,7 @@ where
 impl<'a, C, T, O> Push<&'a [T]> for SliceRegion<C, O>
 where
     C: Region + Push<&'a T>,
-    O: OffsetContainer<C::Index>,
+    O: IndexContainer<C::Index>,
 {
     #[inline]
     fn push(&mut self, item: &'a [T]) -> <SliceRegion<C, O> as Region>::Index {
@@ -419,7 +419,7 @@ where
 impl<'a, T, R, O> ReserveItems<&'a [T]> for SliceRegion<R, O>
 where
     R: Region + ReserveItems<&'a T>,
-    O: OffsetContainer<R::Index>,
+    O: IndexContainer<R::Index>,
 {
     #[inline]
     fn reserve_items<I>(&mut self, items: I)
@@ -434,7 +434,7 @@ where
 impl<C, T, O> Push<Vec<T>> for SliceRegion<C, O>
 where
     C: Region + Push<T>,
-    O: OffsetContainer<C::Index>,
+    O: IndexContainer<C::Index>,
 {
     #[inline]
     fn push(&mut self, item: Vec<T>) -> <SliceRegion<C, O> as Region>::Index {
@@ -448,7 +448,7 @@ where
 impl<C, T, O> Push<&Vec<T>> for SliceRegion<C, O>
 where
     for<'a> C: Region + Push<&'a T>,
-    O: OffsetContainer<C::Index>,
+    O: IndexContainer<C::Index>,
 {
     #[inline]
     fn push(&mut self, item: &Vec<T>) -> <SliceRegion<C, O> as Region>::Index {
@@ -459,7 +459,7 @@ where
 impl<'a, C, T, O> Push<&&'a Vec<T>> for SliceRegion<C, O>
 where
     C: Region + Push<&'a T>,
-    O: OffsetContainer<C::Index>,
+    O: IndexContainer<C::Index>,
 {
     #[inline]
     fn push(&mut self, item: &&'a Vec<T>) -> <SliceRegion<C, O> as Region>::Index {
@@ -470,7 +470,7 @@ where
 impl<'a, T, R, O> ReserveItems<&'a Vec<T>> for SliceRegion<R, O>
 where
     for<'b> R: Region + ReserveItems<&'b T>,
-    O: OffsetContainer<R::Index>,
+    O: IndexContainer<R::Index>,
 {
     #[inline]
     fn reserve_items<I>(&mut self, items: I)
@@ -484,7 +484,7 @@ where
 impl<'a, C, O> Push<ReadSlice<'a, C, O>> for SliceRegion<C, O>
 where
     C: Region + Push<<C as Region>::ReadItem<'a>>,
-    O: OffsetContainer<C::Index>,
+    O: IndexContainer<C::Index>,
 {
     #[inline]
     fn push(&mut self, item: ReadSlice<'a, C, O>) -> <SliceRegion<C, O> as Region>::Index {
@@ -505,7 +505,7 @@ where
 impl<'a, C, O> Push<ReadSliceInner<'a, C, O>> for SliceRegion<C, O>
 where
     C: Region + Push<<C as Region>::ReadItem<'a>>,
-    O: OffsetContainer<C::Index>,
+    O: IndexContainer<C::Index>,
 {
     #[inline]
     fn push(&mut self, item: ReadSliceInner<'a, C, O>) -> <SliceRegion<C, O> as Region>::Index {
@@ -523,7 +523,7 @@ where
 impl<T, R, O, const N: usize> Push<[T; N]> for SliceRegion<R, O>
 where
     for<'a> R: Region + Push<&'a T>,
-    O: OffsetContainer<R::Index>,
+    O: IndexContainer<R::Index>,
 {
     #[inline]
     fn push(&mut self, item: [T; N]) -> <SliceRegion<R, O> as Region>::Index {
@@ -534,7 +534,7 @@ where
 impl<'a, T, R, O, const N: usize> Push<&'a [T; N]> for SliceRegion<R, O>
 where
     R: Region + Push<&'a T>,
-    O: OffsetContainer<R::Index>,
+    O: IndexContainer<R::Index>,
 {
     #[inline]
     fn push(&mut self, item: &'a [T; N]) -> <SliceRegion<R, O> as Region>::Index {
@@ -545,7 +545,7 @@ where
 impl<'a, T, R, O, const N: usize> Push<&&'a [T; N]> for SliceRegion<R, O>
 where
     R: Region + Push<&'a T>,
-    O: OffsetContainer<R::Index>,
+    O: IndexContainer<R::Index>,
 {
     #[inline]
     fn push(&mut self, item: &&'a [T; N]) -> <SliceRegion<R, O> as Region>::Index {
@@ -556,7 +556,7 @@ where
 impl<'a, T, R, O, const N: usize> ReserveItems<&'a [T; N]> for SliceRegion<R, O>
 where
     R: Region + ReserveItems<&'a T>,
-    O: OffsetContainer<R::Index>,
+    O: IndexContainer<R::Index>,
 {
     fn reserve_items<I>(&mut self, items: I)
     where
@@ -569,7 +569,7 @@ where
 impl<'a, R, O> ReserveItems<ReadSlice<'a, R, O>> for SliceRegion<R, O>
 where
     R: Region + ReserveItems<<R as Region>::ReadItem<'a>> + 'a,
-    O: OffsetContainer<R::Index>,
+    O: IndexContainer<R::Index>,
 {
     fn reserve_items<I>(&mut self, items: I)
     where
@@ -616,7 +616,7 @@ mod tests {
         let mut r = <SliceRegion<MirrorRegion<u8>>>::default();
         let index = r.push([1; 4]);
 
-        // Offset 4 is out of bounds and expected to panic.
+        // Index 4 is out of bounds and expected to panic.
         let _ = r.index(index).get(4);
     }
 
diff --git a/src/lib.rs b/src/lib.rs
index 23af4ae..759a508 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 
 pub mod impls;
 
-use crate::impls::offsets::OffsetContainer;
+use crate::impls::index::IndexContainer;
 pub use impls::columns::ColumnsRegion;
 pub use impls::mirror::MirrorRegion;
 pub use impls::option::OptionRegion;
@@ -183,7 +183,7 @@ impl<R: Default, S: Default> Default for FlatStack<R, S> {
     }
 }
 
-impl<R: Region, S: OffsetContainer<<R as Region>::Index>> Debug for FlatStack<R, S>
+impl<R: Region, S: IndexContainer<<R as Region>::Index>> Debug for FlatStack<R, S>
 where
     for<'a> R::ReadItem<'a>: Debug,
 {
@@ -192,7 +192,7 @@ where
     }
 }
 
-impl<R: Region, S: OffsetContainer<<R as Region>::Index>> FlatStack<R, S> {
+impl<R: Region, S: IndexContainer<<R as Region>::Index>> FlatStack<R, S> {
     /// Returns a flat stack that can absorb `capacity` indices without reallocation.
     ///
     /// Prefer [`Self::merge_capacity`] over this function to also pre-size the regions.
@@ -226,11 +226,11 @@ impl<R: Region, S: OffsetContainer<<R as Region>::Index>> FlatStack<R, S> {
         self.indices.push(index);
     }
 
-    /// Returns the element at the `offset` position.
+    /// Returns the element at the `index` position.
     #[inline]
     #[must_use]
-    pub fn get(&self, offset: usize) -> R::ReadItem<'_> {
-        self.region.index(self.indices.index(offset))
+    pub fn get(&self, index: usize) -> R::ReadItem<'_> {
+        self.region.index(self.indices.index(index))
     }
 
     /// Returns the number of indices in the stack.
@@ -289,7 +289,7 @@ impl<R: Region, S: OffsetContainer<<R as Region>::Index>> FlatStack<R, S> {
 impl<R, S> FlatStack<R, S>
 where
     R: Region,
-    S: OffsetContainer<<R as Region>::Index>,
+    S: IndexContainer<<R as Region>::Index>,
 {
     /// Iterate the items in this stack.
     #[inline]
@@ -316,7 +316,7 @@ impl<R: Region> FlatStack<R> {
 impl<T, R, S> Extend<T> for FlatStack<R, S>
 where
     R: Region + Push<T>,
-    S: OffsetContainer<<R as Region>::Index>,
+    S: IndexContainer<<R as Region>::Index>,
 {
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         let iter = iter.into_iter();
@@ -327,7 +327,7 @@ where
     }
 }
 
-impl<'a, R: Region, S: OffsetContainer<<R as Region>::Index>> IntoIterator for &'a FlatStack<R, S> {
+impl<'a, R: Region, S: IndexContainer<<R as Region>::Index>> IntoIterator for &'a FlatStack<R, S> {
     type Item = R::ReadItem<'a>;
     type IntoIter = Iter<'a, R, S::Iter<'a>>;
 
@@ -390,7 +390,7 @@ where
 impl<R, S, T> FromIterator<T> for FlatStack<R, S>
 where
     R: Region + Push<T>,
-    S: OffsetContainer<<R as Region>::Index>,
+    S: IndexContainer<<R as Region>::Index>,
 {
     fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
         let iter = iter.into_iter();
@@ -424,7 +424,7 @@ pub struct PushIter<I>(pub I);
 
 #[cfg(test)]
 mod tests {
-    use crate::impls::deduplicate::{CollapseSequence, ConsecutiveOffsetPairs};
+    use crate::impls::deduplicate::{CollapseSequence, ConsecutiveIndexPairs};
     use crate::impls::tuple::TupleARegion;
 
     use super::*;
@@ -582,7 +582,7 @@ mod tests {
         test_copy::<_, <(u8, u8) as RegionPreference>::Region>((1, 2));
         test_copy::<_, <(u8, u8) as RegionPreference>::Region>(&(1, 2));
 
-        test_copy::<_, ConsecutiveOffsetPairs<OwnedRegion<_>>>([1, 2, 3].as_slice());
+        test_copy::<_, ConsecutiveIndexPairs<OwnedRegion<_>>>([1, 2, 3].as_slice());
 
         test_copy::<_, CollapseSequence<OwnedRegion<_>>>([1, 2, 3].as_slice());
         test_copy::<_, CollapseSequence<OwnedRegion<_>>>(&[1, 2, 3]);
diff --git a/tests/recursive.rs b/tests/recursive.rs
index 2dba7a5..65e4cd1 100644
--- a/tests/recursive.rs
+++ b/tests/recursive.rs
@@ -1,6 +1,6 @@
 //! Demonstration of how to encode recursive data structures.
 
-use flatcontainer::impls::deduplicate::ConsecutiveOffsetPairs;
+use flatcontainer::impls::deduplicate::ConsecutiveIndexPairs;
 use flatcontainer::{IntoOwned, Push, Region, StringRegion};
 
 #[derive(Clone)]
@@ -135,7 +135,7 @@ where
 
 #[test]
 fn recursive() {
-    let mut region = <ListRegion<ConsecutiveOffsetPairs<StringRegion>>>::default();
+    let mut region = <ListRegion<ConsecutiveIndexPairs<StringRegion>>>::default();
     let r = List("abc", Some(Box::new(List("def", None))));
     let index = region.push(&r);