Why i changed the blog's name

This one's *not* be about programming... mostly. Ok, it is. It always is.

This is an explanation on why I changed the name I had for this blog. The previous name was officially Run or Debug, but now I called Left Fold. Why would you do that, you ask?

Well, the main story is because I hated the previous name but still I didn't have the courage (or the will) to change it. And truly, I didn't have a better name in mind... Until recently!

I started to learn F# recently and as a guy who comes mostly from C# a lot of concepts were new to me, and some were not new, I just didn't know their name. It has been quite a journey, as anyone who has the same background as me would understand. I jumped from a general OOP language to a non-pure functional language.

One of those concepts "learned" is called a left fold. I am aware it does exist in C# too, and it is all but new, but hear me out, I just never had thought about it this way. So, what the hell is a left fold after all? Let's dive in this surprisingly simple concept.

Think of a list of values. Let's say, a list of strings with the alphabet inside:

["a"; "b"; "c"; "d"; "e"; "f"; "g"; "h"; "i"; "j"; "k"; "l"; "m"; "n"; "o"; "p"; "q"; "r"; "s"; "t"; "u"; "v"; "w"; "x"; "y"; "z"]

The concept of fold is simply this: take an initial state and for each letter in that list produce a new state based on the letter. Then feed that state to the function along with the next letter and produce the next state. Let's see an example in C#:

	var l = new List<string> {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"};
	var folded = l.Aggregate((state, item) => state + item);

view raw LeftFold C#.cs hosted with ❤ by GitHub

Of course, everyone using Linq knows the Aggregate method. But really, how frequently do you use it? We use the variations surely... Sum, Max, Min, etc. But I never really thought about those methods in terms that they might be just a derivation from an underlying concept. And that concept is the left fold!

Let's look again at how it works, in simple terms:

1. Start with a state. In the snippet above this state is an empty string implicitly, but there is another overload that accepts a seed state.
2. Take that state and an item in the list, and execute the function passed in. The function should produce a new state.
3. Repeat 2 for all items in the list.

Now let's define some of the LINQ methods in terms of Aggregate, just for kicks. This time we'll use a list of ints

	var values = new List<int> {4,2,4,100,6,8};
	//Sum
	Console.WriteLine(values.Aggregate(((state, item) => state + item)));
	//Max
	Console.WriteLine(values.Aggregate(((state, item) => state > item ? state : item)));
	//Min
	Console.WriteLine(values.Aggregate(((state, item) => state < item ? state : item)));
	//All(x=> x % 2 == 0)
	Console.WriteLine(values.Aggregate(true, (state, item) => (item % 2 == 0 && state) ? true : false));
	//Count
	Console.WriteLine(values.Aggregate((state, item) => state + 1));

view raw LeftFold linq operators.cs hosted with ❤ by GitHub

So, you can see the usefulness of the concept now. In fact, many more Linq operators can be defined in terms of a left fold, those were just the most obvious ones. Of course, in the background they are actually not defined like that, but i'm getting a point across.

This is a big topic, but I don't want a big post, so let's call it a day.
TL;DR: I didn't like the previous name and I like this one because of how useful the actual concept is.