Parse trait

[Luro02]

Right now this crate uses FromStr, but with #45 it might be better to use a custom trait, which has better support for parsing (the data will be consumed) and it would allow creating custom spans (without having to worry about indexing strings).

I think of something like this (inspired by syn):

pub trait Parse<'a> {
    type Error;

    fn parse(input: Cursor<'a>) -> Result<Self, Self::Error>;

    /// Returns how many chars will be consumed when parsing, if this is known.
    fn consumes() -> Option<usize> { None }
}

struct Cursor<'a> {
    buffer: &'a str,
    position: usize,
}

impl Cursor<'a> {
    pub fn take(&mut self, n: usize) -> Result<&str, Error> {
        self.position += n;
        self.peek(n)
    }

    pub fn peek(&self, n: usize) -> Result<&str, Error> {
        self.buffer.get(self.position..self.position+n).ok_or_else(|| Error::unexpected_eof(n))
    }

    pub fn tag<T: AsRef<str>>(&self, expected: T) -> Result<(), Error> {
        let tag = buffer.take()?;

        if expected.as_ref() == tag {
            Ok(())
        } else {
            Err(Error::mismatched_tag(expected.as_ref(), tag))
        }
    }
}

The nice thing is that with the above approach one could make the Cursor generic over different kind of inputs (not limited to &str):

use std::marker::PhantomData;

struct Cursor<'a, T = &'a str> {
    buffer: T,
    position: usize,
    _p: PhantomData<&'a T>,
}