haskell中的seq和$有什么区别？

Question

我无法理解seq和$的区别， seq强制执行求值， $也做同样的事情。

Answer 1

($) :: (a -> b) -> a -> b接受一个函数和一个值。 它返回一个重击。 当该重击被强制执行时，它将产生将函数应用于该值的结果。

> let x = succ $ (2 :: Int)

> :sprint x
x = _

> x
3

> :sprint x
x = 3

($)完全等同于普通函数应用程序，但是具有较低的运算符优先级，这对于避免某些括号很有用。

print (take 10 (map (* 2) (filter even [1..])))

print $ take 10 $ map (* 2) $ filter even [1..]

seq :: a -> b -> b非常不同：它在结果和它的第一个参数之间安排了一个依存关系，因此当强制执行结果时，第一个参数首先被求值：

> let y = succ (1 :: Int)

> :sprint y
y = _

> let z = y `seq` (3 :: Int)

> :sprint z
z = _

> z
3

> :sprint z
z = 3

> :sprint y
y = 2

此处， y和z最初是未评估的重击。 但是评估z也会带来评估y的副作用，因为我们已经使用seq安排了对y的依赖关系。 您还可以使用Debug.Trace trace来观察评估的顺序：

> import Debug.Trace

> (trace "a evaluated" ()) `seq` (trace "b evaluated" ())
a evaluated
b evaluated
()

> let p = (trace "a evaluated" (1 :: Int), trace "b evaluated" (2 :: Int))

> :sprint p
p = (_,_)

> snd p
b evaluated
2

> :sprint p
p = (_,2)

> fst p
a evaluated
1

> :sprint p
p = (1,2)

seq是一个低级操作，主要出于性能原因而有用，因为它使您可以控制何时评估thunk。 例如，在foldl'的定义中使用seq以确保在进行下一步之前评估折叠的每个步骤的结果。 它的表兄弟foldl没有执行此操作，因此它经常会堆积一系列深层嵌套的thunk，这在评估时可能导致堆栈溢出。

Answer 2

默认情况下，Haskell被懒惰地求值。 因此，具有seq签名（ seq a -> b -> b ）的“正常”函数将忽略其第一个参数，然后返回其第二个参数-它无法使用该参数做任何其他事情，因为它不知道它们是什么！

但是seq有点特殊，并且做些不同。 相反，它严格评估其第一个参数， 然后返回其第二个参数。 这对于多种目的很有用，例如，强制执行副作用的顺序，或者用于防止在计算过程中积累大量的重击。 您可以在这里找到更多信息： https : //wiki.haskell.org/Seq 。

就像@palik所说的， $的类型签名是完全不同的，它的作用也不同：它将函数应用于参数。 $和普通函数应用程序之间的区别在于，它的运算符优先级很低，因此您可以避免编写很多括号。

Answer 3

seq和($)具有不同的类型签名：

λ> :t seq
seq :: a -> b -> b
λ> :t ($)
($) :: (a -> b) -> a -> b
λ> (+1) `seq` 2
2
λ> (+1) $ 2
3