equivalent.hs

data AnyObservable t = forall o. (ObservableData o, DataType o ~ t) => AnyObservable o

existential.swift

/// Existential type wrapper around an ObservableData constraining the data type to the type parameter T.
/// Useful as a return value for functions that return some observable but the concrete observable type isn't known.
public final class AnyObservableData<T>: ObservableData {

    // MARK: Init

    public static func make<U: ObservableData>(_ observable: U) -> AnyObservableData<U.Event> {
        return AnyObservableData<U.Event>(
            getter: { return observable.data },
            addObserver: { cb in return observable.addObserver(cb) },
            removeObserver: { token in return observable.removeObserver(with: token) }
        )
    }

    // ObservableData

    public typealias Event = T

    public var data: T {
        return getter()
    }

    public func addObserver(_ observer: @escaping (T) -> Void) -> ObserverToken {
        return self.addObserver_(observer)
    }

    public func removeObserver(with token: ObserverToken) {
        return self.removeObserver_(token)
    }

    // MARK: Private

    private init(
        getter: @escaping () -> T,
        addObserver: @escaping (@escaping (T) -> Void) -> ObserverToken,
        removeObserver: @escaping (ObserverToken) -> Void
    ) {
        self.getter = getter
        self.addObserver_ = addObserver
        self.removeObserver_ = removeObserver
    }

    private let getter: () -> T
    private let addObserver_: (@escaping (T) -> Void) -> ObserverToken
    private let removeObserver_: (ObserverToken) -> Void
}