2

考虑以下 Scala 案例:(受此文启发)

sealed abstract class Expr
case class X() extends Expr
case class Const(value : Int) extends Expr
case class Add(left : Expr, right : Expr) extends Expr
case class Mult(left : Expr, right : Expr) extends Expr
case class Neg(expr : Expr) extends Expr

在 Haxe 中,这将响应:

enum Expr {
    X();
    Const(val:Int);
    Add(left:Expr, right:Expr);
    Mult(left:Expr, right:Expr);
    Neg(expr:Expr);
}

在这两种语言中,为任何类型的嵌套表达式编写 eval 函数都非常简单。但是我对以下简化函数感兴趣(仅关注乘法):

在斯卡拉:

def simplify(expression: Expr): Expr = expression match {
    case Mult(_, Const(0)) => Const(0)
    case Mult(Const(0), _) => Const(0)
    case Mult(left, Const(1)) => simplify(left)
    case Mult(Const(1), right) => simplify(right)
    case Mult(Const(leftVal), Const(rightVal)) => Const(leftVal * rightVal)
    case Mult(left, right) => Mult(simplify(left),simplify(right))

    case Add(left, right) => Add(simplify(left),simplify(right))
    case Neg(left) => simplify(left)
    case _ => expression
}

我的问题:在 Haxe 中编写等效内容的最简洁/干净的方法是什么?这些是我的尝试,但我对任何一个都不太满意。

第一个(有点讨厌):

public static function simplify(expr:Expr):Expr{
    switch(expr){
        case Mult(left, right):
            if(left.enumEq(Const(0)) || right.enumEq(Const(0))) return Const(0);
            switch(left){
                case Const(leftVal):
                    if(leftVal == 1) return right.simplify();
                    switch(right){
                        case Const(rightVal): return Const(rightVal * leftVal);
                        default:
                    }
                default:
                    switch(right){
                        case Const(rightVal):
                            if(rightVal == 1) return left.simplify();
                        default: 
                    }
            }
            return Mult(left.simplify(), right.simplify());
        case Add(left, right): return Add(left.simplify(), right.simplify());
        case Neg(expr): return Neg(expr.simplify());
        default: return expr;
    }
}

另一个尝试(更简洁,但很hacky):

public static function simplify(expr:Expr):Expr{
    switch(expr){
        case Mult(left, right):
            if(left.enumEq(Const(0)) || right.enumEq(Const(0))) return Const(0);
            if(left.enumEq(Const(1))) return right.simplify();
            if(right.enumEq(Const(1))) return left.simplify();
            if(left.enumConstructor() == right.enumConstructor() &&
                    left.enumConstructor() == Const(null).enumConstructor())
                return Const(Std.int(left.enumParameters()[0] *
                    right.enumParameters()[0]));
            return Mult(left.simplify(), right.simplify());
        case Add(left, right): return Add(left.simplify(), right.simplify());
        case Neg(expr): return Neg(expr.simplify());
        default: return expr;
    }
}
4

1 回答 1

3

Haxe 目前不支持深度模式匹配。这是 3.0 版中正在实施的事情之一。

于 2012-11-13T06:20:27.577 回答