Swift - 具有可交换性的模式匹配

标签 swift enums pattern-matching expression commutativity

Swift - 具有关联值和可交换性的模式匹配枚举

swift 5.0,Xcode 10.2.1

我在 Swift 中有一个 Expression 枚举。

enum Expression {
    indirect case add(Expression, Expression)
    indirect case subtract(Expression, Expression)
    indirect case multiply(Expression, Expression)
    indirect case divide(Expression, Expression)
    indirect case power(Expression, Expression)
    indirect case log(Expression, Expression)
    indirect case root(Expression, Expression)
    case x
    case n(Int)
}

extension Expression: Equatable {
    static func == (lhs: Expression, rhs: Expression) -> Bool {
        switch (lhs, rhs) {
        case let (.add(a, b), .add(c, d)) where a == c && b == d,
             let (.subtract(a, b), .subtract(c, d)) where a == c && b == d,
             let (.multiply(a, b), .multiply(c, d)) where a == c && b == d,
             let (.divide(a, b), .divide(c, d)) where a == c && b == d,
             let (.power(a, b), .power(c, d)) where a == c && b == d,
             let (.log(a, b), .log(c, d)) where a == c && b == d,
             let (.root(a, b), .root(c, d)) where a == c && b == d:
            return true
        case let (.n(a), .n(b)) where a == b:
            return true
        case (.x, .x):
            return true
        default:
            return false
        }
    }
}

第一次尝试

我对我的 Expression 类型执行了很多模式匹配。加法和乘法的可交换性产生了很多长的模式匹配表达式。我想找到一种方法来简化和缩短它,所以我决定制作一个 ExpressionPattern 枚举并定义模式匹配运算符 (~=) 的重载。

enum ExpressionPattern {
    case commutativeMultiply(Expression, Expression)
    case commutativeAdd(Expression, Expression)
}

func ~= (lhs: ExpressionPattern, rhs: Expression) -> Bool {
    switch lhs {
    case let .commutativeMultiply(a, b):
        switch rhs {
        case .multiply(a, b), .multiply(b, a):
            return true
        default:
            return false
        }

    case let .commutativeAdd(a, b):
        switch rhs {
        case .add(a, b), .add(b, a):
            return true
        default:
            return false
        }
    default:
        return false
    }
}

我希望能够替换模式匹配语句,例如:

case let .add(.n(3), a), let .add(a, .n(3)) where a > 10: //matches (a + 3), (3 + a)
//...

与:

case let .commutativeAdd(.n(3), a) where a > 10: //matches (a + 3), (3 + a)
//...

当我第一次尝试这样做时,我收到一条错误消息“模式变量绑定(bind)不能出现在表达式中”。

注意:我认为如果我使用没有值绑定(bind)的精确最终值,则此匹配有效,但我在整个项目的许多地方都使用了此功能。

尝试用法:

let expression: Expression = Expression.add(.divide(.n(1), .n(2)), .subtract(.n(3), .n(4)))
switch expression {

case let .commutativeAdd(.subtract(a, b), .divide(c, d)): //Error: Pattern variable binding cannot appear in an expression.
    print("This matches: ((\(a) - \(b)) + (\(c) ÷ \(d))) and ((\(c) ÷ \(d) + (\(a) - \(b)))")

default: 
   break

}


第二次尝试

第二次尝试时,我更改了 Expression== 函数的定义,并尝试覆盖其默认实现的 ~= .

extension Expression: Equatable {
    static func == (lhs: Expression, rhs: Expression) -> Bool {
        switch (lhs, rhs) {
        case let (.add(a, b), .add(c, d)) where  (a == c && b == d) || (a == d && b == c),
             let (.subtract(a, b), .subtract(c, d)) where a == c && b == d,
             let (.multiply(a, b), .multiply(c, d)) where  (a == c && b == d) || (a == d && b == c),
             let (.divide(a, b), .divide(c, d)) where a == c && b == d,
             let (.power(a, b), .power(c, d)) where a == c && b == d,
             let (.log(a, b), .log(c, d)) where a == c && b == d,
             let (.root(a, b), .root(c, d)) where a == c && b == d:
            return true
        case let (.n(a), .n(b)) where a == b:
            return true
        case (.x, .x):
            return true
        default:
            return false
        }
    }

    static func ~= (lhs: Expression, rhs: Expression) -> Bool {
        return lhs == rhs
    }
}

尝试用法:

let expression: Expression = Expression.add(.divide(.n(1), .n(2)), .subtract(.n(3), .n(4)))
print(expression == .add(.subtract(.n(3), .n(4)), .divide(.n(1), .n(2)))) //Prints "true"

switch expression {
case .add(.subtract(.n(3), .n(4)), .divide(.n(1), .n(2))):
    print("Matched")
default:
    print("Not matched")
}

//Prints "Not matched"

注意:理想情况下应该打印“匹配”。


问题

我如何找到一种方法来使用成熟的模式匹配,同时考虑到某些情况的可交换性。

注意:这必须能够用于匹配具有可交换性的嵌套情况(即 .add(.multiply(..., ...), ...))。这一点尤其重要,因为在用加法和乘法匹配某些东西时需要更多的案例。

最佳答案

我改变了你的第二个用法如下

switch expression {
case let e where e == .add(.subtract(.n(3), .n(4)), .divide(.n(1), .n(2))):
    print("Matched")
default:
    print("Not matched")
}

我认为它会起作用。

关于Swift - 具有可交换性的模式匹配,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/56431814/

相关文章:

performance - 如何使用 Swift (beta) Array 击败 NSMutableArray 的性能?

c# - 在枚举中表示项目状态的优雅方式

wpf - 枚举到 Brush IValueConverter 尝试将 System.String 转换为 IValueConverter 时抛出异常?

scala - 用匹配器计数

scala - 是否可以将命名参数用于 Scala 案例类匹配?

c - 在没有数组的长序列中搜索模式字符串

ios - 将 DayLightSavingTime 应用于 NSDate

ios - 使用 swift 检查从图库中选择的模式 uiimage

c# - 后台 worker 可以有一个通用的方法吗?

ios - Firebase Swift - 当搜索 Controller 过滤结果时,实时更新不起作用