Stopping off for a Curry.

2009-04-30T21:28:00.000-07:00

One of the positives of the global downturn in the IT industry (and probably the only one), is that I now have more time on my hands to wander off (programmatically speaking) to investigate the more esoteric areas of the C# language.

Yesterday, while writing unit-test code for the new Ximura lock-free collection classes, I embarked on one such walk-about in to the realms of functional programming.

Currying while Hurrying

Currying, or as it is affectionately known – Schönfinkelisation (I wonder why that name didn’t catch on?) is at it’s simplest, the process of reducing a function with n parameters, to n-1 parameters, by wrapping one of the parameters in a holding function.

Complicated? Well a little, but it does allow for a lot of reuse of your functions if you do it right, and it’s a nice tool to have on your coding tool belt.

Functional Iterators

First off, a little diversion to look at functional iterators. Below is a brief code snippet that add 5 integers to a HashSet [note: you’re going to need Visual Studio 2008 to run these samples].

HashSet<int> coll = new HashSet<int>();


int[] data = {42,46,77,345,-12};


foreach (var local in data)

   coll.Add(local);

A more functional way to write the last statement would be like this.

data.ForEach(i => coll.Add(i));

Where the ForEach extension method is a the method below:

public static void ForEach<T>(this IEnumerable<T> items, Action<T> action)

{
   foreach (var item in items)

       action(item);
}

You can see another example of how I used this code here (the full set of these Ximura extension method can be found here).

Now that we have got the basics down, let’s have some curry.

The Curry Monster

So let’s create a simple function to print out a range of numbers, starting from an initial seed number. The traditional way to do this would be like this:

for (int i = 0; i < 40; i++)

   Console.WriteLine(i);

However in out brave new functional world we would write it like this:

Enumerable.Range(0, 40)

   .ForEach(i => Console.WriteLine(i));

Not the most exciting use of functional programming, but let’s take this further and use it to show Currying in action. First we create a function:

Action<int,int> fnOutput = (total, start) =>

   Enumerable.Range(start, total)

       .ForEach(i => Console.WriteLine(i));

The eagle-eyed amongst you might have noticed that I have switched the start and total parameters, well more on that later. Anyway, now that we have our function we can just call it to output our list of numbers, so for instance to print out 20 to 59, and 45 to 84, we would call the following:

fnOutput(40,20);

fnOutput(40,45);

The total parameter (value 40) is used twice, but if we wanted, we could curry this out of the way, so that it is passed automatically. To do this we would create a new function, let’s call it fnOutput40:

Action<int> fnOutput40 = fnOutput.Curry()(40);

Then we could just call this new function with just the start parameter, as follows, and get the same output as the total parameter of 40 is passed automatically:

fnOutput40(20);

fnOutput40(45);

So, Currying, in the right circumstances can simplify your code when dealing with complex functions. For this example, I have used a integer parameter, but any value-type or class parameter can be Curried.

Just taking a look at the curry function itself, you can see that it takes a function of type <T1,T2,TResult> and returns a function of type <T2, TResult> essentially wrapping the first parameter in the function so that it can be passed around within the new function.

public static Func<T1, Func<T2, TResult>>
Curry<T1, T2, TResult>(this Func<T1, T2, TResult> f)
{
     return p1 => p2 => f(p1, p2);
}

That's all folks.

The full set of Ximura currying functions can be found here, they have been expanded for both functions and actions for up to 4 parameters.

To use them in your project you can either copy the code directly, or add the Ximura Base project as a reference and add the Ximura.Helper namespace to your class.

The ForEach and Currying method will be automatically suggested by Intellisense when you are coding.

Hope you enjoy them,

Paul Stancer

May 1st 2009

Work in progress / work is progressing.

2009-04-16T09:07:00.001-07:00

Well, work progresses on getting the full Ximura project up and running. Version 3.0 becomes more of a rewrite from version 2.0 every day (I’m sure there is some code somewhere that hasn’t been changed), but I am adding significant new functionality, better security, and implementing major performance improvements.

Still, we still need a working system at some point.

I’ll be posting updates regarding the various parts of the system architecture over the next few months. For those of you interested in Ximura and how it works, and the design decisions that have gone in to it, then this blog should hopefully answer most of those questions.

Currently the code is compilable, but will not start due to major changes to the threading and job scheduling engines (more on that in my next post). However the code can be accessed through Subversion at http://code.google.com/p/ximura/. Also the project has been evaluated by Ohloh (https://www.ohloh.net/p/ximura) which has estimated our effort so far at USD $1.6 million. Obviously this means absolutely nothing, as an open source project is only valued on how useful it is to the community, but it leaves a warm fuzzy feeling that there is something there of value, even if it is based on Mickey Mouse money.

In code,

Paul Stancer.