In che modo la forse Monad si riferisce al tipo di opzione?

Leggendo la documentazione sul tipo Option di F #, sembra che si comporti esattamente come il tipo Maybe in Haskell, nel senso che può modellare "niente" ( None in F #, Nothing in Haskell) o un valore del suo tipo di argomento ( Some in F #, Just in Haskell).

In Haskell, tuttavia, Maybe è anche una monade e l'impianto idraulico è tale da consentire calcoli su valori Maybe , precoce ritorno Nothing se una delle variabili nel calcolo è Nothing . Usato in questo modo, Maybe è un semplice gestore di errori (o meglio, un dispositivo che ignora gli errori), e il fatto che si tratti di una monade consente di spostare la piastra di prova. Guarda questo articolo di Wikipedia per un bell'esempio sintetico. Non credo che Option supporti questo tipo di uso monadico (in effetti, mi chiedo se non vi sia alcun concetto esplicito di una monade in F #). Se vuoi questo comportamento in .NET, suppongo che useresti Option.Value per tutti i tuoi argomenti e completi l'intero calcolo in un try / catch su NullReferenceException .

Quindi, mentre Option è simile a Maybe tipo , non è equivalente a Maybe monad .

Sì, sono equivalenti nel senso che il Option digita insieme a Option.bind e il tipo costruttore Some costituiscono una monade.

Mentre le monadi (come nella classe Monad ) sono una parte centrale dell'identità di Haskells, da un punto di vista concettuale sono un costrutto indipendente dal linguaggio. Un modello di design, se vuoi. Se si dispone di un tipo e si dispone di un binding e una funzione di ritorno con firme specifiche che obbediscono a un particolare insieme di leggi, si dispone di una monade, indipendentemente dalla lingua utilizzata.

Le espressioni di calcolo F # forniscono solo uno zucchero di sintassi programmabile per le monadi, simile alla notazione in Haskell. Sebbene non sia presente un generatore di espressioni di calcolo Option fornito in modo predefinito, è possibile definire facilmente una versione ridotta come questa:

type OptionBuilder () = 
    member this.Bind(m, f) = Option.bind f m
    member this.Return(a) = Some a 

let option = OptionBuilder ()  

E usalo in questo modo:

let c = 
    option {
        let! a = Some 4
        let! b = None
        return a + b
    }

che è un equivalente zuccherato di qualcosa del genere:

let c =
    (Some 4) 
    |> Option.bind (fun a ->
        None 
        |> Option.bind (fun b ->
             Some (a + b)))

Si noti come i membri del builder rispecchiano la classe di tipi Monad e come si può scrivere un codice monadico, anche se convoluto, senza un builder.

Sono equivalenti e sono entrambe monadi. La differenza sta nel fatto che un monad significa qualcosa in Haskell - esiste un typeclass Monad esplicito e "do notation" può essere usato per eliminare un sacco di caratteri durante la scrittura del codice monadico. In F #, la notazione del builder e let! e do! possono essere usati per sbarazzarsi di una simile piastra, ma c'è non una nozione esplicita di un tipo "essere una monade". Il sistema di tipi di Haskell include typeclass (di cui la classe generale Monad è) e tipi con caratteri più elevati (di cui un singolo Monad è), che consentono di scrivere codice che funzioni per tutte le monadi. Il sistema di tipi di F # non ha nessuna di queste caratteristiche.

Quindi sì, il Option di F # e il% co_de di Haskell sono identici e entrambe le monadi. È solo che Haskell ti offre molti più strumenti per lavorare con le monadi di F #.