匹配SML中的两个自定义数据类型

Question

我有两种自定义数据类型，

datatype expression = Constant of int
                    | Variable of string
                    | Operator of string * expression
                    | Pair of expression list
                    | List of expression list

datatype pattern = ConstantP of int
                 | VariableP of string
                 | OperatorP of string * pattern
                 | PairP of pattern list
                 | ListP of pattern list
                 | UnorderedListP of pattern list
                 | Wildcard

我应该实现一个功能

match (fn : expression * pattern -> (string * expression) list option) 

得到一个表达和一个模式。 如果可以进行匹配，则返回SOME (list of bindings) ，否则返回NONE 。

匹配应通过以下方式完成：

在表达式和列表（表达式*模式）的元组上定义匹配项。 表达式和模式可以匹配，也可以不匹配。 如果匹配，匹配将生成一个绑定列表-名称和值对（（字符串*表达式）列表），列表的顺序无关紧要。 匹配使用以下规则：

• 通配符匹配任何内容，并产生一个空的绑定列表。
• VariableP s匹配任何值v并返回具有一个绑定（s，v）的列表。 每个变量名s在每个模式中最多出现一次。
• ConstantP 42仅匹配常量42，并产生一个空的绑定列表。 对于其余整数，其工作方式相同。
• Paira [a1，a2]如果a1匹配b1，a2匹配b2，则匹配表达式Pair [b1，b2]。 匹配产生两个匹配的串联列表。
• 如果xs中的每个值都与ps中的对应模式匹配，则ListP ps匹配表达式List xs。 匹配产生一个列表，我们将所有匹配接收到的绑定进行串联。
• 如果运算符a和b的名称相同，并且“ x”匹配“ y”，则OperatorP（a，x）匹配表达式Operator（b，y）。 通过匹配x和y，匹配产生了一个绑定列表。

如果可以给我一些指导，我认为我的功能应该是这样的，但我不确定递归地涵盖所有情况

fun match(e: expression, p: pattern) : (string * expression) list option =
    case p of 
         Wildcard => SOME []
       | VariableP s => ...

Answer 1

使用更多的模式匹配。
然后您逐一浏览规则列表并进行翻译，然后在规则取决于子匹配项时重复进行。
您只需要定义匹配构造函数的大小写，就可以保留最后一个默认大小写不匹配的情况。

fun match (_, Wildcard) = SOME []
  | match (Constant x, ConstantP y) = if x = y then SOME [] else NONE
  | match (Pair [p1, p2], PairP [p1', p2']) = 
                                  let 
                                      val match1 = match (p1, p1')
                                  in case match1 of
                                         NONE => NONE
                                       | SOME ls => ...
                                  end
  | ...
  | match _ = NONE 

但是您可以通过定义一些辅助函数来使事情变得更加方便。
（一旦输入全部，上面的Pair子句将变得笨拙。）

例如，仅当两个可选列表都不为NONE可以将两个可选列表串联起来作为函数：

fun appendOptional (SOME xs, SOME ys) = SOME (xs @ ys)
  | appendOptional _ = NONE

并让您写一行

  | match (Pair[p1, p2], PairP[p1', p2']) = appendOptional(match(p1, p1'), match(p2, p2'))

该功能在其他情况下也可能会派上用场。
（如果没有帮助函数，列表规则即使不是不可能的，也是很痛苦的。）

一个更详细的示例：

datatype expression =  Constant of int
                     | Variable of string
                     | Pair of expression list

datatype pattern = ConstantP of int
                 | VariableP of string
                 | PairP of pattern list
                 | Wildcard

fun appendOptional (SOME xs, SOME ys) = SOME (xs @ ys)
  | appendOptional _ = NONE

fun match (_, Wildcard) = SOME []
  | match (Constant x, ConstantP y) = if x = y then SOME [] else NONE
  | match (Pair [p1, p2], PairP [p1', p2']) = appendOptional (match (p1, p1'), match (p2, p2'))
  | match (e, VariableP v) = SOME [(v, e)] 
  | match _ = NONE 

测试：

- match (Constant 32, ConstantP 1);
val it = NONE : (string * expression) list option

- match (Constant 32, ConstantP 32);
val it = SOME [] : (string * expression) list option

- match (Constant 32, VariableP "x");
val it = SOME [("x",Constant 32)] : (string * expression) list option

- match (Pair [Constant 32, Variable "y"], PairP [VariableP "a", VariableP "b"]);
val it = SOME [("a",Constant 32),("b",Variable "y")]
  : (string * expression) list option