函数式语言如何模拟副作用？

发布于 2024-09-25 21:37:15 字数 40 浏览 3 评论 0原文

既然副作用破坏了引用透明性，那么它们是否违背了函数式语言的观点呢？

原文

分享到QQ

分享到微博

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

发布评论

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

寄意 2024-10-02 21:37:15

纯函数式编程语言使用两种技术来模拟副作用：

1) 表示外部状态的世界类型，其中类型系统保证该类型的每个值仅使用一次。

在使用这种方法的语言中，函数 print 和 read 可能具有类型 (string, world) ->世界和世界-> (string, world) 分别。

它们可以这样使用：

let main w =
  let w1 = print ("What's your name?", w) in
  let (name, w2) = read w1 in
  let w3 = print ("Your name is " ^ name, w2) in
  w3

但不是这样：（

let main w =
  let w1 = print ("What's your name?", w) in
  let (name, w2) = read w in
  let w3 = print ("Your name is " ^ name, w2) in
  w3

因为 w 使用了两次）

所有具有副作用的内置函数都将获取并返回一个世界值。由于所有具有副作用的函数要么是内置函数，要么调用其他具有副作用的函数，这意味着所有具有副作用的函数都需要获取并返回一个世界。

这样，就不可能使用相同的参数两次调用具有副作用的函数，并且不会违反引用透明度。

2) IO monad，其中所有具有副作用的操作都必须在该 monad 内执行。

通过这种方法，所有具有副作用的操作都将具有类型io some。例如 print 将是一个类型为 string ->; 的函数。 io unit 和 read 的类型为 io string。

访问执行操作的值的唯一方法是使用“一元绑定”操作（例如，在 haskell 中称为 >>=），将 IO 操作作为一个参数，并使用一个描述如何处理结果的函数，如下所示另一个操作数。

上面的例子对于 Monadic IO 来说是这样的：

let main =
  (print "What's your name?") >>=
  (lambda () -> read >>=
  (lambda name -> print ("Your name is " ^ name)))

There are two techniques that are used by purely functional programming languages to model side effects:

1) A world type that represents external state, where each value of that type is guaranteed by the type system to be used only once.

In a language that uses this approach the function print and read might have the types (string, world) -> world and world -> (string, world) respectively.

They might be used like this:

let main w =
  let w1 = print ("What's your name?", w) in
  let (name, w2) = read w1 in
  let w3 = print ("Your name is " ^ name, w2) in
  w3

But not like this:

let main w =
  let w1 = print ("What's your name?", w) in
  let (name, w2) = read w in
  let w3 = print ("Your name is " ^ name, w2) in
  w3

(because w is used twice)

All built-in functions with side-effects would take and return a world value. Since all functions with side-effects are either built-ins or call other functions with side-effects, this means that all functions with side-effects need to take and return a world.

This way it is not possible to call a function with side-effects twice with the same arguments and referential transparency is not violated.

2) An IO monad where all operations with side effects have to be executed inside that monad.

With this approach all operations with side effects would have type io something. For example print would be a function with type string -> io unit and read would have type io string.

The only way to access the value of performing operation would be to use the "monadic bind" operation (called >>= in haskell for example) with the IO operation as one argument and a function describing what to do with the result as the other operand.

The example from above would look like this with monadic IO:

let main =
  (print "What's your name?") >>=
  (lambda () -> read >>=
  (lambda name -> print ("Your name is " ^ name)))

回复收藏 0 原文

绅刃 2024-10-02 21:37:15

有多种选项可用于以函数式语言处理 I/O。

别太纯洁了许多函数式语言并不是纯粹的函数式语言。更重要的是他们支持
函数式编程而不是强制执行。这是迄今为止最常见的问题解决方案
函数式编程中的 I/O。（示例：Lisp、Scheme、Standard ML、Erlang 等）
流转换。早期的 Haskell I/O 就是这样完成的。如果您有的话，请查看我下面的链接了解详细信息
想要更多信息。（提示：您可能不知道。）
连续传递 I/O（其他答案中提到的“世界传递”）。在这个中你传递一个令牌
I/O 周围的数据充当保持引用完整性所需的“不同值”
活。如果没记错的话，多种 ML 方言都会使用它。
上面的“延续”或“世界”事物可以包装在各种数据类型中，其中最著名的是
在 Haskell 中使用 monad 来扮演这个角色。请注意，理论上，这与
封面，但是删除了跟踪“世界”/“延续”状态变量的乏味。

有一篇研究论文详尽地分析了这些。

函数式 I/O 是一个持续的研究领域，还有其他语言以有趣且令人费解的方式解决这个问题。霍尔逻辑在某些研究语言中使用。其他（例如 Mercury）使用唯一性输入。还有一些（例如 Clean）使用效果系统。其中我对水星的接触非常非常有限，所以我无法对细节发表评论。有一个不过，如果您对这个方向感兴趣，请参阅论文，深入详细介绍 Clean 的 I/O 系统。