C# lambda expressions without variable / parameter declaration?

Question

What's it called when a method that takes a lambda expression as the parameter, such as Enumerable.Where, is invoked without actually declaring a variable or method parameter in the expression?

For example, I'm familiar with this lambda expression syntax:

public string GetDigits(string input)
{
    return new String(input.Where(i => Char.IsDigit(i)).ToArray());
}

However, I was surprised to find out that this can also be written as:

public string GetDigits(string input)
{
    return new String(input.Where(Char.IsDigit).ToArray());
}

What's going on in that second snippet, where the Char.IsDigit() method is (apparently) being called with an implicit parameter? What is this syntax called?

Answer 1

Methods don't accept lambdas as parameters. They accept delegates as parameters. A lambda is just one way of creating a delegate.

Another way is supplying a method group, as is done in your second example, which can be converted to a delegate.

A similar way is to use the anonymous method feature. This was more or less replaced with lambdas when they were added though, so you don't see it much. Your example using that syntax would be:

Func<char, bool> predicate = delegate(char c) { return Char.IsDigit(c); };

Yet another way would be to create a delegate using Delegate.CreateDelegate. (This isn't something you see all that often though.)

A final way is to have a delegate variable that you got from somewhere else. (That somewhere else would have created the delegate using one of these other options.)

What's going on in that second snippet, where the Char.IsDigit() method is (apparently) being called with an implicit parameter? What is this syntax called?

It's not being called. That's the whole point. We're trying to create a delegate. A delegate is an object that keeps track of a method to be invoked, and an object that it should be invoked on. You can then invoke the delegate and it will call the method that was used to create it. So here you're not calling IsDigit, you're creating a delegate that is pointing to the IsDigit method, and that will call it whenever that delegate is invoked.

When you use a lambda you're creating a new method, possibly in a new class, (neither of which have a name you can refer to, but they'll have one at runtime) and the body of that anonymous method will call IsDigit. The lambda then resolves to a delegate pointing to that anonymous method, which maintains the semantics of the other example of having a method that when called, calls an anonymous method which, in its implementation, calls IsDigit. It's adding an extra layer of indirection (that may or may not just get optimized out at runtime) to accomplish the same thing.

Answer 2

The signature of Enumerable.Where is:

public static IEnumerable<TSource> Where<TSource>(
    this IEnumerable<TSource> source,
    Func<TSource, bool> predicate
)

This:

input.Where(i => Char.IsDigit(i))

is equivalent to writing:

Func<char, bool> temp = i => Char.IsDigit(i);
input.Where(temp);

so it creates an anonymous function with a parameter i that calls Char.IsDigit.

This:

input.Where(Char.IsDigit)

is equivalent to

Func<char, bool> temp = Char.IsDigit;
input.Where(temp);

that is equivalent to:

Func<char, bool> temp = new Func<char, bool>(Char.IsDigit);
input.Where(temp);

so it creates a delegate to Char.IsDigit and then passes it to input.Where.

So the second one removes the "man-in-the-middle" (the anonymous function). In this particular case it is "legal" because the i parameter of the anonymous function is passed "as is" to Char.IsDigit. It would have been different if it was:

input.Where(i => !Char.IsDigit(i))

in this case, you can't remove the man-in-the-middle (the anonymous function).

There is no name for all of this (or you could call the first "creating and passing a delegate to an anonymous function" and the second "creating and passing a delegate created from a method group"... but they aren't beautiful catchphrases, they are more a description of what you are doing)

Answer 3

Because the compiler will implicitly cast the method group to a delegate if it finds a single method that matches the expected signature, in this case a delegate taking a single char as input and returning a bool.

Answer 4

Your Where expects a Func<char, bool>, which is a delegate for methods that take a char argument and return a bool. Anything that matches this delegate is a valid argument for this Where.

• The lambda you wrote initially matches this delegate by type inference: the compiler expects that i is char, based on the generic parameter of the enumerable source - and infers the return type as bool, because that's what the method call expression inside the lambda would return.
• The Char.IsDigit method itself also matches this. Thus, referencing the method is another valid way of expressing the same thing. This is called a method group.

The semantic equivalence of these two possible arguments for Where also makes sense if you consider that for every lambda expression, the compiler generates an anonymous method and then passes that anonymous method where the delegate was expected.

To illustrate this, consider your original snippet:

Where(i => Char.IsDigit(i))

The above gets lowered by the compiler to:

bool AnAnonymousMethod(char i)
{
    return Char.IsDigit(i);
}

and then:

Where(AnAnonymousMethod)

As you can see, the lambda syntax (in cases where you don't have captured variables, like here) is just syntactic sugar for writing an anonymous method and then using the method group of this newly written method as the argument wherever a compatible delegate is expected.