如何链接signalproducer传递结果

Question

给定函数multiply()和convert()(概念的最小示例，我实际上计划在每个函数内查询远程服务器)，实现multiplyAndConvert()的更短方法是什么?

// call two async functions passing the result the from the first 
// as the argument to the second
multiplyAndConvert(3).startWithResult { val in
    print("(val.value!)")
}
func convert(_ val: Int) -> SignalProducer<String, NSError> {
    return SignalProducer<String, NSError> { observer, _ in
        observer.send(value: String(val))
        observer.sendCompleted()
    }
}
func multiply(_ val: Int) -> SignalProducer<Int, NSError> {
    return SignalProducer<Int,NSError> { observer, _ in
        observer.send(value: val * 2)
        observer.sendCompleted()
    }
}
func multiplyAndConvert(_ val: Int) -> SignalProducer<String, NSError> {
    return SignalProducer<String, NSError> { observer, _ in
        multiply(val).startWithResult { res2 in
            switch res2 {
                case .success(let val2):
                    convert(val2).startWithResult { res3 in
                        switch res3 {
                            case .success(let val3):
                                observer.send(value:val3)
                                observer.sendCompleted()
                            case .failure(let err):
                                observer.send(error:err)
                        }
                    }
                case .failure(let err):
                    observer.send(error: err)
            }
            observer.sendCompleted()
        }
    }
}

我知道一定有一种更优雅的方式来做到这一点，但我不知道它是什么。我已经使用了map, flatMap, flatten和大多数其他函数，但找不到更好的解决方案。

Answer 1

使用flatMap:

func multiplyAndConvert(_ val: Int) -> SignalProducer<String, NSError> {
  return multiply(val).flatMap(.concat) { multipliedVal in
    return convert(multipliedVal)
  }
}

您也可以直接将convert作为第二个参数传递给flatMap，而不是给它一个闭包，因为它已经是正确的类型(Int -> SignalProducer<String, NSError>)

multiply(val).flatMap(.concat, transform: convert)

但是如果convert函数在扩展的代码中引用了self，这可能会导致保留循环，在这种情况下，您需要传递一个捕获[weak self]的闭包

flatMap在这里的作用是获取相乘信号:

-----.value(multipliedValue)-.completed

，并使用提供的闭包将其映射为信号的信号:

    .value(convertedMultipliedValue)
    /
----x-.completed

，然后"扁平化"这个信号信号的信号信号(使用。concat扁平化策略，通过连接所有的子信号来扁平化信号信号-但这在这里并不重要，因为我们只扁平化一个子信号)，得到:

----.value(convertedMultipliedValue)-.completed