f# - 避免嵌套模式匹配(可能与monad)

Question

如何重写嵌套模式匹配，例如以下示例，以便 None只指定一次？我认为 Maybe monad 解决了这个问题。 F# 核心库中是否有类似的东西？或者，有没有替代方法？

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

您可以使用内置功能解决此问题: 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>"  

坦率地说，我怀疑在这里引入成熟的“可能”实现(通过计算表达式)可以缩短代码。

编辑 :梦想模式 - 开启

我认为如果 F# 对特殊情况有更轻量级的语法，那么带有 Option.bind 的版本可以更小: lambda 引用其参数的某个成员:

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

这就是如何在已经具有此类功能的 Nemerle 中重写示例:

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"