impl Trait for Version 2.0.0 of Chomp

.travis.yml

@@ -2,11 +2,8 @@ language: rust
 sudo: false
 
 rust:
-  - stable
-  - beta
+  # We require nightly for conservative_impl_trait, unboxed_closures and fn_traits
   - nightly
-  # Minimum supported version (bitflags fails on 1.7 due to op_assign_traits not being stable):
-  - 1.8.0
 
 # necessary for `travis-cargo coveralls --no-sudo`
 addons:

Cargo.toml

@@ -22,11 +22,11 @@ include = [
 ]
 
 [dependencies]
-bitflags   = "0.7.0"
+bitflags   = "0.9.0"
 conv       = { version = "0.3.3", default-features = false, features = ["std"] }
-either     = { version = "0.1.7" }
+either     = { version = "1.1.0" }
 debugtrace = { version = "0.1.0" }
-tendril    = { version = "0.2.2", optional = true }
+tendril    = { version = "0.3.0", optional = true }
 
 # Technically a dev-dependency, but dev-dependencies are not allowed to be optional,
 # compiletest_rs fails to compile on stable and beta

README.md

@@ -15,7 +15,7 @@ Chomp is a fast monadic-style parser combinator library designed to work on stab
 
 For its current capabilities, you will find that Chomp performs consistently as well, if not better, than optimized C parsers, while being vastly more expressive. For an example that builds a performant HTTP parser out of smaller parsers, see [http_parser.rs](examples/http_parser.rs).
 
-##Installation
+## Installation
 
 Add the following line to the dependencies section of your `Cargo.toml`:
 
@@ -24,7 +24,7 @@ Add the following line to the dependencies section of your `Cargo.toml`:
 chomp = "0.3.1"
 ```
 
-##Usage
+## Usage
 
 Parsers are functions from a slice over an input type `Input<I>` to a `ParseResult<I, T, E>`, which may be thought of as either a success resulting in type `T`, an error of type `E`, or a partially completed result which may still consume more input of type `I`.
 
@@ -125,6 +125,6 @@ Unless you explicitly state otherwise, any contribution intentionally submitted
 the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any
 additional terms or conditions.
 
-##Contact
+## Contact
 
 File an issue [here](https://github.com/m4rw3r/chomp/issues/new) on Github or visit [gitter.im/m4rw3r/chomp](https://gitter.im/m4rw3r/chomp).

benches/combinators.rs

@@ -1,3 +1,4 @@
+#![feature(conservative_impl_trait)]
 #![feature(test)]
 extern crate test;
 #[macro_use]
@@ -14,115 +15,115 @@ use chomp::buffer::InputBuf;
 fn count_vec_1k(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(1024).collect::<Vec<u8>>();
 
-    fn count_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
-        count(i, 1024, any)
+    fn count_vec<I: Input>() -> impl Parser<I, Output=Vec<I::Token>, Error=Error<I::Token>> {
+        count(1024, any)
     }
 
     b.iter(|| {
-        parse_only(count_vec, &data)
+        count_vec().parse(&data[..])
     })
 }
 
 #[bench]
 fn count_vec_10k(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(10240).collect::<Vec<u8>>();
 
-    fn count_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
-        count(i, 10240, any)
+    fn count_vec<I: Input>() -> impl Parser<I, Output=Vec<I::Token>, Error=Error<I::Token>> {
+        count(10240, any)
     }
 
     b.iter(|| {
-        parse_only(count_vec, &data)
+        count_vec().parse(&data[..])
     })
 }
 
 #[bench]
 fn many_vec_1k(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(1024).collect::<Vec<u8>>();
 
-    fn many_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
-        many(i, any)
+    fn many_vec<I: Input>() -> impl Parser<I, Output=Vec<I::Token>, Error=Error<I::Token>> {
+        many(any)
     }
 
     b.iter(|| {
-        parse_only(many_vec, &data)
+        many_vec().parse(&data[..])
     })
 }
 
 #[bench]
 fn many_vec_10k(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(10024).collect::<Vec<u8>>();
 
-    fn many_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
-        many(i, any)
+    fn many_vec<I: Input>() -> impl Parser<I, Output=Vec<I::Token>, Error=Error<I::Token>> {
+        many(any)
     }
 
     b.iter(|| {
-        parse_only(many_vec, &data)
+        many_vec().parse(&data[..])
     })
 }
 
 #[bench]
 fn many1_vec_1k(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(1024).collect::<Vec<u8>>();
 
-    fn many1_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
-        many1(i, any)
+    fn many1_vec<I: Input>() -> impl Parser<I, Output=Vec<I::Token>, Error=Error<I::Token>> {
+        many1(any)
     }
 
     b.iter(|| {
-        parse_only(many1_vec, &data)
+        many1_vec().parse(&data[..])
     })
 }
 
 #[bench]
 fn many1_vec_10k(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(10024).collect::<Vec<u8>>();
 
-    fn many1_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
-        many1(i, any)
+    fn many1_vec<I: Input>() -> impl Parser<I, Output=Vec<I::Token>, Error=Error<I::Token>> {
+        many1(any)
     }
 
     b.iter(|| {
-        parse_only(many1_vec, &data)
+        many1_vec().parse(&data[..])
     })
 }
 
 #[bench]
 fn count_vec_10k_maybe_incomplete(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(10024).collect::<Vec<u8>>();
 
-    fn count_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
-        count(i, 10024, any)
+    fn count_vec<I: Input>() -> impl Parser<I, Output=Vec<I::Token>, Error=Error<I::Token>> {
+        count(10024, any)
     }
 
     b.iter(|| {
-        count_vec(InputBuf::new(&data))
+        count_vec().parse(InputBuf::new(&data))
     })
 }
 
 #[bench]
 fn many_vec_10k_maybe_incomplete(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(10024).collect::<Vec<u8>>();
 
-    fn many_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
-        many(i, any)
+    fn many_vec<I: Input>() -> impl Parser<I, Output=Vec<I::Token>, Error=Error<I::Token>> {
+        many(any)
     }
 
     b.iter(|| {
-        many_vec(InputBuf::new(&data))
+        many_vec().parse(InputBuf::new(&data))
     })
 }
 
 #[bench]
 fn many1_vec_10k_maybe_incomplete(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(10024).collect::<Vec<u8>>();
 
-    fn many1_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
-        many1(i, any)
+    fn many1_vec<I: Input>() -> impl Parser<I, Output=Vec<I::Token>, Error=Error<I::Token>> {
+        many1(any)
     }
 
     b.iter(|| {
-        many1_vec(InputBuf::new(&data))
+        many1_vec().parse(InputBuf::new(&data))
     })
 }

benches/http_bench.rs

@@ -1,4 +1,6 @@
 #![feature(test)]
+#![feature(trace_macros)]
+#![feature(conservative_impl_trait)]
 extern crate test;
 #[macro_use]
 extern crate chomp;
@@ -51,65 +53,66 @@ fn is_not_space(c: u8)        -> bool { c != b' ' }
 fn is_end_of_line(c: u8)      -> bool { c == b'\r' || c == b'\n' }
 fn is_http_version(c: u8)     -> bool { c >= b'0' && c <= b'9' || c == b'.' }
 
-fn end_of_line<I: U8Input>(i: I) -> SimpleResult<I, u8> {
-    parse!{i; (token(b'\r') <|> ret b'\0') >> token(b'\n')}
+fn end_of_line<I: Input<Token=u8>>() -> impl Parser<I, Output=u8, Error=Error<u8>> {
+    parse!{(token(b'\r') <|> ret(b'\0')) >> token(b'\n')}
 }
 
-fn http_version<I: U8Input>(i: I) -> SimpleResult<I, I::Buffer> {
-    parse!{i;
+fn http_version<I: Input<Token=u8>>() -> impl Parser<I, Output=I::Buffer, Error=Error<u8>> {
+    parse!{
         string(b"HTTP/");
         take_while1(is_http_version)
     }
 }
 
-fn request_line<I: U8Input>(i: I) -> SimpleResult<I, Request<I::Buffer>> {
-    parse!{i;
+fn request_line<I: Input<Token=u8>>() -> impl Parser<I, Output=Request<I::Buffer>, Error=Error<u8>> {
+    parse!{
         let method  = take_while1(is_token);
                       take_while1(is_space);
         let uri     = take_while1(is_not_space);
                       take_while1(is_space);
         let version = http_version();
 
-        ret Request {
+        ret(Request {
             method:  method,
             uri:     uri,
             version: version,
-        }
+        })
     }
 }
 
-fn message_header_line<I: U8Input>(i: I) -> SimpleResult<I, I::Buffer> {
-    parse!{i;
+fn message_header_line<I: Input<Token=u8>>() -> impl Parser<I, Output=I::Buffer, Error=Error<u8>> {
+    parse!{
                    take_while1(is_horizontal_space);
         let line = take_till(is_end_of_line);
                    end_of_line();
 
-        ret line
+        ret(line)
     }
 }
 
-fn message_header<I: U8Input>(i: I) -> SimpleResult<I, Header<I::Buffer>> {
-    parse!{i;
+fn message_header<I: Input<Token=u8>>() -> impl Parser<I, Output=Header<I::Buffer>, Error=Error<u8>> {
+    parse!{
         let name  = take_while1(is_token);
                     token(b':');
         let lines = many1(message_header_line);
 
-        ret Header {
+        ret(Header {
             name:  name,
             value: lines,
-        }
+        })
     }
 }
 
 #[inline(never)]
-fn request<I: U8Input>(i: I) -> SimpleResult<I, (Request<I::Buffer>, Vec<Header<I::Buffer>>)> {
-    parse!{i;
+fn request<I: Input<Token=u8>>() -> impl Parser<I, Output=(Request<I::Buffer>, Vec<Header<I::Buffer>>), Error=Error<u8>>
+  where I::Buffer: ::std::ops::Deref<Target=[u8]> {
+    parse!{
         let r = request_line();
                 end_of_line();
         let h = many(message_header);
                 end_of_line();
 
-        ret (r, h)
+        ret((r, h))
     }
 }
 
@@ -126,7 +129,7 @@ Connection: keep-alive\r
 \r";
 
     b.iter(|| {
-        parse_only(request, data)
+        request().parse(&data[..])
     })
 }
 
@@ -138,7 +141,7 @@ Host: localhost\r
 \r";
 
     b.iter(|| {
-        parse_only(request, data)
+        request().parse(&data[..])
     })
 }
 
@@ -157,7 +160,7 @@ Cookie: azk=ue1-5eb08aeed9a7401c9195cb933eb7c966\r
 \r";
 
     b.iter(|| {
-        parse_only(request, data)
+        request().parse(&data[..])
     })
 }
 
@@ -166,7 +169,7 @@ fn multiple_requests(b: &mut Bencher) {
     let data = include_bytes!("./data/http-requests.txt");
 
     b.iter(|| {
-        let r: Result<Vec<_>, _> = parse_only(parser!{many(request)}, data);
+        let (_, r): (_, Result<Vec<_>, _>) = many(request).parse(&data[..]);
 
         r
     })