有没有办法将“if case”语句编写为表达式？

考虑这段代码：

enum Type {
    case Foo(Int)
    case Bar(Int)

    var isBar: Bool {
        if case .Bar = self {
            return true
        } else {
            return false
        }
    }
}

真恶心。我想写这样的东西：

enum Type {
    case Foo(Int)
    case Bar(Int)

    var isBar: Bool {
        return case .Bar = self
    }
}

但这样的构造在 Swift 中似乎不存在，或者我找不到它。

由于每个案例都有相关的数据，我认为不可能实现~=运算符（或任何其他帮助器）以与上述表达式等效的方式。无论如何，if case所有枚举的语句都是免费存在的，不需要手动实现。

因此我的问题是：有没有更简洁/声明/干净/惯用的方式来实现isBar比我上面有的？或者更直接的说，有什么办法可以表达if case 声明作为斯威夫特表达式?

更新2：另一种解决方法...创建一个var返回一个Int仅基于案例，然后使用静态（或实例，我认为静态看起来更干净）方法来测试案例的等效性。它不会与Equatable，您不必重载运算符（除非您想用一个运算符替换静态方法），并且您也不必创建单独的var isFoo, var isBar, etc.

我知道您使用这个示例来提出一个更通用的问题（我如何使用“if case”作为表达式？），但如果这是不可能的，这可能是一个有效的解决方法。如果这解决的是“症状”而不是“问题”，我深表歉意

enum Something{
    case Foo(Int)
    case Bar(Int)

    static func sameCase(a: Something, b: Something) -> Bool {
        return a.caseValue == b.caseValue
    }

    var caseValue: Int {
        switch self {
        case .Foo(_):
            return 0
        case .Bar(_):
            return 1
        }
    }

    //if necessary
    var isBar: Bool {
        return Something.sameCase(self, b: Something.Bar(0))
    }
}

Something.sameCase(.Bar(0), b: .Foo(0)) // false
Something.sameCase(.Bar(1), b: .Foo(2)) // false
Something.sameCase(.Foo(0), b: .Foo(0)) // true
Something.sameCase(.Bar(1), b: .Bar(2)) // true


Something.Bar(0).isBar // true
Something.Bar(5).isBar // true
Something.Foo(5).isBar // false

更新1：

好吧，这似乎可行。如果您重载 == 运算符以忽略值并仅在两个枚举相同时返回 true，则您可以在 isFoo 方法中传递任何值并仍然确定类型。

我假设您需要自定义此函数以适应关联的值，但这似乎是朝着正确方向迈出的一步

enum Something {
    case Foo(Int)
    case Bar(Int)

    var isFoo: Bool {
        return self == .Foo(0) // number doesn't matter here... see below
    }
}

func ==(a: Something, b: Something) -> Bool {
    switch (a,b) {
    case (.Bar(_), .Bar(_)):
        return true
    case (.Foo(_), .Foo(_)):
        return true
    default:
        return false

    }
}

let oneFoo = Something.Foo(1)
let twoFoo = Something.Foo(2)
let oneBar = Something.Bar(1)
let twoBar = Something.Bar(2)

oneFoo == twoFoo // true
oneFoo == oneFoo // true
oneFoo == oneBar // false
oneFoo == twoBar // false

OLD:

您可以使用self和casename 直接检查它是哪种情况，你不必使用case关键词。希望这适合您的情况：

enum Something{
    case Foo(Int)
    case Bar(Int)

    var isFoo: Bool {
        switch self {
        case Foo:
            return true
        case Bar:
            return false
        }
    }
}