谁能解释ZF表达式的第二条归约规则？

Question

[ e | v <- f:fs, q ] [ e | v <- f:fs, q ]减少为[ e | q ] [ v := f ] ++ [ e | v <- fs, q ] [ e | q ] [ v := f ] ++ [ e | v <- fs, q ]

[ e | v <- f:fs, q ]的输出 [ e | v <- f:fs, q ]应该是一个列表。 将两个列表放在一起表示什么意思？ 我的意思是您不能像这样["a"]["b"]仅仅将两个列表放在一起。

另外，符号:=是否等于= ？

Answer 1

不知道您在哪里看到过它，很难确定是什么意思。 [e | q][v := f] [e | q][v := f]是无效 Haskell代码（除了一些创造性地使用语言扩展的）。

可能意味着更像

[e' | q'] ++ [e | v <- fs, q]

其中e'是e ，其中v所有实例v f替换，而q'是q ， v所有实例v f替换

因此，例如，如果f为5，则e为v*2而q为odd v

[v*2 | v <- 5:fs, odd v]

这将减少到

[5*2|odd 5] ++ [v*2 | v <- fs, odd v]

由于odd 5减少为True我们最终得到

[5*2] ++ [v*2 | f<- fs, odd v]

Answer 2

您提到的符号不是Haskell代码，而是用于替换的元符号，该符号在编程语言理论中经常使用。

如果e和t是Haskell表达式，并且x是Haskell变量，我们将e [x := t]表示为表达式e ，其中x所有自由出现都已被t替换（并避免捕获）。 例如

x [x := t]                       ===> t
x+3 [x := t]                     ===> t+3
f x + (\x -> x + 32) x [x := t]  ===> f t + (\x -> x + 32) t
[ f x y | y <- [1..x] ] [x := t] ===> [ f t y | y <- [1..t] ]

同样，这不是Haskell运算符，而是“数学”元级别的运算符，该运算符将Haskell代码（语法）作为输入，并生成Haskell代码（语法）作为输出。

通常利用它来定义lambda的beta减少：

(\x -> e) t ---beta---> e [x := t]

无论如何，在发布的表达式中

[ e | q ] [ v := f ] ++ [ e | v <- fs, q ]

第[...]最后是Haskell的列表内涵，而[v := f]是元的符号，用于替换。 例如，这是一个经过全面评估的示例

[ f x y | x <- 1:2:[] , y <- [0..x] ]
===> definition of list comprehension
[ f x y | y <- [0..x] ] [x := 1] ++ [ f x y | x <- 2:[] , y <- [0..x] ]
===> substitution
[ f 1 y | y <- [0..1] ] ++ [ f x y | x <- 2:[] , y <- [0..x] ]
===> definition of list comprehension
[ f 1 y | y <- [0..1] ] 
      ++ [ f x y | y <- [0..x] ] [x := 2] 
      ++ [ f x y | x <- [] , y <- [0..x] ]
===> substitution
[ f 1 y | y <- [0..1] ] ++ [ f 2 y | y <- [0..2] ] ++ [ f x y | x <- [] , y <- [0..x] ]
===> definition of list comprehension
[ f 1 y | y <- [0..1] ] ++ [ f 2 y | y <- [0..2] ] ++ []
===> many other steps here
[ f 1 0, f 1 1 ] ++ [ f 2 0, f 2 1, f 2 2 ] ++ []
===> concatenation
[ f 1 0, f 1 1, f 2 0, f 2 1, f 2 2 ]