   <|> NumericExpression.Paren <~> (left_paren *> numeric_expression <* right_paren)
 
 let exponent_expresion = paren_expression
-  <|> curry(NumericExpression.Exp) <~> (numeric_expression <* exponent_op) <*> numeric_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
-  <|> curry(NumericExpression.Multiply) <~> (numeric_expression <* mult_op) <*> numeric_expression
-  <|> curry(NumericExpression.Divide) <~> (numeric_expression <* divide_op) <*> numeric_expression
+  <|> NumericExpression.CreateMult <~> (numeric_expression <* mult_op) <*> numeric_expression
+  <|> NumericExpression.CreateDiv <~> (numeric_expression <* divide_op) <*> numeric_expression
 
 let add_expression = multiply_expression
-  <|> curry(NumericExpression.Add) <~> (numeric_expression <* plus_op) <*> numeric_expression
-  <|> curry(NumericExpression.Subtract) <~> (numeric_expression <* subtract_op) <*> numeric_expression
+  <|> NumericExpression.CreateAdd <~> (numeric_expression <* plus_op) <*> numeric_expression
+  <|> NumericExpression.CreateSub <~> (numeric_expression <* subtract_op) <*> numeric_expression

    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)

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
