扩展Swift中的SequenceType

我想知道为什么

SequenceType

中的

map（）

和

filter（）

都返回

数组。
事实上，我认为没有必要。再次返回一个序列对我来说感觉更明智

但是，我在尝试添加顺序版本时遇到了问题。以下是我对map的尝试：

extension SequenceType {

   func seqMap<T, S: SequenceType where S.Generator.Element == T>(
        transform: Self.Generator.Element -> T) -> S 
   {
        var sourceGen = generate()
        let tGen: AnyGenerator<T> = anyGenerator {
            if let el = sourceGen.next() {
                return transform(el)
            } else {
                return nil
            }
        }
        return AnySequence { tGen }
    }
}

扩展序列类型{
函数序列图(
转换：Self.Generator.Element->T）->S
{
var sourceGen=generate（）
设tGen:AnyGenerator=AnyGenerator{
如果让el=sourceGen.next（）{
返回变换（el）
}否则{
归零
}
}
返回任意序列{tGen}
}
}

XCode在最后一个return语句中告诉我以下错误：

cannot invoke initializer for type 'AnySequence<T>' with an argument list of type '(() -> AnyGenerator<T>)'
note: overloads for 'AnySequence<T>' exist with these partially matching parameter lists: (S), (() -> G)

无法使用类型为“（（）->AnyGenerator）”的参数列表调用类型为“AnySequence”的初始值设定项
注意：“AnySequence”的重载存在于这些部分匹配的参数列表中：（S），（（）->G）

实际上，我的
tGen
类型是
（）->G
，那么为什么XCode认为它不明确呢？
如果拆分return语句，问题会变得更加明显：

let tSeq = AnySequence { tGen }
return tSeq // error: cannot convert return expression of type 'AnySequence<T>' to return type 'S'

要解决此问题，请将返回类型更改为
AnySequence
并删除泛型类型
S
：

extension SequenceType {

    func seqMap<T>(transform: Self.Generator.Element -> T) -> AnySequence<T>
    {
        var sourceGen = generate()
        let tGen: AnyGenerator<T> = anyGenerator {
            if let el = sourceGen.next() {
                return transform(el)
            } else {
                return nil
            }
        }
        return AnySequence { tGen }
    }
}

你可以用

someSequence.lazy.map { ... }

获取映射值的（延迟评估）序列。
非常感谢您的详细解释。我收到的错误消息有点误导。我不知道懒惰的属性。现在，这是有道理的。
extension SequenceType {

    func seqMap<T>(transform: Self.Generator.Element -> T) -> AnySequence<T>
    {
        var sourceGen = generate()
        return AnySequence(anyGenerator {
            sourceGen.next().map(transform)
        })
    }
}

/// A sequence containing the same elements as a `Base` sequence, but
/// on which some operations such as `map` and `filter` are
/// implemented lazily.
///
/// - See also: `LazySequenceType`
public struct LazySequence<Base : SequenceType> 

someSequence.lazy.map { ... }