Multi merge

[schwa]

Merging multiple signals means you end up with a "lops sided" tuple. Is there a better way to merge multiple signals?

let signal = Signal("Hello")
signal.merge(Signal("world"))
.merge(Signal("how are you?"))
.merge(Signal("42"))
.next() {
    print($0)        // ((("Hello", "world"), "how are you?"), "42")
    print($0.0.0.1)  // world
}

[JensRavens]

I never really thought about using merge that much (just used it 2 days ago for the first time myself). It was mostly intended to be flatMapped into a common value on the next step anyway (like merging the text of a draft with a text that just got typed).

While I would prefer an array of Signals as the argument, this would not be type safe anymore (it would just be an array of signals, but you won't know each of their types).

Maybe you have an idea how to improve that situation?

For your current case if would be possible to specify a merge operation for signals of the same type like merge(signals: [Signal<T>]).

[schwa]

I'm wondering if a multiple merge functions that took multiple signals might be better?

merge(a: Signal, b: Signal)
merge(a: Signal, b: Signal, c: Signal)
merge(a: Signal, b: Signal, c: Signal, d: Signal)

etc.

This way you keep type safety and a flat return structure and still support a reasonable number of signals.

In my code i have four signals at once (building up complex UI from two async http calls, a reverse geocode, and a map snapshot image). I could make them serial but they are intrinsically independent of each other.

[IwanKaramazow]

This was actually something I ran into immediately when using this library.
I mainly use Interstellar for form validation. Every form gets its own signal.
They all have to compose somehow to a main signal which holds a value that represents if all forms in certain view are valid. As a quick solution to this problem I came up with a function:

func combineSignals<T>(signals: [Signal<T>], f: (T,T)-> T) -> Signal<T> {
    return signals.dropFirst().reduce(signals.first!){ $0.merge($1).map { f($0) }
    }
}

It takes an array of signals and a function which 'merges' both values of a tuple into one.
Although this is very specific to my use case, it'll probably a good idea to somehow generalize this in version 2.0.

Maybe implement the transducers protocol?

[JensRavens]

If all signals do have the same type, it would be possible to define a merge function like this:

extension Signal {
  public class func combine<T>(signals: [Signal<T>]) -> Signal<[T]>
}

[vittoriom]

I would also be quite interested in such a function 👍