Review README and benchmarks

Author: d-plaindoux

Cargo.toml

@@ -13,3 +13,4 @@ members = [
 [profile.release]
 lto = "fat"
 codegen-units = 1
+debug = true

README.md

@@ -202,21 +202,29 @@ to Rust to manage the language in Rust.
 ## V0
 
 In V0, transpilation is a direct style generation of Parsec without any
-optimisations. To this end, the `AST` is translated directly into a parser
-parser using the `core` library.
+optimisations. To this end, the `AST` is translated directly into a parser 
+using the `core` library.
 cf. [celma parser in direct style](https://github.com/d-plaindoux/celma/blob/master/lang/v0/parser/src/parser.rs).
 
 ### Benchmarks
 
-Material: 
+- Material: MacBookPro Apple M2 Max 64G
+- [Samples](https://github.com/d-plaindoux/celma/blob/master/lang/v0/macro/benches/data/) used for the benchmarks.
 
-```sh
-test json_apache      ... bench:   1,652,349 ns/iter (+/- 119,721) = 75 MB/s
-test json_canada_nom  ... bench:     135,309 ns/iter (+/- 4,034) = 68 MB/s
-test json_canada_pest ... bench:  61,084,354 ns/iter (+/- 2,746,834) = 36 MB/s
-test json_data        ... bench:     133,788 ns/iter (+/- 10,607) = 69 MB/s
+#### HTTP Header
+
+```shell
+test http_data        ... bench:      11,845 ns/iter (+/- 382)       = 65 MB/s
 ```
 
+#### JSON
+
+```shell
+test json_apache      ... bench:   1,560,412 ns/iter (+/- 21,383)    = 87 MB/s
+test json_canada_nom  ... bench:     127,925 ns/iter (+/- 15,263)    = 82 MB/s
+test json_canada_pest ... bench:  57,397,799 ns/iter (+/- 3,442,455) = 43 MB/s
+test json_data        ... bench:     126,348 ns/iter (+/- 5,283)     = 81 MB/s
+```
 
 ## V1
 

lang/v0/macro/benches/http.rs

@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-use bencher::{Bencher, benchmark_group, benchmark_main, black_box};
+use bencher::{benchmark_group, benchmark_main, black_box, Bencher};
 use celma_v0_core::parser::and::AndOperation;
 use celma_v0_core::parser::char::{alpha, digit};
 use celma_v0_core::parser::core::eos;
 use celma_v0_core::parser::response::Response::{Reject, Success};
 use celma_v0_core::parser::specs::Parse;
-use celma_v0_core::stream::char_stream::CharStream;
+use celma_v0_core::stream::array_stream::ArrayStream;
 use celma_v0_core::stream::position::Position;
 use celma_v0_core::stream::specs::Stream;
 use celma_v0_macro::parsec_rules;
@@ -45,13 +45,14 @@ parsec_rules!(
 // -------------------------------------------------------------------------------------------------
 
 fn http_data(b: &mut Bencher) {
-    let data = include_str!("data/request.http");
+    let vec = include_str!("data/request.http").chars().collect::<Vec<char>>();
+    let data = vec.as_slice();
     b.bytes = data.len() as u64;
     parse(b, data)
 }
 
-fn parse(b: &mut Bencher, buffer: &str) {
-    let stream = CharStream::new_with_position(buffer, <usize>::new());
+fn parse(b: &mut Bencher, buffer: &[char]) {
+    let stream = ArrayStream::new_with_position(buffer, <usize>::new());
 
     b.iter(|| {
         let response = http_header()

lang/v0/macro/benches/json.rs

@@ -17,15 +17,15 @@
 #[macro_use]
 extern crate bencher;
 
-use bencher::{Bencher, black_box};
+use bencher::{black_box, Bencher};
 
 use celma_v0_core::parser::and::AndOperation;
 use celma_v0_core::parser::char::{digit, space};
 use celma_v0_core::parser::core::eos;
 use celma_v0_core::parser::literal::delimited_string;
 use celma_v0_core::parser::response::Response::{Reject, Success};
 use celma_v0_core::parser::specs::Parse;
-use celma_v0_core::stream::char_stream::CharStream;
+use celma_v0_core::stream::array_stream::ArrayStream;
 use celma_v0_core::stream::position::Position;
 use celma_v0_core::stream::specs::Stream;
 use celma_v0_macro::parsec_rules;
@@ -59,7 +59,7 @@ fn mk_f64(a: Vec<char>) -> f64 {
 }
 
 parsec_rules!(
-    let json:{JSON}          = S _=(array | object | string | null | boolean | number) S
+    let json:{JSON}          = S _=(string | number | boolean | null | array | object ) S
     let number:{JSON}        = f=NUMBER                                -> {JSON::Number(f)}
     let string:{JSON}        = s=STRING                                -> {JSON::String(s)}
     let null:{JSON}          = "null"                                  -> {JSON::Null}
@@ -82,46 +82,58 @@ parsec_rules!(
 // -------------------------------------------------------------------------------------------------
 
 fn json_data(b: &mut Bencher) {
-    let data = include_str!("data/data.json");
+    let vec = include_str!("data/data.json")
+        .chars()
+        .collect::<Vec<char>>();
+    let data = vec.as_slice();
     b.bytes = data.len() as u64;
     parse(b, data)
 }
 
 // -------------------------------------------------------------------------------------------------
 
 fn json_canada_pest(b: &mut Bencher) {
-    let data = include_str!("data/canada_pest.json");
+    let vec = include_str!("data/canada_pest.json")
+        .chars()
+        .collect::<Vec<char>>();
+    let data = vec.as_slice();
     b.bytes = data.len() as u64;
     parse(b, data)
 }
 
 // -------------------------------------------------------------------------------------------------
 
 fn json_canada_nom(b: &mut Bencher) {
-    let data = include_str!("data/canada_nom.json");
+    let vec = include_str!("data/canada_nom.json")
+        .chars()
+        .collect::<Vec<char>>();
+    let data = vec.as_slice();
     b.bytes = data.len() as u64;
     parse(b, data)
 }
 
 // -------------------------------------------------------------------------------------------------
 
 fn json_apache(b: &mut Bencher) {
-    let data = include_str!("data/apache_builds.json");
+    let vec = include_str!("data/apache_builds.json")
+        .chars()
+        .collect::<Vec<char>>();
+    let data = vec.as_slice();
     b.bytes = data.len() as u64;
     parse(b, data)
 }
 
 // -------------------------------------------------------------------------------------------------
 
-fn parse(b: &mut Bencher, buffer: &str) {
-    let stream = CharStream::new_with_position(buffer, <usize>::new());
+fn parse(b: &mut Bencher, buffer: &[char]) {
+    let stream = ArrayStream::new_with_position(buffer, <usize>::new());
 
     b.iter(|| {
         let response = json().and_left(eos()).parse(black_box(stream.clone()));
 
         match response {
             Success(_, _, _) => (),
-            Reject(s, _) => panic!("parse error at {:?}", s.position()),
+            Reject(s, _) => panic!("parse error for {:?} at {:?}", s.next().0, s.position()),
         }
     });
 }