 let subtract_op = char("-")
 let number = nat
 
+// TODO: This algorithm requires a bit of backtracking -- can rewrite to avoid that.
+// Example: 3 + 5, the number 3 is parsed several times before we back track up to the add_expression
+// I think, that is the case anyway. I should brush up on the parsing of Expressions.
+
 let numeric_expression:Tokenizer<NumericExpression> = add_expression
 
 let number_literal_expr = NumericExpression.NumberLiteral <~> number

    case Divide(NumericExpression, NumericExpression)
    case Add(NumericExpression, NumericExpression)
    case Subtract(NumericExpression, NumericExpression)
}
func curry<A,B,C>(f:(A,B)->C)(_ a:A)(_ b:B) -> C {
    return f(a,b)

  <|> NumericExpression.Paren <~> (left_paren *> numeric_expression <* right_paren)

let exponent_expresion = paren_expression
  <|> NumericExpression.CreateExp <~> (numeric_expression <* exponent_op) <*> numeric_expression

let prefix_expression = exponent_expresion
  <|> plus_op *> numeric_expression
  <|> NumericExpression.Negate <~> (subtract_op *> numeric_expression)

let multiply_expression = prefix_expression
  <|> NumericExpression.CreateMult <~> (numeric_expression <* mult_op) <*> numeric_expression
  <|> NumericExpression.CreateDiv <~> (numeric_expression <* divide_op) <*> numeric_expression

let add_expression = multiply_expression
  <|> NumericExpression.CreateAdd <~> (numeric_expression <* plus_op) <*> numeric_expression
  <|> NumericExpression.CreateSub <~> (numeric_expression <* subtract_op) <*> numeric_expression
