Question

F＃中是否可以根据案例而不是案例内容来匹配被歧视的联盟？例如，如果我想按照Flag大小写的元素过滤列表，是否可以按此过滤？目前，我被迫有三个独立的功能来过滤我想要的方式。这是我到目前为止的方法：

type Option = 
 {Id : string
  Arg : string}

type Argument =
     | Flag of string
     | Option of Option
     | Unannotated of string

//This is what I'm going for, but it does not work as the "other" match case will never be matched
let LocateByCase (case:Argument) (args : Argument List) =
    args
    |> List.filter (fun x -> match x with
                             | case -> true
                             | _ -> false)

let LocateAllFlags args =
    args
    |> List.filter (fun x -> match x with
                             | Flag y -> true
                             | _ -> false)
let LocateAllOptions args =
    args
    |> List.filter (fun x -> match x with
                             | Option y -> true
                             | _ -> false)

let LocateAllUnannotated args =
    args
    |> List.filter (fun x -> match x with
                             | Unannotated y -> true
                             | _ -> false)

我是否遗漏了F＃语言的某些方面，这会使这更容易处理？

Answer 1

没有内置方法可以找出DU值的情况。面对这种要求时，通常的做法是为每种情况提供适当的功能：

type Argument =
     | Flag of string
     | Option of Option
     | Unannotated of string
    with
     static member isFlag = function Flag _ -> true | _ -> false
     static member isOption = function Option _ -> true | _ -> false
     static member isUnannotated = function Unannotated _ -> true | _ -> false

let LocateByCase case args = List.filter case args

let LocateAllFlags args = LocateByCase Argument.isFlag args

（不用说，LocateByCase函数实际上是多余的，但我决定保留它以使答案更清晰）

警告：下面的脏兮兮

或者，您可以将案例作为引文提供，并使自己成为一个函数，分析该引用，从中提取案例名称，并将其与给定值进行比较：

open FSharp.Quotations

let isCase (case: Expr<'t -> Argument>) (value: Argument) = 
    match case with
    | Patterns.Lambda (_, Patterns.NewUnionCase(case, _)) -> case.Name = value.GetType().Name
    | _ -> false

// Usage:
isCase <@ Flag @> (Unannotated "")  // returns false
isCase <@ Flag @> (Flag "")  // returns true

然后使用此功能过滤：

let LocateByCase case args = List.filter (isCase case) args

let LocateAllFlags args = LocateByCase <@ Flag @> args

HOWEVER ，这实际上是一个肮脏的黑客。它的肮脏和黑客来自这样一个事实：因为你不能在编译时需要一定的引用形状，它将允许荒谬的程序。例如：

isCase <@ fun() -> Flag "abc" @> (Flag "xyz")  // Returns true!
isCase <@ fun() -> let x = "abc" in Flag x @> (Flag "xyz")  // Returns false. WTF?
// And so on...

如果编译器的未来版本决定以稍微不同的方式生成报价，并且您的代码将无法识别它们并且始终报告错误否定，则可能会发生另一个问题。

如果可能的话，我建议尽量避免弄乱报价。表面看起来很容易，但实际上是easy over simple的情况。

在歧视的工会案件上匹配而不是内容

1 个答案: