Why is it not possible to declare a function with VAR return type?

Question

In C#, we have var data type but we can't use it as functions return type.
Why this is not possible?

public var myFunction()
{
    var = some operations
}

Answer 1

I believe it's partly due to the design of the compiler. Eric Lippert blogged about why fields can't use implicit typing, and I suspect some of the same arguments hold for methods.

But you could easily end up with ambiguity anyway. For example:

var Method1(bool callMethod2)
{
    return callMethod2 ? Method2() : null;
}

var Method2()
{
    return Method1(false);
}

What should the type be here?

A simpler example:

var Method1(bool throwException)
{
    if (!throwException)
    {
        return Method1(true);
    }
    throw new Exception("Bang!");
}

Admittedly this sort of ambiguity could simply be disallowed, but I suspect that the design team felt that the added complexity of both design and implementation wasn't worth the benefit. Don't forget that they're running with limited resources - given a choice between var for methods and async/await, I'd pick the latter in a heartbeat. (Admittedly there are other features I'd have picked instead of dynamic, but that's a different matter...)

Note that return type inference is performed for lambda expressions, so the very idea of it isn't crazy. For example:

IEnumerable<string> x = new[] { "x", "y", "z" };

var result = x.Select(s => { return s.Length; }); // Long form

There the compiler infers the complete type of the lambda expression when it performs overload resolution on Select, converting it to a Func<string, int>. It's not inconceivable to apply the same ideas to methods - just complicated.

Answer 2

var is NOT a datatype in C#. That's why you cannot use it as a return parameter. The compiler infers the type at compile time from the right handside of the assignment and bearing in mind that it is known at compile time you need to use the real type as return value. In C# 4.0 you could use the dynamic type:

public dynamic myFunction()
{
    var = some operations
}