Introduction

There's a neat operator in ReasonML that's called a "fast pipe" it looks like this: -> or like this |.. And it allows for a nice visual flow when calling functions that take a type as their first argument (it we were using an object-oriented language, these functions might be defined as methods on an object).

Why two syntaxes?

The new release of ReasonML 3.3.x deprecated the use of |. as the fast pipe operator, preferring instead the skinny arrow syntax: ->. We'll probably see both of them in documentation and examples for a while.

What does it actually do?

The fast pipe takes everything on the left side of the operator, and applies the result of that expression as the first argument of the function on the right side of the operator.

This sort of simulates what it feels like to call a method on an object in an object-oriented language.

For example, if we had a class Person in Python, with a method greet, that took a message as a string, we could call it like this:

personA.greet("hello").

In Reason, the practice is to create a person type, but keep any functions that work on the person type as stand-alone functions that take the person type as the first argument. Something like this:

type person;
let greet = (person, string) => string;

See above that greet takes a person, and a string, and returns another string that, presumably, greets that person.

To call this in Reason without fast piping, we'd do this:

let greeting = greet(personA, "hello");

But if we want to feel more like greet is a method instead of a standalone function, we can use the fast-pipe operator:

let greeting = personA->greet("hello");
/* or */
let greeting = personA|.greet("hello");

See how the thing on the left (personA) gets applied as the first argument of the function on the right?

This might seem marginally useful. But we really start to see the beauty once we start chaining function calls:

maybeSomething->Belt.Option.map(a => a)->Belt.Option.getExn

We end up with a calling structure that looks a bit like the 'ol JQuery method chaining pattern! This ends up being extra super convenient when working a lot with code that wraps Javascript libraries, since so many JS libraries use object methods heavily.

In Summary

"Fast piping" is a way to conveniently call functions that take an object (or type) as their first parameter. The preferred syntax is ->, but is also exists as |.. Fast piping is very useful for the APIs found in the 'Belt' standard module, and can be super duper useful when wrapping object-oriented Javascript APIs.