F# – Pipe Forward and Pipe Backward

Yan Cui

I help clients go faster for less using serverless technologies.

I’m taking a bit of time to brush up my knowledge of F# and see if I can write better F# code and one of the things I notice is that whilst I use pipe-forward operator (|>) often when working with collections I don’t nearly use the pipe-backward operator (<|) as frequently as I should. It makes sense as the pipe-forward operator works similar to the way LINQ and IEnumerable works, just to remind myself and others like me how these work:

Pipe-forward operator (|>)

Pipe-forward operator lets you pass an intermediate result onto the next function, it’s defined as:

let (|>) x f = f x

For instance, to apply a filter (i.e. IEnumerable.Where) for even numbers to a list of integers from 1 to 10, you can write:


You can add further processing steps to this intermediate result:


Forward composition operator (>>)

The forward composition operator lets you ‘compose’ functions together in a way similar to the way the pipe-forward operator lets you chain function delegates together, it is defined as:

let (>>) f g x = g (f x)

Now imagine if you have two functions:


You can use them to build a high-order function that returns triples the square of a float, n, using the >> operator:


This is syntactically cleaner and easier to read than:


and it’s especially useful when chaining together a large number of functions.

Pipe-backward operator (<|)

The pipe-backward operator takes a function on the left and applies it to a value on the right:

let (<|) f x = f x

As unnecessary as it seems, the pipe-backward operator has an important purpose in allowing you to change operator precedence without those dreaded parentheses everywhere and improve readability of your code,.

For example:


can be written as


Backward composition operator (<<)

The inverse of the forward composition operator, the << operator takes two functions and applies the right function first and then the left, it’s defined as:

let (<<) f g x = f (g x)

Mostly I find it more suitable than the forward composition operator in cases where you want to negate the result of some function, for example, to find the odd numbers in a list:


Whenever you’re ready, here are 4 ways I can help you:

  1. Production-Ready Serverless: Join 20+ AWS Heroes & Community Builders and 1000+ other students in levelling up your serverless game. This is your one-stop shop for quickly levelling up your serverless skills.
  2. Do you want to know how to test serverless architectures with a fast dev & test loop? Check out my latest course, Testing Serverless Architectures and learn the smart way to test serverless.
  3. I help clients launch product ideas, improve their development processes and upskill their teams. If you’d like to work together, then let’s get in touch.
  4. Join my community on Discord, ask questions, and join the discussion on all things AWS and Serverless.

13 thoughts on “F# – Pipe Forward and Pipe Backward”

  1. Nice article. As a beginner, I was only using the |>, which shows up in a lot of examples.

    Thanks for the examples of when you use the other operators.

  2. Pingback: Elm – functional reactive dreams + missile command | theburningmonk.com

  3. Pingback: Being visually honest with F# | theburningmonk.com

  4. Pingback: F# by example: FizzBuzz kata rivisited - More on Pattern-Matching - VGALTES.COM

  5. Pingback: Automating Xamarin Builds with FAKE – Part 2: Building PCL, iOS, and Android Projects – Wintellect DevCenter

  6. Here a puzzle for you- how is the first not equal to the second?

    let first = Seq.toList <| Seq.take 6 Seq.take 6 |> Seq.toList

    The second one compiles, the first does not

  7. Great question! The reason the first doesn’t compile is down to the limitation of F# type inferencer works left-to-right, and the all-important type here (as determined by sizes) is not known by the time it reads Seq.toList ‘b’ does not match the type ”c list’.

    The same limitation manifests itself in something as simple as “Seq.map (fun fi -> fi.Name) fis” which will require you to annotate “fi”, whereas “fis |> Seq.map (fun fi -> fi.Name)” works without annotations. Another reason why F# people use |> so heavily.

  8. Pingback: Extracting basic statistics from your code repository using F#

  9. Pingback: Hack your commit history for fun and profit | JUST EAT Technology

  10. Pingback: In praise of syntactic sugar – Mubashir Qasim

  11. Pingback: In praise of syntactic sugar | A bunch of data

  12. Pingback: In praise of syntactic sugar – Win-Vector Blog

Leave a Comment

Your email address will not be published. Required fields are marked *