函数 Array<Optional<T>> 转换为 Optional<Array<T>>。

Question

我想要做的是：

extension Array<Optional<T>> {   
  func unwrap() -> Optional<Array<T>> {
    let a = self.flatMap() { a in
      switch a {
      case Optional.Some(let x): return [x]
      case Optional.None: return []
      }
    }
    if a.count == self.count {
      return Optional.Some(a)
    } else {
      return Optional.None
    }   
  } 
}

但是，它编译时出现错误使用未声明的类型T。 这是我想要使用它的方式:

let a = [Optional.Some(2), Optional.Some(3), Optional.Some(4)]
let b = [Optional.Some(1), Optional.None]
a.unwrap() // Optional[2, 3, 4]
b.unwrap() // nil

我该如何解决这个问题？或者在Swift中不存在这种可能性吗？

- Alfred Zien

---

语法 extension Array<Optional<T>> 是非法和毫无意义的。你想做什么？ - matt

@matt添加到问题 - Alfred Zien

Answer 1

试试这个：

protocol OptionalType {
    typealias W
    var optional: W? { get }
}

extension Optional: OptionalType {
    typealias W = Wrapped
    var optional: W? { return self }
}

extension Array where Element: OptionalType {
    func unwrap() -> [Element.W]? {
        return reduce(Optional<[Element.W]>([])) { acc, e in
            acc.flatMap { a in e.optional.map { a + [$0] } }
        }
    } 
}

然后，

let a: [Int?] = [1,   2, 3]
let b: [Int?] = [1, nil, 3]

a.unwrap() // ==> [1, 2, 3]
b.unwrap() // ==> nil

- findall

---

这很聪明！不错。 - Aaron Brager

看起来很棒，但也非常令人困惑。你能建议一下，在哪里可以阅读更多关于Swift类型系统的内容吗？ - Alfred Zien

@AlfredZien 抱歉，我只读过苹果公司关于Swift的资料。我想我的"Scala"和"Haskell"的经验经常对我有所帮助。 - findall

有没有更好看的解决方案？ - Rodrigo Ruiz

Answer 2

Swift 4

受 @findall 的解决方案启发，这个方案适用于Swift 4：

protocol OptionalType {
    associatedtype Wrapped
    var optional: Wrapped? { get }
}

extension Optional: OptionalType {
    var optional: Wrapped? { return self }
}

extension Sequence where Iterator.Element: OptionalType {
    func removeNils() -> [Iterator.Element.Wrapped] {
        return self.flatMap { $0.optional }
    }
}

测试：

class UtilitiesTests: XCTestCase {
    
    func testRemoveNils() {
        let optionalString: String? = nil
        let strings: [String?] = ["Foo", optionalString, "Bar", optionalString, "Baz"]
        XCTAssert(strings.count == 5)
        XCTAssert(strings.removeNils().count == 3)
        let integers: [Int?] = [2, nil, 4, nil, nil, 5]
        XCTAssert(integers.count == 6)
        XCTAssert(integers.removeNils().count == 3)
    }
}

- Sajjon

Answer 3

findall的解决方案是可行的，尽管我认为在这种情况下避免使用泛型更易读：

func unwrap<Element>(optionalArray : [Element?]) -> [Element]? {
    let unwrappedArray = optionalArray.flatMap { (a) -> [Element] in
        switch a {
        case Optional.Some(let x): return [x]
        case Optional.None: return []
        }
    }

    return unwrappedArray.count == optionalArray.count ? Optional.Some(unwrappedArray) : Optional.None
}

使用方法：

let a = [Optional.Some(2), Optional.Some(3), Optional.Some(4)]
let b = [Optional.Some(1), Optional.None]

// Both are [Int]?
let unwrappedA = unwrap(a) // [2, 3, 4]
let unwrappedB = unwrap(b) // nil

另请参阅：如何确定在Swift中的泛型是否为可选项？

- Aaron Brager