我正在将一些 F# 代码转换为 OCaml，我看到有很多使用这个管道操作符<|的情况，例如：
let printPeg expr =
printfn "%s" <| pegToString expr
<| 运算符似乎仅仅定义为:
# let ( <| ) a b = a b ;;
val ( <| ) : ('a -> 'b) -> 'a -> 'b = <fun>
我在想为什么在F＃中定义和使用这个运算符，是为了避免像这样使用括号吗？
let printPeg expr =
Printf.printf "%s" ( pegToString expr )
就我所知，那将是将上面的F#代码转换为OCaml，对吗？
另外，我该如何在OCaml中实现F#的<<和>>运算符？
(看起来|>运算符只需这样实现：let ( |> ) a b = b a ;;)
为什么他们要定义并在F#中使用这个运算符，难道只是为了避免输入括号吗？
这是因为函数式编程的方式假设通过一系列的函数将值传递。比较以下两种写法：
let f1 str server =
str
|> parseUserName
|> getUserByName server
|> validateLogin <| DateTime.Now
let f2 str server =
validateLogin(getUserByName(server, (parseUserName str)), DateTime.Now)
|>和函数组合>><<运算符传递给高级函数时，它们可以产生另一种有趣的效果，例如在这里。validateLogin DateTime.Now (getUserByName server (parseUserName str))。 - J D直接来自F#源码:
let inline (|>) x f = f x
let inline (||>) (x1,x2) f = f x1 x2
let inline (|||>) (x1,x2,x3) f = f x1 x2 x3
let inline (<|) f x = f x
let inline (<||) f (x1,x2) = f x1 x2
let inline (<|||) f (x1,x2,x3) = f x1 x2 x3
let inline (>>) f g x = g(f x)
let inline (<<) f g x = f(g x)
OCaml Batteries支持这些运算符，但由于优先级、结合性和其他语法怪癖(比如Camlp4)，它使用不同的符号。最近才确定了要使用哪些特定符号，有一些变化。请参见：Batteries API：
val (|>) : 'a -> ('a -> 'b) -> 'b
函数应用。x |> f 等同于 f x。
val ( **> ) : ('a -> 'b) -> 'a -> 'b
函数应用。f **> x 相当于 f x。 注意：该运算符的名称并不是固定的，很快就会更改。
val (|-) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c
函数复合。f |- g 是一个函数 x -> g (f x)。这也等同于应用 <** 两次。
val (-|) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
函数组合。f -| g 表示 fun x -> f (g x)。 在数学上，这被称为操作符o。
但是，Batteries trunk 提供了：
val ( @@ ) : ('a -> 'b) -> 'a -> 'b
函数应用。[f @@ x] 等同于 [f x]。
val ( % ) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
函数组合：数学中的[o]运算符。
val ( |> ) : 'a -> ('a -> 'b) -> 'b
"管道"：函数应用。[x |> f] 等同于 [f x]。
val ( %> ) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c
管道函数组合。[f %> g] 是 [fun x -> g (f x)]。
<< 和 >>。 - lukstafi<|）在我看来几乎没什么用处。它让你在极少数情况下避免使用括号，但更普遍的情况是它通过引入更多的运算符使语法更加复杂，这使得那些经验较少的F#程序员（现在有很多人）更难理解你的代码。因此，我已经停止使用它。
|> 运算符则更有用，但仅因为它在 OCaml 无法处理的情况下帮助 F# 正确地推断类型。例如，下面是一些 OCaml 代码：List.map (fun o -> o#foo) os
foo属性之前推断出 o 的类型，因此惯用的解决方法是重写代码，使用 |> 使F#能够在使用 foo 之前推断出 o 的类型：os |> List.map (fun o -> o.foo)
<<和>>），因为它们会使语法更加复杂。我也不喜欢那些引入大量操作符的解析器组合库。let f1 str server =
str
|> parseUserName
|> getUserByName server
|> validateLogin <| DateTime.Now
我会将此写成：
let f2 str server =
let userName = parseUserName str
let user = getUserByName server userName
validateLogin user DateTime.Now
我的代码中没有括号。我的临时变量有名称，因此它们会出现在调试器中，我可以检查它们，当我将鼠标悬停在它们上面时，Intellisense可以给我类型回溯。这些特性对于非专业F#程序员维护的生产代码非常有价值。