feat: add inline const constructors

also bump msrv to 1.83

Cargo.toml

@@ -10,7 +10,7 @@ categories = ["memory-management", "data-structures"]
 license = "MIT OR Apache-2.0"
 edition = "2021"
 readme = "README.md"
-rust-version = "1.81.0"
+rust-version = "1.83.0"
 
 [package.metadata.docs.rs]
 all-features = true

src/bytes.rs

@@ -71,6 +71,50 @@ where
         Self::inline_empty()
     }
 
+    /// Creates a new inline `HipByt` by copying the given slice.
+    /// The slice **must not** be too large to be inlined.
+    ///
+    /// # Panics
+    ///
+    /// It panics if the slice is too large.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// # use hipstr::HipByt;
+    /// let s = HipByt::inline(b"hello\0");
+    /// assert_eq!(s, b"hello\0");
+    /// ```
+    pub const fn inline(bytes: &[u8]) -> Self {
+        assert!(bytes.len() <= Self::inline_capacity(), "slice too large");
+
+        // SAFETY: length checked above
+        unsafe { Self::inline_unchecked(bytes) }
+    }
+
+    /// Creates a new inline `HipByt` by copying the given the slice.
+    /// Return `None` if the given slice is too large to be inlined.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// # use hipstr::HipByt;
+    /// let s = HipByt::try_inline(b"hello\0").unwrap();
+    /// assert_eq!(s, b"hello\0");
+    /// ```
+    pub const fn try_inline(bytes: &[u8]) -> Option<Self> {
+        if bytes.len() <= Self::inline_capacity() {
+            // SAFETY: length checked above
+            Some(unsafe { Self::inline_unchecked(bytes) })
+        } else {
+            None
+        }
+    }
+
     /// Creates a new `HipByt` with the given capacity.
     ///
     /// The underlying representation is not **normalized**.

src/bytes/raw/inline.rs

@@ -106,19 +106,21 @@ impl<const INLINE_CAPACITY: usize> Inline<INLINE_CAPACITY> {
     /// Creates a new `Inline` string by copying a byte slice.
     #[inline]
     #[cfg(test)]
-    fn new(sl: &[u8]) -> Self {
-        assert!(sl.len() <= INLINE_CAPACITY);
-
-        // SAFETY: length check above
-        unsafe { Self::new_unchecked(sl) }
+    const fn new(sl: &[u8]) -> Option<Self> {
+        if sl.len() <= INLINE_CAPACITY {
+            // SAFETY: length check above
+            Some(unsafe { Self::new_unchecked(sl) })
+        } else {
+            None
+        }
     }
 
     /// Creates a new `Inline` string by copying a short byte slice.
     ///
     /// # Safety
     ///
     /// The input slice's length MUST be at most `INLINE_CAPACITY`.
-    pub unsafe fn new_unchecked(sl: &[u8]) -> Self {
+    pub const unsafe fn new_unchecked(sl: &[u8]) -> Self {
         let len = sl.len();
         debug_assert!(len <= INLINE_CAPACITY);
 
@@ -167,9 +169,7 @@ impl<const INLINE_CAPACITY: usize> Inline<INLINE_CAPACITY> {
 
     /// Returns a mutable view of this inline string.
     #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [u8] {
-        // XXX should add const: waiting for const_mut_refs
-
+    pub const fn as_mut_slice(&mut self) -> &mut [u8] {
         debug_assert!(self.is_valid());
 
         // HACK could be done without less unsafe: maybe_uninit_slice

src/bytes/raw/inline/tests.rs

@@ -6,7 +6,7 @@ type I = Inline<N>;
 
 #[test]
 fn test_clone() {
-    let a: I = Inline::new(b"abc");
+    let a: I = Inline::new(b"abc").unwrap();
     let b = a.clone();
     assert_eq!(a.as_slice(), b.as_slice());
 }