Make parsing of strings optional

This fixes #5 as proposed in that issue. Specifically, it introduces a
trait, `FromByteResponse`, and provides a generic `parse_response`
function that parses input as raw byte strings, and then maps them using
some implementation of that trait. This in turns allows users to choose
how they want to parse byte sequences in an ergonomic way.

Under the hood, this is *slightly* less efficient that it could be.
Specifically, it parses everything as `&[u8]` first, and then maps
everything using calls to `FromByteResponse`. This works fine, but will
cause unnecessary re-allocation of vectors inside a bunch of structs.
The way to work around this is to have `nom` directly use a generic
return value in all its parsers, but this unfortunately doesn't seem to
be supported at the time of writing.

Author: jonhoo

Diff for: src/lib.rs

@@ -1,9 +1,27 @@
 #[macro_use]
 extern crate nom;
 
+pub trait FromByteResponse<'a> {
+    fn from_bytes(&'a [u8]) -> Self;
+}
+
+impl<'a> FromByteResponse<'a> for &'a str {
+    fn from_bytes(b: &'a [u8]) -> Self {
+        use std;
+        std::str::from_utf8(b).unwrap()
+    }
+}
+
+impl<'a> FromByteResponse<'a> for &'a [u8] {
+    fn from_bytes(b: &'a [u8]) -> Self {
+        b
+    }
+}
+
 pub mod builders;
 mod parser;
 pub mod types;
 
-pub use parser::{parse_response, ParseResult};
+pub use parser::ParseResult;
+pub use parser::{parse_response_raw, parse_response, parse_response_str};
 pub use types::*;