Yan Cui
I help clients go faster for less using serverless technologies.
This article is brought to you by
Step Functions, EventBridge, MSK, DynamoDB…stop hacking together AWS services and get back to building!
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 3 ways I can help you:
- 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.
- 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.
- Join my community on Discord, ask questions, and join the discussion on all things AWS and Serverless.
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.
Pingback: Elm – functional reactive dreams + missile command | theburningmonk.com
Pingback: Being visually honest with F# | theburningmonk.com
Pingback: F# by example: FizzBuzz kata rivisited - More on Pattern-Matching - VGALTES.COM
Pingback: Automating Xamarin Builds with FAKE – Part 2: Building PCL, iOS, and Android Projects – Wintellect DevCenter
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
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.
Pingback: Extracting basic statistics from your code repository using F#
Thank you for clearing that up Yam :) I hadn’t realised this was the case.mid always assumed equivalent behaviour in both directions.
Pingback: Hack your commit history for fun and profit | JUST EAT Technology
Pingback: In praise of syntactic sugar – Mubashir Qasim
Pingback: In praise of syntactic sugar | A bunch of data
Pingback: In praise of syntactic sugar – Win-Vector Blog