[RxSwift] Observableの定義を追って理解を深めたい

# はじめに
RxSwiftを勉強しているときに`Observable`クラスの定義を見ていると、プロトコルが(自分にとっては)複雑すぎて頭が混乱してしまいました。
なので`Observable`クラスと、プロトコルの勉強を兼ねて、定義についてまとめていきたいと思います。
※RxSwiftについて多少なりとも理解している方には参考にならないと思います。プロトコルをしっかり理解している人も実際の定義を見た方が早いと思います！


# Observableクラス
```swift

public class Observable<Element> : ObservableType { 省略 }
```
<ul> 
    <li>監視(Observe)される</li>
    <li><strong>next</strong>, <strong>error</strong>, <strong>completed</strong> の3つを通知できる(後で説明)
    <li>任意の型を扱える</li>
    <li><strong>ObservableType</strong>プロトコルに準拠している</li>
    <ul>
        <li>そして、<strong>ObservableType</strong>は<strong>ObservableConvertibleType</strong>プロトコルを継承している</li>
    </ul>
</ul>


以下では`ObservableType`や`ObservableConvertibleType`について説明していきます。


## ObservableType

```swift

public protocol ObservableType: ObservableConvertibleType { 省略 }
```

`Observable`に準拠しているプロトコル。
何が定義されているかというと、、、

1. subscribe(メソッド)
* asObservable(メソッド)

`subscribe`は`ObservableType`プロトコル内で定義されていて
`asObservable`は`ObservableConvertibleType`プロトコルで定義されています。

こんな感じでしょうか↓
![Blank-Template-Wallpaper.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/774264/fd0e2b1a-82f1-3962-2ca7-186f22d76262.jpeg)


### subscribe
```swift

public func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element 
```
**引数**: `ObserverType`プロトコルのassociatedtypeである`Element`と、`ObservableConvertibleType`プロトコルのassociatedtypeである`Element`が等しい値
**戻り値**: `Disposable`プロトコルに準拠した値
※ `Disposable`はsubscribe(購読)の解除を行うためのプロトコルです。

```Swift
observable.subscribe(onNext: {
    print($0)
})
```
実際に使用する際は、`Observable`を持つ値に対して使います。
`onNext`でイベントが流れてきたときに`print($0)`が実行されます。

`onNext`の他には`onError`,`onCompleted`があります。

### asObservable

```swift

public func asObservable() -> Observable<Element> {
        return Observable.create { o in
            return self.subscribe(o)
        }
    }
```

**引数**: なし
**戻り値**: 任意の型`Element`をもつ`Observable`を返す

監視したいけれど、`Observable`じゃない。ってときにこのメソッドを使うと`Observable`として扱える感じです。
ただし、`ObservableType`にしか使えないです。

#### ObserverType

```swift
public protocol ObserverType {
    associatedtype Element

    @available(*, deprecated, renamed: "Element")
    typealias E = Element

    func on(_ event: Event<Element>)
}
extension ObserverType {
    
    public func onNext(_ element: Element) {
        self.on(.next(element))
    }
    
    public func onCompleted() {
        self.on(.completed)
    }
    
    public func onError(_ error: Swift.Error) {
        self.on(.error(error))
    }
}
```
`subscribe`の型のところで新しく出てきた`ObserverType`について説明する前に`Event`について軽く説明します。

```swift

public enum Event<Element> {
    case next(Element)
    case error(Swift.Error)
    case completed
}
```

定義を見るとこのようになっており、

* `next`はObserverに値の更新を通知します。
* `error`はエラー時にエラーを通知します。
* `completed`はイベントが終わったときに完了を通知します。

```swift

func on(_ event: Event<Element>)
```
このメソッドを実際に使う際は、以下の様にどちらを使っても構いません。

```swift
observer.on(.next(element))
observer.onNext(element)
```



## ObservableConvertibleType

```swift

public protocol ObservableConvertibleType {
    associatedtype Element

    @available(*, deprecated, renamed: "Element")
    typealias E = Element

    func asObservable() -> Observable<Element>
}
```
`Observable`クラスに準拠している`ObservableType`プロトコルが継承している`ObservableConvertibleType`プロトコルについてみていきます（ややこしいな...）

```swift
    func asObservable() -> Observable<Element>
```
このメソッドについては
[ObservableType](#observabletype)の[asObservable](#asobservable)を見てください。

このプロトコルでは難しいことはないのでよかったです。

# 終わりに
自分の思考を整理するために書いていたところが大きかったため、あまり理解しやすい内容とはいえないかもしれませんが、個人的にはだいぶ理解が深まったなと思っています。
やはり、定義にジャンプしてコードを追うことは（脳に抵抗がありますが）大事だと思いました。