genarena 0.1.2

//! A slot-reservable arena with generational keys.
//!
//! This crate provides an [`Arena`] that stores values and returns stable,
//! copyable keys. Keys remain valid across insertions and removals, and are
//! protected against accidental reuse via *generations*.
//!
//! In addition to a standard insert/remove API, the arena supports a
//! **reservation** workflow, allowing you to obtain a key *before* constructing
//! its value.
//!
//! # Overview
//!
//! The arena stores elements in a contiguous `Vec`, reusing freed slots.
//! Each slot is tagged with a generation counter. A key consists of:
//!
//! - an index into the arena
//! - a generation
//!
//! When a slot is reused, its generation is incremented, ensuring that stale
//! keys no longer access the new value.
//!
//! # Features
//!
//! - **O(1)** insertion and removal
//! - **Stable keys** using generational indices
//! - **No ABA problem**: stale keys are detected via generation mismatch
//! - **Reservation API** enables constructing self-referential or cyclic data
//!
//! # Examples
//!
//! Basic usage:
//!
//! ```
//! use genarena::Arena;
//!
//! let mut arena = Arena::new_with_default();
//!
//! let key = arena.insert("hello");
//! assert_eq!(arena.get(key), Some(&"hello"));
//!
//! arena.remove(key);
//! assert_eq!(arena.get(key), None);
//! ```
//!
//! Keys are invalidated after removal:
//!
//! ```
//! use genarena::Arena;
//!
//! let mut arena = Arena::new_with_default();
//!
//! let k1 = arena.insert(1);
//! arena.remove(k1);
//!
//! // The slot of the removed element is reused here.
//! let k2 = arena.insert(2);
//!
//! assert_ne!(k1, k2);
//! assert!(!arena.contains_key(k1));
//! assert_eq!(arena.get(k2), Some(&2));
//! ```
//!
//! # Reservations
//!
//! A reservation allows obtaining a key before the value is available.
//!
//! ```
//! use genarena::Arena;
//!
//! let mut arena = Arena::new_with_default();
//!
//! let reservation = arena.reserve();
//! let key = reservation.key();
//!
//! // key is known, but no value yet
//! assert!(!arena.contains_key(key));
//!
//! let key2 = arena.claim(reservation, 42);
//! assert_eq!(key, key2);
//! assert_eq!(arena.get(key), Some(&42));
//! ```
//!
//! Reservations can also be canceled, which allows reusing the reserved slot
//! for later insertions:
//!
//! ```
//! use genarena::Arena;
//!
//! let mut arena = Arena::new_with_default();
//!
//! let reservation = arena.reserve();
//! let key = reservation.key();
//!
//! arena.cancel(reservation);
//!
//! let new_key = arena.insert(1);
//!
//! assert!(!arena.contains_key(key));
//! assert!(arena.contains_key(new_key));
//! ```

use std::iter::FusedIterator;
use std::marker::PhantomData;
use std::ops::{Index, IndexMut};
use std::{iter, mem, slice, vec};

use crate::key::{Generation, Key, Reservation};

pub mod key;
#[cfg(test)]
mod tests;

/// A slot-reservable arena with generational keys.
///
/// See the [crate documentation](crate) for more details.
pub struct Arena<K, T> {
    entries: Vec<Entry<T>>,

    /// Amount of occupied slots.
    len: usize,

    /// Index of the next vecant entry, or the length of `entries`.
    next: usize,

    _key: PhantomData<K>,
}

impl<K, T> Clone for Arena<K, T>
where
    T: Clone,
{
    fn clone(&self) -> Self {
        Self {
            entries: self.entries.clone(),
            len: self.len,
            next: self.next,
            _key: PhantomData,
        }
    }

    fn clone_from(&mut self, source: &Self) {
        self.entries.clone_from(&source.entries);
        self.len = source.len;
        self.next = source.next;
    }
}

impl<K, T> Default for Arena<K, T> {
    fn default() -> Self {
        Self::new()
    }
}

#[derive(Clone)]
struct Entry<T> {
    generation: Generation,
    slot: Slot<T>,
}

impl<T> Entry<T> {
    fn is_occupied(&self) -> bool {
        matches!(self.slot, Slot::Occupied(_))
    }

    fn is_reserved_for<K>(&self, reservation: &Reservation<K>) -> bool {
        self.generation == reservation.key.generation
            && matches!(self.slot, Slot::Reserved)
    }
}

#[derive(Clone)]
enum Slot<T> {
    Occupied(T),
    Reserved,
    Vecant { next: usize },
}

impl<T> Arena<Key, T> {
    /// Creates an empty [`Arena`] with the default key ([`Key`]).
    ///
    /// See [`Arena::new`].
    pub fn new_with_default() -> Self {
        Self { entries: Vec::new(), len: 0, next: 0, _key: PhantomData }
    }
}

impl<K, T> Arena<K, T> {
    /// Creates an empty [`Arena`] with a custom key.
    ///
    /// In order to use a custom key, your key type must be convertible from and
    /// into the type [`Key`]. See [`key_newtype_impls`].
    ///
    /// See also [`Arena::new_with_default`].
    ///
    /// # Examples
    ///
    /// ```
    /// # use genarena::{Arena, key::Key, key_newtype_impls};
    ///
    /// struct CustomKey(Key);
    /// key_newtype_impls!(CustomKey);
    ///
    /// let arena: Arena<CustomKey, i32> = Arena::new();
    /// assert!(arena.is_empty());
    /// ```
    pub fn new() -> Self {
        Self { entries: Vec::new(), len: 0, next: 0, _key: PhantomData }
    }

    /// Creates an ampty [`Arena`] with a preallocated capacity.
    ///
    /// See [`Vec::with_capacity`], which is called internally with `capacity`.
    pub fn with_capcity(capacity: usize) -> Self {
        Self {
            entries: Vec::with_capacity(capacity),
            len: 0,
            next: 0,
            _key: PhantomData,
        }
    }

    /// Returns the number of elements in the arena.
    pub fn len(&self) -> usize {
        self.len
    }

    /// Returns `true` if the arena contains no elements.
    pub fn is_empty(&self) -> bool {
        self.len == 0
    }
}

impl<K, T> Arena<K, T>
where
    K: From<Key>,
    Key: From<K>,
{
    /// Returns `true` if the arena contains a value for the specified key.
    ///
    /// # Examples
    ///
    /// ```
    /// # use genarena::Arena;
    /// #
    /// let mut arena = Arena::new_with_default();
    ///
    /// let key = arena.insert(42);
    /// assert!(arena.contains_key(key));
    ///
    /// arena.remove(key);
    /// let key2 = arena.insert(10);
    ///
    /// assert!(!arena.contains_key(key));
    /// assert!(arena.contains_key(key2));
    /// ```
    pub fn contains_key(&self, key: K) -> bool {
        let k = Key::from(key);

        self.entries
            .get(k.index)
            .is_some_and(|e| e.generation == k.generation && e.is_occupied())
    }

    /// Inserts a value to the arena, and returns it's key.
    ///
    /// # Examples
    ///
    /// ```
    /// # use genarena::Arena;
    /// #
    /// let mut arena = Arena::new_with_default();
    /// let key = arena.insert("value");
    /// assert!(!arena.is_empty());
    /// ```
    pub fn insert(&mut self, value: T) -> K {
        self.len += 1;
        let key = self.insert_slot(Slot::Occupied(value));
        K::from(key)
    }

    /// Reserves a slot in the arena, and returns a [`Reservation`].
    ///
    /// A reservation can be either by [claimed] or [canceled]. While it's
    /// possible to not do either, it will use up a slot in the arena that will
    /// not be reused.
    ///
    /// [claimed]: Arena::claim
    /// [canceled]: Arena::cancel
    ///
    /// # Examples
    ///
    /// ```
    /// # use genarena::Arena;
    /// #
    /// let mut arena = Arena::new_with_default();
    /// let reservation = arena.reserve();
    /// let res_key = reservation.key();
    /// assert!(!arena.contains_key(res_key));
    ///
    /// let key = arena.claim(reservation, "a");
    /// assert_eq!(res_key, key);
    /// assert_eq!(arena.get(key), Some(&"a"));
    /// ```
    pub fn reserve(&mut self) -> Reservation<K> {
        let key = self.insert_slot(Slot::Reserved);
        Reservation::new(key)
    }

    /// Claims a reservation.
    ///
    /// # Examples
    ///
    /// ```
    /// # use genarena::Arena;
    /// #
    /// let mut arena = Arena::new_with_default();
    /// let reservation = arena.reserve();
    /// let key = arena.claim(reservation, 42);
    /// assert_eq!(arena.get(key), Some(&42));
    /// ```
    pub fn claim(&mut self, reservation: Reservation<K>, value: T) -> K {
        let key = reservation.key;
        let entry = &mut self.entries[key.index];

        debug_assert!(entry.is_reserved_for(&reservation));

        self.len += 1;
        entry.slot = Slot::Occupied(value);

        K::from(key)
    }

    /// Cancels a reservation.
    ///
    /// # Panics
    ///
    /// Panics if the generation of the reservation key is the max generation.
    ///
    /// # Examples
    ///
    /// ```
    /// # use genarena::Arena;
    /// #
    /// let mut arena = Arena::new_with_default();
    /// let reservation = arena.reserve();
    /// let res_key = reservation.key();
    /// arena.cancel(reservation);
    ///
    /// let reuse_key = arena.insert("a");
    /// assert!(!arena.contains_key(res_key));
    /// assert!(arena.contains_key(reuse_key));
    /// ```
    pub fn cancel(&mut self, reservation: Reservation<K>) {
        let key = reservation.key;
        let entry = &mut self.entries[key.index];

        debug_assert!(entry.is_reserved_for(&reservation));

        entry.generation = entry.generation.next().unwrap();
        entry.slot = Slot::Vecant { next: self.next };
        self.next = key.index;
    }

    fn insert_slot(&mut self, slot: Slot<T>) -> Key {
        let index = self.next;

        let generation = if index == self.entries.len() {
            let generation = Generation::FIRST;
            self.entries.push(Entry { generation, slot });
            self.next = index + 1;
            generation
        } else {
            self.next = match self.entries.get(index) {
                Some(Entry { slot: Slot::Vecant { next }, .. }) => *next,
                _ => unreachable!("next should point to a vecant slot"),
            };
            self.entries[index].slot = slot;
            self.entries[index].generation
        };

        Key { index, generation }
    }

    /// Removes a key from the arena, returning the value at the key if the key
    /// was previously in the arena.
    ///
    /// # Panics
    ///
    /// Panics if the generation of the key is the max generation, and the key
    /// is in the arena.
    ///
    /// # Examples
    ///
    /// ```
    /// # use genarena::Arena;
    /// # use genarena::key::Key;
    /// #
    /// let mut arena = Arena::new_with_default();
    /// let key = arena.insert('a');
    /// assert_eq!(arena.remove(key), Some('a'));
    /// assert_eq!(arena.remove(key), None);
    /// ```
    pub fn remove(&mut self, key: K) -> Option<T> {
        let k = Key::from(key);

        let entry = self
            .entries
            .get_mut(k.index)
            .filter(|e| e.generation == k.generation && e.is_occupied())?;

        match mem::replace(&mut entry.slot, Slot::Vecant { next: self.next }) {
            Slot::Occupied(value) => {
                entry.generation = entry.generation.next().unwrap();

                self.len -= 1;
                self.next = k.index;

                Some(value)
            }
            _ => unreachable!("should be occupied"),
        }
    }

    /// Returns a reference to the value corresponding to the key.
    ///
    /// # Examples
    ///
    /// ```
    /// # use genarena::Arena;
    /// #
    /// let mut arena = Arena::new_with_default();
    /// let key = arena.insert("a");
    /// assert_eq!(arena.get(key), Some(&"a"));
    /// arena.remove(key);
    /// assert_eq!(arena.get(key), None);
    /// ```
    pub fn get(&self, key: K) -> Option<&T> {
        let k = Key::from(key);

        let entry = self
            .entries
            .get(k.index)
            .filter(|e| e.generation == k.generation)?;

        match entry.slot {
            Slot::Occupied(ref value) => Some(value),
            _ => None,
        }
    }

    /// Returns a mutable reference to the value corresponding to the key.
    ///
    /// # Examples
    ///
    /// ```
    /// # use genarena::Arena;
    /// #
    /// let mut arena = Arena::new_with_default();
    /// let key = arena.insert("a");
    /// if let Some(x) = arena.get_mut(key) {
    ///     *x = "b";
    /// }
    /// assert_eq!(arena[key], "b");
    /// ```
    pub fn get_mut(&mut self, key: K) -> Option<&mut T> {
        let k = Key::from(key);

        let entry = self
            .entries
            .get_mut(k.index)
            .filter(|e| e.generation == k.generation)?;

        match entry.slot {
            Slot::Occupied(ref mut value) => Some(value),
            _ => None,
        }
    }
}

impl<K, T> Arena<K, T>
where
    K: From<Key>,
{
    /// An iterator visiting all key-value pairs. The iterator element type is
    /// `(K, &'a T)`.
    pub fn iter(&self) -> Iter<'_, K, T> {
        Iter {
            inner: self.entries.iter().enumerate(),
            len: self.len,
            _key: PhantomData,
        }
    }

    /// An iterator visiting all key-value pairs, with mutable reference to the
    /// value. The iterator element type is `(K, &'a mut T)`.
    pub fn iter_mut(&mut self) -> IterMut<'_, K, T> {
        IterMut {
            inner: self.entries.iter_mut().enumerate(),
            len: self.len,
            _key: PhantomData,
        }
    }

    /// An iterator visiting all keys. The iterator element type is `K`.
    pub fn keys(&self) -> Keys<'_, K, T> {
        Keys {
            inner: self.entries.iter().enumerate(),
            len: self.len,
            _key: PhantomData,
        }
    }

    /// An iterator visiting all values. The iterator element type is `&'a T`.
    pub fn values(&self) -> Values<'_, T> {
        Values { inner: self.entries.iter(), len: self.len }
    }

    /// An iterator visiting all values mutably. The iterator element type is
    /// `&'a mut T`.
    pub fn values_mut(&mut self) -> ValuesMut<'_, T> {
        ValuesMut { inner: self.entries.iter_mut(), len: self.len }
    }

    /// Creates a consuming iterator visiting all the values. The iterator
    /// element type is `T`.
    pub fn into_values(self) -> IntoValues<T> {
        IntoValues { inner: self.entries.into_iter(), len: self.len }
    }
}

impl<K, T> Index<K> for Arena<K, T>
where
    K: From<Key>,
    Key: From<K>,
{
    type Output = T;

    fn index(&self, key: K) -> &Self::Output {
        self.get(key).expect("no entry found for key")
    }
}

impl<K, T> IndexMut<K> for Arena<K, T>
where
    K: From<Key>,
    Key: From<K>,
{
    fn index_mut(&mut self, key: K) -> &mut Self::Output {
        self.get_mut(key).expect("no entry found for key")
    }
}

pub struct Iter<'a, K, T> {
    inner: iter::Enumerate<slice::Iter<'a, Entry<T>>>,
    len: usize,
    _key: PhantomData<K>,
}

impl<'a, K, T> Iterator for Iter<'a, K, T>
where
    K: From<Key>,
{
    type Item = (K, &'a T);

    fn next(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some((index, entry)) = self.inner.next()
        {
            if let Slot::Occupied(ref value) = entry.slot {
                self.len -= 1;
                let key = Key { index, generation: entry.generation };
                return Some((K::from(key), value));
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        (self.len, Some(self.len))
    }
}

impl<'a, K, T> DoubleEndedIterator for Iter<'a, K, T>
where
    K: From<Key>,
{
    fn next_back(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some((index, entry)) = self.inner.next_back()
        {
            if let Slot::Occupied(ref value) = entry.slot {
                self.len -= 1;
                let key = Key { index, generation: entry.generation };
                return Some((K::from(key), value));
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }
}

impl<K, T> ExactSizeIterator for Iter<'_, K, T>
where
    K: From<Key>,
{
    fn len(&self) -> usize {
        self.len
    }
}

impl<K, T> FusedIterator for Iter<'_, K, T> where K: From<Key> {}

pub struct IterMut<'a, K, T> {
    inner: iter::Enumerate<slice::IterMut<'a, Entry<T>>>,
    len: usize,
    _key: PhantomData<K>,
}

impl<'a, K, T> Iterator for IterMut<'a, K, T>
where
    K: From<Key>,
{
    type Item = (K, &'a mut T);

    fn next(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some((index, entry)) = self.inner.next()
        {
            if let Slot::Occupied(ref mut value) = entry.slot {
                self.len -= 1;
                let key = Key { index, generation: entry.generation };
                return Some((K::from(key), value));
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        (self.len, Some(self.len))
    }
}

impl<'a, K, T> DoubleEndedIterator for IterMut<'a, K, T>
where
    K: From<Key>,
{
    fn next_back(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some((index, entry)) = self.inner.next_back()
        {
            if let Slot::Occupied(ref mut value) = entry.slot {
                self.len -= 1;
                let key = Key { index, generation: entry.generation };
                return Some((K::from(key), value));
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }
}

impl<K, T> ExactSizeIterator for IterMut<'_, K, T>
where
    K: From<Key>,
{
    fn len(&self) -> usize {
        self.len
    }
}

impl<K, T> FusedIterator for IterMut<'_, K, T> where K: From<Key> {}

pub struct IntoIter<K, T> {
    inner: iter::Enumerate<vec::IntoIter<Entry<T>>>,
    len: usize,
    _key: PhantomData<K>,
}

impl<K, T> Iterator for IntoIter<K, T>
where
    K: From<Key>,
{
    type Item = (K, T);

    fn next(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some((index, entry)) = self.inner.next()
        {
            if let Slot::Occupied(value) = entry.slot {
                self.len -= 1;
                let key = Key { index, generation: entry.generation };
                return Some((K::from(key), value));
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        (self.len, Some(self.len))
    }
}

impl<K, T> DoubleEndedIterator for IntoIter<K, T>
where
    K: From<Key>,
{
    fn next_back(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some((index, entry)) = self.inner.next_back()
        {
            if let Slot::Occupied(value) = entry.slot {
                self.len -= 1;
                let key = Key { index, generation: entry.generation };
                return Some((K::from(key), value));
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }
}

impl<K, T> ExactSizeIterator for IntoIter<K, T>
where
    K: From<Key>,
{
    fn len(&self) -> usize {
        self.len
    }
}

impl<K, T> FusedIterator for IntoIter<K, T> where K: From<Key> {}

impl<'a, K, T> IntoIterator for &'a Arena<K, T>
where
    K: From<Key>,
{
    type Item = (K, &'a T);

    type IntoIter = Iter<'a, K, T>;

    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

impl<'a, K, T> IntoIterator for &'a mut Arena<K, T>
where
    K: From<Key>,
{
    type Item = (K, &'a mut T);

    type IntoIter = IterMut<'a, K, T>;

    fn into_iter(self) -> Self::IntoIter {
        self.iter_mut()
    }
}

impl<K, T> IntoIterator for Arena<K, T>
where
    K: From<Key>,
{
    type Item = (K, T);

    type IntoIter = IntoIter<K, T>;

    fn into_iter(self) -> Self::IntoIter {
        IntoIter {
            inner: self.entries.into_iter().enumerate(),
            len: self.len,
            _key: PhantomData,
        }
    }
}

pub struct Keys<'a, K, T> {
    inner: iter::Enumerate<slice::Iter<'a, Entry<T>>>,
    len: usize,
    _key: PhantomData<K>,
}

impl<'a, K, T> Iterator for Keys<'a, K, T>
where
    K: From<Key>,
{
    type Item = K;

    fn next(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some((index, entry)) = self.inner.next()
        {
            if entry.is_occupied() {
                self.len -= 1;
                let key = Key { index, generation: entry.generation };
                return Some(K::from(key));
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }
}

impl<'a, K, T> DoubleEndedIterator for Keys<'a, K, T>
where
    K: From<Key>,
{
    fn next_back(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some((index, entry)) = self.inner.next_back()
        {
            if entry.is_occupied() {
                self.len -= 1;
                let key = Key { index, generation: entry.generation };
                return Some(K::from(key));
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }
}

impl<K, T> ExactSizeIterator for Keys<'_, K, T>
where
    K: From<Key>,
{
    fn len(&self) -> usize {
        self.len
    }
}

impl<K, T> FusedIterator for Keys<'_, K, T> where K: From<Key> {}

pub struct Values<'a, T> {
    inner: slice::Iter<'a, Entry<T>>,
    len: usize,
}

impl<'a, T> Iterator for Values<'a, T> {
    type Item = &'a T;

    fn next(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some(entry) = self.inner.next()
        {
            if let Slot::Occupied(ref value) = entry.slot {
                self.len -= 1;
                return Some(value);
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }
}

impl<'a, T> DoubleEndedIterator for Values<'a, T> {
    fn next_back(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some(entry) = self.inner.next_back()
        {
            if let Slot::Occupied(ref value) = entry.slot {
                self.len -= 1;
                return Some(value);
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }
}

impl<T> ExactSizeIterator for Values<'_, T> {
    fn len(&self) -> usize {
        self.len
    }
}

impl<T> FusedIterator for Values<'_, T> {}

pub struct ValuesMut<'a, T> {
    inner: slice::IterMut<'a, Entry<T>>,
    len: usize,
}

impl<'a, T> Iterator for ValuesMut<'a, T> {
    type Item = &'a mut T;

    fn next(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some(entry) = self.inner.next()
        {
            if let Slot::Occupied(ref mut value) = entry.slot {
                self.len -= 1;
                return Some(value);
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }
}

impl<'a, T> DoubleEndedIterator for ValuesMut<'a, T> {
    fn next_back(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some(entry) = self.inner.next_back()
        {
            if let Slot::Occupied(ref mut value) = entry.slot {
                self.len -= 1;
                return Some(value);
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }
}

impl<T> ExactSizeIterator for ValuesMut<'_, T> {
    fn len(&self) -> usize {
        self.len
    }
}

impl<T> FusedIterator for ValuesMut<'_, T> {}

pub struct IntoValues<T> {
    inner: vec::IntoIter<Entry<T>>,
    len: usize,
}

impl<T> Iterator for IntoValues<T> {
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some(entry) = self.inner.next()
        {
            if let Slot::Occupied(value) = entry.slot {
                self.len -= 1;
                return Some(value);
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }
}

impl<T> DoubleEndedIterator for IntoValues<T> {
    fn next_back(&mut self) -> Option<Self::Item> {
        while self.len != 0
            && let Some(entry) = self.inner.next_back()
        {
            if let Slot::Occupied(value) = entry.slot {
                self.len -= 1;
                return Some(value);
            }
        }

        debug_assert_eq!(self.len, 0);
        None
    }
}

impl<T> ExactSizeIterator for IntoValues<T> {
    fn len(&self) -> usize {
        self.len
    }
}

impl<T> FusedIterator for IntoValues<T> {}