Swift 具有可选元素的数组上的 flatMap 具有不同的行为

Question

let arr: [Int?] = [1,2,3,4,nil]

let arr1 = arr.flatMap { next in
    next
}
// arr1: [1,2,3,4]
let arr2: [Int?] = arr.flatMap { next -> Int? in
   next
}
// arr2: [Optional(1), Optional(2), Optional(3), Optional(4)]

我对这些代码感到困惑，为什么它们有所不同？

更新：请看这些代码，我

let arr: [Int?] = [1,2,3,4,nil]

let arr1: [Int?] = arr.flatMap { next in
    next
}
// arr1: [Optional(1), Optional(2), Optional(3), Optional(4), nil]
let arr2: [Int?] = arr.flatMap { next -> Int? in
    next
}
// arr2: [Optional(1), Optional(2), Optional(3), Optional(4)]

Answer 1

这与您提供的显式类型有关 arr2。当您指定 arr2 必须是 [Int?] 类型时，Swift 会遵守并简单地将值包装在一个可选值中。但是，flatMap 操作 return 是数组的非 nil 值，这使得 arr1 是 [Int] 类型的原因显而易见。要查看 flatMap returns 数组的非 nil 值，只需查看函数的声明注释即可。此外，如果您了解 flatMap 操作在一般用途中的作用，即它解开值的内部包装，您就会明白为什么函数 return 是类型 [Int] 的值。考虑 arr，它的类型是 [Int?]。以包装形式重写 arr 的类型，它变成 Array<Optional<Int>>。对于 flatMap 函数解包内部包装，该函数必须 return 类型为 Array<Int> 的值。为此，该函数必须抛出 nil 值。

Answer 2

作为，这是由于您为结果提供的显式类型。在您的第二个示例中，这会导致由双重包装的可选值引起的混淆。为了更好地理解问题，让我们看一下 flatMap 函数签名。

@warn_unused_result
public func flatMap<T>(@noescape transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]

当您显式指定结果的类型为 [Int?] 时，因为 flatMap return 泛型类型 [T] – Swift 将推断 T 变为 Int?.

现在这会引起混淆，因为您传递给 flatMap 的闭包需要元素输入和 returns T?。因为 T 是 Int?，这个闭包现在将是 returning T??（一个双重包裹的可选）。这编译得很好，因为类型可以自由地提升为可选类型，包括可选类型被提升为双重可选类型。

所以发生的事情是数组中的 Int? 元素被提升为 Int?? 元素，然后 flatMap 将它们解包回 Int?。这意味着 nil 元素无法从你的 arr1 中过滤掉，因为它们被双重包装，并且 flatMap 仅在第二层包装上运行。

为什么 arr2 是能够从中过滤掉 nil 似乎是 推广的结果您传递给 flatMap 的闭包 。因为您显式地将闭包的 return 类型注释为 Int?，所以闭包将从 (Element) -> Int? 隐式提升为 (Element) -> Int??（闭包 return 类型可以得到以与其他类型相同的方式自由提升）——而不是将元素本身从 Int? 提升到 Int??，因为没有类型注释，闭包将是推断为 (Element) -> Int??.

这个怪癖似乎允许 nil 避免被双重包装，因此允许 flatMap 将其过滤掉（不完全确定这是否是预期的行为）。

您可以在下面的示例中看到此行为：

func optionalIntArrayWithElement(closure: () -> Int??) -> [Int?] {
    let c = closure() // of type Int??
    if let c = c { // of type Int?
        return [c]
    } else {
        return []
    }
}

// another quirk: if you don't explicitly define the type of the optional (i.e write 'nil'),
// then nil won't get double wrapped in either circumstance
let elementA : () -> Int? = {Optional<Int>.None} // () -> Int?
let elementB : () -> Int?? = {Optional<Int>.None} // () -> Int??

// (1) nil gets picked up by the if let, as the closure gets implicitly upcast from () -> Int? to () -> Int??
let arr = optionalIntArrayWithElement(elementA)

// (2) nil doesn't get picked up by the if let as the element itself gets promoted to a double wrapped optional
let arr2 = optionalIntArrayWithElement(elementB)

if arr.isEmpty {
    print("nil was filtered out of arr") // this prints
}

if arr2.isEmpty {
    print("nil was filtered out of arr2") // this doesn't print
}

故事的寓意

远离双重包装的可选值，它们会给你带来超级混乱的行为！

如果您正在使用 flatMap，那么如果您传入 [Int?]，您应该期望返回 [Int]。如果要保留元素的可选性，请改用 map。

Swift 具有可选元素的数组上的 flatMap 具有不同的行为

Swift flatMap on array with elements are optional has different behavior

type-inference

optional

flatmap

swift

故事的寓意