Forward piping in F#

In F# it’s possible to chain function calls and feed the return value of each function to the next using the forward type operator which looks like this: |> . We can literally read it as “pipe forward”.

If we have a function that increments an integer like this…:

let incrementByOne x = x + 1

Then we normally call it as follows:

let res = incrementByOne 10

With forward piping we can supply the input parameter first as follows:

let resAlt = 10 |> incrementByOne

A useful application of forward piping is that we can chain functions. We have the following simple functions:

let incrementByOne x = x + 1
let triple x = x * 3
let halve x = x / 2
let double x = x * 2

We can chain them and supply the return value of each function to the next stage as follows:

let res = 10 |> incrementByOne |> triple |> halve |> double

So 10 is fed to incrementByOne, whose return value will be 11. 11 is then supplied to triple and so on. The end result will be 32.

Note that the single pipe forward operator works on functions that have one input parameter only.

If a function requires 2 or more input parameters then we need to increase the number of pipes as follows:

let addThreeNumbers x y z = x + y + z
let addTwoNumbers x y = x + y
let two = (15, 28) ||> addTwoNumbers
let three = (10, 20, 30) |||> addThreeNumbers

View all F# related articles here.

About Andras Nemes
I'm a .NET/Java developer living and working in Stockholm, Sweden.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s


A great site

Elliot Balynn's Blog

A directory of wonderful thoughts

HarsH ReaLiTy

A Good Blog is Hard to Find

Softwarearchitektur in der Praxis

Wissenswertes zu Webentwicklung, Domain-Driven Design und Microservices

Technology Talks

on Microsoft technologies, Web, Android and others

Software Engineering

Web development

Disparate Opinions

Various tidbits

chsakell's Blog


Once Upon a Camayoc

Bite-size insight on Cyber Security for the not too technical.

Guru N Guns's

OneSolution To dOTnET.

Johnny Zraiby

Measuring programming progress by lines of code is like measuring aircraft building progress by weight.

%d bloggers like this: