¿Hay un flujo de trabajo de opción estándar en F#?

No hay un constructor de cómputo estándar para las opciones, pero si no necesita cosas como la pereza (como se agregó en los ejemplos que vinculó), el código es lo suficientemente sencillo como para que no haya razón para no confiar en él (particularmente dada la sugerente función Option.bind de la biblioteca estándar). He aquí un ejemplo bastante mínimo:

type OptionBuilder() =
    member x.Bind(v,f) = Option.bind f v
    member x.Return v = Some v
    member x.ReturnFrom o = o
    member x.Zero () = None

let opt = OptionBuilder()

He creado una biblioteca de código abierto FSharp.Interop.NullOptAble disponible en nuget.

No solo funciona como un flujo de trabajo de opción, sino que también funciona como un flujo de trabajo null o nullable.

let x = Nullable(3)
let y = Nullable(3)
option {
    let! x' = x
    let! y' = y
    return (x' + y')
} (* |> should equal (Some 6) *)

Funciona igual de bien que

let x = Some(3)
let y = Some(3)
option {
    let! x' = x
    let! y' = y
    return (x' + y')
} (* |> should equal (Some 6) *)

O incluso

let x = "Hello "
let y = "World"
option {
    let! x' = x
    let! y' = y
    return (x' + y')
} (* |> should equal (Some "Hello World") *)

Y si algo es null o None

let x = "Hello "
let y:string = null
option {
    let! x' = x
    let! y' = y
    return (x' + y')
} (* |> should equal None *)

Finalmente si tienes un montón de cosas de tipo nullable, tengo un cexpr para chooseSeq {} y si yield! algo null/None simplemente no consigue ceder.

Ver más ejemplos aquí.