[RxSwift] What are Combining Operators?

Start With

We will start with 'start with' operator. lol

This operator lets us to pass the value, which will be the starting value of the sequence. Let's take a look at the code below.

let disposeBag = DisposeBag()

let numbers = Observable.of(2, 3, 4)

let observable = numbers.startWith(1)
observable.subscribe(onNext: {
    print($0)
}).disposed(by: disposeBag)

This will make the 'numbers' observable to start with 1, and the result will be like:

1
2
3
4

---

Concat

To explain the concat operatort easier, it is like adding two or more sequences.

let numbers1 = Observable.of(1, 2)
let numbers2 = Observable.of(3, 4)

let observable = Observable.concat([numbers1, numbers2])

observable.subscribe(onNext: {
    print($0)
}).disposed(by: disposeBag)

This code will print out:

1
2
3
4

We can concat more than two observables like this:

let numbers1 = Observable.of(1, 2)
let numbers2 = Observable.of(3, 4)
let numbers3 = Observable.of(10, 20)

let observable = Observable.concat([numbers1, numbers2, numbers3])

observable.subscribe(onNext: {
    print($0)
}).disposed(by: disposeBag)

This code above will result like this:

1
2
3
4
10
20

---

Merge

Merge operator is similar to concat but, merge operator depends the order by time. The faster the value arrived at the observable, the earlier it will be placed in the merged observable.

let left = PublishSubject<Int>()
let right = PublishSubject<Int>()

let source = Observable.of(left.asObservable(), right.asObservable())

let observable = source.merge()
observable.subscribe(onNext: {
    print($0)
}).disposed(by: disposeBag)

left.onNext(1)
right.onNext(5)
left.onNext(2)
left.onNext(3)
right.onNext(6)

This code will run like:

1
5
2
3
6

As we can see, merge operator contains 'left' as well as 'right', as soon as the values arrive.

---

Combine Latest

Combine latest operator always keeps track of the latest value, which are coming from the sequences.

let left = PublishSubject<Int>()
let right = PublishSubject<Int>()

let observable = Observable.combineLatest(left, right, resultSelector: { lastLeft, lastRight in
    "\(lastLeft) \(lastRight)"
})

let disposable = observable.subscribe(onNext: { value in
    print(value)
}).disposed(by: disposeBag)

left.onNext(30)
right.onNext(2)
left.onNext(54)
right.onNext(5)
right.onNext(9)

If we run this code,

30 2
54 5
54 5
54 9

we can see that the latest value of each observables are returned until the new value has arrived.

---

With Latest From

This operator is heavily used on user interface side. Let's look at the code below.

let button = PublishSubject<Void>()
let textField = PublishSubject<String>()

let observable = button.withLatestFrom(textField)
let disposable = observable.subscribe(onNext: {
    print($0)
})

textField.onNext("Ap")
textField.onNext("Appl")
textField.onNext("Apple")

button.onNext(())
button.onNext(())

textField.onNext("Application")

button.onNext(())

If we run this,

Apple
Apple
Application

we can see that it always returns the latest arrived value.

---

Reduce

Reduce operator is widely used in other programming languages.

Both ver1 and ver2 works exactly the same. It adds all the values in the 'source' observable.

let source = Observable.of(1, 2, 3, 4)

// ver1
source.reduce(0, accumulator: +)
    .subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

// ver2
source.reduce(0, accumulator: {
    summary, newValue in
    return summary + newValue
}).subscribe(onNext: {
    print($0)
}).disposed(by: disposeBag)

So the results will be like:

10
10

---

Scan

Scan operator works(we can use) exactly same as the reduce operator except the only difference, which this operator returns the progress.

let source = Observable.of(1, 2, 3, 4)

source.scan(0, accumulator: +)
    .subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

source.scan(0, accumulator: {
    summary, newValue in
    return summary + newValue
}).subscribe(onNext: {
    print($0)
}).disposed(by: disposeBag)

If we run this code,

1
3
6
10
1
3
6
10

it will like the above. And we can see that it returns the progress of adding all the values in the observable.