Swift中如何使用Reactive Cocoa合并三个无关联的Signal？

Hey there! Let's work through this signal merging problem you're dealing with. You're right that the and operator isn't meant for merging signal values—it's typically used to coordinate completion events between signals instead. And while combineLatest is a solid option for combining signals, its requirement that every signal emits at least one value can be a hurdle depending on your setup.

Let's break down two solutions tailored to your scenario with Signal1<Int, NoError>, Signal2<String, NoError>, and Signal3<SomeType, NoError>:

Solution 1: Combine Latest Values (With Fallbacks for Initial States) #

If your goal is to get the latest value from all three signals whenever any of them updates, but you need to handle cases where a signal might not have emitted a value yet, you have two approaches here:

Option A: Add Default Initial Values #

Use the startWith operator to inject a default value into each signal. This ensures combineLatest has a value to work with from every signal right away:

// Assume your signals are named signal1, signal2, signal3
let combinedSignals = Signal.combineLatest(
    signal1.startWith(0), // Default Int value
    signal2.startWith(""), // Default String value
    signal3.startWith(SomeType.default) // Default instance of your custom type
)

combinedSignals.observeValues { intVal, stringVal, someTypeVal in
    // Handle all three latest values here
    print("Updated - Int: \(intVal), String: \(stringVal), SomeType: \(someTypeVal)")
}

Option B: Wrap Values in Optionals #

If you don't want to use default values (e.g., a default doesn't make sense for your SomeType), map each signal to emit optional values. This lets combineLatest trigger even if some signals haven't emitted a value yet:

let optionalSignal1 = signal1.map { Optional($0) }
let optionalSignal2 = signal2.map { Optional($0) }
let optionalSignal3 = signal3.map { Optional($0) }

let combinedSignals = Signal.combineLatest(optionalSignal1, optionalSignal2, optionalSignal3)

combinedSignals.observeValues { intOpt, stringOpt, someTypeOpt in
    // Check which signals have new values and handle accordingly
    if let newInt = intOpt {
        print("New Int value: \(newInt)")
    }
    if let newString = stringOpt {
        print("New String value: \(newString)")
    }
    if let newSomeType = someTypeOpt {
        print("New SomeType value: \(newSomeType)")
    }
}

Solution 2: Merge Independent Events #

If you don't need to track all three latest values at once—instead, you just want to respond whenever any of the three signals emits a value—use an enum to unify the signal types, then merge them:

First, define an enum to wrap each signal's value type:

enum SignalUpdate {
    case int(Int)
    case string(String)
    case someType(SomeType)
}

Then map each signal to this enum and merge them into a single signal:

let mappedSignal1 = signal1.map { SignalUpdate.int($0) }
let mappedSignal2 = signal2.map { SignalUpdate.string($0) }
let mappedSignal3 = signal3.map { SignalUpdate.someType($0) }

let mergedSignals = Signal.merge(mappedSignal1, mappedSignal2, mappedSignal3)

mergedSignals.observeValues { update in
    switch update {
    case .int(let value):
        // Handle Int signal updates
        print("Received Int: \(value)")
    case .string(let value):
        // Handle String signal updates
        print("Received String: \(value)")
    case .someType(let value):
        // Handle SomeType signal updates
        print("Received SomeType: \(value)")
    }
}

Pick the solution that aligns with your exact use case—either combining latest values with fallbacks, or merging individual events as they come!

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