Python中的管道？ - 想想 async.js / Haskell 的 `do` / F# 的 `|>`

Question

Continuation-passing style 如何通过 Python 实现？

（我认为这是正确的术语）

---

我的代码开始变得乱七八糟，我有map、filter 和lambdas 链，如下所示：

(lambda a,b: (lambda c:(lambda d: d*d)(c-b))(a*b))(5,6)

---

“管道表达式”可以在多种语言中找到，例如：

F# 解决方案（例如：|>）

let complexFunction =
    2                            (* 2 *)
    |> ( fun x -> x + 5)         (* 2 + 5 = 7 *)
    |> ( fun x -> x * x)         (* 7 * 7 = 49 *)
    |> ( fun x -> x.ToString() ) (* 49.ToString = "49" *)

Haskell 解决方案（例如：do、pipes）

 main = do
     hSetBuffering stdout NoBuffering
     str <- runEffect $
         ("End of input!" <$ P.stdinLn) >-> ("Broken pipe!" <$ P.stdoutLn)
     hPutStrLn stderr str

JavaScript（例如：async.js）：

async.waterfall([
    function(callback) {
        callback(null, 'one', 'two');
    },
    function(arg1, arg2, callback) {
      // arg1 now equals 'one' and arg2 now equals 'two'
        callback(null, 'three');
    },
    function(arg1, callback) {
        // arg1 now equals 'three'
        callback(null, 'done');
    }
], function (err, result) {
    // result now equals 'done'    
});

不过，我知道最后一种策略更适用于异步函数响应解析（请参阅：callback hell）。

如何在单个 Python 表达式/行中呈现我的所有处理阶段？

Answer 1

AFAIK，Python 中没有标准功能可以做到这一点。

有一个名为Pipe 的模块覆盖了运算符|，但它被合理地认为是有害的（在改变其语义的同时覆盖运算符）。

但是，您可以为此实现简单的Fluent interface。这是一个例子：

class P:
    def __init__(self, initial):
        self.result = initial

    def __call__(self, func, *args, **kwargs):
        self.result = func(self.result, *args, **kwargs)
        return self

    def map(self, func):
        self.result = map(func, self.result)
        return self

    def filter(self, func):
        self.result = filter(func, self.result)
        return self

    def get(self):
        return self.result

x = P(2)(lambda x: x + 5)(lambda x: x * x)(lambda x: str(x)).get()
z = P(range(10)).map(lambda x: x * 3).filter(lambda x: x % 2 == 0).get()
print(x, list(z))       # prints 49 [0, 6, 12, 18, 24]