Basic of RxSwift

ReactiveX (usually abbreviated to “Rx”) is a combination of the best ideas from the Observer pattern, the Iterator pattern, and functional programming

I am going to talk about RxSwift which is part of Rx in Swift Version. Basically, RxSwift is a framework for interacting with swift programming language and RxCocoa is a framework that helps make Cocoa APIs used in iOS and OS X easier to use with reactive techniques.

Observable and Observer

Whenever people talk about RxSwift first thing in my mind is Observable and Observer.

- Observable: emits notifications of changes.
- Observer: subscribes to an Observable, in order to be notified when it has changed.

Note: We can have more than one Observer listening to an Observable. So when that Observable changes it will notify to all its Observers.

Here are some examples of Observable:

let helloObservable = Observable.just(“Hello”)
let arrayObservable = Observable.from([“H”, “e”, “l”, “l”, “o”])
let dictObservable = Observable.from([1:”Hello”, 2: “RxSwift”])

And Here are some examples of Observer as well:

So we can subscribe to Observable by calling `subscribe(on:(Event<T>)->())`

let helloObservable = Observable.just(“Hello”)
let subscription = helloObservable.subscribe { event in 
 print(event)
}

The out put will be:

Output:
next(“Hello”)
completed

So helloObservable will send its contained value “Hello” to its subscription. it sends the event to the pass block. subscription variable called subscribe method which receive the event from its Observable.

In RxSwift, Event is just a enumeration type with 3 states:
- .next(value: T): when value added to an Observable then it will send next event to its subscribers
- .error(error: Error): if error happened, it sends error event and terminate the process
- .completed: when Observable ends normally, it sends *completed event* to its subscribers.

let arryObservable = Observable.from([“H”, “e”, “l”, “l”, “o”])
let subscription = arrayObservable.subscribe { event in 
 switch event {
 case .next (let value):
 print(value)
 case .error (let error):
 print(error)
 case .completed:
 print(“completed”)
 }
}
Output is going to be:
H
e 
l 
l 
o
completed

DisposeBag
DisposeBag is a virtual bag of Observer objects which are disposed when their parent object is deallocated. it is deal with memory management. So if we want to cancel the subscription we can do it by just calling dispose on it. We can also add a subscription with the **DisposeBag** which will cancel automatically on deinit of the DisposeBag instance.

let bag = DisposeBag()
let helloObservable = Observable.just(“Hello”)
let subscription = helloObservable.subscribe { event in 
 print(event)
}
//adding a subscription to a DisposeBag
subscription.disposed(by: bag)

##Transforming 
Sometimes we want to transform, combine or filter the elements emitted by the Observable before the Observer receives them. Here are some basic operations of transformation:

Map
To transform elements emitted by Observable before they reach their Observers, you can use map operation. Imagine a transformation that multiplies each value of the sequence with 10 before emitting.

Observable<Int>.of(1, 2, 3, 4, 5).map { value in 
 return value * 10
 }.subscribe(onNext: {
 print($0)
})

The output will be:
10 20 30 40 50

FlatMap
Imagine that an Observable that consists of objects that are themselves Observable and we want to create a new sequence from those. This is where FlatMap comes into play. FlatMap emerges the results and emitting the results as its own Observable.

let observable1 = Observable<Int>.of(1,2)
let observable2 = Observable<Int>.of(1,2)
let observableOfobservable = Observable.of(observable1, observable2)
observableOfobservable.flatMap{ return $0 }.subscribe(onNext: {
 print($0)
})

The output will be:
1 2 1 2

Scan
Scan starts with initial seed value and is used to aggregate value just like reduce in swift.

Observable.of(1, 2, 3, 4, 5).scan(0) { seed, value in
 return seed + value 
}.subscribe(onNext: {
 print($0)
})

The output will be:
1 3 6 10 15

Filter
The basic filter operation works similar to swift equivalent. I just define a condition that needs to be passed and if the condition fulfilled a *.next event* will be emitted to subscribers.

Observable.of(2, 30, 22, 5, 60, 1).filter{ $0 > 10 }.subscribe(onNext: {
 print($0)
})

The output will be:
30 22 60