[INFO] fetching crate gramatica 0.2.0...
[INFO] testing gramatica-0.2.0 against beta-2023-04-20 for beta-1.70-1
[INFO] extracting crate gramatica 0.2.0 into /workspace/builds/worker-2-tc2/source
[INFO] validating manifest of crates.io crate gramatica 0.2.0 on toolchain beta-2023-04-20
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+beta-2023-04-20" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking crates.io crate gramatica 0.2.0
[INFO] finished tweaking crates.io crate gramatica 0.2.0
[INFO] tweaked toml for crates.io crate gramatica 0.2.0 written to /workspace/builds/worker-2-tc2/source/Cargo.toml
[INFO] crate crates.io crate gramatica 0.2.0 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" "+beta-2023-04-20" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded memchr v2.0.1
[INFO] [stderr]   Downloaded thread_local v0.3.5
[INFO] [stderr]   Downloaded utf8-ranges v1.0.0
[INFO] [stderr]   Downloaded lazy_static v1.0.0
[INFO] [stderr]   Downloaded aho-corasick v0.6.4
[INFO] [stderr]   Downloaded libc v0.2.36
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-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:5ff2268d62e97bff2cde7d5815dd6ed5b47097566f13b8d0ca110b04b60e07ed" "/opt/rustwide/cargo-home/bin/cargo" "+beta-2023-04-20" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 95ab741a560d52d75148aa2a3faccc33445261faef66e63224ece32782ea4479
[INFO] running `Command { std: "docker" "start" "-a" "95ab741a560d52d75148aa2a3faccc33445261faef66e63224ece32782ea4479", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "95ab741a560d52d75148aa2a3faccc33445261faef66e63224ece32782ea4479", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "95ab741a560d52d75148aa2a3faccc33445261faef66e63224ece32782ea4479", kill_on_drop: false }`
[INFO] [stdout] 95ab741a560d52d75148aa2a3faccc33445261faef66e63224ece32782ea4479
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-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=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-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:5ff2268d62e97bff2cde7d5815dd6ed5b47097566f13b8d0ca110b04b60e07ed" "/opt/rustwide/cargo-home/bin/cargo" "+beta-2023-04-20" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 31a618b520fdbe03c005d8c756507d5fd12dc658ca7f0ebd5e5ff2e4894ab1bf
[INFO] running `Command { std: "docker" "start" "-a" "31a618b520fdbe03c005d8c756507d5fd12dc658ca7f0ebd5e5ff2e4894ab1bf", kill_on_drop: false }`
[INFO] [stderr]    Compiling libc v0.2.36
[INFO] [stderr]    Compiling void v1.0.2
[INFO] [stderr]    Compiling lazy_static v1.0.0
[INFO] [stderr]    Compiling utf8-ranges v1.0.0
[INFO] [stderr]    Compiling regex-syntax v0.4.2
[INFO] [stderr]    Compiling unreachable v1.0.0
[INFO] [stderr]    Compiling thread_local v0.3.5
[INFO] [stderr]    Compiling memchr v2.0.1
[INFO] [stderr]    Compiling aho-corasick v0.6.4
[INFO] [stderr]    Compiling regex v0.2.6
[INFO] [stderr]    Compiling gramatica v0.2.0 (/opt/rustwide/workdir)
[INFO] [stdout] warning: variant `Bounds` is never constructed
[INFO] [stdout]    --> src/compiler.rs:466:3621
[INFO] [stdout]     |
[INFO] [stdout] 465 | enum Token{DummyStart,
[INFO] [stdout]     |      ----- variant in this enum
[INFO] [stdout] 466 | Static,Mut,Const,Crate,Extern,As,Struct,Enum,Union,Mod,Unsafe,FN,Pub,LittleSelf,Type,For,Trait,DEFAULT,Impl,Where,Super,BOX,Ref,Typeof,StaticLifetime,Continue,Return,Break,Yield,Move,Match,If,Else,LiteralLet,While,Loop,In,True,False,Catch,Use,Terminal,Nonterminal,ShebangLine,LitInteger(usize),LitByte,LitChar(char),LiteralLifetime(String),LitFloat,LitStr(String),LitStrRaw,LitByteStr,LitByteStrRaw,NoSpace,InnerDocComment,OuterDocComment(String),LiteralIdent(String),Shebang,NumberSign,FatArrow,EqualEqual,NE,Equal,LArrow,RArrow,LE,GE,MinusEqual,AndEqual,OrEqual,PlusEqual,StarEqual,SlashEqual,CaretEqual,PercentEqual,GT,Underscore,OrOr,Vertical,Comma,AndAnd,Ampersand,DotDotDot,DotDot,Dot,ModSep,Colon,Caret,Percent,Semicolon,Bang,At,Star,QuestionMark,LBracket,RBracket,LPar,RPar,LBrace,RBrace,LT,Plus,Minus,Slash,WholeCrate(Vec<Rc<Token>>),MaybeShebang,MaybeInnerAttrs,InnerAttrs,InnerAttr,MaybeOuterAttrs(Vec<AttrKind>),OuterAttrs(Vec<AttrKind>),OuterAttr(AttrKind),MetaItem(AttrKind),MetaSeq(Vec<AttrKind>),MaybeModItems(Vec<Rc<Token>>),ModItems(Vec<Rc<Token>>),AttrsAndVis(Vec<AttrKind>),ModItem(Vec<AttrKind>,ItemKind),Item(ItemKind),StmtItem(ItemKind),ItemStatic,ItemConst,ItemMacro(ItemKind),ViewItem(ViewKind),ExternFnItem,UseItem(ViewKind),ViewPath(ViewKind),BlockItem(ItemKind),MaybeTyAscription(Option<TyLf>),MaybeInitExpr(Option<ExprKind>),ItemStruct(ItemKind),StructDeclArgs(Vec<(String,TyLf)>),StructTupleArgs,StructDeclFields(Vec<(String,TyLf)>),StructDeclField(String,TyLf),StructTupleFields,StructTupleField,ItemEnum(ItemKind),EnumDefs(Vec<(String,Vec<TyLf>)>),EnumDef(String,Vec<TyLf>),EnumArgs(Vec<TyLf>),ItemUnion,ItemMod,ItemForeignMod,MaybeAbi,MaybeForeignItems,ForeignItems,ForeignItem,ItemForeignStatic,ItemForeignFn,FnDeclAllowVariadic,FnParamsAllowVariadic,Visibility,IdentsOrSelf(Vec<String>),IdentOrSelf(String),ItemType,ForSized,ItemTrait,MaybeTraitItems,TraitItems,TraitItem,TraitConst,MaybeConstDefault,TraitType,MaybeUnsafe,MaybeDefaultMaybeUnsafe,TraitMethod,TypeMethod,Method,ImplMethod(ItemKind),ItemImpl(ItemKind),MaybeImplItems(Vec<ItemKind>),ImplItems(Vec<ItemKind>),ImplItem(ItemKind),MaybeDefault,ImplConst,ImplType,ItemFn(ItemKind),ItemUnsafeFn,FnDecl(Vec<(PatKind,TyLf)>,Option<TyKind>),FnDeclWithSelf(bool,bool,bool,Option<TyLf>,Vec<(PatKind,TyLf)>,Option<TyKind>),FnDeclWithSelfAllowAnonParams,FnParams(Vec<(PatKind,TyLf)>),FnAnonParams,FnParamsWithSelf(bool,bool,bool,Option<TyLf>,Vec<(PatKind,TyLf)>),FnAnonParamsWithSelf,MaybeParams(Vec<(PatKind,TyLf)>),Params(Vec<(PatKind,TyLf)>),Param(PatKind,TyLf),InferrableParams(Vec<(PatKind,Option<TyLf>)>),InferrableParam(PatKind,Option<TyLf>),MaybeCommaParams(Vec<(PatKind,TyLf)>),MaybeCommaAnonParams,MaybeAnonParams,AnonParams,AnonParam,AnonParamsAllowVariadicTail,NamedArg,RetTy(Option<TyKind>),GenericParams(Vec<String>,Vec<String>),MaybeWhereClause,WhereClause,WherePredicates,WherePredicate,MaybeForLifetimes,TyParams(Vec<String>),PathNoTypesAllowed(PathNKind),PathGenericArgsWithoutColons(PathWKind),GenericArgs(Vec<TyLf>),GenericValues(Vec<TyLf>),MaybeTySumsAndOrBindings(Vec<TyLf>),MaybeBindings,Pat(PatKind),PatsOr(PatKind),BindingMode(BindKind),LitOrPath(PathKind),PatField,PatFields,PatStruct,PatTup(Vec<PatKind>),PatTupElts(Vec<PatKind>),PatVec,PatVecElts,Ty(TyKind),TyPrim(TyKind),TyBareFn,TyFnDecl,TyClosure,ForInType,ForInTypeSuffix,MaybeMut(bool),MaybeMutOrConst,TyQualifiedPathAndGenericValues,TyQualifiedPath,MaybeTySums(Vec<TyLf>),TySums(Vec<TyLf>),TySum(TyLf),TySumElt(TyLf),TyPrimSum(TyLf),TyPrimSumElt(TyLf),MaybeTyParamBounds,TyParamBounds,Boundseq,Polybound,Bindings,Binding,TyParam(String),MaybeBounds,Bounds,Bo...
[INFO] [stdout]     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `Token` has derived impls for the traits `Debug` and `Clone`, but these are intentionally ignored during dead code analysis
[INFO] [stdout]     = note: `#[warn(dead_code)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 1 warning emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished dev [unoptimized + debuginfo] target(s) in 8.94s
[INFO] running `Command { std: "docker" "inspect" "31a618b520fdbe03c005d8c756507d5fd12dc658ca7f0ebd5e5ff2e4894ab1bf", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "31a618b520fdbe03c005d8c756507d5fd12dc658ca7f0ebd5e5ff2e4894ab1bf", kill_on_drop: false }`
[INFO] [stdout] 31a618b520fdbe03c005d8c756507d5fd12dc658ca7f0ebd5e5ff2e4894ab1bf
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-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=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-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:5ff2268d62e97bff2cde7d5815dd6ed5b47097566f13b8d0ca110b04b60e07ed" "/opt/rustwide/cargo-home/bin/cargo" "+beta-2023-04-20" "test" "--frozen" "--no-run" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] df18fc3a3c49c3a4560fed706249b1c09c2016da2ac4f7340739712238c03f39
[INFO] running `Command { std: "docker" "start" "-a" "df18fc3a3c49c3a4560fed706249b1c09c2016da2ac4f7340739712238c03f39", kill_on_drop: false }`
[INFO] [stderr]    Compiling gramatica v0.2.0 (/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: 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/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/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/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/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] 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[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/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[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/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: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[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: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/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: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: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: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: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/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: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[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/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[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[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/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: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/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/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: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[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: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: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/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[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: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: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/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[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: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/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.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/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: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/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[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: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/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[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/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: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/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.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/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_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.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/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/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.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_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: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/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.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_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/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/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/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: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.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/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: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/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/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/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_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/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/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.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/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/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/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/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/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.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/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.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/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/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/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/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_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/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 34 previous errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0063, E0308.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0063`.
[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[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: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] [stderr] error: could not compile `gramatica` (example "calculator_by_hand") due to 35 previous errors
[INFO] [stdout] error: aborting due to 25 previous errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] For more information about this error, try `rustc --explain E0308`.
[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] [stderr] error: could not compile `gramatica` (example "calculator") due to 26 previous errors
[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/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: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/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: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/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/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/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/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: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: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: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: aborting due to 33 previous errors; 6 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0308`.
[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] [stderr] error: could not compile `gramatica` (example "json") due to 34 previous errors; 6 warnings emitted
[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] error: aborting due to 38 previous errors; 6 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0308`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `gramatica` (example "xml") due to 39 previous errors; 6 warnings emitted
[INFO] [stdout] warning: variant `Bounds` is never constructed
[INFO] [stdout]    --> src/compiler.rs:466:3621
[INFO] [stdout]     |
[INFO] [stdout] 465 | enum Token{DummyStart,
[INFO] [stdout]     |      ----- variant in this enum
[INFO] [stdout] 466 | Static,Mut,Const,Crate,Extern,As,Struct,Enum,Union,Mod,Unsafe,FN,Pub,LittleSelf,Type,For,Trait,DEFAULT,Impl,Where,Super,BOX,Ref,Typeof,StaticLifetime,Continue,Return,Break,Yield,Move,Match,If,Else,LiteralLet,While,Loop,In,True,False,Catch,Use,Terminal,Nonterminal,ShebangLine,LitInteger(usize),LitByte,LitChar(char),LiteralLifetime(String),LitFloat,LitStr(String),LitStrRaw,LitByteStr,LitByteStrRaw,NoSpace,InnerDocComment,OuterDocComment(String),LiteralIdent(String),Shebang,NumberSign,FatArrow,EqualEqual,NE,Equal,LArrow,RArrow,LE,GE,MinusEqual,AndEqual,OrEqual,PlusEqual,StarEqual,SlashEqual,CaretEqual,PercentEqual,GT,Underscore,OrOr,Vertical,Comma,AndAnd,Ampersand,DotDotDot,DotDot,Dot,ModSep,Colon,Caret,Percent,Semicolon,Bang,At,Star,QuestionMark,LBracket,RBracket,LPar,RPar,LBrace,RBrace,LT,Plus,Minus,Slash,WholeCrate(Vec<Rc<Token>>),MaybeShebang,MaybeInnerAttrs,InnerAttrs,InnerAttr,MaybeOuterAttrs(Vec<AttrKind>),OuterAttrs(Vec<AttrKind>),OuterAttr(AttrKind),MetaItem(AttrKind),MetaSeq(Vec<AttrKind>),MaybeModItems(Vec<Rc<Token>>),ModItems(Vec<Rc<Token>>),AttrsAndVis(Vec<AttrKind>),ModItem(Vec<AttrKind>,ItemKind),Item(ItemKind),StmtItem(ItemKind),ItemStatic,ItemConst,ItemMacro(ItemKind),ViewItem(ViewKind),ExternFnItem,UseItem(ViewKind),ViewPath(ViewKind),BlockItem(ItemKind),MaybeTyAscription(Option<TyLf>),MaybeInitExpr(Option<ExprKind>),ItemStruct(ItemKind),StructDeclArgs(Vec<(String,TyLf)>),StructTupleArgs,StructDeclFields(Vec<(String,TyLf)>),StructDeclField(String,TyLf),StructTupleFields,StructTupleField,ItemEnum(ItemKind),EnumDefs(Vec<(String,Vec<TyLf>)>),EnumDef(String,Vec<TyLf>),EnumArgs(Vec<TyLf>),ItemUnion,ItemMod,ItemForeignMod,MaybeAbi,MaybeForeignItems,ForeignItems,ForeignItem,ItemForeignStatic,ItemForeignFn,FnDeclAllowVariadic,FnParamsAllowVariadic,Visibility,IdentsOrSelf(Vec<String>),IdentOrSelf(String),ItemType,ForSized,ItemTrait,MaybeTraitItems,TraitItems,TraitItem,TraitConst,MaybeConstDefault,TraitType,MaybeUnsafe,MaybeDefaultMaybeUnsafe,TraitMethod,TypeMethod,Method,ImplMethod(ItemKind),ItemImpl(ItemKind),MaybeImplItems(Vec<ItemKind>),ImplItems(Vec<ItemKind>),ImplItem(ItemKind),MaybeDefault,ImplConst,ImplType,ItemFn(ItemKind),ItemUnsafeFn,FnDecl(Vec<(PatKind,TyLf)>,Option<TyKind>),FnDeclWithSelf(bool,bool,bool,Option<TyLf>,Vec<(PatKind,TyLf)>,Option<TyKind>),FnDeclWithSelfAllowAnonParams,FnParams(Vec<(PatKind,TyLf)>),FnAnonParams,FnParamsWithSelf(bool,bool,bool,Option<TyLf>,Vec<(PatKind,TyLf)>),FnAnonParamsWithSelf,MaybeParams(Vec<(PatKind,TyLf)>),Params(Vec<(PatKind,TyLf)>),Param(PatKind,TyLf),InferrableParams(Vec<(PatKind,Option<TyLf>)>),InferrableParam(PatKind,Option<TyLf>),MaybeCommaParams(Vec<(PatKind,TyLf)>),MaybeCommaAnonParams,MaybeAnonParams,AnonParams,AnonParam,AnonParamsAllowVariadicTail,NamedArg,RetTy(Option<TyKind>),GenericParams(Vec<String>,Vec<String>),MaybeWhereClause,WhereClause,WherePredicates,WherePredicate,MaybeForLifetimes,TyParams(Vec<String>),PathNoTypesAllowed(PathNKind),PathGenericArgsWithoutColons(PathWKind),GenericArgs(Vec<TyLf>),GenericValues(Vec<TyLf>),MaybeTySumsAndOrBindings(Vec<TyLf>),MaybeBindings,Pat(PatKind),PatsOr(PatKind),BindingMode(BindKind),LitOrPath(PathKind),PatField,PatFields,PatStruct,PatTup(Vec<PatKind>),PatTupElts(Vec<PatKind>),PatVec,PatVecElts,Ty(TyKind),TyPrim(TyKind),TyBareFn,TyFnDecl,TyClosure,ForInType,ForInTypeSuffix,MaybeMut(bool),MaybeMutOrConst,TyQualifiedPathAndGenericValues,TyQualifiedPath,MaybeTySums(Vec<TyLf>),TySums(Vec<TyLf>),TySum(TyLf),TySumElt(TyLf),TyPrimSum(TyLf),TyPrimSumElt(TyLf),MaybeTyParamBounds,TyParamBounds,Boundseq,Polybound,Bindings,Binding,TyParam(String),MaybeBounds,Bounds,Bo...
[INFO] [stdout]     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `Token` has derived impls for the traits `Debug` and `Clone`, but these are intentionally ignored during dead code analysis
[INFO] [stdout]     = note: `#[warn(dead_code)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 1 warning emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] running `Command { std: "docker" "inspect" "df18fc3a3c49c3a4560fed706249b1c09c2016da2ac4f7340739712238c03f39", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "df18fc3a3c49c3a4560fed706249b1c09c2016da2ac4f7340739712238c03f39", kill_on_drop: false }`
[INFO] [stdout] df18fc3a3c49c3a4560fed706249b1c09c2016da2ac4f7340739712238c03f39
