How does the compiler infer types in the delegate example?

Question

In the following delegate example, how does the compiler infer what type the variable alpha is?

delegate double Doubler(double x);

public class Test
{
    Doubler dbl = (alpha) => //How does it determine what type is alpha?
    {
        return alpha * 2
    };

    Console.WriteLine(dbl(10)); //Is it when the method is called?  int here;

    Console.WriteLine(dbl(5.5)); //double here???
}

I found this statement on a website, I guess based on the responses, is it incorrect?

"In our example, we specified the type of the argument. If you want, you can let the compiler figure out the type of argument. In this case, pass only the name of the argument and not its type. Here is an example:"

Answer 1

You declare it in your delegate.

delegate double Doubler(double x);

x is your alpha.

You could easily replace your code with:

Doubler dbl = delegate (double x)
{
   return x*2;
};

Also you could simplify your lambda expression:

Doubler dbl = alpha => alpha*2;

Answer 2

You specified that the input type is double when you defined the Doubler delegate. For both examples the input type is double.

Answer 3

This language feature looks simple but in fact is really quite complicated. It would take far too much space to describe here exactly what all the consequences of this feature are. If you are really interested in how the compiler works out the type of the formal parameter to the lambda, you should read my five-part series of articles discussing how we do this, and what the consequences are to the compiler design.

Here's my archive of all my articles where I discuss the implications of lambda expressions:

http://blogs.msdn.com/ericlippert/archive/tags/Lambda+Expressions/default.aspx

You should read the series entitled "Lambda Expressions vs. Anonymous Methods".

If you're interested in how the compiler performs other type inferences, here's my archive of articles on that:

http://blogs.msdn.com/ericlippert/archive/tags/Type+Inference/default.aspx

If you're the sort of person who prefers watching video to reading text, here's a video I made in 2006 explaining some of the type inference scenarios:

http://blogs.msdn.com/ericlippert/archive/2006/11/17/a-face-made-for-email-part-three.aspx