混合 DU 和其他值时的 F# 模式匹配

Question

表达以下代码最有效的方式是什么？

match cond.EvalBool() with
| true ->                
    match body.Eval() with
    | :? ControlFlowModifier as e ->
        match e with
        | Break(scope) -> e :> obj //Break is a DU element of ControlFlowModifier
        | _ -> next() //other members of CFM should call next()
    | _ -> next() //all other values should call next()
| false -> null

cond.EvalBool 返回布尔结果，其中 false 应返回 null true 应该再次运行整个块（它包含在一个名为 next 的函数中） 或者如果找到了特殊的break值，那么循环应该退出并返回break值。

有什么方法可以将该代码块压缩为更小的代码吗？

Answer 1

我认为你写的代码很好。这是我稍微喜欢的另一种选择：

let isBreak = function | Break(_) -> true | _ -> false
if cond.EvalBool() then
  match body.Eval() with
  | :? ControlFlowModifier as e when isBreak e -> e :> obj
  | _ -> next()
else
  null

Answer 2

我想指出，Eval 的结果类型似乎有一个子类型层次结构，如果它也是 DU，那么您可以

match body.Eval() with
| ControlFlowModifier(Break e) -> box e
| _ -> next()

对嵌套模式执行类似 Hurray 的操作。

Answer 3

我不太喜欢匹配布尔值而不是使用 if-else。 符

let isBreak = function Break _ -> true | _ -> false
...

if cond.EvalBool() then
    match body.Eval() with
    | :? ControlFlowModifier as e when isBreak e -> box e
    | _ -> next()
else null

或者，如果您认为不需要特殊的 isBreak 函数（我理解），让我们尝试创建一个更通用的函数：C# 的 as 运算

let tryCast<'T> (o : obj) =
    match o with
    | :? 'T as x -> Some x
    | _ -> None
...

if cond.EvalBool() then
    match body.Eval() |> tryCast with
    | Some (Break _ as e) -> box e //Break is a DU element of ControlFlowModifier
    | _ -> next() //all other values should call next()
else null

Answer 4

我最终为此创建了一个活动模式。
其他地方也存在类似的逻辑，因此我可以使其可重用，

let rec next() : obj =
if cond.EvalBool() then 
    match body.Eval() with
    | IsBreak(res) -> res
    | _ -> step.Eval() |> ignore ; next()
else null

看起来不错吗？

Answer 5

要展平嵌套的 match 构造，您需要使用嵌套模式。这最适合受歧视的联合（正如 Brian 所指出的 - 我同意设计 F# 代码以主要使用受歧视的联合是你能做的最好的事情）。

否则，如果您想使用 match 简洁地编写代码，则需要一些活动模式（ssp 发布了一个示例，其中显示了专门针对您的问题的活动模式）。但是，您可以使用以下两个可重用的活动模式来执行此操作：

let (|TryCast|_|) a : 'res option =    
  match (box a) with 
  | :? 'res as r -> Some(r)
  | _ -> None

let (|Value|) (l:Lazy<_>) = l.Value  

第一个类似于 :?，但它允许您嵌套其他模式以匹配该值（这对于 是不可能的） >如）。第二个强制评估惰性值（我认为它们都可以在 F# 库中声明，因为它们非常有用）。现在你可以写：

match lazy cond.EvalBool(), lazy body.Eval() with
| Value(true), Value(TryCast((Break(scope) : ControlFlowModifier)) as e) -> 
    e :> obj //Break is a DU element of ControlFlowModifier  
| Value(true), _ -> 
    next() //all other values should call next()  
| _, _ -> null 

编辑：正如罗杰在评论中指出的那样，这个版本的代码可能不太可读。我认为更好的选择是仅使用 TryCast 并以稍微不同的方式格式化原始代码（尽管这不是完全标准的缩进，但它是正确的并且 F# 编译器可以很好地处理它）：

match cond.EvalBool() with 
| false -> null 
| true ->                 
match body.Eval() with 
| TryCast(Break(scope) as e) -> e :> obj
| _ -> next()

这可能是基于模式匹配的最可读选项，但您也可以使用 if 代替第一个 match，如 kvb 版本中所示，并将其与 TryCast 结合使用> （这实际上取决于个人喜好）：

if cond.EvalBool() then
  match body.Eval() with 
  | TryCast(Break(scope) as e) -> e :> obj
  | _ -> next()
else null

无论如何，我相信 TryCast 使代码更具可读性，因为您避免了一次嵌套（这是其他需要的，因为 :? .. ..）。

Answer 6

如果你的意思是“最有效的方法”作为最短的代码，我也投票给美联社：

let (|CondEval|_|) (c,_) = if c.EvalBool() then Some true else None
let (|BodyEval|_|) (_,b) =
  match b.Eval() with
  | ControlFlowModifier as e -> Some e
  | _ -> None

match cond,body with
| CondEval _ & BodyEval e -> e :> obj
| true -> next()
| false -> null