案例表达/列表理解中的模式匹配

Jules 发表于 Dev

朱尔斯

为什么以下尝试在列表理解中进行模式匹配不起作用？

示例：同时替换术语数据类型中的原子。

数据类型：

data Term a 
    = Atom a
    | Compound (Term a) (Term a)
    deriving Show

用原子来表示原子的替换算法（如果有匹配则选择第一个匹配替换，然后忽略其余匹配）：

subs :: [(Term a, Term a)] -> Term a -> Term a
subs subList term = case term of 
    atom@(Atom x)       ->  let substitutions = 
                                [ s | s@(Atom x, _) <- subList ]
                            in  if null substitutions
                                then atom
                                else snd . head $ substitutions
    (Compound t1 t2)    -> Compound (subs subList t1) (subs subList t2)

一些测试数据：

subList = [((Atom 'a'), Compound (Atom 'b') (Atom 'c'))]
term1 = Atom 'a' 
term2 = Atom 'x'

运行示例将导致：

>: subs subList term1
Compound (Atom 'b') (Atom 'c')

这是理想的行为，并且

>: subs subList term2
Compound (Atom 'b') (Atom 'c')

不是。

粗暴的显式匹配工作原理：

subs'' :: [(Term Char, Term Char)] -> Term Char -> Term Char
subs'' subList term = case term of 
    atom@(Atom _)       ->  let substitutions = 
                            [ s | s@(Atom 'a', _) <- subList ]
                            in  if null substitutions
                                then atom
                                else snd . head $ substitutions
    (Compound t1 t2)    -> Compound (subs subList t1) (subs subList t2)

subs''' subList term = case term of 
     atom@(Atom _)       ->  let substitutions = 
                             [ s | s@(Atom 'x', _) <- subList ]
                             in  if null substitutions
                                 then atom
                                 else snd . head $ substitutions
     (Compound t1 t2)    -> Compound (subs subList t1) (subs subList t2)

将测试数据输入以下内容：

>: subs'' subList term1 或者 >: subs'' subList term2
Compound (Atom 'b') (Atom 'c')

>: subs''' subList term1 或者 >: subs''' subList term2
Atom 'x'

我想念什么？

安德拉斯·科瓦奇斯（AndrásKovács）

Haskell具有线性模式，这意味着模式中不得有重复的变量。同样，内部表达式中的模式变量会遮盖外部变量，而不是建立相同变量的相等性。

您正在尝试执行以下操作：

charEq :: Char -> Char -> Bool
charEq c c = True
charEq _ _ = False

但是由于重复的变量，这是一个错误。如果我们将第二个c移到内部表达式，它会编译，但仍无法按预期工作：

charEq :: Char -> Char -> Bool
charEq c d = case d of
  c -> True
  _ -> False

这里的innerc只是一个新的变量，它遮蔽了外部c，因此charEq总是返回True。

如果我们想检查是否相等，则必须==显式使用：

subs :: [(Term a, Term a)] -> Term a -> Term a
subs subList term = case term of 
    atom@(Atom x)       ->  let substitutions = 
                                [ s | s@(Atom x', _) <- subList, x == x' ]
                            in  if null substitutions
                                then atom
                                else snd . head $ substitutions
    (Compound t1 t2)    -> Compound (subs subList t1) (subs subList t2)

本文收集自互联网，转载请注明来源。

如有侵权，请联系[email protected] 删除。