Lista di opzioni a scomparsa

Question

Dato un elenco [Some 1; Some 2; Some 3] Desidero un'uscita Some 6. Dato un elenco [Some 1; None] dovrebbe produrre None.

Ma lo trovo un po 'più difficile di quanto avessi immaginato di ottenere in modo pulito.

il meglio che potevo venire con era presente

let someNums = [Some 1; Some 2; Some 3] 
someNums 
|> List.reduce (fun st v -> 
    Option.bind (fun x -> 
    Option.map (fun y -> x + y) st) v) 

Answer 1

si può realizzare questo definendo una funzione map2 per i valori di opzione:

let optionMap2 f x y = 
    match x, y with 
    | (Some x', Some y') -> Some (f x' y') 
    | _ -> None 

Ciò consentirebbe di scrivere la funzione che si desidera:

let sumSome = List.fold (optionMap2 (+)) (Some 0) 

Esempio:

> [Some 1; Some 2; Some 3] |> sumSome;; 
val it : int option = Some 6 
> [Some 1; None; Some 3] |> sumSome;; 
val it : int option = None 

Al momento, la funzione optionMap2 non è disponibile nella libreria F # core, ma probably will be part of the Option module in the future.

Answer 2

let lift op a b = 
    match a, b with 
    | Some av, Some bv -> Some(op av bv) 
    | _, _ -> None 

let plus = lift (+) 

[Some 1; Some 2; Some 3] 
|> List.reduce plus 
// val it : int option = Some 6 


[Some 1; None] 
|> List.reduce plus 
// val it : int option = None 

con piega

[Some 1; None] 
|> List.fold plus (Some 0) 
// val it : int option = None 

[Some 1; Some 2; Some 3] 
|> List.fold plus (Some 0) 
// val it : int option = Some 6 

[Some 1; None; Some 2] 
|> List.fold plus (Some 0) 
// val it : int option = None 

Answer 3

Ecco un'implementazione ingenua del sequence Gustavo parlato:

let rec sequence = 
    function 
    | [] -> Some [] 
    | (Some o :: os) -> 
     sequence os 
     |> Option.map (fun os' -> o::os') 
    | _ -> None 

(per favore notare che questo non è ricorsiva in coda e non ottimizzato per niente così si dovrebbe trasformarlo, se hai intenzione di bisogno per grandi liste)

che avrebbe funzionato altrettanto Gustavo ti ha detto:

> sequence [Some 1; Some 2; Some 2] |> Option.map List.sum;; 
val it : int option = Some 5 

> sequence [Some 1; None; Some 2] |> Option.map List.sum;; 
val it : int option = None