Come eseguire la corrispondenza del modello in Rx. Dove e Seleziona in un unico operatore?

Question

Supponiamo che io sono questo tipo:

type T = int option 

e un'osservabile di quel tipo:

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

Sto cercando un modo migliore per esprimere questo:

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

Un osservabile che si propaga solo nel caso Some.

Ci sono diverse cose che non mi piacciono.

• sto usando 2 operatori
• Sono pattern matching due volte
• Il secondo pattern matching non è esaustivo (rende visual studio mostrano un messaggio di avviso e si sente dispari)
• troppo codice. Il pattern si ripete ogni volta che ho bisogno di un pattern matching.

Answer 1

Non è possibile utilizzare Observable.choose? qualcosa di simile:

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

Se si dispone di un tipo che non è un'opzione, dire:

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

e un modello attivo parziale:

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

allora si può fare:

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

Answer 2

Grazie a @Lee mi è venuta una buona soluzione.

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

Questo funziona per qualsiasi tipo di unione, non solo Opzione.