用纯函数式语言保持状态

Question

我正在尝试弄清楚如何执行以下操作，假设您正在开发直流电机的控制器，您希望让它以用户设置的特定速度旋转，

(def set-point (ref {:sp 90}))

(while true
  (let [curr (read-speed)]
    (controller @set-point curr)))

现在该设定点可以通过web 应用程序，我想不出一种不使用 ref 来做到这一点的方法，所以我的问题是函数式语言如何处理这类事情？ （尽管这个例子是在 clojure 中的，但我对总体思路很感兴趣。）

Answer 1

这不会回答你的问题，但我想展示这些事情是如何在 Clojure 中完成的。它可能会对稍后阅读本文的人有所帮助，这样他们就不需要阅读 monad、反应式编程或其他“复杂”主题来使用 Clojure。

Clojure 不是一种纯函数式语言，在这种情况下，暂时将纯函数放在一边并模型 具有身份的系统的固有状态。

在 Clojure 中，您可能会使用其中一种引用类型。有多种可供选择，并且知道使用哪一种可能很困难。好消息是它们都支持统一更新模型，因此稍后更改引用类型应该非常简单。

我选择了 atom 但根据您的要求，使用它可能更合适ref 或 代理。

电机是程序中的一个标识。它是某些事物的“标签”，在不同时间具有不同的值，并且这些值彼此相关（即电机的速度）。我在原子上放置了一个 :validator 以确保速度永远不会低于零。

(def motor (atom {:speed 0} :validator (comp not neg? :speed)))

(defn add-speed [n]
  (swap! motor update-in [:speed] + n))

(defn set-speed [n]
  (swap! motor update-in [:speed] (constantly n)))

> (add-speed 10)
> (add-speed -8)
> (add-speed -4) ;; This will not change the state of motor
                 ;; since the speed would drop below zero and
                 ;; the validator does not allow that!
> (:speed @motor)
2
> (set-speed 12)
> (:speed @motor)
12

如果您想更改电机标识的语义，您至少有两种其他参考类型可供选择。

• 如果你想异步改变电机的速度，你可以使用代理。然后您需要将 swap! 更改为 send。例如，如果调整电机速度的客户端与使用电机速度的客户端不同，那么“最终”更改速度就可以了。

• 另一种选择是使用ref，如果电机需要与系统中的其他身份进行协调，这将是合适的。如果您选择此引用类型，则可以使用 alter 更改 swap!。此外，所有状态更改都在带有 dosync 的事务中运行，以确保事务中的所有身份都以原子方式更新。

在 Clojure 中不需要 Monad 来建模身份和状态！

Answer 2

对于这个答案，我将把“纯粹的函数式语言”解释为“一种排除副作用的 ML 风格语言”，我将其解释为“Haskell”，我将其解释为“GHC” 。这些都不是严格正确的，但考虑到你将其与 Lisp 衍生物进行对比，并且 GHC 相当突出，我猜这仍然是你问题的核心。

与往常一样，Haskell 中的答案是一些技巧，其中对可变数据（或任何具有副作用的数据）的访问是以这样一种方式构建的，即类型系统保证它从内部“看起来”是纯粹的，同时生成的最终程序会产生预期的副作用。与 monad 相关的常见事务占了很大一部分，但细节并不重要，而且大多会分散人们对问题的注意力。在实践中，这只是意味着你必须明确副作用可能发生的位置和顺序，并且不允许你“作弊”。

可变性原语通常由语言运行时提供，并通过在运行时也提供的某些 monad 中生成值的函数进行访问（通常是 IO，有时是更专门的）。首先，让我们看一下您提供的 Clojure 示例：它使用 ref，此处的文档：

虽然 Var 通过线程隔离确保可变存储位置的安全使用，但事务引用 (Refs) 通过软件事务内存 (STM) 系统确保可变存储位置的安全共享使用。引用在其生命周期内绑定到单个存储位置，并且只允许该位置在事务中发生变化。

有趣的是，整个段落非常直接地翻译成 GHC Haskell。我猜“Vars”相当于 Haskell 的MVar，而“Refs”几乎肯定相当于TVar 位于 stm 包 中。

因此，要将示例转换为 Haskell，我们需要一个创建 TVar 的函数：

setPoint :: STM (TVar Int)
setPoint = newTVar 90

...我们可以在如下代码中使用它：

updateLoop :: IO ()
updateLoop = do tvSetPoint <- atomically setPoint
                sequence_ . repeat $ update tvSetPoint
  where update tv = do curSpeed <- readSpeed
                       curSet   <- atomically $ readTVar tv
                       controller curSet curSpeed

在实际使用中，我的代码将比那个，但我在这里留下了更详细的内容，希望不那么神秘。

我想有人可能会反对说这段代码不是纯粹的并且使用的是可变状态，但是......那又怎样呢？在某个时刻，程序将运行，我们希望它进行输入和输出。重要的是，我们保留了纯代码的所有好处，即使在使用它来编写具有可变状态的代码时也是如此。例如，我使用 repeat 函数实现了副作用的无限循环；但 repeat 仍然是纯粹的并且行为可靠，我对它所做的任何事情都不会改变这一点。

Answer 3

一种以功能性方式解决显然需要可变性（例如 GUI 或 Web 应用程序）的问题的技术是 函数式响应式编程。

Answer 4

为此所需的模式称为 Monad。如果您真的想进入函数式编程，您应该尝试了解 monad 的用途以及它们的功能。作为起点，我建议此链接。

作为对 monad 的简短非正式解释：

Monad 可以被视为在程序中传递的数据 + 上下文。这就是解说中经常使用的“宇航服”。您可以将数据和上下文一起传递，并将任何操作插入到此 Monad 中。一旦数据被插入到上下文中，通常就无法取回数据，您只能以相反的方式插入操作，以便它们结合上下文来处理数据。通过这种方式，看起来好像您已经将数据取出来了，但如果仔细观察，您却根本没有取出来。

根据您的应用程序，上下文几乎可以是任何内容。结合多个实体、异常、选项或现实世界（i/o-monad）的数据结构。在上面链接的论文中，上下文将是算法的执行状态，因此这与您想到的事情非常相似。

Answer 5

在 Erlang 中，您可以使用进程来保存该值。像这样的东西：

holdVar(SomeVar) ->
  receive %% wait for message
    {From, get} ->             %% if you receive a get
      From ! {value, SomeVar}, %% respond with SomeVar
      holdVar(SomeVar);        %% recursively call holdVar
                               %% to start listening again

    {From, {set, SomeNewVar}} -> %% if you receive a set
      From ! {ok},               %% respond with ok
      holdVar(SomeNewVar);       %% recursively call holdVar with
                                 %% the SomeNewVar that you received 
                                 %% in the message
  end.