Case 语句和模式匹配

Question

我正在为一项作业使用 SML 进行编码，并且已经完成了一些练习题，但我觉得我错过了一些东西 - 我觉得我使用了太多 case 语句。这是我正在做的事情以及我遇到的问题的问题陈述：

1. 编写一个函数 all_except_option，它接受一个字符串和一个字符串列表。如果字符串不在列表中，则返回 NONE，否则返回 SOME lst，其中 lst 类似于参数列表，只是字符串不在其中。

   fun all_ except_option(str : 字符串, lst : 字符串列表) =
     案例列表 
      [] =>没有任何
     | x::xs =>案例 Same_string(x, str) of
                  真=>一些xs
                |假=>案例 all_except_option(str, xs) of
                             无=>没有任何
                           |一些 y=>一些（x::y）  
   

2. 编写一个函数 get_substitutions1，它接受一个字符串列表 list（字符串列表、替换项的列表）和一个字符串 s 并返回一个字符串列表。结果包含替换中某个列表中也包含 s 的所有字符串，但 s 本身不应出现在结果中。

   fun get_substitutions1(lst : 字符串列表 list, s : 字符串) = 
     案例列表
       [] => []
     | x::xs =>案例 all_ except_option(s, x) of
                    无=> get_substitutions1(xs, s)
                   |一些 y => y @ get_substitutions1(xs, s)
   

- same_string 是提供的函数， 有趣的same_string（s1：字符串，s2：字符串）= s1 = s2

Answer 1

首先，我将开始在函数定义中使用模式匹配
而不是“顶级”案例陈述。它基本上可以归结为
脱糖后也是同样的情况。另外，除非严格需要，否则我会摆脱显式类型注释：

fun all_except_option (str, []) = NONE
  | all_except_option (str, x :: xs) =
    case same_string(x, str) of
      true  => SOME xs
    | false => case all_except_option(str, xs) of
                 NONE   => NONE
               | SOME y => SOME (x::y)

fun get_substitutions1 ([], s) = []
  | get_substitutions1 (x :: xs, s) =
    case all_except_option(s, x) of
      NONE   => get_substitutions1(xs, s)
    | SOME y => y @ get_substitutions1(xs, s)

如果速度不重要，那么您可以合并第一个函数中的两种情况：

fun all_except_option (str, []) = NONE
  | all_except_option (str, x :: xs) =
    case (same_string(x, str), all_except_option(str, xs)) of
      (true, _)       => SOME xs
    | (false, NONE)   => NONE
    | (false, SOME y) => SOME (x::y)

但是由于您在第二个函数中使用追加（@），并且因为它不是
尾递归，我不认为这是您主要关心的问题。请记住
附加是潜在的“邪恶”，你几乎应该总是使用串联（并且
然后在返回结果时反转结果）并尽可能进行尾递归（它
总是如此）。

如果您真的喜欢显式类型注释，那么您可以这样做：

val rec all_except_option : string * string list -> string list option  =
 fn (str, []) => NONE
  | (str, x :: xs) =>
    case (same_string(x, str), all_except_option(str, xs)) of
      (true, _)       => SOME xs
    | (false, NONE)   => NONE
    | (false, SOME y) => SOME (x::y)


val rec get_substitutions1 : string list list * string -> string list =
 fn ([], s) => []
  | (x :: xs, s) =>
    case all_except_option(s, x) of
      NONE   => get_substitutions1(xs, s)
    | SOME y => y @ get_substitutions1(xs, s)

但这只是我的首选方式，如果我真的必须添加类型注释。

顺便问一下，为什么要有 same_string 函数？您可以直接进行比较。使用辅助函数只是很奇怪，除非您计划在某个时候将其与某些特殊逻辑进行交换。然而你的函数名称并不表明这一点。

Answer 2

除了 Jesper.Reenberg 提到的内容之外，我只是想提一下，bool 上的 true 和 false 匹配可以替换为如果-那么-else。然而，有些人认为 if-then else 比 case 语句更难看

Answer 3

fun same_string( s1: string, s2: string ) = if String.compare( s1, s2 ) = EQUAL then true else false


fun contains( [],   s: string ) = false
|   contains( h::t, s: string ) = if same_string( s, h ) then true else contains( t, s )


fun all_except_option_successfully( s: string, [] )   = []
|   all_except_option_successfully( s: string, h::t ) = if same_string( s, h ) then t else ( h :: all_except_option_successfully( s, t ) )


fun all_except_option( s: string, [] )   = NONE
|   all_except_option( s: string, h::t ) = if same_string( s, h ) then SOME t else if contains( t, s ) then SOME ( h :: all_except_option_successfully( s, t ) ) else NONE