Swift:调用SequenceOf的无参数扩展时缺少参数

有人能看到这只虫子吗？操场坚持认为论点2不存在，但没有论点1

代码的目的是计算一个相等值的运行次数，并返回由这些值及其计数组成的元组序列。我对这段代码做了大量的工作，对它进行了优化和完善，直到我非常确定它应该可以工作……但是尽管它可以编译，但我不能按预期的方式调用它

调用下面的代码时出现的错误是调用中缺少参数2的参数

extension SequenceOf {
    func CountRuns<T: Equatable>() -> SequenceOf<(T, Int)> {
        return SequenceOf<(T, Int)>([])
        return SequenceOf<(T, Int)> { () -> GeneratorOf<(T, Int)> in
            var generator = self.generate()
            var previousValue: T?
            var start = true
            return GeneratorOf<(T, Int)> { () -> (T, Int)? in
                var count = 1
                var retValue: (T, Int)?
                while(true) {
                    var value = generator.next() as T?
                    if start {
                        previousValue = value
                        start = false
                    } else if value != nil && value! == previousValue! {
                        count++
                    } else {
                        if previousValue != nil {
                            retValue = (previousValue!, count)
                        }
                        previousValue = value
                        break
                    }
                }
                return retValue
            }
        }
    }
}

println(SequenceOf(y).CountRuns())

Playground execution failed: <EXPR>:327:23: error: missing argument for parameter #2 in call
println(SequenceOf(y).CountRuns())
                      ^

SequenceOf的扩展{
func CountRuns（）->SequenceOf{
（[]）的返回序列
中{（）->GeneratorOf的返回序列
var生成器=self.generate（）
var先前的值：T？
var start=true
返回{（）->（T，Int）的生成器
变量计数=1
变量值：（T，Int）？
while（true）{
var value=generator.next（）作为T？
如果开始{
前一个值=前一个值
开始=错误
}否则，如果值！=nil&&value！==previousValue{
计数++
}否则{
如果上一个值！=nil{
retValue=（上一个值！计数）
}
前一个值=前一个值
打破
}
}
返回值
}
}
}
}
println（SequenceOf（y）.CountRuns（））
游乐场执行失败：：327:23:错误：调用中缺少参数#2的参数
println（SequenceOf（y）.CountRuns（））
^

您遇到的问题是，无法使用进一步专门化泛型子类型的方法来扩展泛型类型。也就是说，您的

countRuns

方法要求

SequenceOf

的泛型子类型

T

是

equalable

，但您只能在原始类型声明中提供这些约束，而不能在扩展中提供

解决方案是将

countRuns

声明为顶级函数，如下所示：

func countRuns<T: Equatable>(s: SequenceOf<T>) -> SequenceOf<(T, Int)> {
    return SequenceOf<(T, Int)> { () -> GeneratorOf<(T, Int)> in

        // note the change from self.generate() to s.generate() here
        var generator = s.generate()

        var previousValue: T?
        var start = true
        return GeneratorOf<(T, Int)> { () -> (T, Int)? in
            var count = 1
            var retValue: (T, Int)?
            while(true) {
                var value = generator.next() as T?
                if start {
                    previousValue = value
                    start = false
                } else if value != nil && value! == previousValue! {
                    count++
                } else {
                    if previousValue != nil {
                        retValue = (previousValue!, count)
                    }
                    previousValue = value
                    break
                }
            }
            return retValue
        }
    }
}

println(countRuns(SequenceOf(y)))

func countRuns（s:SequenceOf）->SequenceOf{
中{（）->GeneratorOf的返回序列
//注意这里从self.generate（）到s.generate（）的变化
var生成器=s.generate（）
var先前的值：T？
var start=true
返回{（）->（T，Int）的生成器
变量计数=1
变量值：（T，Int）？
while（true）{
var value=generator.next（）作为T？
如果开始{
前一个值=前一个值
开始=错误
}否则，如果值！=nil&&value！==previousValue{
计数++
}否则{
如果上一个值！=nil{
retValue=（上一个值！计数）
}
前一个值=前一个值
打破
}
}
返回值
}
}
}
println（countRuns（SequenceOf（y）））

---

这一点在本章结尾部分（有一点）有所涉及。

我找到了一个更好的答案！谢谢内特让我走上正轨

诀窍是比较器需要来自定义类型的顶层。因此，最终的解决方案只有三个更改，第二行、第十六行和调用中。更改是传递比较器，并使用比较器而不是直接压缩值

extension SequenceOf {
    func CountRuns(areEqual: (T, T) -> Bool) -> SequenceOf<(T, Int)> {
        return SequenceOf<(T, Int)>([])
        return SequenceOf<(T, Int)> { () -> GeneratorOf<(T, Int)> in
            var generator = self.generate()
            var previousValue: T?
            var start = true
            return GeneratorOf<(T, Int)> { () -> (T, Int)? in
                var count = 1
                var retValue: (T, Int)?
                while(true) {
                    var value = generator.next() as T?
                    if start {
                        previousValue = value
                        start = false
                    } else if value != nil && areEqual(value!, previousValue!) {
                        count++
                    } else {
                        if previousValue != nil {
                            retValue = (previousValue!, count)
                        }
                        previousValue = value
                        break
                    }
                }
                return retValue
            }
        }
    }
}

let y = [0, 0, 0, 2, 2, 2, 3, 4 ,4, 5, 65, 65]
println(SequenceOf(y).CountRuns(==).ToArray())
let z = [0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 3.0, 4.0, 4.0, 5.0, 65.0, 65.0]
println(SequenceOf(z).CountRuns(==).ToArray())

// Prints:
// [(0, 3), (2, 3), (3, 1), (4, 2), (5, 1), (65, 2)]
// [(0.0, 3), (2.0, 3), (3.0, 1), (4.0, 2), (5.0, 1), (65.0, 2)]

SequenceOf的扩展{
func CountRuns（等于：（T，T）->Bool）->SequenceOf{
（[]）的返回序列
中{（）->GeneratorOf的返回序列
var生成器=self.generate（）
var先前的值：T？
var start=true
返回{（）->（T，Int）的生成器
变量计数=1
变量值：（T，Int）？
while（true）{
var value=generator.next（）作为T？
如果开始{
前一个值=前一个值
开始=错误
}如果值！=nil&&areEqual（值！，前一个值！），则为else{
计数++
}否则{
如果上一个值！=nil{
retValue=（上一个值！计数）
}
前一个值=前一个值
打破
}
}
返回值
}
}
}
}
设y=[0,0,0,2,2,2,3,4,4,5,65,65]
println（SequenceOf（y）.CountRuns（=）.ToArray（））
设z=[0.0,0.0,0.0,2.0,2.0,2.0,3.0,4.0,4.0,5.0,65.0,65.0]
println（SequenceOf（z）.CountRuns（=）.ToArray（））
//印刷品：
// [(0, 3), (2, 3), (3, 1), (4, 2), (5, 1), (65, 2)]
// [(0.0, 3), (2.0, 3), (3.0, 1), (4.0, 2), (5.0, 1), (65.0, 2)]

---

然后，这就可以作为通用等式协议问题的一般解决方案。

Hmm……这就行了。但不是我想要的，因为我想做链锁。