C# LINQ, Monads, and Abstraction
I want to show you a little trick. If you are a C# developer looking to learn some functional programming, this post might be interesting for you.
Here’s the definition of the
SelectMany method in C# LINQ:
This method gets two parameters:
source—which is a sequence of values;
selector—which is a function that should be applied to each value in the
The method returns a sequence of values, each element is the result of invoking the
selector function to an item in the
Type parameters allows to specify a type of the source elements as
TSource and a type of returned elements as
You may check examples of using
Moving from C# to Haskell
Now let’s do some simple changes.
First, let’s change types
TResult to a shorter versions of
b. We’ll get:
Now, let’s change the name of the interface from
And now for the interesting part.
Let’s switch this method definition from C# language to Haskell. Without changing any types the signature of
SelectMany will look like the following:
This definition describes the same signature as the original
If we’ll look at the Monad definition in Haskell, we’ll find that each Monad should have an implementation of the
bind operator that has the following signature:
As you can see, the signature is the same as in LINQ
SelectMany method. And it is not a coincidence.
If you are a C# developer interested in functional programming, I recommend you to watch this video with Brian Beckman. It won’t make you a functional programming expert, but it is a good starting point in learning it.
Have fun! And don’t fear the Monad!