Reason/OCaml中管道操作符|>与普通参数传递的使用时机规范

Hey there! Great question about this handy little operator—it’s easy to get excited about it once you see how it can clean up code, but let’s break down exactly what it does, the best practices for using it, and when to dial back the enthusiasm.

First: What Is |>? #

The |> operator (often called the "pipe operator") is just syntactic sugar for function calls. It takes the value on its left and passes it as the last argument to the function on its right.

For example:

(* Regular function call *)
List.length ["apple"; "banana"; "cherry"];;

(* Equivalent with |> *)
["apple"; "banana"; "cherry"] |> List.length;;

A slightly more complex example shows its real utility:

(* Nested calls (hard to read—you have to parse from the inside out) *)
String.capitalize_ascii (String.trim (String.lowercase_ascii "  HELLO world  "));;

(* Pipe version (reads left-to-right like a data flow) *)
"  HELLO world  "
|> String.lowercase_ascii
|> String.trim
|> String.capitalize_ascii;;

Core Usage Guidelines #

The pipe operator shines when it serves one key purpose: making code more readable by emphasizing the flow of data. Here’s how to use it effectively:

• Use it for sequential data processing chains
  This is its sweet spot. When you’re transforming a value through a series of functions (each taking the previous result as input), pipes turn nested, hard-to-scan code into a linear, intuitive sequence. The example above is perfect for this—you can follow exactly how the string is modified step by step.

• Don’t force it on simple, single function calls
  There’s no benefit to writing 5 |> succ instead of succ 5—the latter is shorter and just as clear. Using pipes here just adds unnecessary syntax and makes your code look overly deliberate.

• Respect function parameter order
  Remember: |> passes the left value as the last argument to the right function. If your function’s "primary data parameter" isn’t the last one, using pipes will feel clunky (or even produce wrong results). For example, if you have add : int -> int -> int (where add x y returns x + y), then 3 |> add 5 gives you 8 (since it’s add 5 3), not 7. If you need to pipe into a function with the wrong parameter order, use Fun.flip to reverse the arguments first—or just skip the pipe.

• Keep pipe chains concise
  A pipe chain with 3-5 steps is great, but once you hit 6+ steps, consider breaking it up with let bindings. Long chains become hard to scan, and splitting them into logical chunks makes debugging and maintenance easier:

  (* Too long *)
  raw_user_input
  |> validate_format
  |> sanitize_text
  |> parse_json
  |> extract_user_data
  |> encrypt_sensitive_fields
  |> save_to_database;;
  
  (* Better *)
  let validated_and_sanitized =
    raw_user_input
    |> validate_format
    |> sanitize_text
    |> parse_json
  in
  validated_and_sanitized
  |> extract_user_data
  |> encrypt_sensitive_fields
  |> save_to_database;;
  

A Word About Overusing It #

It’s totally normal to want to use a shiny new tool everywhere—but remember: the pipe operator’s job is to improve readability, not to show off. If using it makes your code harder to follow (like forcing it into places where a regular function call is clearer), dial it back. The goal is code that’s easy for you (and other developers) to understand at a glance.

内容的提问来源于stack exchange，提问作者Slava Knyazev