consider exposing split_at_* methods for input

Author: avitex

src/display/error.rs

@@ -1,6 +1,6 @@
 use crate::error::{self, Context};
 use crate::fmt::{self, Write};
-use crate::input::{Bytes, Input, Private};
+use crate::input::{Bytes, Input};
 
 use super::{DisplayBase, InputDisplay, PreferredFormat};
 

src/error/context.rs

@@ -229,6 +229,9 @@ pub enum CoreOperation {
     SkipStrWhile,
     SkipUntil,
     SkipUntilConsume,
+    // Splitting
+    SplitAt,
+    SplitAtByte,
     // Taking
     Take,
     TakeArray,
@@ -292,6 +295,8 @@ impl CoreOperation {
             Self::SkipUntil => "skip input until a pattern matches",
             Self::SkipUntilConsume => "skip input until a pattern matches and consume it",
             Self::SkipStrWhile => "skip UTF-8 input while a condition remains true",
+            Self::SplitAt => "split input at a token index",
+            Self::SplitAtByte => "split input at a byte index",
             Self::Take => "take a length of input",
             Self::TakeArray => "take an array of bytes",
             Self::TakeWhile => "take input while a pattern matches",

src/input/bytes/mod.rs

@@ -126,6 +126,18 @@ impl<'i> Input<'i> for Bytes<'i> {
     fn display(&self) -> InputDisplay<'i> {
         InputDisplay::new(self)
     }
+
+    #[inline(always)]
+    fn split_at_opt(self, mid: usize) -> Option<(Self, Self)> {
+        slice::split_at_opt(self.as_dangerous(), mid).map(|(head, tail)| {
+            // We split at a known length making the head input bound.
+            let head = Bytes::new(head, self.bound().close_end());
+            // For the tail we derive the bound constraint from self.
+            let tail = Bytes::new(tail, self.bound());
+            // Return the split input parts.
+            (head, tail)
+        })
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -231,7 +243,7 @@ impl<'i> Bytes<'i> {
     where
         E: From<ExpectedLength<'i>>,
     {
-        match self.split_at(N, operation) {
+        match self.split_at_for(N, operation) {
             Ok((head, tail)) => {
                 // SAFETY: safe as we took only N amount.
                 let arr = unsafe { slice::slice_to_array_unchecked(head.as_dangerous()) };
@@ -328,18 +340,6 @@ impl<'i> Private<'i, u8> for Bytes<'i> {
         }
     }
 
-    #[inline(always)]
-    fn split_at_opt(self, mid: usize) -> Option<(Self, Self)> {
-        slice::split_at_opt(self.as_dangerous(), mid).map(|(head, tail)| {
-            // We split at a known length making the head input bound.
-            let head = Bytes::new(head, self.bound().close_end());
-            // For the tail we derive the bound constraint from self.
-            let tail = Bytes::new(tail, self.bound());
-            // Return the split input parts.
-            (head, tail)
-        })
-    }
-
     #[inline(always)]
     unsafe fn split_at_byte_unchecked(self, mid: usize) -> (Self, Self) {
         let (head, tail) = slice::split_at_unchecked(self.as_dangerous(), mid);

src/input/string/mod.rs

@@ -144,6 +144,22 @@ impl<'i> Input<'i> for String<'i> {
     fn display(&self) -> InputDisplay<'i> {
         InputDisplay::new(self).str_hint()
     }
+
+    #[inline(always)]
+    fn split_at_opt(self, mid: usize) -> Option<(Self, Self)> {
+        let string = self.as_dangerous();
+        let iter = &mut string.chars();
+        if iter.nth(mid.saturating_sub(1)).is_some() {
+            let byte_mid = string.as_bytes().len() - iter.as_str().as_bytes().len();
+            // SAFETY: we take byte_mid as the difference between the parent
+            // string and the remaining string left over from the char iterator.
+            // This means both the index can only ever be valid and the bytes in
+            // between are valid UTF-8.
+            Some(unsafe { self.split_at_byte_unchecked(byte_mid) })
+        } else {
+            None
+        }
+    }
 }
 
 impl<'i> Private<'i, char> for String<'i> {
@@ -184,22 +200,6 @@ impl<'i> Private<'i, char> for String<'i> {
         }
     }
 
-    #[inline(always)]
-    fn split_at_opt(self, mid: usize) -> Option<(Self, Self)> {
-        let string = self.as_dangerous();
-        let iter = &mut string.chars();
-        if iter.nth(mid.saturating_sub(1)).is_some() {
-            let byte_mid = string.as_bytes().len() - iter.as_str().as_bytes().len();
-            // SAFETY: we take byte_mid as the difference between the parent
-            // string and the remaining string left over from the char iterator.
-            // This means both the index can only ever be valid and the bytes in
-            // between are valid UTF-8.
-            Some(unsafe { self.split_at_byte_unchecked(byte_mid) })
-        } else {
-            None
-        }
-    }
-
     #[inline(always)]
     unsafe fn split_at_byte_unchecked(self, mid: usize) -> (Self, Self) {
         let (head, tail) = slice::split_str_at_unchecked(self.as_dangerous(), mid);

src/input/traits.rs

@@ -76,6 +76,54 @@ pub trait Input<'i>: Private<'i, Self::Token> {
     /// Returns an [`InputDisplay`] for formatting.
     fn display(&self) -> InputDisplay<'i>;
 
+    /// Splits the input into two at the token index `mid`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `mid > self.len()`.
+    #[inline]
+    fn split_at<E>(self, mid: usize) -> Result<(Self, Self), E>
+    where
+        E: From<ExpectedLength<'i>>,
+    {
+        self.split_at_for(mid, CoreOperation::SplitAt)
+    }
+
+    /// Splits the input into two at the token index `mid`.
+    ///
+    /// Returns `Some(Self)` if `mid` is a valid token index, `None` if `mid` is
+    /// out of bounds.
+    fn split_at_opt(self, mid: usize) -> Option<(Self, Self)>;
+
+    /// Splits the input into two at the byte index `mid`.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`ExpectedLength`] if `mid > self.len()` and [`ExpectedValid`]
+    /// if `mid` is not a valid token boundary.
+    #[inline]
+    fn split_at_byte<E>(self, mid: usize) -> Result<(Self, Self), E>
+    where
+        E: From<ExpectedValid<'i>>,
+        E: From<ExpectedLength<'i>>,
+    {
+        self.split_at_byte_for(mid, CoreOperation::SplitAtByte)
+    }
+
+    /// Splits the input into two at the byte index `mid`.
+    ///
+    /// Returns `Some(Self)` if `mid` is a valid token index, `None` if `mid` is
+    /// out of bounds or not a valid token boundary.
+    fn split_at_byte_opt(self, mid: usize) -> Option<(Self, Self)> {
+        if self.verify_token_boundary(mid).is_ok() {
+            // SAFETY: we verified that the index is a token boundary so this is
+            // safe.
+            unsafe { Some(self.split_at_byte_unchecked(mid)) }
+        } else {
+            None
+        }
+    }
+
     ///////////////////////////////////////////////////////////////////////////
     // Provided methods
 
@@ -271,11 +319,6 @@ pub trait Private<'i, Token>: Sized + Clone + DisplayBase + Debug + Display {
     /// Returns what was expected at that index.
     fn verify_token_boundary(&self, index: usize) -> Result<(), CoreExpected>;
 
-    /// Split the input at the token index `mid`.
-    ///
-    /// Return `Some` if mid is a valid index, `None` if not.
-    fn split_at_opt(self, mid: usize) -> Option<(Self, Self)>;
-
     /// Splits the input at the byte index `mid` without any validation.
     ///
     /// # Safety
@@ -300,7 +343,7 @@ pub(crate) trait PrivateExt<'i>: Input<'i> {
     ///
     /// Returns an error if `mid > self.len()`.
     #[inline(always)]
-    fn split_at<E>(self, mid: usize, operation: CoreOperation) -> Result<(Self, Self), E>
+    fn split_at_for<E>(self, mid: usize, operation: CoreOperation) -> Result<(Self, Self), E>
     where
         E: From<ExpectedLength<'i>>,
     {
@@ -325,7 +368,7 @@ pub(crate) trait PrivateExt<'i>: Input<'i> {
     /// Returns [`ExpectedLength`] if `mid > self.len()` and [`ExpectedValid`]
     /// if `mid` is not a valid token boundary.
     #[inline(always)]
-    fn split_at_byte<E>(self, mid: usize, operation: CoreOperation) -> Result<(Self, Self), E>
+    fn split_at_byte_for<E>(self, mid: usize, operation: CoreOperation) -> Result<(Self, Self), E>
     where
         E: From<ExpectedValid<'i>>,
         E: From<ExpectedLength<'i>>,
@@ -379,7 +422,7 @@ pub(crate) trait PrivateExt<'i>: Input<'i> {
     ///
     /// Returns an error if the input is empty.
     #[inline(always)]
-    fn split_token<E>(self, operation: CoreOperation) -> Result<(Self::Token, Self), E>
+    fn split_token_for<E>(self, operation: CoreOperation) -> Result<(Self::Token, Self), E>
     where
         E: From<ExpectedLength<'i>>,
     {
@@ -419,7 +462,7 @@ pub(crate) trait PrivateExt<'i>: Input<'i> {
     ///
     /// Returns an error if the input does not have the prefix.
     #[inline(always)]
-    fn split_prefix<P, E>(self, prefix: P, operation: CoreOperation) -> Result<(Self, Self), E>
+    fn split_prefix_for<P, E>(self, prefix: P, operation: CoreOperation) -> Result<(Self, Self), E>
     where
         E: From<ExpectedValue<'i>>,
         P: Prefix<Self> + Into<Value<'i>>,
@@ -475,7 +518,7 @@ pub(crate) trait PrivateExt<'i>: Input<'i> {
 
     /// Splits the input up to when the pattern matches.
     #[inline(always)]
-    fn split_until<P, E>(self, pattern: P, operation: CoreOperation) -> Result<(Self, Self), E>
+    fn split_until_for<P, E>(self, pattern: P, operation: CoreOperation) -> Result<(Self, Self), E>
     where
         E: From<ExpectedValue<'i>>,
         P: Pattern<Self> + Into<Value<'i>> + Copy,
@@ -499,7 +542,7 @@ pub(crate) trait PrivateExt<'i>: Input<'i> {
     ///
     /// Returns an error if the input does not have the pattern.
     #[inline(always)]
-    fn split_until_consume<P, E>(
+    fn split_until_consume_for<P, E>(
         self,
         pattern: P,
         operation: CoreOperation,
@@ -542,7 +585,11 @@ pub(crate) trait PrivateExt<'i>: Input<'i> {
     ///
     /// Returns an error from the provided function if it fails.
     #[inline(always)]
-    fn try_split_while<F, E>(self, mut f: F, operation: CoreOperation) -> Result<(Self, Self), E>
+    fn try_split_while_for<F, E>(
+        self,
+        mut f: F,
+        operation: CoreOperation,
+    ) -> Result<(Self, Self), E>
     where
         E: WithContext<'i>,
         F: FnMut(Self::Token) -> Result<bool, E>,
@@ -602,7 +649,7 @@ pub(crate) trait PrivateExt<'i>: Input<'i> {
     ///
     /// Returns an error from the provided function if it fails.
     #[inline(always)]
-    fn try_split_consumed<F, T, E>(
+    fn try_split_consumed_for<F, T, E>(
         self,
         f: F,
         operation: CoreOperation,
@@ -639,7 +686,7 @@ pub(crate) trait PrivateExt<'i>: Input<'i> {
     ///
     /// Returns an error if the expected value was not present.
     #[inline(always)]
-    fn split_expect<F, T, E>(
+    fn split_expect_for<F, T, E>(
         self,
         f: F,
         expected: &'static str,
@@ -674,7 +721,7 @@ pub(crate) trait PrivateExt<'i>: Input<'i> {
     /// Returns an error from the provided function if it fails or if the
     /// expected value was not present.
     #[inline(always)]
-    fn try_split_expect<F, T, E>(
+    fn try_split_expect_for<F, T, E>(
         self,
         f: F,
         expected: &'static str,
@@ -727,7 +774,7 @@ pub(crate) trait PrivateExt<'i>: Input<'i> {
     /// - the provided function returns an amount of input read that is greater
     ///   than the actual length
     #[inline(always)]
-    fn try_split_external<F, T, E, Ex>(
+    fn try_split_external_for<F, T, E, Ex>(
         self,
         f: F,
         expected: &'static str,
@@ -742,7 +789,7 @@ pub(crate) trait PrivateExt<'i>: Input<'i> {
     {
         match f(self.clone()) {
             Ok((read, ok)) => self
-                .split_at_byte(read, operation)
+                .split_at_byte_for(read, operation)
                 .map(|(_, remaining)| (ok, remaining)),
             Err(external) => Err(self.map_external_error(external, expected, operation)),
         }