Question

如何将一个参数传递给多个函数？例如，如果我希望将元组（2,5）传递给fst和snd，然后将每个结果作为两个参数传递给另一个函数-可以用以下示例说明假设的，无效的代码： (2,5) |> (fst & snd) |> addUp(nr1, nr2)

Answer 1

The pipeline operator is useful for implementing what the name suggests - a pipeline where you need to pass some input through a series of transformations.

If you want a more complex flow of data, then you'll get much better results just by using the normal mechanism for passing data through a program that F# provides, i.e. variables:

let tuple = (2,5) 
let nr1 = fst tuple
let nr2 = snd tuple 
addUp nr1 nr2

If you happen to be working with tuples, you can also use pattern matching:

let tuple = (2,5) 
let nr1, nr2 = tuple
addUp nr1 nr2

You can invent combinators and operators like |> to do this without variables, but that defeats the purpose of the pipeline operator which is to make code more readable.

Answer 2

因此，让我们从一个更好的例子开始……并猜测您要追求的目标

已定义的let的添加方式如下……明确表明它在2个元组上运行……不进行咖喱处理。

let addUp : (int * int) -> int =
    fun (x,y) -> x + y

你想去（说）

let z = (2,4)|> (fun (x,y) -> 2*x,y) |> addUp

这很丑。

但是请注意，我们正在创建一个转换2个元组的管道，然后对其应用一些功能。

现在元组是一个“函子” ...这意味着当我们获得一个在元组内部对类型进行操作的函数时，我们可以将其转换（提升）为对整个元组进行操作的函数。

>

2元组是函子的两倍；

module TupleFst = 
    let map : ('a -> 'b) -> ('a * 'c) -> ('b * 'c) = 
        fun f (x,y) -> (f x, y)
module TupleSnd = 
    let map : ('a -> 'b) -> ('c * 'a) -> ('c * 'b) = 
        fun f (x,y) -> (x,f y)

我已经用签名定义了它们，以使显而易见的事情发生。

在TupleFst中，我们采用对元组的第一个元素进行操作的函数，然后将其“提升”为对整个元组进行操作的函数（映射第一个元素）。

在TupleSnd中，我们是元组的第二个成员。

所以我们现在可以将示例编写为...。

let z = (2,4)|> TupleFst.map ((*) 2) |> addUp

更好吗？...值得商......在这个琐碎的示例中，它可能会使生活变得更糟，但是原理仍然存在。...如果您在FSharpPlus的函子和应用程序中查找更多信息... 。它可以应用于各种数据结构。

我认为该程序包使用了从Haskell窃取的相同语法糖，我认为您可以将上面的代码写为：

let z = ((*) 2) <!> (2,4) |> addUp

但是我还没有安装它并使所有功能正常工作...所以上面可能有错字（啊...我不确定如何告诉FSharpPlus哪个函子选择“地图”从...所以上面是模棱两可的，可能无法编译...您当然可以定义自己的运算符，而不是“ map”）

let (<!>) = TupleFst.map
let (<!!>) = TupleSnd.map
let z1 = ((*) 2) <!> (2,4) |> addUp
let z2 = ((*) 2) <!!> (2,4) |> addUp

这确实编译了“！”在元组的第一个元素“ !!”上操作在第二个....（我不确定“ !!”是一个明智的名称...“！”是惯用的..但无论如何）

（在这种情况下，这完全是矫kill过正！！其他答案都更好。。。我想我想证明一下，如果您在一个举足轻重的世界（这里是元组）中工作，通常可以隐藏翻滚）。

Answer 3

import os

path = "/www/css/"
filenames = os.listdir(path)

for filename in filenames:
   old_file = os.path.join(path, filename)
   new_file = os.path.join(path, filename.replace(".", " "))
   os.rename(old_file, new_file)

第二行会将输入元组传递给(2, 5) |> fun t -> first t, second t ||> addUp和first函数，并将它们的合并结果作为新元组返回。

这是假设second接受两个常规参数（不是元组）。如果要使用元组，请在最后一行使用常规管道运算符addUp。

完整示例：

|>

将一个参数传递给多个函数？

3 个答案: