Implement nom traits for more slices, not just byte slices

This can be useful in cases where you already have an in-memory flat representation,
but want to use Nom to traverse it in a custom order.

This has a few opinionated decisions:
- `InputIter` is only implemented when `T: Copy`. This could easily be relaxed to `T: Clone`,
  but that could be surprising if T is expensive to clone.
- `Compare` is only implemented when `T: Eq`. This could be relaxed to PartialEq.

src/traits.rs

@@ -332,10 +332,13 @@ pub trait InputTake: Sized {
   fn take_split(&self, count: usize) -> (Self, Self);
 }
 
-impl<'a> InputIter for &'a [u8] {
-  type Item = u8;
+impl<'a, T> InputIter for &'a [T]
+where
+  T: Copy,
+{
+  type Item = T;
   type Iter = Enumerate<Self::IterElem>;
-  type IterElem = Copied<Iter<'a, u8>>;
+  type IterElem = Copied<Iter<'a, T>>;
 
   #[inline]
   fn iter_indices(&self) -> Self::Iter {
@@ -362,7 +365,7 @@ impl<'a> InputIter for &'a [u8] {
   }
 }
 
-impl<'a> InputTake for &'a [u8] {
+impl<'a, T> InputTake for &'a [T] {
   #[inline]
   fn take(&self, count: usize) -> Self {
     &self[0..count]
@@ -738,9 +741,12 @@ fn lowercase_byte(c: u8) -> u8 {
   }
 }
 
-impl<'a, 'b> Compare<&'b [u8]> for &'a [u8] {
+impl<'a, 'b, T> Compare<&'b [T]> for &'a [T]
+where
+  T: Eq,
+{
   #[inline(always)]
-  fn compare(&self, t: &'b [u8]) -> CompareResult {
+  fn compare(&self, t: &'b [T]) -> CompareResult {
     let pos = self.iter().zip(t.iter()).position(|(a, b)| a != b);
 
     match pos {
@@ -790,8 +796,8 @@ impl<'a, 'b> CompareIgnoreCase<&'b [u8]> for &'a [u8] {
 }
 
 impl<
-    T: InputLength + InputIter<Item = u8> + InputTake + UnspecializedInput,
-    O: InputLength + InputIter<Item = u8> + InputTake,
+    T: Eq + InputLength + InputIter<Item = T> + InputTake + UnspecializedInput,
+    O: InputLength + InputIter<Item = T> + InputTake,
   > Compare<O> for T
 {
   #[inline(always)]

tests/issues.rs

@@ -206,3 +206,40 @@ fn issue_1231_bits_expect_fn_closure() {
   }
   assert_eq!(example(&[0xff]), Ok((&b""[..], (1, 1))));
 }
+
+#[test]
+fn non_byte_slices_can_be_parsed() {
+  use nom::branch::alt;
+  use nom::bytes::complete::tag;
+  use nom::combinator::map;
+  use nom::sequence::tuple;
+
+  #[derive(Debug, PartialEq, Eq)]
+  enum Token {
+    Open, Close, Comma, Num(u8),
+  }
+
+  fn magnitude(input: &[Token]) -> IResult<&[Token], u8> {
+    // An element can be either a pair of elements, or a number literal.
+    alt((magnitude_of_pair, parse_number_from_token))(input)
+  }
+  fn magnitude_of_pair(input: &[Token]) -> IResult<&[Token], u8> {
+    let eat = |t| tag(std::slice::from_ref(t));
+    let parser = tuple((eat(&Token::Open), magnitude, eat(&Token::Comma), magnitude, eat(&Token::Close)));
+    let mut discard_delimiter_parser = map(parser, |(_, l, _, r, _)| 3 * l + 2 * r);
+    discard_delimiter_parser(input)
+  }
+  fn parse_number_from_token(input: &[Token]) -> IResult<&[Token], u8> {
+    use nom::Err;
+    match input.get(0) {
+        None => Err(Err::Incomplete(Needed::new(1))),
+        Some(Token::Num(n)) => Ok((&input[1..], *n)),
+        Some(_) => Err(Err::Error(nom::error::Error { input, code: nom::error::ErrorKind::Tag })),
+    }
+  }
+
+  let tokenstream = vec![Token::Open, Token::Num(4), Token::Comma, Token::Num(3), Token::Close];
+  let (remaining, magnitude) = magnitude_of_pair(&tokenstream).unwrap();
+  assert_eq!(remaining, &[]);
+  assert_eq!(magnitude, 18);
+}