     case Divide(NumericExpression, NumericExpression)
     case Add(NumericExpression, NumericExpression)
     case Subtract(NumericExpression, NumericExpression)
+
+    static let CreateExp = curry(Exp)
+    static let CreateMult = curry(Multiply)
+    static let CreateDiv = curry(Divide)
+    static let CreateAdd = curry(Add)
+    static let CreateSub = curry(Subtract)
 }
 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

let numeric_expression:Tokenizer<NumericExpression> = add_expression

let number_literal_expr = NumericExpression.NumberLiteral <~> number

  <|> 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
