从枚举中提取 Swift 2 值

Question

在 Swift 2 之前，我经常使用带有关联值的枚举并添加函数来提取特定值，如下所示:

public enum Maybe <T> {
  case Unknown
  case Known(T)

  public var value: T? {
    switch self {
    case .Unknown: return nil
    case .Known(let value): return value
    }
  }
}

这将允许我做这样的事情:

let maybe = .Known("Value")
let val = maybe.value ?? "Another Value"

我想摆脱这些方便的功能并依赖于 Swift 2 的新语法。这样做是可能的:

let val: String
if case .Known(let value) = maybe {
  val = value
} else {
  val = "Another Value"
}

但我不知道如何使用 ?? 运算符甚至三元运算符将其压缩回一行。

这是否可能，或者我是否坚持在枚举上定义“提取”选项？

更新(澄清)

Maybe 枚举只是一个示例，但解决方案需要在具有多个关联值的枚举上工作...例如 Either:

public enum Either<L, R> {
  case Left(Box<L>)
  case Right(Box<R>)

  public func left() -> L?{
    switch self {
    case let Left(value):
      return value.value
    default:
      return nil
    }
  }

  public func right() -> R?{
    switch self {
    case let Right(value):
      return value.value
    default:
      return nil
    }
  }
}  

我正在寻找的语法类似于:

let val = (case .Known(let value) = maybe) ?? "AnotherValue"

我想做的是轻松提取特定案例的关联值，否则提供默认值。

对于 Either 它可能是这样的:

let val = (case .Left(let value) = either) ?? "AnotherValue"

有道理吗？

Answer 1

你想要的语法在今天的 Swift 中是不可能的(明天 Swift 感觉不太可能，但我常常感到惊讶)。可用的最佳解决方案是提取函数，如 left() -> L? 和 right() -> R?。 case 不是您可以扩展的通用返回值函数。参见 Rob Rix 的 Either了解当前关于这个问题的一些最佳想法。

Swift 中的一个关键选择是有很多语句不是表达式。 switch 就是其中之一。在 Swift 制作出诸如 switch 和 if 之类的表达式之前，构建这种语法 IMO 将非常困难。

---

只需为它定义??:

func ??<T>(lhs: Maybe<T>, @autoclosure defaultValue: () throws -> T) rethrows -> T {
    switch lhs {
    case .Unknown: return try defaultValue()
    case .Known(let value): return value
    }
}


let maybe = Maybe.Known("Value")

let val = maybe ?? "Another Value"

这样做可以让我们在 Swift2 中获得一些不错的特性。例如，我们可以懒惰地评估 rhs，我们可以处理 throw in rhs:

func computeIt() -> String {
    print("LAZY!")
    return "Computed"
}

maybe ?? computeIt() // Does not print "LAZY!"
Maybe.Unknown ?? computeIt() // Does print "LAZY!"

enum Error: ErrorType {
    case Failure
}
func fail() throws -> String {
    throw Error.Failure
}

try maybe ?? fail() // Doesn't throw

do {
    try Maybe.Unknown ?? fail() // throws
} catch {
    print("THROW")
}