seq 力如何发挥作用？

发布于 2024-11-16 10:42:31 字数 1160 浏览 5 评论 0原文

背景

这个问题源自 Brent Yorgey 在 OPLSS 上提出的挑战：编写一个函数 f :: (Int -> Int) -> Bool 区分 f undefined 和 f (\x -> undefined)。我们所有的答案都使用了 seq 或类似 bang 模式的东西，将糖分转化为 seq。例如：

f :: (Int -> Int) -> Bool
f g = g `seq` True

*Main> f undefined
*** Exception: Prelude.undefined
*Main> f (\x -> undefined)
True

GHC 对 seq 的评论说，

e1 `seq` e2

使用脱糖，

case e1 of { _ -> e2 }

所以我尝试手动脱糖。它不起作用：

f' g = case g of { _ -> True }

*Main> f' undefined
True
*Main> f' (\x -> undefined)
True

问题

此行为是否取决于描述的更复杂的seq在评论末尾，如果是这样，它是如何运作的？如果没有这些原语，可以编写这样的 f 吗？

x  `seq` e2 ==> case seq# x RW of (# x, _ #) -> e2    -- Note shadowing!
e1 `seq` e2 ==> case seq# x RW of (# _, _ #) -> e2

原文

Background

This question arises from a challenge Brent Yorgey posed at OPLSS: write a function f :: (Int -> Int) -> Bool that distinguishes f undefined from f (\x -> undefined). All of our answers either used seq or something like bang patterns that desugar into seq. For example:

f :: (Int -> Int) -> Bool
f g = g `seq` True

*Main> f undefined
*** Exception: Prelude.undefined
*Main> f (\x -> undefined)
True

The GHC commentary on seq says that

e1 `seq` e2

used to desugar into

case e1 of { _ -> e2 }

so I tried desugaring manually. It didn't work:

f' g = case g of { _ -> True }

*Main> f' undefined
True
*Main> f' (\x -> undefined)
True

Question

Does this behavior depend on the more complex seq described at the end of the commentary, and if so, how does it work? Could such an f be written without these primitives?

x  `seq` e2 ==> case seq# x RW of (# x, _ #) -> e2    -- Note shadowing!
e1 `seq` e2 ==> case seq# x RW of (# _, _ #) -> e2

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

浮世清欢 2024-11-23 10:42:31

seq 无法在 Haskell 中实现。相反，它是一个原始的“钩子”，用于在 Haskell 运行的任何运行时对弱头范式进行求值。例如，在 GHC 上，它被编译为 GHC Core 中的一个 case，这会触发对最外层构造函数的求值。

由于它无法在纯 Haskell 中实现，因此（在 GHC 中）将其定义为 primop：

pseudoop   "seq"
       a -> b -> b
       { Evaluates its first argument to head normal form, and then returns its second
         argument as the result. }

由于函数没有范式，因此 seq 一旦达到 1，就会停止求值。

编译器神奇地可用。对于其他原语（例如 par 或 unsafeCoerce、RealWorld 令牌、forkOn 等）也是如此。所有有用的东西。

seq cannot be implemented in Haskell. Instead, it is a primitive "hook" into evaluation to weak-head normal form in whatever runtime your Haskell is running on. E.g. on GHC it is compiled to a case in GHC Core, which triggers evaluation to the outermost constructor.

Since it can't be implemented in pure Haskell, it is defined (in GHC) as a primop:

pseudoop   "seq"
       a -> b -> b
       { Evaluates its first argument to head normal form, and then returns its second
         argument as the result. }

Since functions don't have a normal form, seq halts evaluation once it reaches one.

Magically available to the compiler. The same goes for other primitives like par or unsafeCoerce, the RealWorld token, forkOn and so on. All the useful stuff.

回复收藏 0 原文