F#：嵌套的可区分联合和匹配

Question

我有 2 个嵌套的可区分联合：

type ServiceTypes =
    | Contexts
    | Context of int
    | Producers

type ServiceActions =
    | Get of ServiceTypes
    | Update of ServiceTypes

和一个嵌套的匹配语句：

let s_action = match action with
               | Get(stype) -> sprintf "Get%s" (match stype with
                                                | Contexts -> sprintf "Contexts"
                                                | Context(id)  -> (sprintf "Context/%d" id))
                                                | _ -> raise (RequestException("get"))
               | Update(stype) -> sprintf "Update%s" (match stype with
                                                      | Producers -> (sprintf "Producers")
                                                      | _ -> raise (RequestException("update")))

目标是使用类似于 req.Send(Update Producers) 的调用构建请求字符串。

无论如何，由于我不明白的原因，编译器给了我 2 个警告：

1. 警告上收到 此规则将永远不会匹配
2. 在 Update(stype) 上，我在第一个 match stype 我在此表达式上得到不完整的模式匹配。例如，值“Producers”可能表示模式未涵盖的情况。

所以问题是为什么我会收到这两个警告？我是否错过了匹配工作方式中的某些内容？

Answer 1

虽然嵌套匹配表达式有时是有必要的，但在这种特殊情况下，如果我是您，我会编写一个更具可读性的单级匹配：

let s_action = 
   match action with
   | Get Contexts     -> "GetContexts"
   | Get (Context id) -> sprintf "GetContext/%d" id
   | Update Producers -> "UpdateProducers"
   | Get _    -> raise (RequestException "get")
   | Update _ -> raise (RequestException "update")

这会实现与您的代码完全相同的效果。

Answer 2

您的右括号位置错误。

| Context(id)  -> (sprintf "Context/%d" id))
| _ -> raise (RequestException("get"))

应该是

| Context(id)  -> (sprintf "Context/%d" id)
| _ -> raise (RequestException("get")))

---

确实，为了清楚起见，我会去掉所有无关的括号（在这种情况下实际上是每个括号）：

let s_action =
    match action with
    | Get stype    -> match stype with
                        | Contexts   -> "Contexts"
                        | Context id -> sprintf "Context/%d" id
                        | _          -> RequestException "get" |> raise
                      |> sprintf "Get%s"
    | Update stype -> match stype with
                        | Producers -> "Producers"
                        | _         -> RequestException "update" |> raise
                      |> sprintf "Update%s"

我个人认为这更具可读性，但当然这是主观的，所以YMMV。

Answer 3

由于您在错误的位置关闭了括号，您的代码实际上变成：

let s_action =
  match action with
  | Get(stype) -> sprintf "Get%s" (match stype with
                                   | Contexts -> sprintf "Contexts"
                                   | Context(id)  -> (sprintf "Context/%d" id))
  | _ -> raise (RequestException("get")) (* Closing parenthesis should be here *)
  | Update(stype) -> sprintf "Update%s" (match stype with
                                         | Producers -> (sprintf "Producers")
                                         | _ -> raise (RequestException("update")))

显然您可以看到第一个 match stype with 不覆盖 Producers 和最后一个模式 由于之前的模式 _，Update(stype) 永远不会匹配。因此，所有编译器警告都是合理的。

你似乎过度使用了拟态；这是一个清理版本：

let s_action =
 match action with
 | Get stype -> sprintf "Get%s" <| match stype with
                                   | Contexts -> sprintf "Contexts"
                                   | Context id -> sprintf "Context/%d" id
                                   | _ -> raise <| RequestException "get"
 | Update stype -> sprintf "Update%s" <| match stype with
                                         | Producers -> sprintf "Producers"
                                         | _ -> raise <| RequestException "update"