从命令式功能到纯功能性，然后再返回：Monads与范围内的延续-CSDN博客

这则影片随附此文章，没有它不会有太大意义

上个月，我在Curry On会议上做了演讲，该会议是与学术，编程语言会议ECOOP共同举办的新会议。 Curry On旨在弥合学术界之间的鸿沟。我的学术兴趣不包括编程语言，我认为编程语言是计算机科学的一门学科，与其他任何学科相比，它始终被高估和交付不足（可能是AI除外）。我对算法比对抽象更感兴趣，并且编程语言研究主要与后者有关。但是，作为开发人员，我必须使用我选择使用的编程语言提供的抽象，并且令我感到震惊的是，我注意到某些抽象从学术语言到主流的流行，在某些情况下使身体不好，主要引起疼痛。举个例子，我想想一想，与使用Haskell相比，现在Java中使用monad的人越来越多。

在我的演讲中，我提出了命令式编程的核心抽象是阻塞线程。一旦将其删除，您将失去大多数其他命令式抽象，例如控制流和异常处理（要求它们在库中重新实现），命令式语言带来的大多数优势包括事后调试，性能分析和自动背压。这也使代码难于编写和阅读。我认为，无论您是否使用monad减轻其痛苦，异步编程都是对命令式语言的厌恶。异步和命令之间的不匹配是根本的。一直以来，我们可以达到与monads一样强大的抽象（如果不是更多的话），这自然是命令式语言的合适之选，与它们的结构和功能完美地结合在一起。

如果您还没有的话，现在是观看演讲的好时机：

在我的演讲中，我声称就像monads是纯函数式编程的超级抽象一样，延续是命令式编程的超级抽象，并且引入了一种抽象，我称为“作用域延续”，这仅是带分隔符的延续。一种特殊的酱料（我不知道这个概念是否在其他地方讨论过；如果有，我很想知道它的专有名称（请参阅文章末尾的附加内容））。

由于我在演讲之前不久就想到了这个主意，因此在介绍范围内的延续时我并没有做好准备，并且由于此后我最近对该主题进行了更多考虑，所以我想继续讨论这个主意。我提出了三点主张：

范围内的延续自然符合命令性代码
范围连续像单子一样强大
有范围的延续比单子更好

我认为我为第1点说明了理由，因为范围内的延续使您可以保持命令式控制流，并且它们保留了堆栈上下文，这对于事后调试和性能分析至关重要。当谈到＃2时，我更加模糊，直觉地注意到了monad与续奏之间的联系，并提供了一些示例，但没有提供证明，因此听众理所当然地要求我这么做。

第一轮：连锁–定界延续vs.单子

演讲结束后，我与朱利安·阿尼（ Julian Arni ）进行了交谈，后者向我展示了丹·皮波尼（ Dan Piponi）撰写的博客文章《所有人的母亲》 。有关Reddit的讨论）使我想到了由Andrzej Filinski ¹于1994年提出的证明，定界的连续性（在Filinski的论文中称为部分或可组合的连续性）可以表示任何一元组合。他说：

我们表明，任何其单元和扩展操作可表示为纯功能术语的monad都可以通过“可组合的延续”嵌入按值调用语言中…

…值得注意的是，monad对“不纯”函数式编程没有可比的影响。可能的主要原因可能是……单子框架已经内置在渴望有效的功能性语言的语义核心中，因此无需明确表达。语言（例如，可更新状态，异常或一流的延续）和语言外部（I / O，OS接口等）的“不纯净”构造都遵循一元法。似乎唯一缺少的方面是程序员能够以与内置效果相同的便捷性和自然性使用自己的，特定于应用程序的单子抽象（例如，不确定性或解析器）。

……在下文中，我们将证明……具有第一类延续性的一种语言……已经“单调完成”，因为任何以某种扭曲的单调风格表达的程序也可以直接编写。

我没有遵循Filinski论文的必要背景，但是，如果我没有记错的话，证明的困难源于以下事实：从单子形式到连续形式（他称之为“直接样式”）的转换是不是单调函数或单调作曲者的简单数学映射（Haskell称之为bind ），而是需要对其源代码表示进行更深层次的转换。但是，我将以一种有希望的方式介绍定界连续的具体实现方式，以期解释moand-continuation相似性背后的直觉。

定界的延续捕获了调用堆栈的一部分。它使我们暂停计算然后再恢复它。让我们看一下Java中定界的延续API：

public class Continuation<T> implements Runnable, Serializable, Cloneable {
   public Continuation(Callable<T> target) { ... }
   public T run() { ... }
   public boolean isDone() { ... }
   public T getResult() { ... }

   public static Continuation<?> suspend(Consumer<Continuation<?>> ccc) { ... }
}

suspend方法（类似于Scheme的shift ）暂停当前的延续（假设我们正在内部运行），并调用（可选）提供的回调ccc （名称ccc是Called with Current Continuation的首字母缩写，这是一种玩法）在Scheme的call-cc ）。 run功能（对应于Scheme的reset ）将执行继续，直到其暂停或终止。因此，例如：

class Foo {
    static int foo() {
       bar();
       bar();
       return 3;
    }

    static void bar() {
        System.out.println("Pausing...");
        Continuation.suspend(null);
    }

    public static void main(String[] args) {
        Continuation<Integer> c = new Continuation(Foo::foo);
        c.run(); // prints "Pausing..."
        c.run(); // prints "Pausing..."
        c.run();
        System.out.println(c.getResult()); // prints "3"
    }
}

因为suspend返回了延续并将其传递给回调，所以我们可以扩展Continuation类并添加一些内部字段以产生ValuedContinuation ：

public class ValuedContinuation<T, Out, In> extends Continuation<T> {
    private Out pauseOut;
    private In pauseIn;
    private RuntimeException pauseInException;

    public run(In in);
    public run(RuntimeException e);
    public Out getPauseValue() { ... }

    public static <Out, In> In pause(Out value) {...}
    public static      <In> In pause(Consumer<ValuedContinuation<?, ?, In>> ccc) {...}
    public static   <V, In> In pause(V x, BiConsumer<V, ValuedContinuation<?, ?, In>> ccc) {...}
}

ValuedContinutation ，我们可以将值传入和传出延续。如果我们调用pause(3) ，则getPauseValue将返回值3 ，而如果使用run(5)恢复继续，则将由pause返回值5 。 run(new RuntimeException())将导致pause以引发该异常。例如：

ValuedContinuation<Void, Integer, Integer> c = new ValuedContinuation<>(() -> {
            int x = pause(5);
            x = pause(x + 10);
            x = pause(x * 100);
            return null;
        });

while(!c.isDone()) {
   c.run(3);
   System.out.println(c.getPauseValue()); // prints: 5, 13, 300
}

现在我们可以理解连续性可以表达任何monad的主张的直觉： 我们的monadic作曲者 （或bind ） 将是传递给pause的回调ccc ； 每次pause的代码是c.run(x)序列中的下一个monadic函数，并且调用c.run(x)正在应用链中的下一个c.run(x)函数。

区别在于，单子函数将蹦床功能返回到封闭的作曲家（绑定），而在这里我们在延续中称作作曲家（我们的ccc ）。正如我在演讲中所声称的，命令式语言中的继续性的优点是它们与所有命令式概念（例如命令式控制流和异常）良好地交互，并保留了对于调试和性能分析非常重要的堆栈上下文。

在继续之前，让我们看一个使用ccc回调的示例。这是“未来单子”延续形式的一个例子。假设我们有一个异步服务：

interface AsyncHandler<T> {
    void success(T result);
    void failure(RuntimeException error);
}

interface AsyncService<T> {
    void submit(AsyncHandler<T> callback);  
}

然后，我们可以定义此方法：

static <T> Consumer<ValuedContinuation<?, ?, T>> await(AsyncService<T> service) {
    return c -> {
        service.submit(new AsyncHandler<T>() {
              public void success(T result) {
                   c.run(result);
              }

              public void failure(RuntimeException error) {
                   c.run(error);
              }
          });
    };
}

我们将在延续中运行的代码中使用该代码，如下所示：

String y = pause(await(service));

上面的代码将暂停继续，直到服务请求完成，然后将其恢复为结果。

第二轮：作曲–范围延续与Monad变形金刚

在演讲中，我还声称单子很难构成² ，即使使用纯功能语言也是如此，这非常适合单子。编写monad（即编写使用异常和 IO 并产生序列的monadic代码）需要使用monad变换器，因为它们利用非常高阶的函数来形成一个让人脑筋急转的lambish间接函数，因此很难理解。

为了创建易于组合的延续，在我的演讲中，我介绍了作用域延续 ，这是带分隔符的延续的变体。范围内的延续是嵌套的延续，在任何级别，代码都可以自由地暂停其任何包含的延续。这个想法与嵌套的try / catch块非常相似，在嵌套的try / catch块中，根据异常类型，执行会跳转到相应嵌套范围的catch块。

为了测试该想法在实践中的效果如何，我已经在Java和Clojure中实现了一个有范围的延续原型。您可以分别在 Quasar和Pulsar的cont分支（此处和此处）中使用作用域延续来查找代码。

为了实现延续，我使用了Quasar的工具，该工具非常简单（尽管有范围的延续可能有一天会进入上游Quasar，但这种情况不会很快发生，因为我们首先需要使工具完全透明且可以不使用，我们希望Java 9发布时该怎么做）。最困难的部分是支持在一个连续引用不仅存在于堆栈中，而且还可能存在于堆中的环境中，克隆嵌套的延续（下面介绍的非确定性延续所需要）。我尝试了三种不同的方法，但我对其中任何一种都不满意。

对于范围连续，我们需要稍微更改Continuation （和类似ValuedContinuation ）类：

public class Continuation<S extends Suspend, T> implements Runnable, Serializable, Cloneable {
   public Continuation(Class<S> scope, Callable<T> target) { ... } // <-- scope
   public T run() { ... }
   public boolean isDone() { ... }
   public T getResult() { ... }

   public static Continuation<?> suspend(S scope, Consumer<Continuation<?>> ccc) { ... } // <-- scope
}

范围是全局名称。在Java中，我选择表示一个范围，就像表示异常范围一样：作为类名（在当前实现中，范围是扩展Suspend类，该类是异常类型）。

范围的延续定义和使用方式如下：

class ACont<T> extends ValuedContinuation<AScope, T> {
    public Continuation(Callable<T> target) {
        super(AScope.class);
        // ...
    }

    public static AScope A = new AScope();
}

// similarly BCont, and then:

static void foo() {
    Continuation<Void> c = new ACont(() -> {
        // ...
        Continuation<Void> c = new BCont(() -> {
            // ...
            suspend(B, ...); // suspends the enclosing BCont
            // ...
            suspend(A, ...); // suspends the enclosing ACont
            // ...
        });
        // ...
    });
    // ...
}

在Clojure中，范围是全局符号，并且可以将范围的延续定义为：

(let 
                   ; ....
                   (let 
                                      ; ....
                                      (pause B ...)
                                      ; ...
                                      (pause A ...)
                                      ; ...
                                      ))])))]
    ; ...
)

范围延续的概念是，暂停任何封闭的延续范围相当于返回到任何封闭的作曲家（绑定）的单子函数。但是在范围连续的情况下，我们不需要monad变换器来转换作曲者或链接的monadic函数。

为了了解这种组合在实际代码中的外观，我实现了两种延续类型： CoIterable （与Python生成器一样，生成具有延续的Iterable并对应于Haskell的list monad）和Ambiguity （实现了不确定性计算）回溯a-la Scheme的amb并对应于Haskell的amb monad。

孤立地， CoIterable的用法如下：

Iterable<Integer> range(int from, int to) {
    return new CoIterable<>(() -> {
        for (int i = from; i < to; i++)
            produce(i);
    });
}

有关CoIterable运算符的示例，例如flatmap ， map和filter请参见此处，并注意，额外的灵活性延续给了我们单子。由于单子函数将蹦床返回给作曲者，因此必须根据单个平面映射作曲者来实现filter和map操作，而对于延续，我们可以从延续中自由选择自己的构图规则，并且可以实现filter并独立于flatMap进行map ，以获得更好的性能。

这是隔离中使用Ambiguity的示例：

Ambiguity<Integer> amb = solve(() -> {
        int a = amb(1, 2, 3); // a is either 1, 2, or 3
        int b = amb(2, 3, 4); // b is either 2, 3, or 4

        assertThat(b < a);    // ... but we know that b < a
        return b;
    });

amb.run(); // returns 2 as that's the only possible solution for b

现在，让我们看看两者是如何无缝组合的：

Ambiguity<Integer> amb = solve(() -> {
    Iterable<Integer> a = iterable(() -> {
        produce(amb(2, 1)); // pauses on Ambiguity and CoIterable
        produce(amb(3, 10));
    });

    int sum = 0;
    for (int x : a) { // using imperative loops on purpose; functional would work, too
        sum += x;
        assertThat(x % 2 == 0); // we assert that all elements are even
    }

    return sum;
});

amb.run(); // returns 12

注意如何a延续中止既对Ambiguity以及对CoIterable范围。它创建一个列表，第一个元素为2或1 ，第二个元素为3或10 ，产生四个可能的列表： (2, 3) ， (2, 10) ， (1, 3)和(1, 10) 。后来，我们断言所有元件必须是偶数，这意味着对于唯一有效的列表a是(2, 10)以及用于唯一可能的值sum是12。

作为最后一个示例（可以在此处和此处的测试中找到更多示例；可以在此处找到Clojure示例），让我们通过另一层嵌套将事情进一步复杂化：

Fiber<Integer> f = new Fiber<>(() -> {
    Ambiguity<Integer> amb = solve(() -> {
        Iterable<Integer> a = iterable(() -> {
            produce(amb(2, 1));
            sleep(20); // pauses on the Fiber scope
            produce(amb(3, 10));
        });

        int sum = 0;
        for (int x : a) {
            sum += x;
            Fiber.sleep(20);
            assertThat(x % 2 == 0);
        }
        return sum;
    });

    return amb.run();
}).start();

f.get(); // returns 12

现在，我们将整个内容嵌套在光纤中-Quasar的轻量级线程实现-仅仅是Java的ForkJoin调度程序调度的延续而已。现在，内嵌套代码a在三个不同范围内暂停没有打破汗水，没有任何形式的变压器。

但是类型安全呢？

Haskell具有非常丰富的类型系统，而Monad可以极大地发挥作用。通过查看（monadic）函数的签名，您可以立即知道它可以“驻留”在哪种monad类型中，并且不能在该monad之外的任何地方使用它。事实证明，可以在不失去其任何期望属性的情况下，对作用域连续进行同样类型的安全键入。为此，我们需要一个（简单的）类型系统来声明：

void foo() suspends A, B

这意味着foo可能会在A和B范围内暂停继续执行，因此只能在两个范围内的代码中调用。然后，将Continuation类定义为（在伪Java中）：

public class Continuation<S extends Suspend, T> implements Runnable, Serializable, Cloneable {
   public Continuation(Class<S> scope, [Callable<T> suspends S|Others] target) { ... }
   public T run() suspends Others { ... }

   public static Continuation<?> suspend(S scope, Consumer<Continuation<?>> ccc) suspends S
}

因此，延续可以运行任何可能在参数化的S范围以及其他范围上可能挂起的目标代码，而run方法可以吞咽S范围，但仍在挂起其他范围。

事实证明，我们已经有了这样的类型系统- 几乎是 Java的检查异常。如果我们创建了Suspend范围（所有范围都从该范围下降），则我们可以使用Java的throws ，就像上面的伪Java中的suspend一样。我之所以没有这样做，是因为Java的类型系统不允许您捕获多个经过检查的异常类型，就像我在上述“ Others所做的那样，这意味着我们需要显式的实例来处理显式的范围变量（挂起一个范围的函数，两个范围等），这可能会使事情变得麻烦。

然后，我们还可以通过参数化范围来提高ValuedContinuation的类型安全性，这样我们就可以：

void foo() suspends CoIterableScope<Integer>

这只会让foo在产生一个Integer序列（而不是String ）的CoIterable中被调用。不幸的是，我们也不能完全做到这一点，因为Java当前不允许泛型异常类型。

未完待续？

我希望通过更深入地讨论范围内的连续性，我能够比我在演讲中挥舞过的手挥舞的方法更好地解释这个想法，并且我很高兴找到菲林斯基的证明（这在PL圈子中可能是众所周知的））。

我希望我的演讲使您相信单语在命令式语言中没有地位（也许除了并行计算之外），如果没有，我很想听听为什么不这样做。我还相信，即使在PFP语言中，范围连续的合成也比monad更好（而且，monad通常不是一种很好的效果建模方法，但这是另外一个讨论）。

最后，尽管我坚信命令性语言应该具有某种形式的轻量级线程（AKA光纤，AKA用户模式线程，AKA绿线程排序）和线程（任何类型）不过是由适当的调度程序调度的延续，我不一定认为命令性语言应该直接将范围化的延续作为抽象公开。毕竟，存在抽象以增加代码重用性，帮助代码维护和帮助验证：总之，它们存在是为了降低开发成本，并且（至少从非研究的角度来看）它们是唯一的度量标准判断³ 。我认为延续性是PFP优雅的monad的优雅命令，但是我还不相信它们在实践中的实用性。

如果您想了解更多有关延续的知识，这就是延续发展的历史，它可以称赞所有合适的人。

附录1

自从首次发布此博客文章以来，我设法在Philip Wadler于1993年发表的一篇论文中找到了关于范围延续的参考，该论文名为Monads and composablecontinuations ，他将范围延续简单地称为“具有多个层次的可组合延续”。沃德勒证明定界的延续可由单子表示，而菲林斯基证明（一年后），二元论可表示为定界的延续，这有理由推论两者是对偶的。尽管如此，有理由认为，即使是对偶，每种也都更适合于特定的编程风格，并且毫无疑问，延续更适合于不纯洁的按值调用的语言（命令式和函数式命令式）。瓦德勒在总结论文时说：

具有多个层次的可组合延续的一个目标是能够将不同的影响分解为不同的层次。 Danvy和Filinski声称以这种方式将各种效果均匀地组合起来相对容易。 Monads还旨在通过简化组合的方式来分解效果。但是，没有统一的规则来组合任何两个单子。本文使用了monad来阐明可组合的延续。可组合的延续词会阐明单子组合的问题吗？