Lambda Expressions

Question

Can somebody explain me lambda expressions & what they can be used for. I have googled for it & have a rough idea. most of the examples give c# code. How about lambda expressions in plain old C...?

Answer 1

There are actually two things called "lambda expressions", which are rather loosely related:

1. Lambda expressions are fundamental part of lambda calculus and are closely related to functional programming

2. In imperative languages, lambda expressions are usually synonyms for anonymous methods. In C#, for example you can pass lambda expression (ie. an expression itself, not just its result) as an argument:

C#:

someCollection.Apply (x => 2*x); // apply expression to every object in collection
// equivalent to 
someCollection.Apply (delegate (int x) { return 2 * X; });

Having said that, C does not support anonymous methods. You can, however, use function pointers to achieve similar results:

int multiply (int x)
{
    return 2 * x;
}

...
collection_apply (some_collection, multiply);

Answer 2

Look here on the MSDN

Answer 3

C doesn't support lamba expressions...if you know perl, I highly recommend the book "higher order perl" which will give you a great introduction to all sorts of functional programming techniques in a familiar (if you know perl) and practical setting.

Answer 4

el.pescado's answer is right but the example that he provides has an easy work around, using a function pointer. Many uses of lambda functions can't be solved with c's function pointers.

Say you write these functions in c:

int Multiply_1(int x) { return(x*1); }
int Multiply_2(int x) { return(x*2); }
int Multiply_3(int x) { return(x*3); }
int Multiply_4(int x) { return(x*4); }
etcetera, to infinity

Those are all pretty easy to understand. Now assume that you want to write a function that takes y as input and returns a pointer to the function Multiply_y():

(int)(int) *Make_Multiplier(int y) { return(Multiply_y); }

Where "Multiply_y" is a dynamically created function of the form of Multiply_1, Multiply_2, etc. Languages that have first-class lambda functions can do that.