How to do pattern matching in Rx. Where and Select in a single operator?

Question

Suppose I have this type:

type T = int option

and an observable of that type:

let o : IObservable<T> = // create the observable

I'm looking for a better way to express this:

o.Where(function | None -> false | Some t -> true)
 .Select(function | Some t -> t)

An observable that only propagates the Some case.

There are several things that I don't like.

• I'm using 2 operators
• I'm pattern matching twice
• The second pattern matching isn't exhaustive (makes visual studio show a warning and feels odd)
• Too much code. The pattern repeats every time I need pattern matching.

Answer 1

Can't you use Observable.choose ? something like this :

let o1 : IObservable<int option> = // ...
let o2 = Observable.choose id o1

If you have a type that is not an option, say:

type TwoSubcases<'a,'b> = | Case1 of 'a | Case2 of 'b

and a partial active pattern:

let (|SecondCase|_|) = function
    | Case1 _ -> None
    | Case2 b -> Some b

then you can do:

let o1 : IObservable<TwoSubcases<int, float>> = // ...
let o2 : IObservable<float> = Observable.choose (|SecondCase|_|) o1 

Answer 2

Thanks to @Lee I came up with a nice solution.

o.SelectMany(function | None -> Observable.Empty() | Some t -> Observable.Return t)

This works for any union type, not only Option.