/**
 * Beispiel aus
 *
 * - Algorithmen und Datenstrukturen für Dummies
 *   - von Andreas Gogol-Döring und Thomas Letschert
 *   - Verlag Wiley-VCH; Oktober 2019
 *  - Kapitel 5, Bäume: Immer einer über den anderen
 *
 * @author A. Gogol-Döring, Th. Letschert
 */

import Foundation


struct AuD_05_11_ExpressionTree {

    enum Expr {
        case Number(number: Int)
        indirect case Add(left: Expr, right: Expr)
        indirect case Sub(left: Expr, right: Expr)
        indirect case Mult(left: Expr, right: Expr)
    }

    static func Evaluate(expr: Expr) -> Int {
        switch expr {
        case .Number(let n): return n
        case .Add(let l, let r): return Evaluate(expr: l) + Evaluate(expr: r)
        case .Sub(let l, let r): return Evaluate(expr: l) - Evaluate(expr: r)
        case .Mult(let l, let r): return Evaluate(expr: l) * Evaluate(expr: r)
        }
    }

    static let two: Expr = .Number(number: 2)
    static let three: Expr = .Number(number: 3)
    static let four: Expr = .Number(number: 4)
    static let five: Expr = .Number(number: 5)
    static let threeTimesFour: Expr = .Mult(left: three, right: four)
    static let twoPlusThreeTimesFour: Expr = .Add(left: two, right: threeTimesFour)
    static let twoPlusThreeTimesFourMinusFive: Expr = .Sub(left: twoPlusThreeTimesFour, right: five)

    static func run() {
        print(Evaluate(expr: twoPlusThreeTimesFourMinusFive))
    }
}