[INFO] fetching crate gramatica 0.2.1...
[INFO] checking gramatica-0.2.1 against master#30f74ff0dc4d66debc8b50724c446f817e5f75f4 for pr-121848-1
[INFO] extracting crate gramatica 0.2.1 into /workspace/builds/worker-7-tc1/source
[INFO] validating manifest of crates.io crate gramatica 0.2.1 on toolchain 30f74ff0dc4d66debc8b50724c446f817e5f75f4
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+30f74ff0dc4d66debc8b50724c446f817e5f75f4" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking crates.io crate gramatica 0.2.1
[INFO] finished tweaking crates.io crate gramatica 0.2.1
[INFO] tweaked toml for crates.io crate gramatica 0.2.1 written to /workspace/builds/worker-7-tc1/source/Cargo.toml
[INFO] crate crates.io crate gramatica 0.2.1 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+30f74ff0dc4d66debc8b50724c446f817e5f75f4" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+30f74ff0dc4d66debc8b50724c446f817e5f75f4" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] ec5390190b3aeb496b45c26124314359dbc95fc33e699f39246ec7950bb449fc
[INFO] running `Command { std: "docker" "start" "-a" "ec5390190b3aeb496b45c26124314359dbc95fc33e699f39246ec7950bb449fc", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "ec5390190b3aeb496b45c26124314359dbc95fc33e699f39246ec7950bb449fc", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "ec5390190b3aeb496b45c26124314359dbc95fc33e699f39246ec7950bb449fc", kill_on_drop: false }`
[INFO] [stdout] ec5390190b3aeb496b45c26124314359dbc95fc33e699f39246ec7950bb449fc
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+30f74ff0dc4d66debc8b50724c446f817e5f75f4" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] ed33532e2a89fe73e60ca257159b02cc48bf810849a5abf8b2b31d327e04f3ea
[INFO] running `Command { std: "docker" "start" "-a" "ed33532e2a89fe73e60ca257159b02cc48bf810849a5abf8b2b31d327e04f3ea", kill_on_drop: false }`
[INFO] [stderr]     Checking aho-corasick v1.0.2
[INFO] [stderr]     Checking regex-automata v0.3.3
[INFO] [stderr]     Checking regex v1.9.1
[INFO] [stderr]     Checking gramatica v0.2.1 (/opt/rustwide/workdir)
[INFO] [stdout] warning: unused import: `std::rc::Rc`
[INFO] [stdout]  --> examples/json.rs:4:5
[INFO] [stdout]   |
[INFO] [stdout] 4 | use std::rc::Rc;
[INFO] [stdout]   |     ^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `BufRead`
[INFO] [stdout]   --> examples/json.rs:16:15
[INFO] [stdout]    |
[INFO] [stdout] 16 | use std::io::{BufRead,Read};
[INFO] [stdout]    |               ^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `std::rc::Rc`
[INFO] [stdout]  --> examples/xml.rs:4:5
[INFO] [stdout]   |
[INFO] [stdout] 4 | use std::rc::Rc;
[INFO] [stdout]   |     ^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `BufRead`
[INFO] [stdout]   --> examples/xml.rs:18:15
[INFO] [stdout]    |
[INFO] [stdout] 18 | use std::io::{BufRead,Read};
[INFO] [stdout]    |               ^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: denote infinite loops with `loop { ... }`
[INFO] [stdout]   --> examples/json.rs:46:1
[INFO] [stdout]    |
[INFO] [stdout] 46 | while true {match characters.next() { None => break, Some('"') => {ret = (Some((size + 1,r + &"\"")));
[INFO] [stdout]    | ^^^^^^^^^^ help: use `loop`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(while_true)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around assigned value
[INFO] [stdout]   --> examples/json.rs:46:74
[INFO] [stdout]    |
[INFO] [stdout] 46 | while true {match characters.next() { None => break, Some('"') => {ret = (Some((size + 1,r + &"\"")));
[INFO] [stdout]    |                                                                          ^                          ^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_parens)]` on by default
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]    |
[INFO] [stdout] 46 - while true {match characters.next() { None => break, Some('"') => {ret = (Some((size + 1,r + &"\"")));
[INFO] [stdout] 46 + while true {match characters.next() { None => break, Some('"') => {ret = Some((size + 1,r + &"\""));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around assigned value
[INFO] [stdout]    --> examples/json.rs:112:104
[INFO] [stdout]     |
[INFO] [stdout] 112 | (&Token::Members(ref list),&Token::Comma,&Token::Pair(ref s,ref value)) => Token::Members({let mut new=(list.clone());
[INFO] [stdout]     |                                                                                                        ^            ^
[INFO] [stdout]     |
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]     |
[INFO] [stdout] 112 - (&Token::Members(ref list),&Token::Comma,&Token::Pair(ref s,ref value)) => Token::Members({let mut new=(list.clone());
[INFO] [stdout] 112 + (&Token::Members(ref list),&Token::Comma,&Token::Pair(ref s,ref value)) => Token::Members({let mut new=list.clone();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around assigned value
[INFO] [stdout]    --> examples/json.rs:128:101
[INFO] [stdout]     |
[INFO] [stdout] 128 | (&Token::Elements(ref list),&Token::Comma,&Token::Value(ref value)) => Token::Elements({let mut new=(list.clone());
[INFO] [stdout]     |                                                                                                     ^            ^
[INFO] [stdout]     |
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]     |
[INFO] [stdout] 128 - (&Token::Elements(ref list),&Token::Comma,&Token::Value(ref value)) => Token::Elements({let mut new=(list.clone());
[INFO] [stdout] 128 + (&Token::Elements(ref list),&Token::Comma,&Token::Value(ref value)) => Token::Elements({let mut new=list.clone();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: denote infinite loops with `loop { ... }`
[INFO] [stdout]   --> examples/xml.rs:44:1
[INFO] [stdout]    |
[INFO] [stdout] 44 | while true {match characters.next() { None => break, Some('"') => {ret = (Some((size + 1,r + &"\"")));
[INFO] [stdout]    | ^^^^^^^^^^ help: use `loop`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(while_true)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around assigned value
[INFO] [stdout]   --> examples/xml.rs:44:74
[INFO] [stdout]    |
[INFO] [stdout] 44 | while true {match characters.next() { None => break, Some('"') => {ret = (Some((size + 1,r + &"\"")));
[INFO] [stdout]    |                                                                          ^                          ^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_parens)]` on by default
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]    |
[INFO] [stdout] 44 - while true {match characters.next() { None => break, Some('"') => {ret = (Some((size + 1,r + &"\"")));
[INFO] [stdout] 44 + while true {match characters.next() { None => break, Some('"') => {ret = Some((size + 1,r + &"\""));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around assigned value
[INFO] [stdout]    --> examples/xml.rs:130:115
[INFO] [stdout]     |
[INFO] [stdout] 130 | (&Token::Attributes(ref attrs),&Token::Space(_),&Token::Attribute(ref a,ref b)) => Token::Attributes({let mut new=(attrs.clone());
[INFO] [stdout]     |                                                                                                                   ^             ^
[INFO] [stdout]     |
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]     |
[INFO] [stdout] 130 - (&Token::Attributes(ref attrs),&Token::Space(_),&Token::Attribute(ref a,ref b)) => Token::Attributes({let mut new=(attrs.clone());
[INFO] [stdout] 130 + (&Token::Attributes(ref attrs),&Token::Space(_),&Token::Attribute(ref a,ref b)) => Token::Attributes({let mut new=attrs.clone();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around assigned value
[INFO] [stdout]    --> examples/xml.rs:151:112
[INFO] [stdout]     |
[INFO] [stdout] 151 | (&Token::Contents(ref list),&Token::Element(ref elem),&Token::CharData(ref s)) => Token::Contents({let mut new=(list.clone());
[INFO] [stdout]     |                                                                                                                ^            ^
[INFO] [stdout]     |
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]     |
[INFO] [stdout] 151 - (&Token::Contents(ref list),&Token::Element(ref elem),&Token::CharData(ref s)) => Token::Contents({let mut new=(list.clone());
[INFO] [stdout] 151 + (&Token::Contents(ref list),&Token::Element(ref elem),&Token::CharData(ref s)) => Token::Contents({let mut new=list.clone();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0061]: this function takes 3 arguments but 2 arguments were supplied
[INFO] [stdout]    --> examples/calculator.rs:9:7
[INFO] [stdout]     |
[INFO] [stdout] 9   | match Parser::<Token,ParsingTables>::parse(&line,None) { Err(x) => println!("error parsing: {:?}" , x), Ok(x) => println!("parsed correct...
[INFO] [stdout]     |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------------ an argument of type `u8` is missing
[INFO] [stdout]     |
[INFO] [stdout] note: associated function defined here
[INFO] [stdout]    --> /opt/rustwide/workdir/src/lib.rs:777:9
[INFO] [stdout]     |
[INFO] [stdout] 777 |     pub fn parse(source:&str, initial:Option<usize>, verbosity:u8) -> Result<T,ParsingError>
[INFO] [stdout]     |            ^^^^^
[INFO] [stdout] help: provide the argument
[INFO] [stdout]     |
[INFO] [stdout] 9   | match Parser::<Token,ParsingTables>::parse(&line, None, /* u8 */) { Err(x) => println!("error parsing: {:?}" , x), Ok(x) => println!("parsed correctly: {:?}" , x), }
[INFO] [stdout]     |                                           ~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0061]: this function takes 3 arguments but 2 arguments were supplied
[INFO] [stdout]    --> examples/json.rs:21:7
[INFO] [stdout]     |
[INFO] [stdout] 21  | match Parser::<Token,ParsingTables>::parse(&buf,None) { Err(x) => println!("error parsing: {:?}" , x), Ok(x) => println!("parsed correctl...
[INFO] [stdout]     |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------- an argument of type `u8` is missing
[INFO] [stdout]     |
[INFO] [stdout] note: associated function defined here
[INFO] [stdout]    --> /opt/rustwide/workdir/src/lib.rs:777:9
[INFO] [stdout]     |
[INFO] [stdout] 777 |     pub fn parse(source:&str, initial:Option<usize>, verbosity:u8) -> Result<T,ParsingError>
[INFO] [stdout]     |            ^^^^^
[INFO] [stdout] help: provide the argument
[INFO] [stdout]     |
[INFO] [stdout] 21  | match Parser::<Token,ParsingTables>::parse(&buf, None, /* u8 */) { Err(x) => println!("error parsing: {:?}" , x), Ok(x) => println!("parsed correctly: {:?}" , x), }
[INFO] [stdout]     |                                           ~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0061]: this function takes 3 arguments but 2 arguments were supplied
[INFO] [stdout]    --> examples/xml.rs:23:7
[INFO] [stdout]     |
[INFO] [stdout] 23  | match Parser::<Token,ParsingTables>::parse(&buf,None) { Err(x) => println!("error parsing: {:?}" , x), Ok(x) => println!("parsed correctl...
[INFO] [stdout]     |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------- an argument of type `u8` is missing
[INFO] [stdout]     |
[INFO] [stdout] note: associated function defined here
[INFO] [stdout]    --> /opt/rustwide/workdir/src/lib.rs:777:9
[INFO] [stdout]     |
[INFO] [stdout] 777 |     pub fn parse(source:&str, initial:Option<usize>, verbosity:u8) -> Result<T,ParsingError>
[INFO] [stdout]     |            ^^^^^
[INFO] [stdout] help: provide the argument
[INFO] [stdout]     |
[INFO] [stdout] 23  | match Parser::<Token,ParsingTables>::parse(&buf, None, /* u8 */) { Err(x) => println!("error parsing: {:?}" , x), Ok(x) => println!("parsed correctly: {:?}" , x), }
[INFO] [stdout]     |                                           ~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:48:186
[INFO] [stdout]    |
[INFO] [stdout] 48 | ...Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 48 | parser.sets[index].predict(State{rule: 1 ,left: 10 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                          +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:49:191
[INFO] [stdout]    |
[INFO] [stdout] 49 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 49 | parser.sets[index].predict(State{rule: 2 ,left: 10 ,right:vec![ 10,11 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:185:32
[INFO] [stdout]     |
[INFO] [stdout] 185 | ...   parser.sets[index].predict(State{rule:1,left:10,right:vec![],position:0,original_set:index,kind:EarleyKind::Predict(state_index),va...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:52:187
[INFO] [stdout]    |
[INFO] [stdout] 52 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 52 | parser.sets[index].predict(State{rule: 3 ,left: 11 ,right:vec![ 9 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                           +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:186:32
[INFO] [stdout]     |
[INFO] [stdout] 186 | ...   parser.sets[index].predict(State{rule:2,left:10,right:vec![10,11],position:0,original_set:index,kind:EarleyKind::Predict(state_inde...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:53:190
[INFO] [stdout]    |
[INFO] [stdout] 53 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 53 | parser.sets[index].predict(State{rule: 4 ,left: 11 ,right:vec![ 12,9 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                              +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:190:32
[INFO] [stdout]     |
[INFO] [stdout] 190 | ...   parser.sets[index].predict(State{rule:3,left:11,right:vec![9],position:0,original_set:index,kind:EarleyKind::Predict(state_index),v...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:73:189
[INFO] [stdout]    |
[INFO] [stdout] 73 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 73 | parser.sets[index].predict(State{rule: 1 ,left: 12 ,right:vec![ 6,7 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                             +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:191:32
[INFO] [stdout]     |
[INFO] [stdout] 191 | ...   parser.sets[index].predict(State{rule:4,left:11,right:vec![12,9],position:0,original_set:index,kind:EarleyKind::Predict(state_index...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:56:187
[INFO] [stdout]    |
[INFO] [stdout] 56 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 56 | parser.sets[index].predict(State{rule: 5 ,left: 12 ,right:vec![ 1 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                           +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:74:192
[INFO] [stdout]    |
[INFO] [stdout] 74 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 74 | parser.sets[index].predict(State{rule: 2 ,left: 12 ,right:vec![ 6,13,7 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:57:193
[INFO] [stdout]    |
[INFO] [stdout] 57 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 57 | parser.sets[index].predict(State{rule: 6 ,left: 12 ,right:vec![ 12,2,12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:195:32
[INFO] [stdout]     |
[INFO] [stdout] 195 | ...   parser.sets[index].predict(State{rule:5,left:12,right:vec![1],position:0,original_set:index,kind:EarleyKind::Predict(state_index),v...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:196:32
[INFO] [stdout]     |
[INFO] [stdout] 196 | ...   parser.sets[index].predict(State{rule:6,left:12,right:vec![12,2,12],position:0,original_set:index,kind:EarleyKind::Predict(state_in...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:77:188
[INFO] [stdout]    |
[INFO] [stdout] 77 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 77 | parser.sets[index].predict(State{rule: 3 ,left: 13 ,right:vec![ 14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:58:193
[INFO] [stdout]    |
[INFO] [stdout] 58 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 58 | parser.sets[index].predict(State{rule: 7 ,left: 12 ,right:vec![ 12,3,12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:59:193
[INFO] [stdout]    |
[INFO] [stdout] 59 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 59 | parser.sets[index].predict(State{rule: 8 ,left: 12 ,right:vec![ 12,4,12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:197:32
[INFO] [stdout]     |
[INFO] [stdout] 197 | ...   parser.sets[index].predict(State{rule:7,left:12,right:vec![12,3,12],position:0,original_set:index,kind:EarleyKind::Predict(state_in...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:78:194
[INFO] [stdout]    |
[INFO] [stdout] 78 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 78 | parser.sets[index].predict(State{rule: 4 ,left: 13 ,right:vec![ 13,10,14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                  +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:60:193
[INFO] [stdout]    |
[INFO] [stdout] 60 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 60 | parser.sets[index].predict(State{rule: 9 ,left: 12 ,right:vec![ 12,5,12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:69:188
[INFO] [stdout]    |
[INFO] [stdout] 69 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 69 | parser.sets[index].predict(State{rule: 1 ,left: 10 ,right:vec![ 11 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:198:32
[INFO] [stdout]     |
[INFO] [stdout] 198 | ...   parser.sets[index].predict(State{rule:8,left:12,right:vec![12,4,12],position:0,original_set:index,kind:EarleyKind::Predict(state_in...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:61:191
[INFO] [stdout]    |
[INFO] [stdout] 61 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 61 | parser.sets[index].predict(State{rule: 10 ,left: 12 ,right:vec![ 3,12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:81:193
[INFO] [stdout]    |
[INFO] [stdout] 81 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 81 | parser.sets[index].predict(State{rule: 5 ,left: 14 ,right:vec![ 5,11,17 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:199:32
[INFO] [stdout]     |
[INFO] [stdout] 199 | ...   parser.sets[index].predict(State{rule:9,left:12,right:vec![12,5,12],position:0,original_set:index,kind:EarleyKind::Predict(state_in...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:72:188
[INFO] [stdout]    |
[INFO] [stdout] 72 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 72 | parser.sets[index].predict(State{rule: 2 ,left: 11 ,right:vec![ 12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:62:194
[INFO] [stdout]    |
[INFO] [stdout] 62 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 62 | parser.sets[index].predict(State{rule: 11 ,left: 12 ,right:vec![ 12,6,12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                  +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:84:189
[INFO] [stdout]    |
[INFO] [stdout] 84 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 84 | parser.sets[index].predict(State{rule: 6 ,left: 15 ,right:vec![ 8,9 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                             +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:73:194
[INFO] [stdout]    |
[INFO] [stdout] 73 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 73 | parser.sets[index].predict(State{rule: 3 ,left: 11 ,right:vec![ 15,17,16 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                  +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:200:32
[INFO] [stdout]     |
[INFO] [stdout] 200 | ...   parser.sets[index].predict(State{rule:10,left:12,right:vec![3,12],position:0,original_set:index,kind:EarleyKind::Predict(state_inde...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:201:32
[INFO] [stdout]     |
[INFO] [stdout] 201 | ...   parser.sets[index].predict(State{rule:11,left:12,right:vec![12,6,12],position:0,original_set:index,kind:EarleyKind::Predict(state_i...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:63:193
[INFO] [stdout]    |
[INFO] [stdout] 63 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 63 | parser.sets[index].predict(State{rule: 12 ,left: 12 ,right:vec![ 7,12,8 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:202:32
[INFO] [stdout]     |
[INFO] [stdout] 202 | ...   parser.sets[index].predict(State{rule:12,left:12,right:vec![7,12,8],position:0,original_set:index,kind:EarleyKind::Predict(state_in...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:85:192
[INFO] [stdout]    |
[INFO] [stdout] 85 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 85 | parser.sets[index].predict(State{rule: 7 ,left: 15 ,right:vec![ 8,16,9 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:76:197
[INFO] [stdout]    |
[INFO] [stdout] 76 | ...Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 76 | parser.sets[index].predict(State{rule: 4 ,left: 12 ,right:vec![ 7,2,13,19,4 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                     +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:66:92
[INFO] [stdout]    |
[INFO] [stdout] 66 | fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => state.values[0].clone(),
[INFO] [stdout]    |                                                                                            ^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 66 | fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => Some(state.values[0].clone()),
[INFO] [stdout]    |                                                                                            +++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:67:12
[INFO] [stdout]    |
[INFO] [stdout] 67 | 1 => { (); Token::Input },
[INFO] [stdout]    |            ^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 67 | 1 => { (); Some(Token::Input) },
[INFO] [stdout]    |            +++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:88:188
[INFO] [stdout]    |
[INFO] [stdout] 88 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 88 | parser.sets[index].predict(State{rule: 8 ,left: 16 ,right:vec![ 17 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:79:186
[INFO] [stdout]    |
[INFO] [stdout] 79 | ...Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 79 | parser.sets[index].predict(State{rule: 5 ,left: 13 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                          +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:80:193
[INFO] [stdout]    |
[INFO] [stdout] 80 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 80 | parser.sets[index].predict(State{rule: 6 ,left: 13 ,right:vec![ 13,1,14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:89:194
[INFO] [stdout]    |
[INFO] [stdout] 89 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 89 | parser.sets[index].predict(State{rule: 9 ,left: 16 ,right:vec![ 16,10,17 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                  +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:212:9
[INFO] [stdout]     |
[INFO] [stdout] 212 |             0 => state.values[0].clone(),
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 212 |             0 => Some(state.values[0].clone()),
[INFO] [stdout]     |                  +++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:69:39
[INFO] [stdout]    |
[INFO] [stdout] 69 | (&Token::Input,&Token::Line) => { (); Token::Input },
[INFO] [stdout]    |                                       ^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 69 | (&Token::Input,&Token::Line) => { (); Some(Token::Input) },
[INFO] [stdout]    |                                       +++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:92:188
[INFO] [stdout]    |
[INFO] [stdout] 92 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 92 | parser.sets[index].predict(State{rule: 10 ,left: 17 ,right:vec![ 5 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:83:191
[INFO] [stdout]    |
[INFO] [stdout] 83 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 83 | parser.sets[index].predict(State{rule: 7 ,left: 14 ,right:vec![ 2,6,3 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:93:188
[INFO] [stdout]    |
[INFO] [stdout] 93 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 93 | parser.sets[index].predict(State{rule: 11 ,left: 17 ,right:vec![ 4 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:86:197
[INFO] [stdout]    |
[INFO] [stdout] 86 | ...Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 86 | parser.sets[index].predict(State{rule: 8 ,left: 15 ,right:vec![ 7,2,13,19,8 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                     +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:94:189
[INFO] [stdout]    |
[INFO] [stdout] 94 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 94 | parser.sets[index].predict(State{rule: 12 ,left: 17 ,right:vec![ 12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                             +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:221:6
[INFO] [stdout]     |
[INFO] [stdout] 221 |                     Token::Line
[INFO] [stdout]     |                     ^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 221 |                     Some(Token::Line)
[INFO] [stdout]     |                     +++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:89:194
[INFO] [stdout]    |
[INFO] [stdout] 89 | ...Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 89 | parser.sets[index].predict(State{rule: 9 ,left: 16 ,right:vec![ 5,2,19,8 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                  +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:72:26
[INFO] [stdout]    |
[INFO] [stdout] 72 | &Token::NewLine => { (); Token::Line },
[INFO] [stdout]    |                          ^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 72 | &Token::NewLine => { (); Some(Token::Line) },
[INFO] [stdout]    |                          +++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:92:189
[INFO] [stdout]    |
[INFO] [stdout] 92 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 92 | parser.sets[index].predict(State{rule: 10 ,left: 17 ,right:vec![ 20 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                             +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:75:77
[INFO] [stdout]    |
[INFO] [stdout] 75 | (&Token::Expression(value),&Token::NewLine) => { {println!("{}" , value);}; Token::Line },
[INFO] [stdout]    |                                                                             ^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 75 | (&Token::Expression(value),&Token::NewLine) => { {println!("{}" , value);}; Some(Token::Line) },
[INFO] [stdout]    |                                                                             +++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:95:189
[INFO] [stdout]    |
[INFO] [stdout] 95 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 95 | parser.sets[index].predict(State{rule: 13 ,left: 17 ,right:vec![ 15 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                             +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:227:26
[INFO] [stdout]     |
[INFO] [stdout] 227 |                 Token::Num(value) => Token::Expression(value),
[INFO] [stdout]     |                                      ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 227 |                 Token::Num(value) => Some(Token::Expression(value)),
[INFO] [stdout]     |                                      +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:93:192
[INFO] [stdout]    |
[INFO] [stdout] 93 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 93 | parser.sets[index].predict(State{rule: 11 ,left: 17 ,right:vec![ 20,18 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:78:23
[INFO] [stdout]    |
[INFO] [stdout] 78 | &Token::Num(value) => Token::Expression(value),
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 78 | &Token::Num(value) => Some(Token::Expression(value)),
[INFO] [stdout]    |                       +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:96:188
[INFO] [stdout]    |
[INFO] [stdout] 96 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 96 | parser.sets[index].predict(State{rule: 14 ,left: 17 ,right:vec![ 1 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:240:30
[INFO] [stdout]     |
[INFO] [stdout] 240 |                     Token::Expression(r) => Token::Expression(l+r),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 240 |                     Token::Expression(r) => Some(Token::Expression(l+r)),
[INFO] [stdout]     |                                             +++++                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:96:187
[INFO] [stdout]    |
[INFO] [stdout] 96 | ...Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 96 | parser.sets[index].predict(State{rule: 12 ,left: 18 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                           +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:249:30
[INFO] [stdout]     |
[INFO] [stdout] 249 |                     Token::Expression(r) => Token::Expression(l-r),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 249 |                     Token::Expression(r) => Some(Token::Expression(l-r)),
[INFO] [stdout]     |                                             +++++                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:81:63
[INFO] [stdout]    |
[INFO] [stdout] 81 | (&Token::Expression(l),&Token::Plus,&Token::Expression(r)) => Token::Expression(l + r),
[INFO] [stdout]    |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 81 | (&Token::Expression(l),&Token::Plus,&Token::Expression(r)) => Some(Token::Expression(l + r)),
[INFO] [stdout]    |                                                               +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:97:188
[INFO] [stdout]    |
[INFO] [stdout] 97 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 97 | parser.sets[index].predict(State{rule: 15 ,left: 17 ,right:vec![ 2 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:258:30
[INFO] [stdout]     |
[INFO] [stdout] 258 |                     Token::Expression(r) => Token::Expression(l*r),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 258 |                     Token::Expression(r) => Some(Token::Expression(l*r)),
[INFO] [stdout]     |                                             +++++                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:84:64
[INFO] [stdout]    |
[INFO] [stdout] 84 | (&Token::Expression(l),&Token::Minus,&Token::Expression(r)) => Token::Expression(l - r),
[INFO] [stdout]    |                                                                ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 84 | (&Token::Expression(l),&Token::Minus,&Token::Expression(r)) => Some(Token::Expression(l - r)),
[INFO] [stdout]    |                                                                +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:97:195
[INFO] [stdout]    |
[INFO] [stdout] 97 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 97 | parser.sets[index].predict(State{rule: 13 ,left: 18 ,right:vec![ 18,11,20 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                   +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:98:188
[INFO] [stdout]    |
[INFO] [stdout] 98 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 98 | parser.sets[index].predict(State{rule: 16 ,left: 17 ,right:vec![ 3 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:100:187
[INFO] [stdout]     |
[INFO] [stdout] 100 | ...Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 100 | parser.sets[index].predict(State{rule: 14 ,left: 19 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                           +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:267:30
[INFO] [stdout]     |
[INFO] [stdout] 267 |                     Token::Expression(r) => Token::Expression(l/r),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 267 |                     Token::Expression(r) => Some(Token::Expression(l/r)),
[INFO] [stdout]     |                                             +++++                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:87:63
[INFO] [stdout]    |
[INFO] [stdout] 87 | (&Token::Expression(l),&Token::Star,&Token::Expression(r)) => Token::Expression(l * r),
[INFO] [stdout]    |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 87 | (&Token::Expression(l),&Token::Star,&Token::Expression(r)) => Some(Token::Expression(l * r)),
[INFO] [stdout]    |                                                               +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:101:92
[INFO] [stdout]     |
[INFO] [stdout] 101 | fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => state.values[0].clone(),
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 101 | fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => Some(state.values[0].clone()),
[INFO] [stdout]     |                                                                                            +++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:274:33
[INFO] [stdout]     |
[INFO] [stdout] 274 |                 Token::Expression(value) => Token::Expression(-value),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 274 |                 Token::Expression(value) => Some(Token::Expression(-value)),
[INFO] [stdout]     |                                             +++++                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:90:64
[INFO] [stdout]    |
[INFO] [stdout] 90 | (&Token::Expression(l),&Token::Slash,&Token::Expression(r)) => Token::Expression(l / r),
[INFO] [stdout]    |                                                                ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 90 | (&Token::Expression(l),&Token::Slash,&Token::Expression(r)) => Some(Token::Expression(l / r)),
[INFO] [stdout]    |                                                                +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:103:36
[INFO] [stdout]     |
[INFO] [stdout] 103 | (&Token::LBrace,&Token::RBrace) => Token::Object(JsonValue::Object(vec![])),
[INFO] [stdout]     |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 103 | (&Token::LBrace,&Token::RBrace) => Some(Token::Object(JsonValue::Object(vec![]))),
[INFO] [stdout]     |                                    +++++                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:101:188
[INFO] [stdout]     |
[INFO] [stdout] 101 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 101 | parser.sets[index].predict(State{rule: 15 ,left: 19 ,right:vec![ 1 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:281:30
[INFO] [stdout]     |
[INFO] [stdout] 281 |                     Token::Expression(r) => Token::Expression(l.powf(r)),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 281 |                     Token::Expression(r) => Some(Token::Expression(l.powf(r))),
[INFO] [stdout]     |                                             +++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:93:46
[INFO] [stdout]    |
[INFO] [stdout] 93 | (&Token::Minus,&Token::Expression(value)) => Token::Expression(- value),
[INFO] [stdout]    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 93 | (&Token::Minus,&Token::Expression(value)) => Some(Token::Expression(- value)),
[INFO] [stdout]    |                                              +++++                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:106:62
[INFO] [stdout]     |
[INFO] [stdout] 106 | (&Token::LBrace,&Token::Members(ref list),&Token::RBrace) => Token::Object(JsonValue::Object(list.clone())),
[INFO] [stdout]     |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 106 | (&Token::LBrace,&Token::Members(ref list),&Token::RBrace) => Some(Token::Object(JsonValue::Object(list.clone()))),
[INFO] [stdout]     |                                                              +++++                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:288:33
[INFO] [stdout]     |
[INFO] [stdout] 288 |                 Token::Expression(value) => Token::Expression(value),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 288 |                 Token::Expression(value) => Some(Token::Expression(value)),
[INFO] [stdout]     |                                             +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:104:187
[INFO] [stdout]     |
[INFO] [stdout] 104 | ...Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 104 | parser.sets[index].predict(State{rule: 16 ,left: 20 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                           +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:96:64
[INFO] [stdout]    |
[INFO] [stdout] 96 | (&Token::Expression(l),&Token::Caret,&Token::Expression(r)) => Token::Expression(l.powf(r)),
[INFO] [stdout]    |                                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 96 | (&Token::Expression(l),&Token::Caret,&Token::Expression(r)) => Some(Token::Expression(l.powf(r))),
[INFO] [stdout]    |                                                                +++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:109:34
[INFO] [stdout]     |
[INFO] [stdout] 109 | &Token::Pair(ref s,ref value) => Token::Members(vec![(s . clone () , value . clone ())]),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 109 | &Token::Pair(ref s,ref value) => Some(Token::Members(vec![(s . clone () , value . clone ())])),
[INFO] [stdout]     |                                  +++++                                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:105:191
[INFO] [stdout]     |
[INFO] [stdout] 105 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 105 | parser.sets[index].predict(State{rule: 17 ,left: 20 ,right:vec![ 20,1 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:99:58
[INFO] [stdout]    |
[INFO] [stdout] 99 | (&Token::LPar,&Token::Expression(value),&Token::RPar) => Token::Expression(value),
[INFO] [stdout]    |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 99 | (&Token::LPar,&Token::Expression(value),&Token::RPar) => Some(Token::Expression(value)),
[INFO] [stdout]    |                                                          +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0061]: this function takes 3 arguments but 2 arguments were supplied
[INFO] [stdout]    --> examples/calculator_by_hand.rs:416:9
[INFO] [stdout]     |
[INFO] [stdout] 416 |         match Parser::<Token,ParsingTables>::parse(&line,None)
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------------ an argument of type `u8` is missing
[INFO] [stdout]     |
[INFO] [stdout] note: associated function defined here
[INFO] [stdout]    --> /opt/rustwide/workdir/src/lib.rs:777:9
[INFO] [stdout]     |
[INFO] [stdout] 777 |     pub fn parse(source:&str, initial:Option<usize>, verbosity:u8) -> Result<T,ParsingError>
[INFO] [stdout]     |            ^^^^^
[INFO] [stdout] help: provide the argument
[INFO] [stdout]     |
[INFO] [stdout] 416 |         match Parser::<Token,ParsingTables>::parse(&line, None, /* u8 */)
[INFO] [stdout]     |                                                   ~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:112:76
[INFO] [stdout]     |
[INFO] [stdout] 112 |   (&Token::Members(ref list),&Token::Comma,&Token::Pair(ref s,ref value)) => Token::Members({let mut new=(list.clone());
[INFO] [stdout]     |  ____________________________________________________________________________^
[INFO] [stdout] 113 | | new.push((s.clone(),value.clone())); new}),
[INFO] [stdout]     | |__________________________________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 112 ~ (&Token::Members(ref list),&Token::Comma,&Token::Pair(ref s,ref value)) => Some(Token::Members({let mut new=(list.clone());
[INFO] [stdout] 113 ~ new.push((s.clone(),value.clone())); new})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:106:191
[INFO] [stdout]     |
[INFO] [stdout] 106 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 106 | parser.sets[index].predict(State{rule: 18 ,left: 20 ,right:vec![ 20,2 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:116:108
[INFO] [stdout]     |
[INFO] [stdout] 116 | (&Token::LitStr(ref s),&Token::Colon,&Token::Value(ref value)) => { let (x0,x1)=(s.clone(),value.clone()); Token::Pair(x0,x1) },
[INFO] [stdout]     |                                                                                                            ^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 116 | (&Token::LitStr(ref s),&Token::Colon,&Token::Value(ref value)) => { let (x0,x1)=(s.clone(),value.clone()); Some(Token::Pair(x0,x1)) },
[INFO] [stdout]     |                                                                                                            +++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:107:191
[INFO] [stdout]     |
[INFO] [stdout] 107 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 107 | parser.sets[index].predict(State{rule: 19 ,left: 20 ,right:vec![ 20,6 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:119:40
[INFO] [stdout]     |
[INFO] [stdout] 119 | (&Token::LBracket,&Token::RBracket) => Token::Array(vec![]),
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 119 | (&Token::LBracket,&Token::RBracket) => Some(Token::Array(vec![])),
[INFO] [stdout]     |                                        +++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:108:191
[INFO] [stdout]     |
[INFO] [stdout] 108 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 108 | parser.sets[index].predict(State{rule: 20 ,left: 20 ,right:vec![ 20,9 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:122:67
[INFO] [stdout]     |
[INFO] [stdout] 122 | (&Token::LBracket,&Token::Elements(ref list),&Token::RBracket) => Token::Array(list.clone()),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 122 | (&Token::LBracket,&Token::Elements(ref list),&Token::RBracket) => Some(Token::Array(list.clone())),
[INFO] [stdout]     |                                                                   +++++                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:125:29
[INFO] [stdout]     |
[INFO] [stdout] 125 | &Token::Value(ref value) => Token::Elements(vec![value . clone ()]),
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 125 | &Token::Value(ref value) => Some(Token::Elements(vec![value . clone ()])),
[INFO] [stdout]     |                             +++++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:111:92
[INFO] [stdout]     |
[INFO] [stdout] 111 | fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => state.values[0].clone(),
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 111 | fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => Some(state.values[0].clone()),
[INFO] [stdout]     |                                                                                            +++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:185:163
[INFO] [stdout]     |
[INFO] [stdout] 185 | ...e_index),values:vec![],computed_value:Token::DummyStart});//Input -> ()
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 185 |                 parser.sets[index].predict(State{rule:1,left:10,right:vec![],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![],computed_value:Some(Token::DummyStart)});//Input -> ()
[INFO] [stdout]     |                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:186:187
[INFO] [stdout]     |
[INFO] [stdout] 186 | ...![Token::DummyStart;2],computed_value:Token::DummyStart});//Input -> Input,Line
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 186 |                 parser.sets[index].predict(State{rule:2,left:10,right:vec![10,11],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;2],computed_value:Some(Token::DummyStart)});//Input -> Input,Line
[INFO] [stdout]     |                                                                                                                                                                                                       +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:190:183
[INFO] [stdout]     |
[INFO] [stdout] 190 | ...![Token::DummyStart;1],computed_value:Token::DummyStart});//Line -> NewLine
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 190 |                 parser.sets[index].predict(State{rule:3,left:11,right:vec![9],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;1],computed_value:Some(Token::DummyStart)});//Line -> NewLine
[INFO] [stdout]     |                                                                                                                                                                                                   +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 26 previous errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0061, E0308.
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:191:186
[INFO] [stdout]     |
[INFO] [stdout] 191 | ...![Token::DummyStart;2],computed_value:Token::DummyStart});//Line -> Expression,NewLine
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 191 |                 parser.sets[index].predict(State{rule:4,left:11,right:vec![12,9],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;2],computed_value:Some(Token::DummyStart)});//Line -> Expression,NewLine
[INFO] [stdout]     |                                                                                                                                                                                                      +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0061`.
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:113:30
[INFO] [stdout]     |
[INFO] [stdout] 113 | &Token::Element(ref elem) => Token::Document(elem.clone()),
[INFO] [stdout]     |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 113 | &Token::Element(ref elem) => Some(Token::Document(elem.clone())),
[INFO] [stdout]     |                              +++++                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:195:183
[INFO] [stdout]     |
[INFO] [stdout] 195 | ...![Token::DummyStart;1],computed_value:Token::DummyStart});//Expression -> Num
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 195 |                 parser.sets[index].predict(State{rule:5,left:12,right:vec![1],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;1],computed_value:Some(Token::DummyStart)});//Expression -> Num
[INFO] [stdout]     |                                                                                                                                                                                                   +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:196:189
[INFO] [stdout]     |
[INFO] [stdout] 196 | ...![Token::DummyStart;3],computed_value:Token::DummyStart});//Expression -> Expression Plus Expression
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 196 |                 parser.sets[index].predict(State{rule:6,left:12,right:vec![12,2,12],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;3],computed_value:Some(Token::DummyStart)});//Expression -> Expression Plus Expression
[INFO] [stdout]     |                                                                                                                                                                                                         +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:197:189
[INFO] [stdout]     |
[INFO] [stdout] 197 | ...![Token::DummyStart;3],computed_value:Token::DummyStart});//Expression -> Expression Minus Expression
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 197 |                 parser.sets[index].predict(State{rule:7,left:12,right:vec![12,3,12],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;3],computed_value:Some(Token::DummyStart)});//Expression -> Expression Minus Expression
[INFO] [stdout]     |                                                                                                                                                                                                         +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:128:72
[INFO] [stdout]     |
[INFO] [stdout] 128 |   (&Token::Elements(ref list),&Token::Comma,&Token::Value(ref value)) => Token::Elements({let mut new=(list.clone());
[INFO] [stdout]     |  ________________________________________________________________________^
[INFO] [stdout] 129 | | new.push(value.clone()); new}),
[INFO] [stdout]     | |______________________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 128 ~ (&Token::Elements(ref list),&Token::Comma,&Token::Value(ref value)) => Some(Token::Elements({let mut new=(list.clone());
[INFO] [stdout] 129 ~ new.push(value.clone()); new})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:198:189
[INFO] [stdout]     |
[INFO] [stdout] 198 | ...![Token::DummyStart;3],computed_value:Token::DummyStart});//Expression -> Expression Star Expression
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 198 |                 parser.sets[index].predict(State{rule:8,left:12,right:vec![12,4,12],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;3],computed_value:Some(Token::DummyStart)});//Expression -> Expression Star Expression
[INFO] [stdout]     |                                                                                                                                                                                                         +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:199:189
[INFO] [stdout]     |
[INFO] [stdout] 199 | ...![Token::DummyStart;3],computed_value:Token::DummyStart});//Expression -> Expression Slash Expression
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 199 |                 parser.sets[index].predict(State{rule:9,left:12,right:vec![12,5,12],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;3],computed_value:Some(Token::DummyStart)});//Expression -> Expression Slash Expression
[INFO] [stdout]     |                                                                                                                                                                                                         +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:200:187
[INFO] [stdout]     |
[INFO] [stdout] 200 | ...![Token::DummyStart;2],computed_value:Token::DummyStart});//Expression -> Minus Expression
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 200 |                 parser.sets[index].predict(State{rule:10,left:12,right:vec![3,12],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;2],computed_value:Some(Token::DummyStart)});//Expression -> Minus Expression
[INFO] [stdout]     |                                                                                                                                                                                                       +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:116:45
[INFO] [stdout]     |
[INFO] [stdout] 116 |   &Token::EmptyElemTag(ref name,ref attrs) => Token::Element(XMLElement{name:name.clone(),
[INFO] [stdout]     |  _____________________________________________^
[INFO] [stdout] 117 | | attrs:attrs.clone(),
[INFO] [stdout] 118 | | contents:vec![],}),
[INFO] [stdout]     | |__________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 116 ~ &Token::EmptyElemTag(ref name,ref attrs) => Some(Token::Element(XMLElement{name:name.clone(),
[INFO] [stdout] 117 | attrs:attrs.clone(),
[INFO] [stdout] 118 ~ contents:vec![],})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:201:190
[INFO] [stdout]     |
[INFO] [stdout] 201 | ...![Token::DummyStart;3],computed_value:Token::DummyStart});//Expression -> Expression Caret Expression
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 201 |                 parser.sets[index].predict(State{rule:11,left:12,right:vec![12,6,12],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;3],computed_value:Some(Token::DummyStart)});//Expression -> Expression Caret Expression
[INFO] [stdout]     |                                                                                                                                                                                                          +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:202:189
[INFO] [stdout]     |
[INFO] [stdout] 202 | ...![Token::DummyStart;3],computed_value:Token::DummyStart});//Expression -> LPar Expression RPar
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 202 |                 parser.sets[index].predict(State{rule:12,left:12,right:vec![7,12,8],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;3],computed_value:Some(Token::DummyStart)});//Expression -> LPar Expression RPar
[INFO] [stdout]     |                                                                                                                                                                                                         +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 35 previous errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0061, E0063, E0308.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0061`.
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:132:26
[INFO] [stdout]     |
[INFO] [stdout] 132 | &Token::LitStr(ref s) => Token::Value(JsonValue::Literal(s.clone())),
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 132 | &Token::LitStr(ref s) => Some(Token::Value(JsonValue::Literal(s.clone()))),
[INFO] [stdout]     |                          +++++                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:121:84
[INFO] [stdout]     |
[INFO] [stdout] 121 |   (&Token::STag(ref name,ref attrs),&Token::Content(ref content),&Token::ETag(_)) => Token::Element(XMLElement{name:name.clone(),
[INFO] [stdout]     |  ____________________________________________________________________________________^
[INFO] [stdout] 122 | | attrs:attrs.clone(),
[INFO] [stdout] 123 | | contents:content.clone(),}),
[INFO] [stdout]     | |___________________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 121 ~ (&Token::STag(ref name,ref attrs),&Token::Content(ref content),&Token::ETag(_)) => Some(Token::Element(XMLElement{name:name.clone(),
[INFO] [stdout] 122 | attrs:attrs.clone(),
[INFO] [stdout] 123 ~ contents:content.clone(),})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:135:22
[INFO] [stdout]     |
[INFO] [stdout] 135 | &Token::Number(v) => Token::Value(JsonValue::Number(v)),
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 135 | &Token::Number(v) => Some(Token::Value(JsonValue::Number(v))),
[INFO] [stdout]     |                      +++++                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:126:153
[INFO] [stdout]     |
[INFO] [stdout] 126 | ...x1)=(name.clone(),attrs.clone()); Token::EmptyElemTag(x0,x1) },
[INFO] [stdout]     |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 126 | (&Token::LT,&Token::Ident(ref name),&Token::Attributes(ref attrs),&Token::MaybeSpace,&Token::CloseEmpty) => { let (x0,x1)=(name.clone(),attrs.clone()); Some(Token::EmptyElemTag(x0,x1)) },
[INFO] [stdout]     |                                                                                                                                                         +++++                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:138:30
[INFO] [stdout]     |
[INFO] [stdout] 138 | &Token::Object(ref value) => Token::Value(value.clone()),
[INFO] [stdout]     |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 138 | &Token::Object(ref value) => Some(Token::Value(value.clone())),
[INFO] [stdout]     |                              +++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:130:84
[INFO] [stdout]     |
[INFO] [stdout] 130 |   (&Token::Attributes(ref attrs),&Token::Space(_),&Token::Attribute(ref a,ref b)) => Token::Attributes({let mut new=(attrs.clone());
[INFO] [stdout]     |  ____________________________________________________________________________________^
[INFO] [stdout] 131 | | new.push((a.clone(),b.clone())); new}),
[INFO] [stdout]     | |______________________________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 130 ~ (&Token::Attributes(ref attrs),&Token::Space(_),&Token::Attribute(ref a,ref b)) => Some(Token::Attributes({let mut new=(attrs.clone());
[INFO] [stdout] 131 ~ new.push((a.clone(),b.clone())); new})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:141:28
[INFO] [stdout]     |
[INFO] [stdout] 141 | &Token::Array(ref list) => Token::Value(JsonValue::Array(list.clone())),
[INFO] [stdout]     |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 141 | &Token::Array(ref list) => Some(Token::Value(JsonValue::Array(list.clone()))),
[INFO] [stdout]     |                            +++++                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:134:100
[INFO] [stdout]     |
[INFO] [stdout] 134 | (&Token::Ident(ref a),&Token::Equal,&Token::LitStr(ref b)) => { let (x0,x1)=(a.clone(),b.clone()); Token::Attribute(x0,x1) },
[INFO] [stdout]     |                                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 134 | (&Token::Ident(ref a),&Token::Equal,&Token::LitStr(ref b)) => { let (x0,x1)=(a.clone(),b.clone()); Some(Token::Attribute(x0,x1)) },
[INFO] [stdout]     |                                                                                                    +++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:137:145
[INFO] [stdout]     |
[INFO] [stdout] 137 | ...(x0,x1)=(name.clone(),attrs.clone()); Token::STag(x0,x1) },
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 137 | (&Token::LT,&Token::Ident(ref name),&Token::Attributes(ref attrs),&Token::MaybeSpace,&Token::GT) => { let (x0,x1)=(name.clone(),attrs.clone()); Some(Token::STag(x0,x1)) },
[INFO] [stdout]     |                                                                                                                                                 +++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `gramatica` (example "calculator") due to 27 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stderr] error: could not compile `gramatica` (example "calculator_by_hand") due to 36 previous errors
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:140:76
[INFO] [stdout]     |
[INFO] [stdout] 140 | (&Token::BeginClose,&Token::Ident(ref s),&Token::MaybeSpace,&Token::GT) => Token::ETag(s.clone()),
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 140 | (&Token::BeginClose,&Token::Ident(ref s),&Token::MaybeSpace,&Token::GT) => Some(Token::ETag(s.clone())),
[INFO] [stdout]     |                                                                            +++++                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:143:28
[INFO] [stdout]     |
[INFO] [stdout] 143 | &Token::CharData(ref s) => Token::Content(vec![XMLContent :: Data (s . clone ())]),
[INFO] [stdout]     |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 143 | &Token::CharData(ref s) => Some(Token::Content(vec![XMLContent :: Data (s . clone ())])),
[INFO] [stdout]     |                            +++++                                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:144:17
[INFO] [stdout]     |
[INFO] [stdout] 144 | &Token::True => Token::Value(JsonValue::True),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 144 | &Token::True => Some(Token::Value(JsonValue::True)),
[INFO] [stdout]     |                 +++++                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:146:57
[INFO] [stdout]     |
[INFO] [stdout] 146 |   (&Token::CharData(ref s),&Token::Contents(ref list)) => Token::Content({let mut new=vec![XMLContent :: Data (s . clone ())];
[INFO] [stdout]     |  _________________________________________________________^
[INFO] [stdout] 147 | | new.extend(list.iter().map(|x|x.clone())); new}),
[INFO] [stdout]     | |________________________________________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 146 ~ (&Token::CharData(ref s),&Token::Contents(ref list)) => Some(Token::Content({let mut new=vec![XMLContent :: Data (s . clone ())];
[INFO] [stdout] 147 ~ new.extend(list.iter().map(|x|x.clone())); new})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:147:18
[INFO] [stdout]     |
[INFO] [stdout] 147 | &Token::False => Token::Value(JsonValue::False),
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 147 | &Token::False => Some(Token::Value(JsonValue::False)),
[INFO] [stdout]     |                  +++++                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:150:17
[INFO] [stdout]     |
[INFO] [stdout] 150 | &Token::Null => Token::Value(JsonValue::Null),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 150 | &Token::Null => Some(Token::Value(JsonValue::Null)),
[INFO] [stdout]     |                 +++++                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:151:83
[INFO] [stdout]     |
[INFO] [stdout] 151 |   (&Token::Contents(ref list),&Token::Element(ref elem),&Token::CharData(ref s)) => Token::Contents({let mut new=(list.clone());
[INFO] [stdout]     |  ___________________________________________________________________________________^
[INFO] [stdout] 152 | | new.push(XMLContent::Element(elem.clone()));
[INFO] [stdout] 153 | | if s != "" {new.push(XMLContent::Data(s.clone()));} new}),
[INFO] [stdout]     | |_________________________________________________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 151 ~ (&Token::Contents(ref list),&Token::Element(ref elem),&Token::CharData(ref s)) => Some(Token::Contents({let mut new=(list.clone());
[INFO] [stdout] 152 | new.push(XMLContent::Element(elem.clone()));
[INFO] [stdout] 153 ~ if s != "" {new.push(XMLContent::Data(s.clone()));} new})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:155:13
[INFO] [stdout]     |
[INFO] [stdout] 155 | 14 => { (); Token::MaybeSpace },
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 155 | 14 => { (); Some(Token::MaybeSpace) },
[INFO] [stdout]     |             +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:157:27
[INFO] [stdout]     |
[INFO] [stdout] 157 | &Token::Space(_) => { (); Token::MaybeSpace },
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 157 | &Token::Space(_) => { (); Some(Token::MaybeSpace) },
[INFO] [stdout]     |                           +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:161:51
[INFO] [stdout]     |
[INFO] [stdout] 161 | (&Token::CharData(ref s),&Token::Space(ref o)) => Token::CharData(format!("{}{}" , s , o)),
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 161 | (&Token::CharData(ref s),&Token::Space(ref o)) => Some(Token::CharData(format!("{}{}" , s , o))),
[INFO] [stdout]     |                                                   +++++                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `parser`
[INFO] [stdout]   --> examples/json.rs:41:13
[INFO] [stdout]    |
[INFO] [stdout] 41 | { fn _match(parser:&mut Parser<Token,ParsingTables>,source:& str)->Option<(usize,String)>{
[INFO] [stdout]    |             ^^^^^^ help: if this is intentional, prefix it with an underscore: `_parser`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_variables)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:164:51
[INFO] [stdout]     |
[INFO] [stdout] 164 | (&Token::CharData(ref s),&Token::Ident(ref o)) => Token::CharData(format!("{}{}" , s , o)),
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 164 | (&Token::CharData(ref s),&Token::Ident(ref o)) => Some(Token::CharData(format!("{}{}" , s , o))),
[INFO] [stdout]     |                                                   +++++                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:167:44
[INFO] [stdout]     |
[INFO] [stdout] 167 | (&Token::CharData(ref s),&Token::Equal) => Token::CharData(format!("{}=" , s)),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 167 | (&Token::CharData(ref s),&Token::Equal) => Some(Token::CharData(format!("{}=" , s))),
[INFO] [stdout]     |                                            +++++                                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:170:47
[INFO] [stdout]     |
[INFO] [stdout] 170 | (&Token::CharData(ref s),&Token::Other(o)) => Token::CharData(format!("{}{}" , s , o)),
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 170 | (&Token::CharData(ref s),&Token::Other(o)) => Some(Token::CharData(format!("{}{}" , s , o))),
[INFO] [stdout]     |                                               +++++                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 34 previous errors; 7 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0061, E0308.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0061`.
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `parser`
[INFO] [stdout]   --> examples/xml.rs:39:13
[INFO] [stdout]    |
[INFO] [stdout] 39 | { fn _match(parser:&mut Parser<Token,ParsingTables>,source:& str)->Option<(usize,String)>{
[INFO] [stdout]    |             ^^^^^^ help: if this is intentional, prefix it with an underscore: `_parser`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_variables)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `gramatica` (example "json") due to 35 previous errors; 7 warnings emitted
[INFO] [stdout] error: aborting due to 39 previous errors; 7 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0061, E0308.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0061`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `gramatica` (example "xml") due to 40 previous errors; 7 warnings emitted
[INFO] running `Command { std: "docker" "inspect" "ed33532e2a89fe73e60ca257159b02cc48bf810849a5abf8b2b31d327e04f3ea", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "ed33532e2a89fe73e60ca257159b02cc48bf810849a5abf8b2b31d327e04f3ea", kill_on_drop: false }`
[INFO] [stdout] ed33532e2a89fe73e60ca257159b02cc48bf810849a5abf8b2b31d327e04f3ea
[INFO] checking gramatica-0.2.1 against try#72eda894eb3548c7ba774079ce0afab42958d4ee for pr-121848-1
[INFO] extracting crate gramatica 0.2.1 into /workspace/builds/worker-7-tc2/source
[INFO] validating manifest of crates.io crate gramatica 0.2.1 on toolchain 72eda894eb3548c7ba774079ce0afab42958d4ee
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+72eda894eb3548c7ba774079ce0afab42958d4ee" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking crates.io crate gramatica 0.2.1
[INFO] finished tweaking crates.io crate gramatica 0.2.1
[INFO] tweaked toml for crates.io crate gramatica 0.2.1 written to /workspace/builds/worker-7-tc2/source/Cargo.toml
[INFO] crate crates.io crate gramatica 0.2.1 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+72eda894eb3548c7ba774079ce0afab42958d4ee" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+72eda894eb3548c7ba774079ce0afab42958d4ee" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 38c8f8191e1432da7ad57400f2030d04076534b15040f82cfa81e4f798301769
[INFO] running `Command { std: "docker" "start" "-a" "38c8f8191e1432da7ad57400f2030d04076534b15040f82cfa81e4f798301769", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "38c8f8191e1432da7ad57400f2030d04076534b15040f82cfa81e4f798301769", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "38c8f8191e1432da7ad57400f2030d04076534b15040f82cfa81e4f798301769", kill_on_drop: false }`
[INFO] [stdout] 38c8f8191e1432da7ad57400f2030d04076534b15040f82cfa81e4f798301769
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+72eda894eb3548c7ba774079ce0afab42958d4ee" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 0d6458a9c3e312d4eef91b6f3ad850f3512bb243a6e6acab33c468c2ad078fc5
[INFO] running `Command { std: "docker" "start" "-a" "0d6458a9c3e312d4eef91b6f3ad850f3512bb243a6e6acab33c468c2ad078fc5", kill_on_drop: false }`
[INFO] [stderr]     Checking aho-corasick v1.0.2
[INFO] [stderr]     Checking regex-automata v0.3.3
[INFO] [stderr]     Checking regex v1.9.1
[INFO] [stderr]     Checking gramatica v0.2.1 (/opt/rustwide/workdir)
[INFO] [stdout] error[E0061]: this function takes 3 arguments but 2 arguments were supplied
[INFO] [stdout]    --> examples/calculator.rs:9:7
[INFO] [stdout]     |
[INFO] [stdout] 9   | match Parser::<Token,ParsingTables>::parse(&line,None) { Err(x) => println!("error parsing: {:?}" , x), Ok(x) => println!("parsed correct...
[INFO] [stdout]     |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------------ an argument of type `u8` is missing
[INFO] [stdout]     |
[INFO] [stdout] note: associated function defined here
[INFO] [stdout]    --> /opt/rustwide/workdir/src/lib.rs:777:9
[INFO] [stdout]     |
[INFO] [stdout] 777 |     pub fn parse(source:&str, initial:Option<usize>, verbosity:u8) -> Result<T,ParsingError>
[INFO] [stdout]     |            ^^^^^
[INFO] [stdout] help: provide the argument
[INFO] [stdout]     |
[INFO] [stdout] 9   | match Parser::<Token,ParsingTables>::parse(&line, None, /* u8 */) { Err(x) => println!("error parsing: {:?}" , x), Ok(x) => println!("parsed correctly: {:?}" , x), }
[INFO] [stdout]     |                                           ~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:185:32
[INFO] [stdout]     |
[INFO] [stdout] 185 | ...   parser.sets[index].predict(State{rule:1,left:10,right:vec![],position:0,original_set:index,kind:EarleyKind::Predict(state_index),va...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `std::rc::Rc`
[INFO] [stdout]  --> examples/json.rs:4:5
[INFO] [stdout]   |
[INFO] [stdout] 4 | use std::rc::Rc;
[INFO] [stdout]   |     ^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `BufRead`
[INFO] [stdout]   --> examples/json.rs:16:15
[INFO] [stdout]    |
[INFO] [stdout] 16 | use std::io::{BufRead,Read};
[INFO] [stdout]    |               ^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:48:186
[INFO] [stdout]    |
[INFO] [stdout] 48 | ...Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 48 | parser.sets[index].predict(State{rule: 1 ,left: 10 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                          +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: denote infinite loops with `loop { ... }`
[INFO] [stdout]   --> examples/json.rs:46:1
[INFO] [stdout]    |
[INFO] [stdout] 46 | while true {match characters.next() { None => break, Some('"') => {ret = (Some((size + 1,r + &"\"")));
[INFO] [stdout]    | ^^^^^^^^^^ help: use `loop`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(while_true)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:49:191
[INFO] [stdout]    |
[INFO] [stdout] 49 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 49 | parser.sets[index].predict(State{rule: 2 ,left: 10 ,right:vec![ 10,11 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:186:32
[INFO] [stdout]     |
[INFO] [stdout] 186 | ...   parser.sets[index].predict(State{rule:2,left:10,right:vec![10,11],position:0,original_set:index,kind:EarleyKind::Predict(state_inde...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:52:187
[INFO] [stdout]    |
[INFO] [stdout] 52 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 52 | parser.sets[index].predict(State{rule: 3 ,left: 11 ,right:vec![ 9 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                           +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:190:32
[INFO] [stdout]     |
[INFO] [stdout] 190 | ...   parser.sets[index].predict(State{rule:3,left:11,right:vec![9],position:0,original_set:index,kind:EarleyKind::Predict(state_index),v...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around assigned value
[INFO] [stdout]   --> examples/json.rs:46:74
[INFO] [stdout]    |
[INFO] [stdout] 46 | while true {match characters.next() { None => break, Some('"') => {ret = (Some((size + 1,r + &"\"")));
[INFO] [stdout]    |                                                                          ^                          ^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_parens)]` on by default
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]    |
[INFO] [stdout] 46 - while true {match characters.next() { None => break, Some('"') => {ret = (Some((size + 1,r + &"\"")));
[INFO] [stdout] 46 + while true {match characters.next() { None => break, Some('"') => {ret = Some((size + 1,r + &"\""));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around assigned value
[INFO] [stdout]    --> examples/json.rs:112:104
[INFO] [stdout]     |
[INFO] [stdout] 112 | (&Token::Members(ref list),&Token::Comma,&Token::Pair(ref s,ref value)) => Token::Members({let mut new=(list.clone());
[INFO] [stdout]     |                                                                                                        ^            ^
[INFO] [stdout]     |
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]     |
[INFO] [stdout] 112 - (&Token::Members(ref list),&Token::Comma,&Token::Pair(ref s,ref value)) => Token::Members({let mut new=(list.clone());
[INFO] [stdout] 112 + (&Token::Members(ref list),&Token::Comma,&Token::Pair(ref s,ref value)) => Token::Members({let mut new=list.clone();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around assigned value
[INFO] [stdout]    --> examples/json.rs:128:101
[INFO] [stdout]     |
[INFO] [stdout] 128 | (&Token::Elements(ref list),&Token::Comma,&Token::Value(ref value)) => Token::Elements({let mut new=(list.clone());
[INFO] [stdout]     |                                                                                                     ^            ^
[INFO] [stdout]     |
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]     |
[INFO] [stdout] 128 - (&Token::Elements(ref list),&Token::Comma,&Token::Value(ref value)) => Token::Elements({let mut new=(list.clone());
[INFO] [stdout] 128 + (&Token::Elements(ref list),&Token::Comma,&Token::Value(ref value)) => Token::Elements({let mut new=list.clone();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:53:190
[INFO] [stdout]    |
[INFO] [stdout] 53 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 53 | parser.sets[index].predict(State{rule: 4 ,left: 11 ,right:vec![ 12,9 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                              +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:56:187
[INFO] [stdout]    |
[INFO] [stdout] 56 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 56 | parser.sets[index].predict(State{rule: 5 ,left: 12 ,right:vec![ 1 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                           +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:57:193
[INFO] [stdout]    |
[INFO] [stdout] 57 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 57 | parser.sets[index].predict(State{rule: 6 ,left: 12 ,right:vec![ 12,2,12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:58:193
[INFO] [stdout]    |
[INFO] [stdout] 58 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 58 | parser.sets[index].predict(State{rule: 7 ,left: 12 ,right:vec![ 12,3,12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:59:193
[INFO] [stdout]    |
[INFO] [stdout] 59 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 59 | parser.sets[index].predict(State{rule: 8 ,left: 12 ,right:vec![ 12,4,12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:60:193
[INFO] [stdout]    |
[INFO] [stdout] 60 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 60 | parser.sets[index].predict(State{rule: 9 ,left: 12 ,right:vec![ 12,5,12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:61:191
[INFO] [stdout]    |
[INFO] [stdout] 61 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 61 | parser.sets[index].predict(State{rule: 10 ,left: 12 ,right:vec![ 3,12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:62:194
[INFO] [stdout]    |
[INFO] [stdout] 62 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 62 | parser.sets[index].predict(State{rule: 11 ,left: 12 ,right:vec![ 12,6,12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                  +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:63:193
[INFO] [stdout]    |
[INFO] [stdout] 63 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 63 | parser.sets[index].predict(State{rule: 12 ,left: 12 ,right:vec![ 7,12,8 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:191:32
[INFO] [stdout]     |
[INFO] [stdout] 191 | ...   parser.sets[index].predict(State{rule:4,left:11,right:vec![12,9],position:0,original_set:index,kind:EarleyKind::Predict(state_index...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:66:92
[INFO] [stdout]    |
[INFO] [stdout] 66 | fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => state.values[0].clone(),
[INFO] [stdout]    |                                                                                            ^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 66 | fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => Some(state.values[0].clone()),
[INFO] [stdout]    |                                                                                            +++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:67:12
[INFO] [stdout]    |
[INFO] [stdout] 67 | 1 => { (); Token::Input },
[INFO] [stdout]    |            ^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 67 | 1 => { (); Some(Token::Input) },
[INFO] [stdout]    |            +++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:195:32
[INFO] [stdout]     |
[INFO] [stdout] 195 | ...   parser.sets[index].predict(State{rule:5,left:12,right:vec![1],position:0,original_set:index,kind:EarleyKind::Predict(state_index),v...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:196:32
[INFO] [stdout]     |
[INFO] [stdout] 196 | ...   parser.sets[index].predict(State{rule:6,left:12,right:vec![12,2,12],position:0,original_set:index,kind:EarleyKind::Predict(state_in...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:69:39
[INFO] [stdout]    |
[INFO] [stdout] 69 | (&Token::Input,&Token::Line) => { (); Token::Input },
[INFO] [stdout]    |                                       ^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 69 | (&Token::Input,&Token::Line) => { (); Some(Token::Input) },
[INFO] [stdout]    |                                       +++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:72:26
[INFO] [stdout]    |
[INFO] [stdout] 72 | &Token::NewLine => { (); Token::Line },
[INFO] [stdout]    |                          ^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 72 | &Token::NewLine => { (); Some(Token::Line) },
[INFO] [stdout]    |                          +++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:75:77
[INFO] [stdout]    |
[INFO] [stdout] 75 | (&Token::Expression(value),&Token::NewLine) => { {println!("{}" , value);}; Token::Line },
[INFO] [stdout]    |                                                                             ^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 75 | (&Token::Expression(value),&Token::NewLine) => { {println!("{}" , value);}; Some(Token::Line) },
[INFO] [stdout]    |                                                                             +++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:78:23
[INFO] [stdout]    |
[INFO] [stdout] 78 | &Token::Num(value) => Token::Expression(value),
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 78 | &Token::Num(value) => Some(Token::Expression(value)),
[INFO] [stdout]    |                       +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:81:63
[INFO] [stdout]    |
[INFO] [stdout] 81 | (&Token::Expression(l),&Token::Plus,&Token::Expression(r)) => Token::Expression(l + r),
[INFO] [stdout]    |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 81 | (&Token::Expression(l),&Token::Plus,&Token::Expression(r)) => Some(Token::Expression(l + r)),
[INFO] [stdout]    |                                                               +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:84:64
[INFO] [stdout]    |
[INFO] [stdout] 84 | (&Token::Expression(l),&Token::Minus,&Token::Expression(r)) => Token::Expression(l - r),
[INFO] [stdout]    |                                                                ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 84 | (&Token::Expression(l),&Token::Minus,&Token::Expression(r)) => Some(Token::Expression(l - r)),
[INFO] [stdout]    |                                                                +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:197:32
[INFO] [stdout]     |
[INFO] [stdout] 197 | ...   parser.sets[index].predict(State{rule:7,left:12,right:vec![12,3,12],position:0,original_set:index,kind:EarleyKind::Predict(state_in...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:87:63
[INFO] [stdout]    |
[INFO] [stdout] 87 | (&Token::Expression(l),&Token::Star,&Token::Expression(r)) => Token::Expression(l * r),
[INFO] [stdout]    |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 87 | (&Token::Expression(l),&Token::Star,&Token::Expression(r)) => Some(Token::Expression(l * r)),
[INFO] [stdout]    |                                                               +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:198:32
[INFO] [stdout]     |
[INFO] [stdout] 198 | ...   parser.sets[index].predict(State{rule:8,left:12,right:vec![12,4,12],position:0,original_set:index,kind:EarleyKind::Predict(state_in...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:90:64
[INFO] [stdout]    |
[INFO] [stdout] 90 | (&Token::Expression(l),&Token::Slash,&Token::Expression(r)) => Token::Expression(l / r),
[INFO] [stdout]    |                                                                ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 90 | (&Token::Expression(l),&Token::Slash,&Token::Expression(r)) => Some(Token::Expression(l / r)),
[INFO] [stdout]    |                                                                +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:199:32
[INFO] [stdout]     |
[INFO] [stdout] 199 | ...   parser.sets[index].predict(State{rule:9,left:12,right:vec![12,5,12],position:0,original_set:index,kind:EarleyKind::Predict(state_in...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:93:46
[INFO] [stdout]    |
[INFO] [stdout] 93 | (&Token::Minus,&Token::Expression(value)) => Token::Expression(- value),
[INFO] [stdout]    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 93 | (&Token::Minus,&Token::Expression(value)) => Some(Token::Expression(- value)),
[INFO] [stdout]    |                                              +++++                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:200:32
[INFO] [stdout]     |
[INFO] [stdout] 200 | ...   parser.sets[index].predict(State{rule:10,left:12,right:vec![3,12],position:0,original_set:index,kind:EarleyKind::Predict(state_inde...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:201:32
[INFO] [stdout]     |
[INFO] [stdout] 201 | ...   parser.sets[index].predict(State{rule:11,left:12,right:vec![12,6,12],position:0,original_set:index,kind:EarleyKind::Predict(state_i...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `std::rc::Rc`
[INFO] [stdout]  --> examples/xml.rs:4:5
[INFO] [stdout]   |
[INFO] [stdout] 4 | use std::rc::Rc;
[INFO] [stdout]   |     ^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `BufRead`
[INFO] [stdout]   --> examples/xml.rs:18:15
[INFO] [stdout]    |
[INFO] [stdout] 18 | use std::io::{BufRead,Read};
[INFO] [stdout]    |               ^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:96:64
[INFO] [stdout]    |
[INFO] [stdout] 96 | (&Token::Expression(l),&Token::Caret,&Token::Expression(r)) => Token::Expression(l.powf(r)),
[INFO] [stdout]    |                                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 96 | (&Token::Expression(l),&Token::Caret,&Token::Expression(r)) => Some(Token::Expression(l.powf(r))),
[INFO] [stdout]    |                                                                +++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/calculator.rs:99:58
[INFO] [stdout]    |
[INFO] [stdout] 99 | (&Token::LPar,&Token::Expression(value),&Token::RPar) => Token::Expression(value),
[INFO] [stdout]    |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 99 | (&Token::LPar,&Token::Expression(value),&Token::RPar) => Some(Token::Expression(value)),
[INFO] [stdout]    |                                                          +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: denote infinite loops with `loop { ... }`
[INFO] [stdout]   --> examples/xml.rs:44:1
[INFO] [stdout]    |
[INFO] [stdout] 44 | while true {match characters.next() { None => break, Some('"') => {ret = (Some((size + 1,r + &"\"")));
[INFO] [stdout]    | ^^^^^^^^^^ help: use `loop`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(while_true)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around assigned value
[INFO] [stdout]   --> examples/xml.rs:44:74
[INFO] [stdout]    |
[INFO] [stdout] 44 | while true {match characters.next() { None => break, Some('"') => {ret = (Some((size + 1,r + &"\"")));
[INFO] [stdout]    |                                                                          ^                          ^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_parens)]` on by default
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]    |
[INFO] [stdout] 44 - while true {match characters.next() { None => break, Some('"') => {ret = (Some((size + 1,r + &"\"")));
[INFO] [stdout] 44 + while true {match characters.next() { None => break, Some('"') => {ret = Some((size + 1,r + &"\""));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around assigned value
[INFO] [stdout]    --> examples/xml.rs:130:115
[INFO] [stdout]     |
[INFO] [stdout] 130 | (&Token::Attributes(ref attrs),&Token::Space(_),&Token::Attribute(ref a,ref b)) => Token::Attributes({let mut new=(attrs.clone());
[INFO] [stdout]     |                                                                                                                   ^             ^
[INFO] [stdout]     |
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]     |
[INFO] [stdout] 130 - (&Token::Attributes(ref attrs),&Token::Space(_),&Token::Attribute(ref a,ref b)) => Token::Attributes({let mut new=(attrs.clone());
[INFO] [stdout] 130 + (&Token::Attributes(ref attrs),&Token::Space(_),&Token::Attribute(ref a,ref b)) => Token::Attributes({let mut new=attrs.clone();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around assigned value
[INFO] [stdout]    --> examples/xml.rs:151:112
[INFO] [stdout]     |
[INFO] [stdout] 151 | (&Token::Contents(ref list),&Token::Element(ref elem),&Token::CharData(ref s)) => Token::Contents({let mut new=(list.clone());
[INFO] [stdout]     |                                                                                                                ^            ^
[INFO] [stdout]     |
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]     |
[INFO] [stdout] 151 - (&Token::Contents(ref list),&Token::Element(ref elem),&Token::CharData(ref s)) => Token::Contents({let mut new=(list.clone());
[INFO] [stdout] 151 + (&Token::Contents(ref list),&Token::Element(ref elem),&Token::CharData(ref s)) => Token::Contents({let mut new=list.clone();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0061]: this function takes 3 arguments but 2 arguments were supplied
[INFO] [stdout]    --> examples/json.rs:21:7
[INFO] [stdout]     |
[INFO] [stdout] 21  | match Parser::<Token,ParsingTables>::parse(&buf,None) { Err(x) => println!("error parsing: {:?}" , x), Ok(x) => println!("parsed correctl...
[INFO] [stdout]     |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------- an argument of type `u8` is missing
[INFO] [stdout]     |
[INFO] [stdout] note: associated function defined here
[INFO] [stdout]    --> /opt/rustwide/workdir/src/lib.rs:777:9
[INFO] [stdout]     |
[INFO] [stdout] 777 |     pub fn parse(source:&str, initial:Option<usize>, verbosity:u8) -> Result<T,ParsingError>
[INFO] [stdout]     |            ^^^^^
[INFO] [stdout] help: provide the argument
[INFO] [stdout]     |
[INFO] [stdout] 21  | match Parser::<Token,ParsingTables>::parse(&buf, None, /* u8 */) { Err(x) => println!("error parsing: {:?}" , x), Ok(x) => println!("parsed correctly: {:?}" , x), }
[INFO] [stdout]     |                                           ~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 26 previous errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0061, E0308.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0061`.
[INFO] [stdout] 
[INFO] [stdout] error[E0063]: missing field `ambiguity_info` in initializer of `State<_>`
[INFO] [stdout]    --> examples/calculator_by_hand.rs:202:32
[INFO] [stdout]     |
[INFO] [stdout] 202 | ...   parser.sets[index].predict(State{rule:12,left:12,right:vec![7,12,8],position:0,original_set:index,kind:EarleyKind::Predict(state_in...
[INFO] [stdout]     |                                  ^^^^^ missing `ambiguity_info`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `gramatica` (example "calculator") due to 27 previous errors
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:212:9
[INFO] [stdout]     |
[INFO] [stdout] 212 |             0 => state.values[0].clone(),
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 212 |             0 => Some(state.values[0].clone()),
[INFO] [stdout]     |                  +++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:221:6
[INFO] [stdout]     |
[INFO] [stdout] 221 |                     Token::Line
[INFO] [stdout]     |                     ^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 221 |                     Some(Token::Line)
[INFO] [stdout]     |                     +++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:227:26
[INFO] [stdout]     |
[INFO] [stdout] 227 |                 Token::Num(value) => Token::Expression(value),
[INFO] [stdout]     |                                      ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 227 |                 Token::Num(value) => Some(Token::Expression(value)),
[INFO] [stdout]     |                                      +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:240:30
[INFO] [stdout]     |
[INFO] [stdout] 240 |                     Token::Expression(r) => Token::Expression(l+r),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 240 |                     Token::Expression(r) => Some(Token::Expression(l+r)),
[INFO] [stdout]     |                                             +++++                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:249:30
[INFO] [stdout]     |
[INFO] [stdout] 249 |                     Token::Expression(r) => Token::Expression(l-r),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 249 |                     Token::Expression(r) => Some(Token::Expression(l-r)),
[INFO] [stdout]     |                                             +++++                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:258:30
[INFO] [stdout]     |
[INFO] [stdout] 258 |                     Token::Expression(r) => Token::Expression(l*r),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 258 |                     Token::Expression(r) => Some(Token::Expression(l*r)),
[INFO] [stdout]     |                                             +++++                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:267:30
[INFO] [stdout]     |
[INFO] [stdout] 267 |                     Token::Expression(r) => Token::Expression(l/r),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 267 |                     Token::Expression(r) => Some(Token::Expression(l/r)),
[INFO] [stdout]     |                                             +++++                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:274:33
[INFO] [stdout]     |
[INFO] [stdout] 274 |                 Token::Expression(value) => Token::Expression(-value),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 274 |                 Token::Expression(value) => Some(Token::Expression(-value)),
[INFO] [stdout]     |                                             +++++                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:281:30
[INFO] [stdout]     |
[INFO] [stdout] 281 |                     Token::Expression(r) => Token::Expression(l.powf(r)),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 281 |                     Token::Expression(r) => Some(Token::Expression(l.powf(r))),
[INFO] [stdout]     |                                             +++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:288:33
[INFO] [stdout]     |
[INFO] [stdout] 288 |                 Token::Expression(value) => Token::Expression(value),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 288 |                 Token::Expression(value) => Some(Token::Expression(value)),
[INFO] [stdout]     |                                             +++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:73:189
[INFO] [stdout]    |
[INFO] [stdout] 73 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 73 | parser.sets[index].predict(State{rule: 1 ,left: 12 ,right:vec![ 6,7 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                             +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0061]: this function takes 3 arguments but 2 arguments were supplied
[INFO] [stdout]    --> examples/calculator_by_hand.rs:416:9
[INFO] [stdout]     |
[INFO] [stdout] 416 |         match Parser::<Token,ParsingTables>::parse(&line,None)
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------------ an argument of type `u8` is missing
[INFO] [stdout]     |
[INFO] [stdout] note: associated function defined here
[INFO] [stdout]    --> /opt/rustwide/workdir/src/lib.rs:777:9
[INFO] [stdout]     |
[INFO] [stdout] 777 |     pub fn parse(source:&str, initial:Option<usize>, verbosity:u8) -> Result<T,ParsingError>
[INFO] [stdout]     |            ^^^^^
[INFO] [stdout] help: provide the argument
[INFO] [stdout]     |
[INFO] [stdout] 416 |         match Parser::<Token,ParsingTables>::parse(&line, None, /* u8 */)
[INFO] [stdout]     |                                                   ~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:74:192
[INFO] [stdout]    |
[INFO] [stdout] 74 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 74 | parser.sets[index].predict(State{rule: 2 ,left: 12 ,right:vec![ 6,13,7 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:77:188
[INFO] [stdout]    |
[INFO] [stdout] 77 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 77 | parser.sets[index].predict(State{rule: 3 ,left: 13 ,right:vec![ 14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:185:163
[INFO] [stdout]     |
[INFO] [stdout] 185 | ...e_index),values:vec![],computed_value:Token::DummyStart});//Input -> ()
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 185 |                 parser.sets[index].predict(State{rule:1,left:10,right:vec![],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![],computed_value:Some(Token::DummyStart)});//Input -> ()
[INFO] [stdout]     |                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:186:187
[INFO] [stdout]     |
[INFO] [stdout] 186 | ...![Token::DummyStart;2],computed_value:Token::DummyStart});//Input -> Input,Line
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 186 |                 parser.sets[index].predict(State{rule:2,left:10,right:vec![10,11],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;2],computed_value:Some(Token::DummyStart)});//Input -> Input,Line
[INFO] [stdout]     |                                                                                                                                                                                                       +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:190:183
[INFO] [stdout]     |
[INFO] [stdout] 190 | ...![Token::DummyStart;1],computed_value:Token::DummyStart});//Line -> NewLine
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 190 |                 parser.sets[index].predict(State{rule:3,left:11,right:vec![9],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;1],computed_value:Some(Token::DummyStart)});//Line -> NewLine
[INFO] [stdout]     |                                                                                                                                                                                                   +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:191:186
[INFO] [stdout]     |
[INFO] [stdout] 191 | ...![Token::DummyStart;2],computed_value:Token::DummyStart});//Line -> Expression,NewLine
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 191 |                 parser.sets[index].predict(State{rule:4,left:11,right:vec![12,9],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;2],computed_value:Some(Token::DummyStart)});//Line -> Expression,NewLine
[INFO] [stdout]     |                                                                                                                                                                                                      +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:195:183
[INFO] [stdout]     |
[INFO] [stdout] 195 | ...![Token::DummyStart;1],computed_value:Token::DummyStart});//Expression -> Num
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 195 |                 parser.sets[index].predict(State{rule:5,left:12,right:vec![1],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;1],computed_value:Some(Token::DummyStart)});//Expression -> Num
[INFO] [stdout]     |                                                                                                                                                                                                   +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:196:189
[INFO] [stdout]     |
[INFO] [stdout] 196 | ...![Token::DummyStart;3],computed_value:Token::DummyStart});//Expression -> Expression Plus Expression
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 196 |                 parser.sets[index].predict(State{rule:6,left:12,right:vec![12,2,12],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;3],computed_value:Some(Token::DummyStart)});//Expression -> Expression Plus Expression
[INFO] [stdout]     |                                                                                                                                                                                                         +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:197:189
[INFO] [stdout]     |
[INFO] [stdout] 197 | ...![Token::DummyStart;3],computed_value:Token::DummyStart});//Expression -> Expression Minus Expression
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 197 |                 parser.sets[index].predict(State{rule:7,left:12,right:vec![12,3,12],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;3],computed_value:Some(Token::DummyStart)});//Expression -> Expression Minus Expression
[INFO] [stdout]     |                                                                                                                                                                                                         +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:198:189
[INFO] [stdout]     |
[INFO] [stdout] 198 | ...![Token::DummyStart;3],computed_value:Token::DummyStart});//Expression -> Expression Star Expression
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 198 |                 parser.sets[index].predict(State{rule:8,left:12,right:vec![12,4,12],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;3],computed_value:Some(Token::DummyStart)});//Expression -> Expression Star Expression
[INFO] [stdout]     |                                                                                                                                                                                                         +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:199:189
[INFO] [stdout]     |
[INFO] [stdout] 199 | ...![Token::DummyStart;3],computed_value:Token::DummyStart});//Expression -> Expression Slash Expression
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 199 |                 parser.sets[index].predict(State{rule:9,left:12,right:vec![12,5,12],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;3],computed_value:Some(Token::DummyStart)});//Expression -> Expression Slash Expression
[INFO] [stdout]     |                                                                                                                                                                                                         +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:200:187
[INFO] [stdout]     |
[INFO] [stdout] 200 | ...![Token::DummyStart;2],computed_value:Token::DummyStart});//Expression -> Minus Expression
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 200 |                 parser.sets[index].predict(State{rule:10,left:12,right:vec![3,12],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;2],computed_value:Some(Token::DummyStart)});//Expression -> Minus Expression
[INFO] [stdout]     |                                                                                                                                                                                                       +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:201:190
[INFO] [stdout]     |
[INFO] [stdout] 201 | ...![Token::DummyStart;3],computed_value:Token::DummyStart});//Expression -> Expression Caret Expression
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 201 |                 parser.sets[index].predict(State{rule:11,left:12,right:vec![12,6,12],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;3],computed_value:Some(Token::DummyStart)});//Expression -> Expression Caret Expression
[INFO] [stdout]     |                                                                                                                                                                                                          +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:78:194
[INFO] [stdout]    |
[INFO] [stdout] 78 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 78 | parser.sets[index].predict(State{rule: 4 ,left: 13 ,right:vec![ 13,10,14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                  +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:81:193
[INFO] [stdout]    |
[INFO] [stdout] 81 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 81 | parser.sets[index].predict(State{rule: 5 ,left: 14 ,right:vec![ 5,11,17 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0061]: this function takes 3 arguments but 2 arguments were supplied
[INFO] [stdout]    --> examples/xml.rs:23:7
[INFO] [stdout]     |
[INFO] [stdout] 23  | match Parser::<Token,ParsingTables>::parse(&buf,None) { Err(x) => println!("error parsing: {:?}" , x), Ok(x) => println!("parsed correctl...
[INFO] [stdout]     |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------- an argument of type `u8` is missing
[INFO] [stdout]     |
[INFO] [stdout] note: associated function defined here
[INFO] [stdout]    --> /opt/rustwide/workdir/src/lib.rs:777:9
[INFO] [stdout]     |
[INFO] [stdout] 777 |     pub fn parse(source:&str, initial:Option<usize>, verbosity:u8) -> Result<T,ParsingError>
[INFO] [stdout]     |            ^^^^^
[INFO] [stdout] help: provide the argument
[INFO] [stdout]     |
[INFO] [stdout] 23  | match Parser::<Token,ParsingTables>::parse(&buf, None, /* u8 */) { Err(x) => println!("error parsing: {:?}" , x), Ok(x) => println!("parsed correctly: {:?}" , x), }
[INFO] [stdout]     |                                           ~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/calculator_by_hand.rs:202:189
[INFO] [stdout]     |
[INFO] [stdout] 202 | ...![Token::DummyStart;3],computed_value:Token::DummyStart});//Expression -> LPar Expression RPar
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 202 |                 parser.sets[index].predict(State{rule:12,left:12,right:vec![7,12,8],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart;3],computed_value:Some(Token::DummyStart)});//Expression -> LPar Expression RPar
[INFO] [stdout]     |                                                                                                                                                                                                         +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 35 previous errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0061, E0063, E0308.
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:84:189
[INFO] [stdout]    |
[INFO] [stdout] 84 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 84 | parser.sets[index].predict(State{rule: 6 ,left: 15 ,right:vec![ 8,9 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                             +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0061`.
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:85:192
[INFO] [stdout]    |
[INFO] [stdout] 85 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 85 | parser.sets[index].predict(State{rule: 7 ,left: 15 ,right:vec![ 8,16,9 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:88:188
[INFO] [stdout]    |
[INFO] [stdout] 88 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 88 | parser.sets[index].predict(State{rule: 8 ,left: 16 ,right:vec![ 17 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:89:194
[INFO] [stdout]    |
[INFO] [stdout] 89 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 89 | parser.sets[index].predict(State{rule: 9 ,left: 16 ,right:vec![ 16,10,17 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                  +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:92:188
[INFO] [stdout]    |
[INFO] [stdout] 92 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 92 | parser.sets[index].predict(State{rule: 10 ,left: 17 ,right:vec![ 5 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `gramatica` (example "calculator_by_hand") due to 36 previous errors
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:93:188
[INFO] [stdout]    |
[INFO] [stdout] 93 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 93 | parser.sets[index].predict(State{rule: 11 ,left: 17 ,right:vec![ 4 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:94:189
[INFO] [stdout]    |
[INFO] [stdout] 94 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 94 | parser.sets[index].predict(State{rule: 12 ,left: 17 ,right:vec![ 12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                             +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:95:189
[INFO] [stdout]    |
[INFO] [stdout] 95 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 95 | parser.sets[index].predict(State{rule: 13 ,left: 17 ,right:vec![ 15 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                             +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:96:188
[INFO] [stdout]    |
[INFO] [stdout] 96 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 96 | parser.sets[index].predict(State{rule: 14 ,left: 17 ,right:vec![ 1 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:97:188
[INFO] [stdout]    |
[INFO] [stdout] 97 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 97 | parser.sets[index].predict(State{rule: 15 ,left: 17 ,right:vec![ 2 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/json.rs:98:188
[INFO] [stdout]    |
[INFO] [stdout] 98 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 98 | parser.sets[index].predict(State{rule: 16 ,left: 17 ,right:vec![ 3 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:101:92
[INFO] [stdout]     |
[INFO] [stdout] 101 | fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => state.values[0].clone(),
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 101 | fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => Some(state.values[0].clone()),
[INFO] [stdout]     |                                                                                            +++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:103:36
[INFO] [stdout]     |
[INFO] [stdout] 103 | (&Token::LBrace,&Token::RBrace) => Token::Object(JsonValue::Object(vec![])),
[INFO] [stdout]     |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 103 | (&Token::LBrace,&Token::RBrace) => Some(Token::Object(JsonValue::Object(vec![]))),
[INFO] [stdout]     |                                    +++++                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:106:62
[INFO] [stdout]     |
[INFO] [stdout] 106 | (&Token::LBrace,&Token::Members(ref list),&Token::RBrace) => Token::Object(JsonValue::Object(list.clone())),
[INFO] [stdout]     |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 106 | (&Token::LBrace,&Token::Members(ref list),&Token::RBrace) => Some(Token::Object(JsonValue::Object(list.clone()))),
[INFO] [stdout]     |                                                              +++++                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:109:34
[INFO] [stdout]     |
[INFO] [stdout] 109 | &Token::Pair(ref s,ref value) => Token::Members(vec![(s . clone () , value . clone ())]),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 109 | &Token::Pair(ref s,ref value) => Some(Token::Members(vec![(s . clone () , value . clone ())])),
[INFO] [stdout]     |                                  +++++                                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:112:76
[INFO] [stdout]     |
[INFO] [stdout] 112 |   (&Token::Members(ref list),&Token::Comma,&Token::Pair(ref s,ref value)) => Token::Members({let mut new=(list.clone());
[INFO] [stdout]     |  ____________________________________________________________________________^
[INFO] [stdout] 113 | | new.push((s.clone(),value.clone())); new}),
[INFO] [stdout]     | |__________________________________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 112 ~ (&Token::Members(ref list),&Token::Comma,&Token::Pair(ref s,ref value)) => Some(Token::Members({let mut new=(list.clone());
[INFO] [stdout] 113 ~ new.push((s.clone(),value.clone())); new})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:116:108
[INFO] [stdout]     |
[INFO] [stdout] 116 | (&Token::LitStr(ref s),&Token::Colon,&Token::Value(ref value)) => { let (x0,x1)=(s.clone(),value.clone()); Token::Pair(x0,x1) },
[INFO] [stdout]     |                                                                                                            ^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 116 | (&Token::LitStr(ref s),&Token::Colon,&Token::Value(ref value)) => { let (x0,x1)=(s.clone(),value.clone()); Some(Token::Pair(x0,x1)) },
[INFO] [stdout]     |                                                                                                            +++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:119:40
[INFO] [stdout]     |
[INFO] [stdout] 119 | (&Token::LBracket,&Token::RBracket) => Token::Array(vec![]),
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 119 | (&Token::LBracket,&Token::RBracket) => Some(Token::Array(vec![])),
[INFO] [stdout]     |                                        +++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:69:188
[INFO] [stdout]    |
[INFO] [stdout] 69 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 69 | parser.sets[index].predict(State{rule: 1 ,left: 10 ,right:vec![ 11 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:122:67
[INFO] [stdout]     |
[INFO] [stdout] 122 | (&Token::LBracket,&Token::Elements(ref list),&Token::RBracket) => Token::Array(list.clone()),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 122 | (&Token::LBracket,&Token::Elements(ref list),&Token::RBracket) => Some(Token::Array(list.clone())),
[INFO] [stdout]     |                                                                   +++++                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:72:188
[INFO] [stdout]    |
[INFO] [stdout] 72 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 72 | parser.sets[index].predict(State{rule: 2 ,left: 11 ,right:vec![ 12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:125:29
[INFO] [stdout]     |
[INFO] [stdout] 125 | &Token::Value(ref value) => Token::Elements(vec![value . clone ()]),
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 125 | &Token::Value(ref value) => Some(Token::Elements(vec![value . clone ()])),
[INFO] [stdout]     |                             +++++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:128:72
[INFO] [stdout]     |
[INFO] [stdout] 128 |   (&Token::Elements(ref list),&Token::Comma,&Token::Value(ref value)) => Token::Elements({let mut new=(list.clone());
[INFO] [stdout]     |  ________________________________________________________________________^
[INFO] [stdout] 129 | | new.push(value.clone()); new}),
[INFO] [stdout]     | |______________________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 128 ~ (&Token::Elements(ref list),&Token::Comma,&Token::Value(ref value)) => Some(Token::Elements({let mut new=(list.clone());
[INFO] [stdout] 129 ~ new.push(value.clone()); new})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:132:26
[INFO] [stdout]     |
[INFO] [stdout] 132 | &Token::LitStr(ref s) => Token::Value(JsonValue::Literal(s.clone())),
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 132 | &Token::LitStr(ref s) => Some(Token::Value(JsonValue::Literal(s.clone()))),
[INFO] [stdout]     |                          +++++                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:135:22
[INFO] [stdout]     |
[INFO] [stdout] 135 | &Token::Number(v) => Token::Value(JsonValue::Number(v)),
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 135 | &Token::Number(v) => Some(Token::Value(JsonValue::Number(v))),
[INFO] [stdout]     |                      +++++                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:138:30
[INFO] [stdout]     |
[INFO] [stdout] 138 | &Token::Object(ref value) => Token::Value(value.clone()),
[INFO] [stdout]     |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 138 | &Token::Object(ref value) => Some(Token::Value(value.clone())),
[INFO] [stdout]     |                              +++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:141:28
[INFO] [stdout]     |
[INFO] [stdout] 141 | &Token::Array(ref list) => Token::Value(JsonValue::Array(list.clone())),
[INFO] [stdout]     |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 141 | &Token::Array(ref list) => Some(Token::Value(JsonValue::Array(list.clone()))),
[INFO] [stdout]     |                            +++++                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:144:17
[INFO] [stdout]     |
[INFO] [stdout] 144 | &Token::True => Token::Value(JsonValue::True),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 144 | &Token::True => Some(Token::Value(JsonValue::True)),
[INFO] [stdout]     |                 +++++                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:73:194
[INFO] [stdout]    |
[INFO] [stdout] 73 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 73 | parser.sets[index].predict(State{rule: 3 ,left: 11 ,right:vec![ 15,17,16 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                  +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:76:197
[INFO] [stdout]    |
[INFO] [stdout] 76 | ...Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 76 | parser.sets[index].predict(State{rule: 4 ,left: 12 ,right:vec![ 7,2,13,19,4 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                     +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:147:18
[INFO] [stdout]     |
[INFO] [stdout] 147 | &Token::False => Token::Value(JsonValue::False),
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 147 | &Token::False => Some(Token::Value(JsonValue::False)),
[INFO] [stdout]     |                  +++++                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:79:186
[INFO] [stdout]    |
[INFO] [stdout] 79 | ...Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 79 | parser.sets[index].predict(State{rule: 5 ,left: 13 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                          +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:80:193
[INFO] [stdout]    |
[INFO] [stdout] 80 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 80 | parser.sets[index].predict(State{rule: 6 ,left: 13 ,right:vec![ 13,1,14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                 +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/json.rs:150:17
[INFO] [stdout]     |
[INFO] [stdout] 150 | &Token::Null => Token::Value(JsonValue::Null),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 150 | &Token::Null => Some(Token::Value(JsonValue::Null)),
[INFO] [stdout]     |                 +++++                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:83:191
[INFO] [stdout]    |
[INFO] [stdout] 83 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 83 | parser.sets[index].predict(State{rule: 7 ,left: 14 ,right:vec![ 2,6,3 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `parser`
[INFO] [stdout]   --> examples/json.rs:41:13
[INFO] [stdout]    |
[INFO] [stdout] 41 | { fn _match(parser:&mut Parser<Token,ParsingTables>,source:& str)->Option<(usize,String)>{
[INFO] [stdout]    |             ^^^^^^ help: if this is intentional, prefix it with an underscore: `_parser`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_variables)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 34 previous errors; 7 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0061, E0308.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0061`.
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:86:197
[INFO] [stdout]    |
[INFO] [stdout] 86 | ...Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 86 | parser.sets[index].predict(State{rule: 8 ,left: 15 ,right:vec![ 7,2,13,19,8 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                     +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `gramatica` (example "json") due to 35 previous errors; 7 warnings emitted
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:89:194
[INFO] [stdout]    |
[INFO] [stdout] 89 | ...Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 89 | parser.sets[index].predict(State{rule: 9 ,left: 16 ,right:vec![ 5,2,19,8 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                  +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:92:189
[INFO] [stdout]    |
[INFO] [stdout] 92 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 92 | parser.sets[index].predict(State{rule: 10 ,left: 17 ,right:vec![ 20 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                             +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:93:192
[INFO] [stdout]    |
[INFO] [stdout] 93 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 93 | parser.sets[index].predict(State{rule: 11 ,left: 17 ,right:vec![ 20,18 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:96:187
[INFO] [stdout]    |
[INFO] [stdout] 96 | ...Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 96 | parser.sets[index].predict(State{rule: 12 ,left: 18 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                           +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]   --> examples/xml.rs:97:195
[INFO] [stdout]    |
[INFO] [stdout] 97 | ...Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]    |
[INFO] [stdout]    = note: expected enum `Option<Token>`
[INFO] [stdout]               found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]    |
[INFO] [stdout] 97 | parser.sets[index].predict(State{rule: 13 ,left: 18 ,right:vec![ 18,11,20 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]    |                                                                                                                                                                                                   +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:100:187
[INFO] [stdout]     |
[INFO] [stdout] 100 | ...Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 100 | parser.sets[index].predict(State{rule: 14 ,left: 19 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                           +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:101:188
[INFO] [stdout]     |
[INFO] [stdout] 101 | ...Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 101 | parser.sets[index].predict(State{rule: 15 ,left: 19 ,right:vec![ 1 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                            +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:104:187
[INFO] [stdout]     |
[INFO] [stdout] 104 | ...Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 104 | parser.sets[index].predict(State{rule: 16 ,left: 20 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                           +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:105:191
[INFO] [stdout]     |
[INFO] [stdout] 105 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 105 | parser.sets[index].predict(State{rule: 17 ,left: 20 ,right:vec![ 20,1 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:106:191
[INFO] [stdout]     |
[INFO] [stdout] 106 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 106 | parser.sets[index].predict(State{rule: 18 ,left: 20 ,right:vec![ 20,2 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:107:191
[INFO] [stdout]     |
[INFO] [stdout] 107 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 107 | parser.sets[index].predict(State{rule: 19 ,left: 20 ,right:vec![ 20,6 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:108:191
[INFO] [stdout]     |
[INFO] [stdout] 108 | ...Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 108 | parser.sets[index].predict(State{rule: 20 ,left: 20 ,right:vec![ 20,9 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Some(Token::DummyStart),ambiguity_info:AmbiguityInfo::default(),});
[INFO] [stdout]     |                                                                                                                                                                                               +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:111:92
[INFO] [stdout]     |
[INFO] [stdout] 111 | fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => state.values[0].clone(),
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 111 | fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => Some(state.values[0].clone()),
[INFO] [stdout]     |                                                                                            +++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:113:30
[INFO] [stdout]     |
[INFO] [stdout] 113 | &Token::Element(ref elem) => Token::Document(elem.clone()),
[INFO] [stdout]     |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 113 | &Token::Element(ref elem) => Some(Token::Document(elem.clone())),
[INFO] [stdout]     |                              +++++                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:116:45
[INFO] [stdout]     |
[INFO] [stdout] 116 |   &Token::EmptyElemTag(ref name,ref attrs) => Token::Element(XMLElement{name:name.clone(),
[INFO] [stdout]     |  _____________________________________________^
[INFO] [stdout] 117 | | attrs:attrs.clone(),
[INFO] [stdout] 118 | | contents:vec![],}),
[INFO] [stdout]     | |__________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 116 ~ &Token::EmptyElemTag(ref name,ref attrs) => Some(Token::Element(XMLElement{name:name.clone(),
[INFO] [stdout] 117 | attrs:attrs.clone(),
[INFO] [stdout] 118 ~ contents:vec![],})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:121:84
[INFO] [stdout]     |
[INFO] [stdout] 121 |   (&Token::STag(ref name,ref attrs),&Token::Content(ref content),&Token::ETag(_)) => Token::Element(XMLElement{name:name.clone(),
[INFO] [stdout]     |  ____________________________________________________________________________________^
[INFO] [stdout] 122 | | attrs:attrs.clone(),
[INFO] [stdout] 123 | | contents:content.clone(),}),
[INFO] [stdout]     | |___________________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 121 ~ (&Token::STag(ref name,ref attrs),&Token::Content(ref content),&Token::ETag(_)) => Some(Token::Element(XMLElement{name:name.clone(),
[INFO] [stdout] 122 | attrs:attrs.clone(),
[INFO] [stdout] 123 ~ contents:content.clone(),})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:126:153
[INFO] [stdout]     |
[INFO] [stdout] 126 | ...x1)=(name.clone(),attrs.clone()); Token::EmptyElemTag(x0,x1) },
[INFO] [stdout]     |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 126 | (&Token::LT,&Token::Ident(ref name),&Token::Attributes(ref attrs),&Token::MaybeSpace,&Token::CloseEmpty) => { let (x0,x1)=(name.clone(),attrs.clone()); Some(Token::EmptyElemTag(x0,x1)) },
[INFO] [stdout]     |                                                                                                                                                         +++++                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:130:84
[INFO] [stdout]     |
[INFO] [stdout] 130 |   (&Token::Attributes(ref attrs),&Token::Space(_),&Token::Attribute(ref a,ref b)) => Token::Attributes({let mut new=(attrs.clone());
[INFO] [stdout]     |  ____________________________________________________________________________________^
[INFO] [stdout] 131 | | new.push((a.clone(),b.clone())); new}),
[INFO] [stdout]     | |______________________________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 130 ~ (&Token::Attributes(ref attrs),&Token::Space(_),&Token::Attribute(ref a,ref b)) => Some(Token::Attributes({let mut new=(attrs.clone());
[INFO] [stdout] 131 ~ new.push((a.clone(),b.clone())); new})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:134:100
[INFO] [stdout]     |
[INFO] [stdout] 134 | (&Token::Ident(ref a),&Token::Equal,&Token::LitStr(ref b)) => { let (x0,x1)=(a.clone(),b.clone()); Token::Attribute(x0,x1) },
[INFO] [stdout]     |                                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 134 | (&Token::Ident(ref a),&Token::Equal,&Token::LitStr(ref b)) => { let (x0,x1)=(a.clone(),b.clone()); Some(Token::Attribute(x0,x1)) },
[INFO] [stdout]     |                                                                                                    +++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:137:145
[INFO] [stdout]     |
[INFO] [stdout] 137 | ...(x0,x1)=(name.clone(),attrs.clone()); Token::STag(x0,x1) },
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 137 | (&Token::LT,&Token::Ident(ref name),&Token::Attributes(ref attrs),&Token::MaybeSpace,&Token::GT) => { let (x0,x1)=(name.clone(),attrs.clone()); Some(Token::STag(x0,x1)) },
[INFO] [stdout]     |                                                                                                                                                 +++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:140:76
[INFO] [stdout]     |
[INFO] [stdout] 140 | (&Token::BeginClose,&Token::Ident(ref s),&Token::MaybeSpace,&Token::GT) => Token::ETag(s.clone()),
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 140 | (&Token::BeginClose,&Token::Ident(ref s),&Token::MaybeSpace,&Token::GT) => Some(Token::ETag(s.clone())),
[INFO] [stdout]     |                                                                            +++++                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:143:28
[INFO] [stdout]     |
[INFO] [stdout] 143 | &Token::CharData(ref s) => Token::Content(vec![XMLContent :: Data (s . clone ())]),
[INFO] [stdout]     |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 143 | &Token::CharData(ref s) => Some(Token::Content(vec![XMLContent :: Data (s . clone ())])),
[INFO] [stdout]     |                            +++++                                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:146:57
[INFO] [stdout]     |
[INFO] [stdout] 146 |   (&Token::CharData(ref s),&Token::Contents(ref list)) => Token::Content({let mut new=vec![XMLContent :: Data (s . clone ())];
[INFO] [stdout]     |  _________________________________________________________^
[INFO] [stdout] 147 | | new.extend(list.iter().map(|x|x.clone())); new}),
[INFO] [stdout]     | |________________________________________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 146 ~ (&Token::CharData(ref s),&Token::Contents(ref list)) => Some(Token::Content({let mut new=vec![XMLContent :: Data (s . clone ())];
[INFO] [stdout] 147 ~ new.extend(list.iter().map(|x|x.clone())); new})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:151:83
[INFO] [stdout]     |
[INFO] [stdout] 151 |   (&Token::Contents(ref list),&Token::Element(ref elem),&Token::CharData(ref s)) => Token::Contents({let mut new=(list.clone());
[INFO] [stdout]     |  ___________________________________________________________________________________^
[INFO] [stdout] 152 | | new.push(XMLContent::Element(elem.clone()));
[INFO] [stdout] 153 | | if s != "" {new.push(XMLContent::Data(s.clone()));} new}),
[INFO] [stdout]     | |_________________________________________________________^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 151 ~ (&Token::Contents(ref list),&Token::Element(ref elem),&Token::CharData(ref s)) => Some(Token::Contents({let mut new=(list.clone());
[INFO] [stdout] 152 | new.push(XMLContent::Element(elem.clone()));
[INFO] [stdout] 153 ~ if s != "" {new.push(XMLContent::Data(s.clone()));} new})),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:155:13
[INFO] [stdout]     |
[INFO] [stdout] 155 | 14 => { (); Token::MaybeSpace },
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 155 | 14 => { (); Some(Token::MaybeSpace) },
[INFO] [stdout]     |             +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:157:27
[INFO] [stdout]     |
[INFO] [stdout] 157 | &Token::Space(_) => { (); Token::MaybeSpace },
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 157 | &Token::Space(_) => { (); Some(Token::MaybeSpace) },
[INFO] [stdout]     |                           +++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:161:51
[INFO] [stdout]     |
[INFO] [stdout] 161 | (&Token::CharData(ref s),&Token::Space(ref o)) => Token::CharData(format!("{}{}" , s , o)),
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 161 | (&Token::CharData(ref s),&Token::Space(ref o)) => Some(Token::CharData(format!("{}{}" , s , o))),
[INFO] [stdout]     |                                                   +++++                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:164:51
[INFO] [stdout]     |
[INFO] [stdout] 164 | (&Token::CharData(ref s),&Token::Ident(ref o)) => Token::CharData(format!("{}{}" , s , o)),
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 164 | (&Token::CharData(ref s),&Token::Ident(ref o)) => Some(Token::CharData(format!("{}{}" , s , o))),
[INFO] [stdout]     |                                                   +++++                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:167:44
[INFO] [stdout]     |
[INFO] [stdout] 167 | (&Token::CharData(ref s),&Token::Equal) => Token::CharData(format!("{}=" , s)),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 167 | (&Token::CharData(ref s),&Token::Equal) => Some(Token::CharData(format!("{}=" , s))),
[INFO] [stdout]     |                                            +++++                                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0308]: mismatched types
[INFO] [stdout]    --> examples/xml.rs:170:47
[INFO] [stdout]     |
[INFO] [stdout] 170 | (&Token::CharData(ref s),&Token::Other(o)) => Token::CharData(format!("{}{}" , s , o)),
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option<Token>`, found `Token`
[INFO] [stdout]     |
[INFO] [stdout]     = note: expected enum `Option<Token>`
[INFO] [stdout]                found enum `Token`
[INFO] [stdout] help: try wrapping the expression in `Some`
[INFO] [stdout]     |
[INFO] [stdout] 170 | (&Token::CharData(ref s),&Token::Other(o)) => Some(Token::CharData(format!("{}{}" , s , o))),
[INFO] [stdout]     |                                               +++++                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `parser`
[INFO] [stdout]   --> examples/xml.rs:39:13
[INFO] [stdout]    |
[INFO] [stdout] 39 | { fn _match(parser:&mut Parser<Token,ParsingTables>,source:& str)->Option<(usize,String)>{
[INFO] [stdout]    |             ^^^^^^ help: if this is intentional, prefix it with an underscore: `_parser`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_variables)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 39 previous errors; 7 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0061, E0308.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0061`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `gramatica` (example "xml") due to 40 previous errors; 7 warnings emitted
[INFO] running `Command { std: "docker" "inspect" "0d6458a9c3e312d4eef91b6f3ad850f3512bb243a6e6acab33c468c2ad078fc5", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "0d6458a9c3e312d4eef91b6f3ad850f3512bb243a6e6acab33c468c2ad078fc5", kill_on_drop: false }`
[INFO] [stdout] 0d6458a9c3e312d4eef91b6f3ad850f3512bb243a6e6acab33c468c2ad078fc5
