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
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,.
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:
I specialise in rapidly transitioning teams to serverless and building production-ready services on AWS.
Are you struggling with serverless or need guidance on best practices? Do you want someone to review your architecture and help you avoid costly mistakes down the line? Whatever the case, I’m here to help.
Check out my new course, Complete Guide to AWS Step Functions. In this course, we’ll cover everything you need to know to use AWS Step Functions service effectively. Including basic concepts, HTTP and event triggers, activities, callbacks, nested workflows, design patterns and best practices.
Here is a complete list of all my posts on serverless and AWS Lambda. In the meantime, here are a few of my most popular blog posts.
- Lambda optimization tip – enable HTTP keep-alive
- You are thinking about serverless costs all wrong
- Many faced threats to Serverless security
- We can do better than percentile latencies
- I’m afraid you’re thinking about AWS Lambda cold starts all wrong
- Yubl’s road to Serverless
- AWS Lambda – should you have few monolithic functions or many single-purposed functions?
- AWS Lambda – compare coldstart time with different languages, memory and code sizes
- Guys, we’re doing pagination wrong