Fixed the bounds on the StdError impl and Positioner trait

src/lib.rs

@@ -412,4 +412,26 @@ r"
         assert_eq!(parser.parse("Fig123"), Ok(("Fig", "123")));
         assert_eq!(parser.parse("GrapeApple"), Ok(("Grape", "Apple")));
     }
+
+    #[test]
+    fn std_error() {
+        use std::fmt;
+        use std::error::Error as StdError;
+        #[derive(Debug)]
+        struct Error;
+        impl fmt::Display for Error {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                write!(f, "error")
+            }
+        }
+        impl StdError for Error {
+            fn description(&self) -> &str { "error" }
+        }
+        let result: Result<((), _), _> = string("abc")
+            .and_then(|_| Err(Error))
+            .parse("abc");
+        assert!(result.is_err());
+        //Test that ParseError can be coerced to a StdError
+        let _ = result.map_err(|err| { let err: Box<StdError> = Box::new(err); err });
+    }
 }

src/primitives.rs

@@ -248,8 +248,8 @@ impl <P: Positioner> ParseError<P> {
 }
 
 impl <P> StdError for ParseError<P>
-    where P: fmt::Display + fmt::Debug + Positioner + Any
-        , P::Position: fmt::Display + fmt::Debug + Positioner + Any {
+    where P: Positioner + fmt::Display + fmt::Debug + Any
+        , P::Position: fmt::Display + fmt::Debug + Any {
     fn description(&self) -> &str { "parse error" }
 }
 
@@ -320,13 +320,21 @@ impl <T: fmt::Display> fmt::Display for Error<T> {
 }
 
 ///The `State<I>` struct keeps track of the current position in the stream `I`
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, PartialEq)]
 pub struct State<I>
     where I: Stream {
-    pub position: <<I as Stream>::Item as Positioner>::Position,
+    pub position: <I::Item as Positioner>::Position,
     pub input: I
 }
 
+impl <I> fmt::Debug for State<I>
+    where I: Stream + fmt::Debug
+        , <I::Item as Positioner>::Position: fmt::Debug {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "State {{ position: {:?}, input: {:?} }}", self.position, self.input)
+    }
+}
+
 impl <I: Stream> State<I> {
     pub fn new(input: I) -> State<I> {
         State { position: <I::Item as Positioner>::start(), input: input }
@@ -419,7 +427,7 @@ impl <I: Iterator + Clone> Stream for IteratorStream<I>
 ///When implementing stream for custom token type this must be implemented for that token to allow
 ///the position to be updated
 pub trait Positioner: Clone + PartialEq {
-    type Position: Clone + Ord + fmt::Debug;
+    type Position: Clone + Ord;
     ///Creates a start position
     fn start() -> Self::Position;
     ///Updates the position given that `self` has been taken from the stream