1. The first expression will be used where you get 2 parameters for a method and return a value.

2. The second expression will be used x -> x * x where you get 1 parameters for a method and return a value.

3. The third expression ( ) -> x will be used ( ) -> x where you get 0 parameters for a method and return a value.

Let's take the third one. Suppose you have an interface which takes no parameters and returns a value.

static interface RandomMath {
    public int random();
}

Now You want to instantiate this interface along with its implementation. Without using lambda it will be done as below:-

Random random = new Random();
RandomMath randomMath = new RandomMath() {
    @Override
    public int random() {
        return random.nextInt();
    }
};

Using lambda it will be like:-

Random random = new Random();
RandomMath randomMath = () -> random.nextInt(); //the third type.

Similarly, for first two it can be used for methods which take two and one parameters and return a value.

static interface PlusMath {
    public int plus(int a, int b);
}

PlusMath plusMath = (a, b) -> a + b;

static interface SquareMath {
    public int square(int a);
}

SquareMath squareMath = a -> a * a;

Well, the other answers cover what \() -> "something" means in Haskell: an unary function that takes () as argument.

• What is a function without arguments? – A value. Actually, it can occasionally be useful to think of variables as nullary functions that evaluate to their value. The let-syntax for a function without arguments (which doesn't actually exist) ends up giving you a variable binding: let x = 42 in ...

• Does lambda calculus have nullary functions? – No. Every function takes exactly one argument. However, this argument may be a list, or the function may return another function that takes the next argument. Haskell prefers the latter solution, so that a b c is actually two function calls ((a b) c). To simulate nullary functions, you have to pass some unused placeholder value.

This is shorthand for declaring a lambda expression which takes no arguments.

() => 42;  // Takes no arguments returns 42
x => 42;   // Takes 1 argument and returns 42
(x) => 42; // Identical to above

The nullary lambda equivalent would be () => 2.

Use a Func<T1, T2, TResult> delegate as the parameter type and pass it in to your Query:

public List<IJob> getJobs(Func<FullTimeJob, Student, FullTimeJob> lambda)
{
  using (SqlConnection connection = new SqlConnection(getConnectionString())) {
    connection.Open();
    return connection.Query<FullTimeJob, Student, FullTimeJob>(sql, 
        lambda,
        splitOn: "user_id",
        param: parameters).ToList<IJob>();   
  }  
}

You would call it:

getJobs((job, student) => {         
        job.Student = student;
        job.StudentId = student.Id;
        return job;
        });

Or assign the lambda to a variable and pass it in.

Your case is similar with Supplier in Java 8

 Supplier<Integer> supplier = () -> 0;
 System.out.println(supplier.get());

Well, the expression fun() -> 2 is a function. Not a number, not a string, not an array of bytes, but a function. The only thing to do with a function is to call it. Or, in other words, execute it. Invoke it. That's what you do with a(). You pass it a parameter () (yes, two parentheses in a row is an actual thing in F#, you can pass it as a parameter), and the function runs and returns you a result. Which is 2. A number.

So, once again: first you have a function. Then you execute it. And the result of that execution is a number.

Now, if you want to multiply a function by three... What do you mean by that? That's kinda nonsensical. Do you mean for it to execute three times longer? Or return three results instead of one? Multiplying by a number is not something you can do with a function.

If you want another function that returns a 6 instead of 2, then just say so:

let a = fun() -> 2*3

Or, if you want to take your first function and build another function on top of it, by multiplying the result of the first function, - then you need to have this second function first call (invoke, execute) the first function, take its result, and multiply that by three:

let a = fun() -> 2
let b = fun() -> a() * 3

As for the very last example - that's a bit trickier.

First, the expression fun _ -> 2. That's also a function. And it takes one parameter. And it doesn't care what that parameter is. It sort of says "I'll take any parameter, whatever you throw at me, I don't care, I'll return you 2 anyway". So you can throw any parameter at it. For example, you can throw a 4 at it. It will take a 4, it's not proud. 4 is just fine. That's what you're doing by (fun _ -> 2) 4. This means "create a function that takes any parameter and returns 2, and execute that function with parameter 4".

You can express the same idea in a way that's a bit longer, but easier to understand:

let a = fun _ -> 2
let b = a 4   // b = 2

And then, as the last step, you take that result of executing the function with parameter 4, and multiply that result by 3. And you get 6. Which is a number. And not a function. So you can't execute (invoke, call) it anymore. Because, you know, you can't execute a number. Only a function.

Sort of! There is a new idiom in town, that is nice and may help you in some cases. It is not fully what you want, but sometimes I think you will like it.

Since underscore ("_") is a valid C# identifier, it is becoming a common idiom to use it as a parameter name to a lambda in cases where you plan to ignore the parameter anyway. If other coders are aware of the idiom, they will know immediately that the parameter is irrelevant.

For example:

ExternalId.IfNotNullDo( _ => ExternalId=ExternalId.Trim());

Easy to type, conveys your intent, and easier on the eyes as well.

Of course, if you're passing your lambda to something that expects an expression tree, this may not work, because now you're passing a one-parameter lambda instead of a no-parameter lambda.

But for many cases, it is a nice solution.