Програмиране с Rust

Курс във Факултета по Математика и Информатика към СУ

Решение на Логически изрази от Иван Стойнев

Обратно към всички решения

Към профила на Иван Стойнев

Резултати

  • 0 точки от тестове
  • 0 бонус точки
  • 0 точки общо
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)

Код

#[derive(Debug, PartialEq, Eq)]
pub enum MyParseError {
UnexpectedExpression,
UnexpectedUnaryOperator,
UnexpectedBinaryOperator,
UnmatchedParenthesis,
ParsingIncomplete,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum MyExpr {
Symbol(char),
Neg(Box<MyExpr>),
Conjunction(Vec<MyExpr>),
Disjunction(Vec<MyExpr>),
}
/// A parser for a simple expression without parentheses.
pub struct BasicExprParser {
expr_stack: Vec<MyExpr>,
}
impl BasicExprParser {
pub fn new() -> Self {
BasicExprParser { expr_stack: vec![] }
}
/// Accepts a symbol/atom.
pub fn accept_symbol(&mut self, ch: char) -> Result<(), MyParseError> {
if let Some(last_expr) = self.expr_stack.last() {
match last_expr {
MyExpr::Conjunction(_) | MyExpr::Disjunction(_) => {
return Err(MyParseError::UnexpectedExpression);
}
_ => {}
}
}
self.expr_stack.push(MyExpr::Symbol(ch));
Ok(())
}
/// Accepts an operator character.
pub fn accept_operator(&mut self, op_char: char) -> Result<(), MyParseError> {
// Ensure valid sequence
if let Some(last_expr) = self.expr_stack.last() {
match last_expr {
MyExpr::Conjunction(_) | MyExpr::Disjunction(_) => match op_char {
'&' | '|' => return Err(MyParseError::UnexpectedBinaryOperator),
'!' => return Err(MyParseError::UnexpectedUnaryOperator),
_ => unreachable!("Invalid operator"),
},
_ => {}
}
} else if op_char == '!' {
return Err(MyParseError::UnexpectedUnaryOperator);
}
match op_char {
'&' => {
let all_exprs = self.expr_stack.drain(..).collect::<Vec<_>>();
self.expr_stack.push(MyExpr::Conjunction(all_exprs));
}
'|' => {
let all_exprs = self.expr_stack.drain(..).collect::<Vec<_>>();
self.expr_stack.push(MyExpr::Disjunction(all_exprs));
}
'!' => {
let top_expr = self.expr_stack.pop().ok_or(MyParseError::UnexpectedUnaryOperator)?;
self.expr_stack.push(MyExpr::Neg(Box::new(top_expr)));
}
_ => unreachable!("Invalid operator"),
}
Ok(())
}
/// Completes parsing and returns the final expression.
pub fn finalize(self) -> Result<MyExpr, MyParseError> {
if self.expr_stack.len() == 1 {
Ok(self.expr_stack.into_iter().next().unwrap())
} else {
Err(MyParseError::ParsingIncomplete)
}
}
}
/// A parser that handles parentheses as well.
pub struct FullExprParser {
storage: Vec<MyExpr>,
open_parens: i32,
}
impl FullExprParser {
pub fn new() -> Self {
FullExprParser {
storage: vec![],
open_parens: 0,
}
}
/// Accepts a symbol/atom.
pub fn accept_symbol(&mut self, ch: char) -> Result<(), MyParseError> {
if let Some(last_expr) = self.storage.last() {
match last_expr {
MyExpr::Conjunction(_) | MyExpr::Disjunction(_) => {
return Err(MyParseError::UnexpectedExpression);
}
_ => {}
}
}
self.storage.push(MyExpr::Symbol(ch));
Ok(())
}
/// Accepts an operator character.
pub fn accept_operator(&mut self, op_char: char) -> Result<(), MyParseError> {
// Ensure valid sequence
if let Some(last_expr) = self.storage.last() {
match last_expr {
MyExpr::Conjunction(_) | MyExpr::Disjunction(_) => match op_char {
'&' | '|' => return Err(MyParseError::UnexpectedBinaryOperator),
'!' => return Err(MyParseError::UnexpectedUnaryOperator),
_ => unreachable!("Invalid operator"),
},
_ => {}
}
} else if op_char == '!' {
return Err(MyParseError::UnexpectedUnaryOperator);
}
match op_char {
'&' => {
let collected = self.storage.drain(..).collect::<Vec<_>>();
self.storage.push(MyExpr::Conjunction(collected));
}
'|' => {
let collected = self.storage.drain(..).collect::<Vec<_>>();
self.storage.push(MyExpr::Disjunction(collected));
}
'!' => {
let popped = self.storage.pop().ok_or(MyParseError::UnexpectedUnaryOperator)?;
self.storage.push(MyExpr::Neg(Box::new(popped)));
}
_ => unreachable!("Invalid operator"),
}
Ok(())
}
/// Accepts an opening parenthesis.
pub fn push_open_paren(&mut self) -> Result<(), MyParseError> {
self.open_parens += 1;
Ok(())
}
/// Accepts a closing parenthesis.
pub fn push_close_paren(&mut self) -> Result<(), MyParseError> {
if self.open_parens == 0 {
return Err(MyParseError::UnmatchedParenthesis);
}
self.open_parens -= 1;
Ok(())
}
/// Finalizes parsing and returns the resulting expression.
pub fn finalize(self) -> Result<MyExpr, MyParseError> {
if self.open_parens > 0 {
Err(MyParseError::UnmatchedParenthesis)
} else if self.storage.len() == 1 {
Ok(self.storage.into_iter().next().unwrap())
} else {
Err(MyParseError::ParsingIncomplete)
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum BoolValue {
TrueVal,
FalseVal,
Deferred(MyExpr),
}
/// Evaluates a given expression against 'truthy' and 'falsy' sets.
pub fn evaluate(expr: &MyExpr, truthy: &[char], falsy: &[char]) -> BoolValue {
match expr {
MyExpr::Symbol(sym) => {
if truthy.contains(sym) {
BoolValue::TrueVal
} else if falsy.contains(sym) {
BoolValue::FalseVal
} else {
BoolValue::Deferred(expr.clone())
}
}
MyExpr::Neg(inner_expr) => {
let outcome = evaluate(inner_expr, truthy, falsy);
match outcome {
BoolValue::TrueVal => BoolValue::FalseVal,
BoolValue::FalseVal => BoolValue::TrueVal,
BoolValue::Deferred(deferred_expr) => {
BoolValue::Deferred(MyExpr::Neg(Box::new(deferred_expr)))
}
}
}
MyExpr::Conjunction(expr_list) => {
for sub_expr in expr_list {
if evaluate(sub_expr, truthy, falsy) == BoolValue::FalseVal {
return BoolValue::FalseVal;
}
}
BoolValue::TrueVal
}
MyExpr::Disjunction(expr_list) => {
for sub_expr in expr_list {
if evaluate(sub_expr, truthy, falsy) == BoolValue::TrueVal {
return BoolValue::TrueVal;
}
}
BoolValue::FalseVal
}
}
}

Лог от изпълнението

Compiling solution v0.1.0 (/tmp/d20241224-258381-17i74il/solution)
error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:372:58
    |
372 |         assert_eq!(eval(&expr!(atom('A')), &['A'], &[]), Value::True);
    |                                                          ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:373:58
    |
373 |         assert_eq!(eval(&expr!(atom('A')), &[], &['A']), Value::False);
    |                                                          ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:375:66
    |
375 |         assert_eq!(eval(&expr!(not(atom('B'))), &['A'], &['B']), Value::True);
    |                                                                  ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:376:66
    |
376 |         assert_eq!(eval(&expr!(not(atom('B'))), &['B'], &['A']), Value::False);
    |                                                                  ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:378:79
    |
378 |         assert_eq!(eval(&expr!(and(atom('A'), atom('B'))), &['A', 'B'], &[]), Value::True);
    |                                                                               ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:379:77
    |
379 |         assert_eq!(eval(&expr!(and(atom('A'), atom('B'))), &['A'], &['B']), Value::False);
    |                                                                             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:380:76
    |
380 |         assert_eq!(eval(&expr!(or(atom('A'), atom('B'))), &['A'], &['B']), Value::True);
    |                                                                            ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:381:78
    |
381 |         assert_eq!(eval(&expr!(or(atom('A'), atom('B'))), &[], &['A', 'B']), Value::False);
    |                                                                              ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:390:13
    |
390 |             Value::False
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:394:13
    |
394 |             Value::True
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:398:13
    |
398 |             Value::False
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:402:13
    |
402 |             Value::True
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:422:13
    |
422 |             Value::False
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:427:13
    |
427 |             Value::True
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:440:13
    |
440 |             Value::False
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:445:13
    |
445 |             Value::True
    |             ^^^^^ use of undeclared type `Value`

error[E0412]: cannot find type `SimpleExprParser` in this scope
  --> tests/solution_test.rs:44:29
   |
44 | fn feed_simple(parser: &mut SimpleExprParser, text: &str) -> Result<(), ParseError> {
   |                             ^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `FullExprParser`
   |
  ::: /tmp/d20241224-258381-17i74il/solution/src/lib.rs:88:1
   |
88 | pub struct FullExprParser {
   | ------------------------- similarly named struct `FullExprParser` defined here

error[E0412]: cannot find type `ParseError` in this scope
  --> tests/solution_test.rs:44:73
   |
44 | fn feed_simple(parser: &mut SimpleExprParser, text: &str) -> Result<(), ParseError> {
   |                                                                         ^^^^^^^^^^
   |
  ::: /tmp/d20241224-258381-17i74il/solution/src/lib.rs:2:1
   |
2  | pub enum MyParseError {
   | --------------------- similarly named enum `MyParseError` defined here
   |
help: an enum with a similar name exists
   |
44 | fn feed_simple(parser: &mut SimpleExprParser, text: &str) -> Result<(), MyParseError> {
   |                                                                         ~~~~~~~~~~~~
help: consider importing this type alias
   |
2  |   use std::string::ParseError;
   |

error[E0412]: cannot find type `ExprParser` in this scope
  --> tests/solution_test.rs:58:27
   |
58 | fn feed_full(parser: &mut ExprParser, text: &str) -> Result<(), ParseError> {
   |                           ^^^^^^^^^^ not found in this scope

error[E0412]: cannot find type `ParseError` in this scope
  --> tests/solution_test.rs:58:65
   |
58 | fn feed_full(parser: &mut ExprParser, text: &str) -> Result<(), ParseError> {
   |                                                                 ^^^^^^^^^^
   |
  ::: /tmp/d20241224-258381-17i74il/solution/src/lib.rs:2:1
   |
2  | pub enum MyParseError {
   | --------------------- similarly named enum `MyParseError` defined here
   |
help: an enum with a similar name exists
   |
58 | fn feed_full(parser: &mut ExprParser, text: &str) -> Result<(), MyParseError> {
   |                                                                 ~~~~~~~~~~~~
help: consider importing this type alias
   |
2  |   use std::string::ParseError;
   |

warning: unused import: `solution::*`
 --> tests/solution_test.rs:2:7
  |
2 |   use solution::*;
  |       ^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
  --> tests/solution_test.rs:75:26
   |
75 |         let mut parser = SimpleExprParser::new();
   |                          ^^^^^^^^^^^^^^^^
   |                          |
   |                          use of undeclared type `SimpleExprParser`
   |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
  --> tests/solution_test.rs:30:9
   |
30 |         Expr::Atom($c)
   |         ^^^^ use of undeclared type `Expr`
...
78 |         assert_eq!(parser.finish().unwrap(), expr!(atom('A')));
   |                                              ---------------- in this macro invocation
   |
   = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
  --> tests/solution_test.rs:85:26
   |
85 |         let mut parser = SimpleExprParser::new();
   |                          ^^^^^^^^^^^^^^^^
   |                          |
   |                          use of undeclared type `SimpleExprParser`
   |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
  --> tests/solution_test.rs:36:9
   |
36 |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
   |         ^^^^ use of undeclared type `Expr`
...
88 |         assert_eq!(parser.finish().unwrap(), expr!(and(atom('A'), atom('B'))));
   |                                              -------------------------------- in this macro invocation
   |
   = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
  --> tests/solution_test.rs:30:9
   |
30 |         Expr::Atom($c)
   |         ^^^^ use of undeclared type `Expr`
...
88 |         assert_eq!(parser.finish().unwrap(), expr!(and(atom('A'), atom('B'))));
   |                                              -------------------------------- in this macro invocation
   |
   = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
  --> tests/solution_test.rs:90:26
   |
90 |         let mut parser = SimpleExprParser::new();
   |                          ^^^^^^^^^^^^^^^^
   |                          |
   |                          use of undeclared type `SimpleExprParser`
   |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
  --> tests/solution_test.rs:39:9
   |
39 |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
   |         ^^^^ use of undeclared type `Expr`
...
92 |         assert_eq!(parser.finish().unwrap(), expr!(or(atom('A'), atom('B'))));
   |                                              ------------------------------- in this macro invocation
   |
   = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
  --> tests/solution_test.rs:30:9
   |
30 |         Expr::Atom($c)
   |         ^^^^ use of undeclared type `Expr`
...
92 |         assert_eq!(parser.finish().unwrap(), expr!(or(atom('A'), atom('B'))));
   |                                              ------------------------------- in this macro invocation
   |
   = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
  --> tests/solution_test.rs:99:26
   |
99 |         let mut parser = SimpleExprParser::new();
   |                          ^^^^^^^^^^^^^^^^
   |                          |
   |                          use of undeclared type `SimpleExprParser`
   |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
101 |         assert_eq!(parser.finish().unwrap(), expr!(not(atom('B'))));
    |                                              --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
101 |         assert_eq!(parser.finish().unwrap(), expr!(not(atom('B'))));
    |                                              --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:108:26
    |
108 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
110 |         assert_eq!(parser.finish().unwrap(), expr!(and(atom('A'), not(atom('B')))));
    |                                              ------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
110 |         assert_eq!(parser.finish().unwrap(), expr!(and(atom('A'), not(atom('B')))));
    |                                              ------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
110 |         assert_eq!(parser.finish().unwrap(), expr!(and(atom('A'), not(atom('B')))));
    |                                              ------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:112:26
    |
112 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
114 |         assert_eq!(parser.finish().unwrap(), expr!(or(not(atom('A')), atom('B'))));
    |                                              ------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
114 |         assert_eq!(parser.finish().unwrap(), expr!(or(not(atom('A')), atom('B'))));
    |                                              ------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
114 |         assert_eq!(parser.finish().unwrap(), expr!(or(not(atom('A')), atom('B'))));
    |                                              ------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:116:26
    |
116 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
118 |         assert_eq!(parser.finish().unwrap(), expr!(and(not(atom('A')), not(atom('B')))));
    |                                              ------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
118 |         assert_eq!(parser.finish().unwrap(), expr!(and(not(atom('A')), not(atom('B')))));
    |                                              ------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
118 |         assert_eq!(parser.finish().unwrap(), expr!(and(not(atom('A')), not(atom('B')))));
    |                                              ------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:125:26
    |
125 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
127 |         assert_eq!(parser.finish().unwrap(), expr!(and(atom('A'), atom('B'), atom('C'))));
    |                                              ------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
127 |         assert_eq!(parser.finish().unwrap(), expr!(and(atom('A'), atom('B'), atom('C'))));
    |                                              ------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:129:26
    |
129 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
133 |             expr!(or(atom('X'), atom('Y'), atom('Z'), atom('W')))
    |             ----------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
133 |             expr!(or(atom('X'), atom('Y'), atom('Z'), atom('W')))
    |             ----------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:141:26
    |
141 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
143 |         assert_eq!(parser.finish().unwrap(), expr!(not(not(not(atom('B'))))));
    |                                              ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
143 |         assert_eq!(parser.finish().unwrap(), expr!(not(not(not(atom('B'))))));
    |                                              ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:145:26
    |
145 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
147 |         assert_eq!(parser.finish().unwrap(), expr!(or(atom('A'), not(not(atom('B'))))));
    |                                              ----------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
147 |         assert_eq!(parser.finish().unwrap(), expr!(or(atom('A'), not(not(atom('B'))))));
    |                                              ----------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
147 |         assert_eq!(parser.finish().unwrap(), expr!(or(atom('A'), not(not(atom('B'))))));
    |                                              ----------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:149:26
    |
149 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
151 |         assert_eq!(parser.finish().unwrap(), expr!(or(not(not(atom('A'))), atom('B'))));
    |                                              ----------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
151 |         assert_eq!(parser.finish().unwrap(), expr!(or(not(not(atom('A'))), atom('B'))));
    |                                              ----------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
151 |         assert_eq!(parser.finish().unwrap(), expr!(or(not(not(atom('A'))), atom('B'))));
    |                                              ----------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:158:26
    |
158 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
162 |             expr!(and(or(and(atom('A'), atom('B')), atom('C')), atom('D')))
    |             --------------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
162 |             expr!(and(or(and(atom('A'), atom('B')), atom('C')), atom('D')))
    |             --------------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
162 |             expr!(and(or(and(atom('A'), atom('B')), atom('C')), atom('D')))
    |             --------------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:165:26
    |
165 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
169 |             expr!(or(and(or(atom('A'), atom('B')), atom('C')), atom('D')))
    |             -------------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
169 |             expr!(or(and(or(atom('A'), atom('B')), atom('C')), atom('D')))
    |             -------------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
169 |             expr!(or(and(or(atom('A'), atom('B')), atom('C')), atom('D')))
    |             -------------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:177:26
    |
177 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
179 |         assert_eq!(parser.finish().unwrap(), expr!(atom('A')));
    |                                              ---------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:181:26
    |
181 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
183 |         assert_eq!(parser.finish().unwrap(), expr!(and(atom('A'), atom('B'))));
    |                                              -------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
183 |         assert_eq!(parser.finish().unwrap(), expr!(and(atom('A'), atom('B'))));
    |                                              -------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:185:26
    |
185 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
187 |         assert_eq!(parser.finish().unwrap(), expr!(or(atom('A'), atom('B'))));
    |                                              ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
187 |         assert_eq!(parser.finish().unwrap(), expr!(or(atom('A'), atom('B'))));
    |                                              ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:189:26
    |
189 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
191 |         assert_eq!(parser.finish().unwrap(), expr!(not(atom('A'))));
    |                                              --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
191 |         assert_eq!(parser.finish().unwrap(), expr!(not(atom('A'))));
    |                                              --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:198:26
    |
198 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
202 |             expr!(or(atom('X'), and(atom('A'), atom('B'))))
    |             ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
202 |             expr!(or(atom('X'), and(atom('A'), atom('B'))))
    |             ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
202 |             expr!(or(atom('X'), and(atom('A'), atom('B'))))
    |             ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:205:26
    |
205 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
209 |             expr!(and(or(atom('A'), atom('B')), atom('X')))
    |             ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
209 |             expr!(and(or(atom('A'), atom('B')), atom('X')))
    |             ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
209 |             expr!(and(or(atom('A'), atom('B')), atom('X')))
    |             ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:217:26
    |
217 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
221 |             expr!(and(atom('X'), not(or(atom('A'), atom('B')))))
    |             ---------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
221 |             expr!(and(atom('X'), not(or(atom('A'), atom('B')))))
    |             ---------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
221 |             expr!(and(atom('X'), not(or(atom('A'), atom('B')))))
    |             ---------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
221 |             expr!(and(atom('X'), not(or(atom('A'), atom('B')))))
    |             ---------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:224:26
    |
224 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
228 |             expr!(or(not(or(atom('A'), atom('B'))), atom('X')))
    |             --------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
228 |             expr!(or(not(or(atom('A'), atom('B'))), atom('X')))
    |             --------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
228 |             expr!(or(not(or(atom('A'), atom('B'))), atom('X')))
    |             --------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:236:26
    |
236 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |           Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |           ^^^^ use of undeclared type `Expr`
...
240 | /             expr!(or(
241 | |                     atom('X'),
242 | |                     and(atom('A'), atom('B')),
243 | |                     and(atom('C'), atom('D')),
244 | |                     atom('Y')
245 | |             ))
    | |______________- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |           Expr::Atom($c)
    |           ^^^^ use of undeclared type `Expr`
...
240 | /             expr!(or(
241 | |                     atom('X'),
242 | |                     and(atom('A'), atom('B')),
243 | |                     and(atom('C'), atom('D')),
244 | |                     atom('Y')
245 | |             ))
    | |______________- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |           Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |           ^^^^ use of undeclared type `Expr`
...
240 | /             expr!(or(
241 | |                     atom('X'),
242 | |                     and(atom('A'), atom('B')),
243 | |                     and(atom('C'), atom('D')),
244 | |                     atom('Y')
245 | |             ))
    | |______________- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:253:26
    |
253 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
257 |             expr!(not(and(atom('A'), not(and(atom('B'), not(and(atom('C'), atom('D'))))))))
    |             ------------------------------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
257 |             expr!(not(and(atom('A'), not(and(atom('B'), not(and(atom('C'), atom('D'))))))))
    |             ------------------------------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
257 |             expr!(not(and(atom('A'), not(and(atom('B'), not(and(atom('C'), atom('D'))))))))
    |             ------------------------------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:266:26
    |
266 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:269:26
    |
269 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:272:26
    |
272 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:276:26
    |
276 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:280:26
    |
280 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:285:26
    |
285 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:289:26
    |
289 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:293:26
    |
293 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:297:26
    |
297 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:306:26
    |
306 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:309:26
    |
309 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:313:26
    |
313 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `SimpleExprParser`
   --> tests/solution_test.rs:317:26
    |
317 |         let mut parser = SimpleExprParser::new();
    |                          ^^^^^^^^^^^^^^^^
    |                          |
    |                          use of undeclared type `SimpleExprParser`
    |                          help: a struct with a similar name exists: `FullExprParser`

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:326:26
    |
326 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:329:26
    |
329 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:333:26
    |
333 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:339:26
    |
339 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:344:26
    |
344 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:348:26
    |
348 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:353:26
    |
353 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `ExprParser`
   --> tests/solution_test.rs:360:26
    |
360 |         let mut parser = ExprParser::new();
    |                          ^^^^^^^^^^ use of undeclared type `ExprParser`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
372 |         assert_eq!(eval(&expr!(atom('A')), &['A'], &[]), Value::True);
    |                          ---------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:372:20
    |
372 |         assert_eq!(eval(&expr!(atom('A')), &['A'], &[]), Value::True);
    |                    ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
373 |         assert_eq!(eval(&expr!(atom('A')), &[], &['A']), Value::False);
    |                          ---------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:373:20
    |
373 |         assert_eq!(eval(&expr!(atom('A')), &[], &['A']), Value::False);
    |                    ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
375 |         assert_eq!(eval(&expr!(not(atom('B'))), &['A'], &['B']), Value::True);
    |                          --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
375 |         assert_eq!(eval(&expr!(not(atom('B'))), &['A'], &['B']), Value::True);
    |                          --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:375:20
    |
375 |         assert_eq!(eval(&expr!(not(atom('B'))), &['A'], &['B']), Value::True);
    |                    ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
376 |         assert_eq!(eval(&expr!(not(atom('B'))), &['B'], &['A']), Value::False);
    |                          --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
376 |         assert_eq!(eval(&expr!(not(atom('B'))), &['B'], &['A']), Value::False);
    |                          --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:376:20
    |
376 |         assert_eq!(eval(&expr!(not(atom('B'))), &['B'], &['A']), Value::False);
    |                    ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
378 |         assert_eq!(eval(&expr!(and(atom('A'), atom('B'))), &['A', 'B'], &[]), Value::True);
    |                          -------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
378 |         assert_eq!(eval(&expr!(and(atom('A'), atom('B'))), &['A', 'B'], &[]), Value::True);
    |                          -------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:378:20
    |
378 |         assert_eq!(eval(&expr!(and(atom('A'), atom('B'))), &['A', 'B'], &[]), Value::True);
    |                    ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
379 |         assert_eq!(eval(&expr!(and(atom('A'), atom('B'))), &['A'], &['B']), Value::False);
    |                          -------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
379 |         assert_eq!(eval(&expr!(and(atom('A'), atom('B'))), &['A'], &['B']), Value::False);
    |                          -------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:379:20
    |
379 |         assert_eq!(eval(&expr!(and(atom('A'), atom('B'))), &['A'], &['B']), Value::False);
    |                    ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
380 |         assert_eq!(eval(&expr!(or(atom('A'), atom('B'))), &['A'], &['B']), Value::True);
    |                          ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
380 |         assert_eq!(eval(&expr!(or(atom('A'), atom('B'))), &['A'], &['B']), Value::True);
    |                          ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:380:20
    |
380 |         assert_eq!(eval(&expr!(or(atom('A'), atom('B'))), &['A'], &['B']), Value::True);
    |                    ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
381 |         assert_eq!(eval(&expr!(or(atom('A'), atom('B'))), &[], &['A', 'B']), Value::False);
    |                          ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
381 |         assert_eq!(eval(&expr!(or(atom('A'), atom('B'))), &[], &['A', 'B']), Value::False);
    |                          ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:381:20
    |
381 |         assert_eq!(eval(&expr!(or(atom('A'), atom('B'))), &[], &['A', 'B']), Value::False);
    |                    ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
389 |             eval(&expr!(not(and(atom('A'), atom('B')))), &['A', 'B'], &[]),
    |                   ------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
389 |             eval(&expr!(not(and(atom('A'), atom('B')))), &['A', 'B'], &[]),
    |                   ------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
389 |             eval(&expr!(not(and(atom('A'), atom('B')))), &['A', 'B'], &[]),
    |                   ------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:389:13
    |
389 |             eval(&expr!(not(and(atom('A'), atom('B')))), &['A', 'B'], &[]),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
393 |             eval(&expr!(not(and(atom('A'), atom('B')))), &['A'], &['B']),
    |                   ------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
393 |             eval(&expr!(not(and(atom('A'), atom('B')))), &['A'], &['B']),
    |                   ------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
393 |             eval(&expr!(not(and(atom('A'), atom('B')))), &['A'], &['B']),
    |                   ------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:393:13
    |
393 |             eval(&expr!(not(and(atom('A'), atom('B')))), &['A'], &['B']),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
397 |             eval(&expr!(not(or(atom('A'), atom('B')))), &['A'], &['B']),
    |                   ------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
397 |             eval(&expr!(not(or(atom('A'), atom('B')))), &['A'], &['B']),
    |                   ------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
397 |             eval(&expr!(not(or(atom('A'), atom('B')))), &['A'], &['B']),
    |                   ------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:397:13
    |
397 |             eval(&expr!(not(or(atom('A'), atom('B')))), &['A'], &['B']),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
401 |             eval(&expr!(not(or(atom('A'), atom('B')))), &[], &['A', 'B']),
    |                   ------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
401 |             eval(&expr!(not(or(atom('A'), atom('B')))), &[], &['A', 'B']),
    |                   ------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
401 |             eval(&expr!(not(or(atom('A'), atom('B')))), &[], &['A', 'B']),
    |                   ------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:401:13
    |
401 |             eval(&expr!(not(or(atom('A'), atom('B')))), &[], &['A', 'B']),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
410 |         assert_eq!(eval(&expr!(atom('A')), &[], &[]), Value::Expr(expr!(atom('A'))));
    |                          ---------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:410:20
    |
410 |         assert_eq!(eval(&expr!(atom('A')), &[], &[]), Value::Expr(expr!(atom('A'))));
    |                    ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:410:55
    |
410 |         assert_eq!(eval(&expr!(atom('A')), &[], &[]), Value::Expr(expr!(atom('A'))));
    |                                                       ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
410 |         assert_eq!(eval(&expr!(atom('A')), &[], &[]), Value::Expr(expr!(atom('A'))));
    |                                                                   ---------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
412 |             eval(&expr!(not(atom('B'))), &[], &[]),
    |                   --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
412 |             eval(&expr!(not(atom('B'))), &[], &[]),
    |                   --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:412:13
    |
412 |             eval(&expr!(not(atom('B'))), &[], &[]),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:413:13
    |
413 |             Value::Expr(expr!(not(atom('B'))))
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
413 |             Value::Expr(expr!(not(atom('B'))))
    |                         --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
413 |             Value::Expr(expr!(not(atom('B'))))
    |                         --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
417 |             eval(&expr!(and(atom('A'), atom('B'), atom('C'))), &['B'], &[]),
    |                   ------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
417 |             eval(&expr!(and(atom('A'), atom('B'), atom('C'))), &['B'], &[]),
    |                   ------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:417:13
    |
417 |             eval(&expr!(and(atom('A'), atom('B'), atom('C'))), &['B'], &[]),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:418:13
    |
418 |             Value::Expr(expr!(and(atom('A'), atom('C'))))
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
418 |             Value::Expr(expr!(and(atom('A'), atom('C'))))
    |                         -------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
418 |             Value::Expr(expr!(and(atom('A'), atom('C'))))
    |                         -------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
421 |             eval(&expr!(and(atom('A'), atom('B'), atom('C'))), &[], &['B']),
    |                   ------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
421 |             eval(&expr!(and(atom('A'), atom('B'), atom('C'))), &[], &['B']),
    |                   ------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:421:13
    |
421 |             eval(&expr!(and(atom('A'), atom('B'), atom('C'))), &[], &['B']),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
426 |             eval(&expr!(or(atom('A'), atom('B'), atom('C'))), &['B'], &[]),
    |                   ------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
426 |             eval(&expr!(or(atom('A'), atom('B'), atom('C'))), &['B'], &[]),
    |                   ------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:426:13
    |
426 |             eval(&expr!(or(atom('A'), atom('B'), atom('C'))), &['B'], &[]),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
430 |             eval(&expr!(or(atom('A'), atom('B'), atom('C'))), &[], &['B']),
    |                   ------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
430 |             eval(&expr!(or(atom('A'), atom('B'), atom('C'))), &[], &['B']),
    |                   ------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:430:13
    |
430 |             eval(&expr!(or(atom('A'), atom('B'), atom('C'))), &[], &['B']),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:431:13
    |
431 |             Value::Expr(expr!(or(atom('A'), atom('C'))))
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
431 |             Value::Expr(expr!(or(atom('A'), atom('C'))))
    |                         ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
431 |             Value::Expr(expr!(or(atom('A'), atom('C'))))
    |                         ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
435 |             eval(&expr!(and(atom('A'), not(atom('B')), atom('C'))), &[], &['B']),
    |                   ------------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
435 |             eval(&expr!(and(atom('A'), not(atom('B')), atom('C'))), &[], &['B']),
    |                   ------------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
435 |             eval(&expr!(and(atom('A'), not(atom('B')), atom('C'))), &[], &['B']),
    |                   ------------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:435:13
    |
435 |             eval(&expr!(and(atom('A'), not(atom('B')), atom('C'))), &[], &['B']),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:436:13
    |
436 |             Value::Expr(expr!(and(atom('A'), atom('C'))))
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
436 |             Value::Expr(expr!(and(atom('A'), atom('C'))))
    |                         -------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
436 |             Value::Expr(expr!(and(atom('A'), atom('C'))))
    |                         -------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
439 |             eval(&expr!(and(atom('A'), not(atom('B')), atom('C'))), &['B'], &[]),
    |                   ------------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
439 |             eval(&expr!(and(atom('A'), not(atom('B')), atom('C'))), &['B'], &[]),
    |                   ------------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
439 |             eval(&expr!(and(atom('A'), not(atom('B')), atom('C'))), &['B'], &[]),
    |                   ------------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:439:13
    |
439 |             eval(&expr!(and(atom('A'), not(atom('B')), atom('C'))), &['B'], &[]),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
444 |             eval(&expr!(or(atom('A'), not(atom('B')), atom('C'))), &[], &['B']),
    |                   ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
444 |             eval(&expr!(or(atom('A'), not(atom('B')), atom('C'))), &[], &['B']),
    |                   ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
444 |             eval(&expr!(or(atom('A'), not(atom('B')), atom('C'))), &[], &['B']),
    |                   ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:444:13
    |
444 |             eval(&expr!(or(atom('A'), not(atom('B')), atom('C'))), &[], &['B']),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
448 |             eval(&expr!(or(atom('A'), not(atom('B')), atom('C'))), &['B'], &[]),
    |                   ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
448 |             eval(&expr!(or(atom('A'), not(atom('B')), atom('C'))), &['B'], &[]),
    |                   ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
448 |             eval(&expr!(or(atom('A'), not(atom('B')), atom('C'))), &['B'], &[]),
    |                   ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:448:13
    |
448 |             eval(&expr!(or(atom('A'), not(atom('B')), atom('C'))), &['B'], &[]),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:449:13
    |
449 |             Value::Expr(expr!(or(atom('A'), atom('C'))))
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
449 |             Value::Expr(expr!(or(atom('A'), atom('C'))))
    |                         ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
449 |             Value::Expr(expr!(or(atom('A'), atom('C'))))
    |                         ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
458 |             eval(&expr!(and(atom('A'), atom('B'), atom('C'))), &['A', 'C'], &[]),
    |                   ------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
458 |             eval(&expr!(and(atom('A'), atom('B'), atom('C'))), &['A', 'C'], &[]),
    |                   ------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:458:13
    |
458 |             eval(&expr!(and(atom('A'), atom('B'), atom('C'))), &['A', 'C'], &[]),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:459:13
    |
459 |             Value::Expr(expr!(atom('B')))
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
459 |             Value::Expr(expr!(atom('B')))
    |                         ---------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
462 |             eval(&expr!(or(atom('A'), atom('B'), atom('C'))), &[], &['A', 'C']),
    |                   ------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
462 |             eval(&expr!(or(atom('A'), atom('B'), atom('C'))), &[], &['A', 'C']),
    |                   ------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:462:13
    |
462 |             eval(&expr!(or(atom('A'), atom('B'), atom('C'))), &[], &['A', 'C']),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:463:13
    |
463 |             Value::Expr(expr!(atom('B')))
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
463 |             Value::Expr(expr!(atom('B')))
    |                         ---------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |         Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
467 |             eval(&expr!(and(atom('A'), not(atom('B')), atom('C'))), &['A', 'C'], &[]),
    |                   ------------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
467 |             eval(&expr!(and(atom('A'), not(atom('B')), atom('C'))), &['A', 'C'], &[]),
    |                   ------------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
467 |             eval(&expr!(and(atom('A'), not(atom('B')), atom('C'))), &['A', 'C'], &[]),
    |                   ------------------------------------------------ in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:467:13
    |
467 |             eval(&expr!(and(atom('A'), not(atom('B')), atom('C'))), &['A', 'C'], &[]),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:468:13
    |
468 |             Value::Expr(expr!(not(atom('B'))))
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
468 |             Value::Expr(expr!(not(atom('B'))))
    |                         --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
468 |             Value::Expr(expr!(not(atom('B'))))
    |                         --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
471 |             eval(&expr!(or(atom('A'), not(atom('B')), atom('C'))), &[], &['A', 'C']),
    |                   ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
471 |             eval(&expr!(or(atom('A'), not(atom('B')), atom('C'))), &[], &['A', 'C']),
    |                   ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
471 |             eval(&expr!(or(atom('A'), not(atom('B')), atom('C'))), &[], &['A', 'C']),
    |                   ----------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:471:13
    |
471 |             eval(&expr!(or(atom('A'), not(atom('B')), atom('C'))), &[], &['A', 'C']),
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:472:13
    |
472 |             Value::Expr(expr!(not(atom('B'))))
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
472 |             Value::Expr(expr!(not(atom('B'))))
    |                         --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
472 |             Value::Expr(expr!(not(atom('B'))))
    |                         --------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |           Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |           ^^^^ use of undeclared type `Expr`
...
482 |                   &expr!(or(
    |  __________________-
483 | |                         atom('X'),
484 | |                         and(atom('A'), atom('B')),
485 | |                         not(and(atom('C'), atom('D'))),
486 | |                         atom('Y')
487 | |                 )),
    | |__________________- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |           Expr::Atom($c)
    |           ^^^^ use of undeclared type `Expr`
...
482 |                   &expr!(or(
    |  __________________-
483 | |                         atom('X'),
484 | |                         and(atom('A'), atom('B')),
485 | |                         not(and(atom('C'), atom('D'))),
486 | |                         atom('Y')
487 | |                 )),
    | |__________________- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:36:9
    |
36  |           Expr::And(vec![$( expr!($tag($( $e )*)) ),*])
    |           ^^^^ use of undeclared type `Expr`
...
482 |                   &expr!(or(
    |  __________________-
483 | |                         atom('X'),
484 | |                         and(atom('A'), atom('B')),
485 | |                         not(and(atom('C'), atom('D'))),
486 | |                         atom('Y')
487 | |                 )),
    | |__________________- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |           Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |           ^^^^ use of undeclared type `Expr`
...
482 |                   &expr!(or(
    |  __________________-
483 | |                         atom('X'),
484 | |                         and(atom('A'), atom('B')),
485 | |                         not(and(atom('C'), atom('D'))),
486 | |                         atom('Y')
487 | |                 )),
    | |__________________- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0425]: cannot find function `eval` in this scope
   --> tests/solution_test.rs:481:13
    |
481 |             eval(
    |             ^^^^ not found in this scope

error[E0433]: failed to resolve: use of undeclared type `Value`
   --> tests/solution_test.rs:491:13
    |
491 |             Value::Expr(expr!(or(atom('X'), atom('B'), not(atom('D')), atom('Y'))))
    |             ^^^^^ use of undeclared type `Value`

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:39:9
    |
39  |         Expr::Or(vec![$( expr!($tag($( $e )*)) ),*])
    |         ^^^^ use of undeclared type `Expr`
...
491 |             Value::Expr(expr!(or(atom('X'), atom('B'), not(atom('D')), atom('Y'))))
    |                         ---------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:30:9
    |
30  |         Expr::Atom($c)
    |         ^^^^ use of undeclared type `Expr`
...
491 |             Value::Expr(expr!(or(atom('X'), atom('B'), not(atom('D')), atom('Y'))))
    |                         ---------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0433]: failed to resolve: use of undeclared type `Expr`
   --> tests/solution_test.rs:33:9
    |
33  |         Expr::Not(Box::new(expr!( $tag($( $e )*) )))
    |         ^^^^ use of undeclared type `Expr`
...
491 |             Value::Expr(expr!(or(atom('X'), atom('B'), not(atom('D')), atom('Y'))))
    |                         ---------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `expr` (in Nightly builds, run with -Z macro-backtrace for more info)

Some errors have detailed explanations: E0412, E0425, E0433.
For more information about an error, try `rustc --explain E0412`.
warning: `solution` (test "solution_test") generated 1 warning
error: could not compile `solution` due to 340 previous errors; 1 warning emitted

История (1 версия и 0 коментара)

Иван качи първо решение на 22.12.2024 13:07 (преди 11 месеца)