View difference between Paste ID: Ys2tWxcc and w1jFDhwQ

 enum TokenType {
     Plus,
     Minus,
     Multiply,
     Divide,
     Number,
     OpenBracket,
     CloseBracket
 };
 struct Token {
     TokenType type;
     std::string data;
     // other useful things
 };
 std::vector<Token> lex(std::string input) {
     std::unordered_map<char, TokenType> singles;
     singles['+'] = TokenType::Plus;
     singles['-'] = TokenType::Minus;
     singles['('] = TokenType::OpenBracket;
     singles[')'] = TokenType::CloseBracket;
     singles['*'] = TokenType::Multiply;
     singles['/'] = TokenType::Divide;
     std::unordered_set<char> whitespace;
     whitespace.insert(' ');
     whitespace.insert('\t');
     whitespace.insert('\r');
     whitespace.insert('\n');
     std::unordered_set<char> nums;
     for(int i = 0; i < 10; i++)
         nums.insert('0' + i);
     std::vector<Token> out;
     for(auto it = input.begin(); it != input.end(); ++it) {
         if (singles.find(*it) != singles.end()) {
             Token t;
             t.type = singles[*it];
             out.push_back(t);
             continue;
         }
         if (whitespace.find(*it) != whitespace.end()) {
             continue;
         }
         if (nums.find(*it) != nums.end()) {
             Token t;
             t.type = TokenType::Number;
             while(nums.find(*it) != nums.end()) {
                 t.data.push_back(*it);
                 ++it;
                 if (it == input.end())
                     break;
             }
             out.push_back(t);
             continue;
         }
         // error
     }
     return out;
-};
+
 class Expression {
     virtual ~Expression() {}
 };
 class BinaryExpression : public Expression {
 public:
      std::unique_ptr<Expression> lhs;
      std::unique_ptr<Expression> rhs;
      virtual char GetType() const = 0; // +,-,/,*
 };
 class MultiplyExpression : public BinaryExpression {
 public:
     virtual char GetType() const { return '*'; }
 };
 class DivideExpression : public BinaryExpression {
 public:
     virtual char GetType() const { return '/'; }
 };
 class PlusExpression : public BinaryExpression {
 public:
     virtual char GetType() const { return '+'; }
 };
 class SubExpression : public BinaryExpression {
 public:
     virtual char GetType() const { return '-'; }
 };
 class NumExpression : public Expression {
 public:
     unsigned int num;
 };
 class Parser {
     std::vector<Token::iterator begin, end;
     std::unique_ptr<Expression> operator()() {
         return ParseMultiplicativeExpression();
     }
     void CheckedIncrement() {
         ++begin;
         if (begin == end) // fuck
     }
     std::unique_ptr<Expression> ParseMultiplicativeExpression() {
         // mul_expression ('*' '/') add_expression (left-associative)
         // add_expression
         auto lhs = ParseAdditiveExpression();
         while(true) {
             if (begin->type == TokenType::Multiply) {
                 CheckedIncrement();
                 auto rhs = ParseAdditiveExpression();
                 auto expr = make_unique<MulExpression>();
                 expr->lhs = lhs;
                 expr->rhs = rhs;
                 lhs = expr;
             }
             if (begin->type == TokenType::Divide) {
                 CheckedIncrement();
                 auto rhs = ParseAdditiveExpression();
                 auto expr = make_unique<DivideExpression>();
                 expr->lhs = lhs;
                 expr->rhs = rhs;
                 lhs = expr;
             }
             break; // not a valid mul expr anymore
         }
         return lhs;
     }
     std::unique_ptr<Expression> ParseAdditiveExpression() {
         // primary_expression ('+' '-') add_expression (right-associative)
         // primary_expression
         auto lhs = ParsePrimaryExpression();
         if (begin->type == TokenType::Plus) {
             CheckedIncrement();
             auto expr = make_unique<PlusExpression>();
             auto rhs = ParseAdditiveExpression();
             expr->lhs = lhs; expr->rhs = rhs;
             return expr;
         }
         if (begin->type == TokenType::Minus) {
             CheckedIncrement();
             auto expr = make_unique<SubExpression>();
             auto rhs = ParseAdditiveExpression();
             expr->lhs = lhs; expr->rhs = rhs;
             return expr;
         }
         // not avalid add expression
         return lhs;
     }
     std::unique_ptr<Expression> ParsePrimaryExpression() {
         if (begin->type == TokenType::Number) {
             // parse number from data here
             CheckedIncrement();
             return make_unique<NumExpression>();
         }
         if (begin->type == TokenType::OpenBracket) {
             CheckedIncrement();
             auto expr = ParseMultiplicativeExpression();
             if (begin->type != TokenType::CloseBracket) { } // fuck
             CheckedIncrement();
             return expr;
         }
     }
 };
 std::unique_ptr<Expression> Parse(std::vector<Token> tokens) {
     Parser p;
     p.begin = tokens.begin();
     p.end = tokens.end();
     return p();
 }