Merge pull request #434 from cuviper/const-slice

Make `Slice::{first,last,split_*}` methods `const`

Author: cuviper

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "indexmap"
 edition = "2021"
-version = "2.13.0"
+version = "2.13.1"
 documentation = "https://docs.rs/indexmap/"
 repository = "https://github.com/indexmap-rs/indexmap"
 license = "Apache-2.0 OR MIT"

RELEASES.md

@@ -1,5 +1,11 @@
 # Releases
 
+## 2.13.1 (2026-04-02)
+
+- Made some `Slice` methods `const`:
+  - `map::Slice::{first,last,split_at,split_at_checked,split_first,split_last}`
+  - `set::Slice::{first,last,split_at,split_at_checked,split_first,split_last}`
+
 ## 2.13.0 (2026-01-07)
 
 - Implemented `Clone` for `IntoKeys` and `IntoValues`.

src/lib.rs

@@ -172,10 +172,10 @@ where
 
 impl<K, V> Bucket<K, V> {
     // field accessors -- used for `f` instead of closures in `.map(f)`
-    fn key_ref(&self) -> &K {
+    const fn key_ref(&self) -> &K {
         &self.key
     }
-    fn value_ref(&self) -> &V {
+    const fn value_ref(&self) -> &V {
         &self.value
     }
     fn value_mut(&mut self) -> &mut V {
@@ -190,7 +190,7 @@ impl<K, V> Bucket<K, V> {
     fn key_value(self) -> (K, V) {
         (self.key, self.value)
     }
-    fn refs(&self) -> (&K, &V) {
+    const fn refs(&self) -> (&K, &V) {
         (&self.key, &self.value)
     }
     fn ref_mut(&mut self) -> (&K, &mut V) {

src/map/slice.rs

@@ -102,8 +102,12 @@ impl<K, V> Slice<K, V> {
     }
 
     /// Get the first key-value pair.
-    pub fn first(&self) -> Option<(&K, &V)> {
-        self.entries.first().map(Bucket::refs)
+    pub const fn first(&self) -> Option<(&K, &V)> {
+        if let [first, ..] = &self.entries {
+            Some(first.refs())
+        } else {
+            None
+        }
     }
 
     /// Get the first key-value pair, with mutable access to the value.
@@ -112,8 +116,12 @@ impl<K, V> Slice<K, V> {
     }
 
     /// Get the last key-value pair.
-    pub fn last(&self) -> Option<(&K, &V)> {
-        self.entries.last().map(Bucket::refs)
+    pub const fn last(&self) -> Option<(&K, &V)> {
+        if let [.., last] = &self.entries {
+            Some(last.refs())
+        } else {
+            None
+        }
     }
 
     /// Get the last key-value pair, with mutable access to the value.
@@ -126,7 +134,7 @@ impl<K, V> Slice<K, V> {
     /// ***Panics*** if `index > len`.
     /// For a non-panicking alternative see [`split_at_checked`][Self::split_at_checked].
     #[track_caller]
-    pub fn split_at(&self, index: usize) -> (&Self, &Self) {
+    pub const fn split_at(&self, index: usize) -> (&Self, &Self) {
         let (first, second) = self.entries.split_at(index);
         (Self::from_slice(first), Self::from_slice(second))
     }
@@ -144,9 +152,12 @@ impl<K, V> Slice<K, V> {
     /// Divides one slice into two at an index.
     ///
     /// Returns `None` if `index > len`.
-    pub fn split_at_checked(&self, index: usize) -> Option<(&Self, &Self)> {
-        let (first, second) = self.entries.split_at_checked(index)?;
-        Some((Self::from_slice(first), Self::from_slice(second)))
+    pub const fn split_at_checked(&self, index: usize) -> Option<(&Self, &Self)> {
+        if let Some((first, second)) = self.entries.split_at_checked(index) {
+            Some((Self::from_slice(first), Self::from_slice(second)))
+        } else {
+            None
+        }
     }
 
     /// Divides one mutable slice into two at an index.
@@ -159,7 +170,7 @@ impl<K, V> Slice<K, V> {
 
     /// Returns the first key-value pair and the rest of the slice,
     /// or `None` if it is empty.
-    pub fn split_first(&self) -> Option<((&K, &V), &Self)> {
+    pub const fn split_first(&self) -> Option<((&K, &V), &Self)> {
         if let [first, rest @ ..] = &self.entries {
             Some((first.refs(), Self::from_slice(rest)))
         } else {
@@ -179,7 +190,7 @@ impl<K, V> Slice<K, V> {
 
     /// Returns the last key-value pair and the rest of the slice,
     /// or `None` if it is empty.
-    pub fn split_last(&self) -> Option<((&K, &V), &Self)> {
+    pub const fn split_last(&self) -> Option<((&K, &V), &Self)> {
         if let [rest @ .., last] = &self.entries {
             Some((last.refs(), Self::from_slice(rest)))
         } else {

src/set/slice.rs

@@ -73,36 +73,47 @@ impl<T> Slice<T> {
     }
 
     /// Get the first value.
-    pub fn first(&self) -> Option<&T> {
-        self.entries.first().map(Bucket::key_ref)
+    pub const fn first(&self) -> Option<&T> {
+        if let [first, ..] = &self.entries {
+            Some(&first.key)
+        } else {
+            None
+        }
     }
 
     /// Get the last value.
-    pub fn last(&self) -> Option<&T> {
-        self.entries.last().map(Bucket::key_ref)
+    pub const fn last(&self) -> Option<&T> {
+        if let [.., last] = &self.entries {
+            Some(&last.key)
+        } else {
+            None
+        }
     }
 
     /// Divides one slice into two at an index.
     ///
     /// ***Panics*** if `index > len`.
     /// For a non-panicking alternative see [`split_at_checked`][Self::split_at_checked].
     #[track_caller]
-    pub fn split_at(&self, index: usize) -> (&Self, &Self) {
+    pub const fn split_at(&self, index: usize) -> (&Self, &Self) {
         let (first, second) = self.entries.split_at(index);
         (Self::from_slice(first), Self::from_slice(second))
     }
 
     /// Divides one slice into two at an index.
     ///
     /// Returns `None` if `index > len`.
-    pub fn split_at_checked(&self, index: usize) -> Option<(&Self, &Self)> {
-        let (first, second) = self.entries.split_at_checked(index)?;
-        Some((Self::from_slice(first), Self::from_slice(second)))
+    pub const fn split_at_checked(&self, index: usize) -> Option<(&Self, &Self)> {
+        if let Some((first, second)) = self.entries.split_at_checked(index) {
+            Some((Self::from_slice(first), Self::from_slice(second)))
+        } else {
+            None
+        }
     }
 
     /// Returns the first value and the rest of the slice,
     /// or `None` if it is empty.
-    pub fn split_first(&self) -> Option<(&T, &Self)> {
+    pub const fn split_first(&self) -> Option<(&T, &Self)> {
         if let [first, rest @ ..] = &self.entries {
             Some((&first.key, Self::from_slice(rest)))
         } else {
@@ -112,7 +123,7 @@ impl<T> Slice<T> {
 
     /// Returns the last value and the rest of the slice,
     /// or `None` if it is empty.
-    pub fn split_last(&self) -> Option<(&T, &Self)> {
+    pub const fn split_last(&self) -> Option<(&T, &Self)> {
         if let [rest @ .., last] = &self.entries {
             Some((&last.key, Self::from_slice(rest)))
         } else {