Don't Break The Build .Net Tutorials

The K-Combinator In C#

After browsing through Programmers.StackExchange I found an interesting post on combinators and how they applied to programming projects. It led me to some interesting links, most notably this post by Reg Braithwaite and saw the Ruby implementation of this as #tag and thought, why not recreate it in C#?

I ran into a few issues, which are due to C# type system, but I was eventually able to overcome them, thanks to the new dynamic keyword in C# 4.0. The definition of the K-combinator (taken from Wikipedia) is (K x) is the function which, for any argument, returns x, so we say". Basically, the K-combinator will take x and then do whatever but return x. So as long as the function doesn't modify x, we're good. Which brings me to the code:

    public static class MyExtensions
    {
        public static dynamic k(this object me, Action<dynamic> action)
        {
            action(me);
            return me;
        }
    }

We use Action because we don't know what the type will be until compile time, but also, since there is going to be no return value, we don't need to use Func. We also know that all objects in C# inherit from System.Object and that everything is an object, so we use the type "me" as object, which means this method will be available to everything. With a return type of dynamic, it will also allow us to operate on any type that could be imagined. Note, that using T (for generic type) instead of dynamic will result in a compiler error as the type must be known at compile time. Needless to say, this is a neat little function that can be used for logging, among other things, but is only possible in .NET 4.0.

Here is an example:

int[] i = {1,2,3,4,5};

int[] b = i.k(x=> Console.WriteLine(x));

Pretty useless example, but this will write each int in i to the console before assigning i to b. However, returning the type of the item makes it an invaluable tool to have when logging while also making logging trivial.