如何在 Swift 中解开任意深度嵌套的选项？

Question

作为 Swift 的一个练习，我正在尝试编写一个扩展方法来解开任意深度嵌套的选项。 这没什么实际用处，只是对 Swift 类型系统的探索。

任意深度嵌套的可选项的示例是 Optional<Optional<Optional<Int>>> 和 Optional<Optional<Optional<Optional<Int>>>>。

我发现这样做的唯一方法是使用类型擦除：

protocol TypeErasedOptional {
    func deeplyUnwrap() -> Any?
}

extension Optional: TypeErasedOptional {
    func deeplyUnwrap() -> Any? {
        switch self {
        case .none: return nil
        case .some(let wrapped as TypeErasedOptional): return wrapped.deeplyUnwrap()
        case .some(let wrapped): return wrapped
        }
    }

    func unwrap<T>(_ type: T.Type = T.self) -> T? {
       switch deeplyUnwrap() {
       case .none: return nil
       case .some(let wrapped as T): return wrapped
       default: return nil
       }
    }
}

这很好用。我们可以解开一个深度嵌套的可选项，但不幸的是我们必须重述Wrapped 类型：

let x = Optional<Optional<Optional<Int>>>(3)
let y = x.unwrap(Int.self)

如果没有类型擦除，我想不出任何方法来做到这一点。一旦你使用类型擦除，你必须重述类型以取回它。我不想要这个。是否可以让更精通 Swift 的人告诉我这无法完成或是否有其他方法？

Answer 1

这里有一个解决方案，可提供多达六层的扁平化Optional：

extension Optional {
    func flatten() -> Wrapped? {
        return self
    }

    func flatten<T>() -> T? where Wrapped == T? {
        return map { $0.flatten() } ?? nil
    }

    func flatten<T>() -> T? where Wrapped == T?? {
        return map { $0.flatten() } ?? nil
    }

    func flatten<T>() -> T? where Wrapped == T??? {
        return map { $0.flatten() } ?? nil
    }

    func flatten<T>() -> T? where Wrapped == T???? {
        return map { $0.flatten() } ?? nil
    }

    func flatten<T>() -> T? where Wrapped == T????? {
        return map { $0.flatten() } ?? nil
    }
}

上述解决方案的优点是类型安全，缺点是它是静态类型的（例如不能在Any 变量上调用flatten()），并且您需要添加更多和如果您需要支持越来越多的嵌套级别，则需要更多的重载。

Answer 2

Optional.flatMap(_:) 似乎可以解决问题。例如：

var a: String??? = "aaa"
let b: String = a?.flatMap{$0} ?? "<nil>"

print(b) // "aaa"

documentation 没有明确提及此功能，但它确实有效。

编辑：不是，请参阅下面的评论。