Reactive Extensions

// Playground - noun: a place where people can play

import UIKit

protocol IDisposable {

    func dispose ()

}

class Disposable : IDisposable {

    let _dispose : () -> ()

    init (dispose : () -> ()) {

        _dispose = dispose

    }

    func dispose() {

        _dispose()

    }

    class func empty() -> IDisposable {

        return Disposable({() in ()})

    }

}

class Observer<T> {

    let _onNext : T -> ()

    init (onNext : T -> ()) {

        _onNext = onNext

    }

    

    func onNext(x:T) { return _onNext(x) }

}

class Observable<T> {

    let _subscribe : Observer<T> -> IDisposable

    init (subscribe : Observer<T> -> IDisposable) {

        _subscribe = subscribe

    }

    

    func subscribe(obs: Observer<T>) -> IDisposable {

        return _subscribe(obs)

    }

}

func map<T,V> (f:T -> V) (xs: Observable<T>) -> Observable<V> {

    return Observable({o in xs.subscribe(Observer({x in o.onNext(f(x))}))})

}

func unit<T>(x:T) -> Observable<T> {

    return Observable ({ (o: Observer<T>) -> IDisposable in o.onNext(x);return Disposable.empty()})

}

func subscribe<T> (xs: Observable<T>) (obs: T -> ()) -> IDisposable {

    return xs.subscribe(Observer(obs))

}

let inc : Int -> Int = { x in x + 1000 }

let xs = unit(42)

let ys = map (inc) (xs:xs)

var ret:Int = 0

subscribe(ys) ({x in ret = x})

var val = ret