Daft Punk's "Technologic" missing word (in C#)

Tomy Durazno — Fri, 21 Aug 2020 00:40:20 +0000

The french duo Daft Punk is one of my favorite bands of all time, they manage to somehow always deliver great songs one after the other. One of them is "Technologic", this tech-word-repetitive machine gun of a song stuck in my brain for a while (specially after this scary baby!)

But, to be reaally technologic, there is a key word that is a must, and that word is "bind".

Why? because this little yet powerful word, also known as 'flatMap', 'andThen', 'collect', 'SelectMany '(and many others) represents something in the world of functional programming*

So I decided to jump into LINQPad and write a little C# code
to retrieve the lyrics from somewhere over the web, parse it and try to find my magic monadic word. With this nice library called AngleSharp for the DOM parsing and after a couple LINQ queries:

async Task Main()
{
    var url = "https://www.lyrics.com/lyric/10258969/Daft+Punk/Technologic";

    async Task<string> GetLyrics(string url) =>
        (await BrowsingContext.New(Configuration.Default.WithDefaultLoader()).OpenAsync(url))
                       .QuerySelectorAll("#lyric-body-text")
                       .Select(m => m.TextContent)
                       .First();

    var lyrics = await GetLyrics(url);

    var regex = new Regex($".*? it");

    lyrics.SplitBy(Environment.NewLine)
          .SelectMany(l => l.SplitBy(","))
          .Select(s => s.Trim().ToLower())
          .Where(s => !string.IsNullOrEmpty(s) && regex.IsMatch(s))
          .GroupBy(s => s)
          .Select(g => g.Key)
          .OrderBy(k => k)
          .GroupBy(k => k[0])
          .Dump();
}

We find out that Daft Punk did not include our reaally special word! NOOO !!

Was it on purpose somehow?

Or did the amazing musical minds of Thomas Bangalter and Guy-Manuel de Homem-Christo missed the beat?

Who cares! Maybe this is an oportunity to make a 'Technologic BIND remix', or something like that.

*You can read what Scott Wlaschin (author of the book 'F# for Fun and Profit') says about it in his site
fsharpforfunandprofit.com

*Or what Joe Albahari (creator of LINQPad, the .NET Programmer’s Playground) says about it in this phenomenal video

Pipe in C#

Tomy Durazno — Thu, 31 Oct 2019 22:23:28 +0000

In functional programming you can express a program in terms of a flow of functions that takes an initial input and manipulates it in order to achieve the desired output. Each function is going to receive as argument the return value of the previous function in the flow chain, making a program that is easy to read and easy to understand what it does at a first glance

Lets look at a simple example written in F#:

seq { for x in 1 .. 10 -> x }
|> Seq.map(fun n -> n * 2) 
|> Seq.filter(fun n -> n > 5) 
|> Enumerable.Sum
|> Console.WriteLine

The first statement is going to create a sequence of numbers from 1 to 10
The second statement is going to multiply each number by 2
The third statement is going to remove from the sequence all the numbers that are less than 5
The fourth statement is going to sum all numbers in the sequence
The last statement is going to output the result to the Console

This is easily achievable because F# has the "|>" operator, that lets us write this type of expressions

But how can we do that in C#, since the language doesn't have this magic operator?

Well, we can build something like that! In order to do it, we first must solve some problems with types

in C#, as in any strongly-typed language, we must know at compile time the types that a function recieves and returns. We can use the 'dynamic' keyword, but that would eliminate the type checking and it doesn't work with some of the other language features (like extension methods, for example).

Ideally, I would like to have all the benefits of type checking but I dont want to have to write all those types. So...

Roslyn To The Rescue!

The new C# compiler, codename 'Roslyn', does a great job at infering the type that a expression returns. So, combining the type inference with some good ol' generics, we can write something like this:

public static C Pipe<A,B,C>(this A obj, Func<A,B> func1, Func<B,C> func2) => func2(func1(obj));

This is an extension method that can be invoked over an instance of type A, and receives as arguments 2 functions, one that takes an A typed instance and returns a B typed, and the second takes a B typed object and returns a C typed one.

By declaring the types this way, the compiler can infer all arguments and return types from the functions. We can go one step further and create declarations of the Pipe function that recieves n number fo functions to be "piped":

public static E Pipe<A,B,C,D,E>(this A obj, Func<A,B> func1, Func<B,C> func2, Func<C,D> func3, Func<D,E> func4) => func4(func3(func2(func1(obj))));

And with this function we can write a program in C# that is equivalent to the one written in F#, not only in behaviour but also in how it looks:

Enumerable.Range(1,10)
      .Pipe(
r => Enumerable.Select(r, n => n * 2),
r => Enumerable.Where(r, n => n > 5),
Enumerable.Sum,
n => { Console.WriteLine(n); return n; }); 
//Since WriteLine returns 'void'

Since we dont have to annotate the function's types, we can go a little 'black magic' and push the type inference to the next level and write a function that returns an anonymous type:

"app.txt".Pipe(
MyUtils.ReadTxtFromDesktop,
string.Concat,
XDocument.Parse, 
n => n.ToXmlDocument(),
n => n.SelectSingleNode("appSettings").ChildNodes.GetNodes(),
//Returns an anonymous object! 
n => n.Select(x => new { Key = x.Attributes["key"].InnerText, Value= x.Attributes["value"].InnerText}),
d => d.Select(a => $"public string { a.Key}  = { a.Value };"));

In this last example, is quite intuitive to understand what the code does:

Reads a Txt file from the desktop
Concatenates all its lines to a single string
Calls 'XDocument.Parse' to convert it

And then pipes some functions to end with the desired output, in the middle invoking a function that returns an anonymous object!

The fact that we are not annotating all the types doesn't mean that the compiler is not doing the type checking:

"app.txt".Pipe(
MyUtils.ReadTxtFromDesktop,
XDocument.Parse, 
n => n.ToXmlDocument(),
n => n.SelectSingleNode("appSettings").ChildNodes.GetNodes(),
//Returns an anonymous object! 
n => n.Select(x => new { Key = x.Attributes["key"].InnerText, Value= x.Attributes["value"].InnerText}),
d => d.Select(a => $"public string { a.Key}  = { a.Value };"));

This last example doesn't compile:

Here is a link to a repo that contains a handful of 'Pipe' declarations (up to 25 functions): https://github.com/TomyDurazno/PipeExtensions

I wrote all the code snippets in this article using LINQPad, a phenomenal .NET IDE/REPL/ORM/Swiss Knife/Whatever that I use almost everyday for the most diverse tasks. Go take a look at https://www.linqpad.net/ and become a LINQPad junkie just like myself!

Thanks and have fun coding in a more declarative way!

Forem: Tomy Durazno

Daft Punk's "Technologic" missing word (in C#)

Pipe in C#