Tukukkk

I have implemented a simple Observable class. I think that there is still room for improvement. Especially the fact that I have separate array to observe results and values what if I want to observe errors for example, I think that this solution can be improved to be scalable. Also I'm not sure who is responsible for the threading the class implementation or the caller.

the desired result is to have an interface that allows:

1) Observable declaration:

private let isLoadingObservable = Observable<Bool>(false)

2) Update value:

self.isLoadingObservable.value = true

3) Observe values changes:

override func viewDidLoad() {

    super.viewDidLoad()



    isLoadingObservable.observeValues(on: self) { isLoading in

        print(isLoading)

    } 

}

Also in case where failure is possible (network call for example) we can user Result :

1) Observable declaration:

private let dataObservable = Observable<[User]>()

2) Update value:

dataObservable.result = Result.failure(URLError.badURL)

3) Observe result changes:

    dataObservable.observeResults(on: self) { result in

        switch result {

        case .success(let value):

            print(value)

        case .failure(let error):

            print(error)

        }

    }

where we have

struct User {

    let name: String

}



enum ServerError: Error {

    case invalidDataError

}

The implementation:

import Foundation



public enum Result<Value> {

    case success(Value)

    case failure(Error)



    var value: Value? {

        switch self {

        case .success(let value):

            return value

        case .failure:

            return nil

        }

    }

}





class ResultObserver<Value> {

    typealias ResultObserverBlock  = (Result<Value>) -> Void



    weak var observer: AnyObject?

    let block: ResultObserverBlock



    init(observer: AnyObject, block: @escaping ResultObserverBlock) {

        self.observer = observer

        self.block = block

    }

}



class ValueObserver<Value> {

    typealias ValueObserverBlock  = (Value) -> Void



    weak var observer: AnyObject?

    let block: ValueObserverBlock



    init(observer: AnyObject, block: @escaping ValueObserverBlock) {

        self.observer = observer

        self.block = block

    }

}



public class Observable<Value> {



    typealias ResultObserverBlock  = (Result<Value>) -> Void

    typealias ValueObserverBlock  = (Value) -> Void



    //MARK: - Private properties

    private var valueObservers  = [ValueObserver<Value>]()

    private var resultObservers = [ResultObserver<Value>]()



    //MARK: - Public properties

    public var result : Result<Value> {

        didSet {

            self.notifyObservers()

        }

    }



    public var value: Value? {

        get{

            return self.result.value

        }

        set {

            if let value = newValue {

                self.result = Result.success(value)

            }

        }

    }



    //MARK: - Struct lifecycle

    public init(_ result: Result<Value>) {

        self.result = result

    }



    public convenience init(_ value: Value) {

        self.init(Result.success(value))

    }



    public convenience init(_ error: Error) {

        self.init(Result.failure(error))

    }



    //MARK: - Observation

    func observeResults(on observer: AnyObject, observerBlock: @escaping ResultObserverBlock) {

        self.resultObservers.append(ResultObserver(observer: observer, block: observerBlock))

        observerBlock(result)

    }



    func observeValues(on observer: AnyObject, observerBlock: @escaping ValueObserverBlock) {

        self.valueObservers.append(ValueObserver(observer: observer, block: observerBlock))

        if let value = value {

            observerBlock(value)

        }

    }



    func remove(observer: AnyObject) {

        self.resultObservers = self.resultObservers.filter({$0.observer !== observer})

        self.valueObservers = self.valueObservers.filter({$0.observer !== observer})

    }



    //MARK: - Helpers

    private func notifyObservers() {

        for observer in self.valueObservers {

            if let value = value {

                observer.block(value)

            }

        }

        for observer in self.resultObservers {

            observer.block(result)

        }

    }

}

There is quite a lot of "almost similar" code due to the fact that you
treat "value observers" and "result observers" separately:
Two classes

class ResultObserver<Value>

class ValueObserver<Value> 

with corresponding type aliases:

typealias ResultObserverBlock  = (Result<Value>) -> Void

typealias ValueObserverBlock  = (Value) -> Void

and instance variables

private var valueObservers  = [ValueObserver<Value>]()

private var resultObservers = [ResultObserver<Value>]()

three init methods, two observeResults() methods, etc.

This would be greatly simplified by just observing a generic
type Value, which in particular can be a Result<>:

class Observer<Value> {

    typealias ObserverBlock  = (Value) -> Void



    weak var observer: AnyObject?

    let block: ObserverBlock



    init(observer: AnyObject, block: @escaping ObserverBlock) {

        self.observer = observer

        self.block = block

    }

}



public class Observable<Value> {



    //MARK: - Private properties

    private var observers  = [Observer<Value>]()



    //MARK: - Public properties

    public var value : Value {

        didSet {

            self.notifyObservers()

        }

    }



    //MARK: - Struct lifecycle

    public init(_ value: Value) {

        self.value = value

    }



    //MARK: - Observation

    func observe(on observer: AnyObject, observerBlock: @escaping Observer<Value>.ObserverBlock) {

        self.observers.append(Observer(observer: observer, block: observerBlock))

        observerBlock(value)

    }



    func remove(observer: AnyObject) {

        self.observers = self.observers.filter({ $0.observer !== observer })

    }



    //MARK: - Helpers

    private func notifyObservers() {

        for observer in self.observers {

            observer.block(value)

        }

    }

}

Note also the use of Observer<Value>.ObserverBlock in order to
avoid defining the same closure type twice.

Now you can observe a simple (boolean) value:

private let isLoadingObservable = Observable(false)



// ...        



isLoadingObservable.observe(on: self) { isLoading in

    print("observed:", isLoading)

}

or a result:

private let dataObservable = Observable(Result<[User]>.success())



// ...



dataObservable.observe(on: self) { result in

    switch result {

    case .success(let value):

        print("Value:",  value)

    case .failure(let error):

        print("Error:", error)

    }

}

Another possible improvement could be to check in func notifyObservers() if the observing object still is alive, and
remove it from the list otherwise.

One of the big draws of an Observable class are the operators like map, flatMap, and scan. At minimum you should implement those three functions.

That said, chaining your Observables together with map, & al. would be a bit problematic since they all would maintain a copy of the last element emitted (in the value parameter.)

I would rather see the Observable class do away with that parameter so I can chain several together without wasting a bunch of memory.