// An interpreter for a small calculator language.

// Representation of expressions in the calculator language.
enum CalcExpr {
  // Number literals
  Num(i64),
  // Addition expressions
  Add(CalcExprPair),
  // Multiplication expressions
  Mul(CalcExprPair),
  // Negation expressions
  Neg(CalcExpr),
}

// A pair of expressions
struct CalcExprPair {
  left: CalcExpr,
  right: CalcExpr,
}

// Evaluate/interpret a calculator expression and return the result.
fn eval(expr: CalcExpr) -> i64 {
  match (expr) {
    Num(num) => num,
    Add(pair) => eval(pair.left) + eval(pair.right),
    Mul(pair) => eval(pair.left) * eval(pair.right),
    Neg(expr) => - eval(expr),
  }
}

// Pretty-print a calculator expression.
fn show(expr: CalcExpr) -> () {
  match (expr) {
    Num(num) => printi64(num),
    Add(pair) => show_pair(pair, "+"),
    Mul(pair) => show_pair(pair, "*"),
    Neg(expr) => {
      print("-");
      show(expr);
    },
  }
}
fn show_pair(pair: CalcExprPair, op: String) -> () {
  print("(");
  show(pair.left);
  print(" ");
  print(op);
  print(" ");
  show(pair.right);
  print(")");
}

fn main(args: [String]) -> () {
  let calcExpr = Add(CalcExprPair {
    left: Mul(CalcExprPair { left: Num(7), right: Num(3) }),
    right: Add(CalcExprPair {
      left: Neg(Mul(CalcExprPair {
        left: Num(2),
        right: Add(CalcExprPair { left: Num(4), right: Num(6) })
      })),
      right: Num(23)
    })
  });
  print("Evaluating calculator expression: ");
  show(calcExpr);
  println("");
  let result = eval(calcExpr);
  print("Result is: ");
  printi64(result);
  println("");
}