Question

What is the proper way to extend the available operators when using RX?

I’d like to build out some operations that I think would be useful.

The first operation is simply the standard deviation of a series.

The second operation is the nth lagged value i.e. if we are lagging 2 and our series is A B C D E F when F is pushed the lag would be D when A is pushed the lag would be null/empty when B is pushed the lag would be null/empty when C is pushed the Lag would be A

Would it make sense to base these types of operators off of the built-ins from rx.codeplex.com or is there an easier way?

Answer 1

In idiomatic Rx, arbitrary delays can be composed by Zip.

let lag (count : int) o = 
    let someo = Observable.map Some o
    let delayed = Observable.Repeat(None, count).Concat(someo)        
    Observable.Zip(someo, delayed, (fun c d -> d))    

As for a rolling buffer, the most efficient way is to simply use a Queue/ResizeArray of fixed size.

let rollingBuffer (size : int) o = 
    Observable.Create(fun (observer : IObserver<_>) -> 
    let buffer = new Queue<_>(size)
    o |> Observable.subscribe(fun v -> 
            buffer.Enqueue(v)
            if buffer.Count = size then
                observer.OnNext(buffer.ToArray())
                buffer.Dequeue() |> ignore
        )
    )

For numbers |> rollingBuffer 3 |> log:

seq [0L; 1L; 2L]
seq [1L; 2L; 3L]
seq [2L; 3L; 4L]
seq [3L; 4L; 5L]
...

For pairing adjacent values, you can just use Observable.pairwise

let delta (a, b) = b - a
let deltaStream = numbers |>  Observable.pairwise |> Observable.map(delta) 

Observable.Scan is more concise if you want to apply a rolling calculation .