Question

对于F＃的许多领域，我仍然是新手。我出于好奇而不是出于实际的业务需求而提出这个问题。有没有办法匹配列表中的第一个 n 项目，无论它们出现的顺序如何？为了澄清，请考虑以下示例：

type MyEnum = 
    | Foo of int
    | Bar of float
    | Baz of string
let list = [ Foo 1 ; Bar 1.0 ; Baz "1" ]

现在，如果列表中的前两项按任意顺序排列为some_func和Foo，我想要调用Bar。只匹配两种可能的排列非常容易：

let result = 
    match list with
    | Foo n :: Bar x :: _ 
    | Bar x :: Foo n :: _ -> some_func n x
    | _ -> failwith "First 2 items must be Foo and Bar"

但是，如果前三项是任意顺序的Foo，Bar和Baz，我需要调用一个函数怎么办？使用上面相同的技术将要求我编写所有6种不同的排列（或 n 用于 n 项目）。理想情况下，我希望能够做到这一点：

let result = 
    match list with
    | (AnyOrder [ Foo n ; Bar x ; Baz s ]) :: _ -> some_func n x s
    | _ -> failwith "First 3 items must be Foo, Bar, and Baz"

有没有办法用某种active pattern来实现这一点，而不必硬编码不同的排列？

Answer 1

这是解决问题的一次尝试。它使用位图对每个联合案例进行评分，并检查分数总和是否为7：

let (|AnyOrder|_|) s =
    let score = function | Foo _ -> 1 | Bar _ -> 2 | Baz _ -> 4
    let firstElementsWithScores =
        s
        |> Seq.truncate 3
        |> Seq.map (fun x -> x, score x)
        |> Seq.sortBy (fun (_, x) -> x)
        |> Seq.toList
    let sumOfScores =
        firstElementsWithScores |> List.sumBy (fun (_, x) -> x)
    if sumOfScores = 7
    then
        match firstElementsWithScores |> List.map fst with
        | [Foo x ; Bar y ; Baz z ] -> Some (x, y, z)
        | _ -> None
    else None

如果得分为7，它会截断输入列表并对其进行排序，然后对截断的评分列表使用模式匹配，以便创建匹配元素的元组。

以下是使用它的一种方法：

let checkMatches s =
    match s with
    | AnyOrder (x, y, z) -> [Foo x; Bar y; Baz z]
    | _ -> []

FSI的一些例子：

> checkMatches list;;
val it : MyEnum list = [Foo 1; Bar 1.0; Baz "1"]
> checkMatches [Foo 1; Bar 1.0; Foo 2];;
val it : MyEnum list = []
> checkMatches [Foo 1; Bar 1.0; Baz "1"; Foo 2];;
val it : MyEnum list = [Foo 1; Bar 1.0; Baz "1"]
> checkMatches [Foo 1; Bar 1.0; Bar 2.0; Foo 2];;
val it : MyEnum list = []
> checkMatches [Bar 1.0; Foo 1; Baz "2.0"; Foo 2];;
val it : MyEnum list = [Foo 1; Bar 1.0; Baz "2.0"]

AnyOrder是带有签名

的部分活动模式

seq<MyEnum> -> (int * float * string) option

Answer 2

非常有趣的案例。 Mark提出的解决方案工作正常，但缺点是功能不可重用，我的意思是非常具体到那个DU。

这是一个通用的解决方案，但缺点是您需要按照创建DU的顺序指定列表。

let (|AnyOrderOfFirst|) n = Seq.take n >> Seq.sort >> Seq.toList

let result = 
    match list with
    | AnyOrderOfFirst 3 [ Foo n ; Bar x ; Baz s ] -> some_func n x s
    | _ -> failwith "First 3 items must be Foo, Bar, and Baz"

如果你改变你的DU改变TAG的顺序而忘记在列表中重新排序它们将永远不会匹配。

如果你想采用这种通用方式，我的建议是：创建一个单元测试来断言匹配始终有效。

按任意顺序匹配列表项目

2 个答案: