Going from Observable to Enumerable/Value without Blocking - f#

Question

I'm having some blocking problems. I am trying to go from push to pull. i.e. I would like to access my data here which in this case is an array after it has been processed through my Observable.
type HistoryBar =
{Open: decimal; High: decimal; Low: decimal; Close: decimal; Time: DateTime; Volume: int; RequestId: int; Index: int; Total: int}
let transformBar =
client.HistoricalData
|> Observable.map(fun args ->
{
Open = args.Open
High = args.High
Low = args.Low
Close = args.Close
Time = args.Date
Volume = args.Volume
RequestId = args.RequestId
Index = args.RecordNumber
Total = args.RecordTotal
}
)
let groupByRequest (obs:IObservable<HistoryBar>) =
let bars = obs.GroupByUntil((fun x -> x.RequestId), (fun x -> x.Where(fun y -> y.Index = y.Total - 1)))
bars.SelectMany(fun (x:IGroupedObservable<int, HistoryBar>) -> x.ToArray())
let obs = transformBar |> groupByRequest
client.RequestHistoricalData(1, sym, DateTime.Now, TimeSpan.FromDays(10.0), BarSize.OneDay, HistoricalDataType.Midpoint, 0)
If I subscribe to obs, than as soon as I make a call to client.RequestHistoricalData everything works fine. What I would like to do is convert obs to the underlying type which in this case is HistoryBar []. I have tried using wait, ToEnumberable with no luck. What is the proper approach here to pull out my last created piece of data?
Edit, adding contrived C# example code to show how the library normally works. What I am really trying to understand here is how one can go from observable to a standard list or array. What I am not certain of is if I required a mutable structure in order to do so. If I had to guess I would say no.
static void Main(string[] args)
{
...
client.HistoricalData += client_HistoricalData;
client.RequestHistoricalData(1, sym, DateTime.Today, TimeSpan.FromDays(10), BarSize.OneDay, HistoricalDataType.Midpoint, 0);
....
}
static void client_HistoricalData(object sender, HistoricalDataEventArgs e)
{
Console.WriteLine("Open: {0}, High: {1}, Low: {2}, Close: {3}, Date: {4}, RecordId: {5}, RecordIndex: {6}", e.Open, e.High, e.Low, e.Close, e.Date, e.RequestId, e.RecordNumber);
}

Answer 1

The question doesn't make very clear how the data is loaded in the first place (whether it is lazy / time-variant etc.) so I'll just assume that it's a time-bound stream of values.
From your code it seems like you want to find the last value in the stream when it completes. The Last method gives you the last value in the stream that was pushed when it completes - this is however synchronous and blocks till the stream completes. The non-blocking version, LastAsync returns an Observable which produces a value when the source completes.
let from0To4 =
Observable.Interval(TimeSpan.FromSeconds(0.1)).Take(5)
let lastValue =
from0To4.LastAsync()
let disposable =
lastValue |> Observable.subscribe(log)
To convert the Observable into a list without blocking in parts, you can use the Buffer methods. To buffer all values until the Observable completes, use ToList.
let fullBuffer =
from0To4.ToList()
let disposable =
fullBuffer |> Observable.subscribe(fun ls -> printfn "Buffer(%d): %A" ls.Count ls)
Output:
Buffer(5): seq [0L; 1L; 2L; 3L; ...]