Evitare la corrispondenza di modelli nidificati (possibilmente con forse Monade)

Question

In che modo la corrispondenza di modelli nidificati, come il seguente esempio, può essere riscritta in modo che None sia specificato una sola volta? I penso che la monad Forse risolva questo problema. C'è qualcosa di simile nella libreria di base di F #? O c'è un approccio alternativo?

match a with 
| Some b -> 
    let c = b.SomeProperty 
    match c with 
    | Some d -> 
     let e = d.SomeProperty 
     //and so on... 
    | None ->() 
| None ->() 

Answer 1

è possibile risolvere questo utilizzando funzionalità integrate: Option.bind

type A = 
    member this.X : B option = Unchecked.defaultof<_> 
and B = 
    member this.Y : С option = Unchecked.defaultof<_> 
and С = 
    member this.Z : string option = Unchecked.defaultof<_> 


let a : A = Unchecked.defaultof<_> 
let v = 
    match 
     a.X 
     |> Option.bind (fun v -> v.Y) 
     |> Option.bind (fun v -> v.Z) with 
    | Some s -> s 
    | None -> "<none>" 

Francamente, dubito che l'introduzione a pieno titolo 'forse' implementazione (tramite le espressioni di calcolo) qui può ridurre il codice.

EDIT: modalità Dream - il

penso che la versione con Option.bind può essere reso più piccolo se F # ha sintassi più leggero per il caso particolare: lambda che si riferiscono a qualche membro della sua tesi :

"123" |> fun s -> s.Length // current version 
"123" |> #.Length // hypothetical syntax 

Questo è come il campione può essere riscritto in Nemerle che ha già tali capacità:

using System; 
using Nemerle.Utility; // for Accessor macro : generates property for given field 

variant Option[T] 
{ 
    | Some {value : T} 
    | None 
} 

module OptionExtensions 
{ 
    public Bind[T, U](this o : Option[T], f : T -> Option[U]) : Option[U] 
    { 
     match(o) 
     { 
      | Option.Some(value) => f(value) 
      | Option.None => Option.None() 
     } 
    } 
} 

[Record] // Record macro: checks existing fields and creates constructor for its initialization 
class A 
{ 
    [Accessor] 
    value : Option[A]; 
} 

def print(_) 
{ 
    // shortened syntax for functions with body -> match over arguments 
    | Option.Some(_) => Console.WriteLine("value"); 
    | Option.None => Console.WriteLine("none"); 
} 

def x = A(Option.Some(A(Option.Some(A(Option.None()))))); 
print(x.Value.Bind(_.Value)); // "value" 
print(x.Value.Bind(_.Value).Bind(_.Value)); // "none" 

Answer 2

Io non suggerisco questo, ma si può anche risolvere con la gestione delle eccezioni:

try 
    <code that just keeps dotting into option.Value with impunity> 
with 
    | :? System.NullReferenceException -> "None" 

Volevo solo sottolineare l'equivalenza approssimativa di gestione delle eccezioni per le monadi Forse/uno o Option.bind. Di solito preferisco uno di loro a lanciare e catturare le eccezioni.

Answer 3

Mi piace la risposta di Desco; si dovrebbe sempre favorire i costrutti incorporati. Ma FWIW, ecco cosa una versione del flusso di lavoro potrebbe apparire come (se ho capito bene il problema):

type CE() = 

    member this.Bind (v,f) = 
    match v with 
     | Some(x) -> f x 
     | None -> None 

    member this.Return v = v 


type A (p:A option) = 

    member this.P 
    with get() = p 


let f (aIn:A option) = CE() { 
    let! a = aIn 
    let! b = a.P 
    let! c = b.P 
    return c.P } 

let x = f (Some(A(None))) 

let y = f (Some(A(Some(A(Some(A(Some(A(None))))))))) 

printfn "Your breakpoint here." 

Answer 4

Utilizzando Option.maybe da FSharpx:

open FSharpx 
type Pet = { Name: string; PreviousOwner: option<string> } 
type Person = { Name: string; Pet: option<Pet> } 

let pers = { Name = "Bob"; Pet = Some {Name = "Mr Burns"; PreviousOwner = Some "Susan"} } 

Option.maybe { 
    let! pet = pers.Pet 
    let! prevOwner = pet.PreviousOwner 
    do printfn "%s was the previous owner of %s." prevOwner pet.Name 
} 

uscita:

Susan was the previous owner of Mr Burns. 

Ma, per esempio con questa persona, invece non c'è proprio nessun uscita:

let pers = { Name = "Bob"; Pet = None }