Strangelights

One area that seams to have been over looked so far is folding. A folding function is similar to a mapping function and mapping functions are supported by the framework library in version 2.0, expect it calls it ConvertAll. For example, the framework defines the following method on the List<T> class:

public List<TOutput> ConvertAll<TOutput>(Converter<T, TOutput> converter);

It’s not hard to see this can be used to map one list to another, like so:

List<string> stringList =

intList.ConvertAll<string>(

delegate(int intput) { return intput.ToString(); }

);

Folding is similar, except that where a mapping function applies a transformation to a list a folding function produces a summary. F# defines a folding function on this list type like so:

let rec fold f acc l =

  match l with

    [] -> acc

  | (h::t) -> fold_left f (f acc h) t 

This is a function that has 3 parameters; the fist one of these is function that takes two parameters, the second is the accumulator and the third is the list to be folded. This translates to C# something like:

public delegate TReturn AStarBToB<TInput, TReturn>

(TInput value1,

TReturn value2);

public static TAcc Fold<TList, TAcc>(

AStarBToB<TList, TAcc> funct,

TAcc acc,

IEnumerable <TList> list)

{

         foreach (TList item in list)

{

                   acc = funct(item, acc);

         }

         return acc;

}

This provides a very easy to create summaries of lists:

// intList = {1, 2, 3, 4, 5, 6}

int result1

= Fold(

delegate(int value1, int value2) { return value1 + value2; },

0,

intList

);

// result1 = 21

string result2 =

Fold(

delegate(int value1, string value2) { return value2 + ", " + value1; },

"",

intList);

// result2 = “, 1, 2, 3, 4, 5, 6”

And that’s it! It takes just one line of code to produce a summering of a list and the technique can be applied to any object that supports the IEnumberable<T> interface, which is quite a few.