Swift带抛出初始化的懒数组疑问：try为何转普通数组？能否实现？

问题1：为何try会强制将懒序列转为普通数组？ #

核心原因是标准库的惰性序列（如LazyMapSequence）没有提供接受抛出闭包的map实现。

当你的闭包包含try时，它的类型变为(Element) throws -> T，而LazySequenceProtocol定义的map方法只支持非抛出的闭包(Element) -> T。此时编译器会 fallback 到Sequence协议的map方法——这个方法虽然支持抛出闭包，但行为是立即遍历整个序列并执行所有闭包，同时通过try统一处理错误，最终返回一个普通的[T]数组。

本质上不是try主动强制转换了序列，而是当闭包抛出时，编译器找不到惰性版本的map实现，只能调用立即求值的普通map，导致所有初始化逻辑被提前执行。

问题2：是否可创建支持抛出的懒加载数组？ #

可以，有两种实用方案：

方案1：用Result包装元素延迟处理错误 #

把抛出的初始化逻辑包装成返回Result<B, Error>的闭包，这样能保持序列的惰性，直到你主动访问元素时再处理错误：

struct B {
    init(i: Int) throws {
        print(i)
        if i == 1 {
            throw NSError(domain: "test", code: 0)
        }
    }
}

// 创建惰性序列，元素为Result类型
let lazySequence = (0..<3).lazy.map { i -> Result<B, Error> in
    Result { try B(i: i) }
}

print(lazySequence) // 不会调用init
print("开始访问元素：")
for result in lazySequence {
    switch result {
    case .success(let b):
        print("成功创建B: \(b)")
    case .failure(let err):
        print("创建失败：\(err)")
    }
}

输出：

LazyMapSequence<Range<Int>, Result<B, Error>>(_base: Range(0..<3), _transform: (Function))
开始访问元素：
0
成功创建B: __lldb_expr_1.B()
1
创建失败：Error Domain=test Code=0 "(null)"
2
成功创建B: __lldb_expr_1.B()

方案2：自定义支持抛出的惰性序列 #

如果不想用Result包装，可以自己实现一个支持抛出闭包的惰性映射序列，核心是在迭代元素时才执行抛出逻辑：

struct LazyThrowingMapSequence<Base: Sequence, Element>: Sequence, IteratorProtocol {
    private var baseIterator: Base.Iterator
    private let transform: (Base.Element) throws -> Element
    
    init(base: Base, transform: @escaping (Base.Element) throws -> Element) {
        self.baseIterator = base.makeIterator()
        self.transform = transform
    }
    
    mutating func next() throws -> Element? {
        guard let element = baseIterator.next() else { return nil }
        return try transform(element)
    }
}

// 给Sequence扩展惰性抛出map方法
extension Sequence {
    func lazyThrowingMap<T>(_ transform: @escaping (Element) throws -> T) -> LazyThrowingMapSequence<Self, T> {
        LazyThrowingMapSequence(base: self, transform: transform)
    }
}

// 使用示例
struct B {
    init(i: Int) throws {
        print(i)
        if i == 1 {
            throw NSError(domain: "test", code: 0)
        }
    }
}

let lazyThrowingSeq = (0..<3).lazyThrowingMap { try B(i: $0) }
print(lazyThrowingSeq) // 不会调用init

print("开始遍历：")
do {
    var iterator = lazyThrowingSeq.makeIterator()
    while let b = try iterator.next() {
        print("得到B: \(b)")
    }
} catch {
    print("捕获错误：\(error)")
}

输出：

LazyThrowingMapSequence<Range<Int>, B>(base: Range(0..<3), transform: (Function))
开始遍历：
0
得到B: __lldb_expr_2.B()
1
捕获错误：Error Domain=test Code=0 "(null)"

注：自定义惰性抛出序列在遍历时，若某个元素抛出错误，遍历会立即终止。

内容的提问来源于stack exchange，提问作者iUrii