Type inferencing for local function return types

[GabeSchaffer]

I understand why var is only supported for locals, but it was implemented when only variables were local. Now that we have local functions, is there a reason C# should not be made to support var function declarations?

Motivation

1. It's common to have nested data structures like Dictionary<CustomerId, Dictionary<InvoiceId, List<OrderDetails>>>. If I want to have a local function that creates such a data structure, I have to name the type multiple times:

Dictionary<CustomerId, Dictionary<InvoiceId, List<OrderDetails>>> FindOrders(Func<Customer, bool> predicate)
{
    var retval = new Dictionary<CustomerId, Dictionary<InvoiceId, List<OrderDetails>>>();
    // populate retval
    return retval;
}

I would like to avoid having the type in multiple places, like this:

var FindOrders(Func<Customer, bool> predicate)
{
    var retval = new Dictionary<CustomerId, Dictionary<InvoiceId, List<OrderDetails>>>();
    // populate retval
    return retval;
}

2. Consider this example to query for customers and group them by region:

IOrderedQueryable<IGrouping<Region, CustomerOrder>> LookupCustomers(Expression<Func<Customer, bool>> predicate)
{
    var customers = dbCtx.Customers.Where(predicate);
    return from cust in customers
           group cust by cust.Region into grp
           orderby grp.Key
           select grp;
}

It's cumbersome to write out the name of the type, but it's tractable. However when somebody decides that the customers need to be grouped by region and district, I fall off a cliff. I can't just change group cust by cust.Region to group cust by new { cust.Region, cust.District} because the anonymous type cannot be spoken in the function signature. Instead I'd like to be able to write it like this:

var LookupCustomers(Expression<Func<Customer, bool>> predicate)
{
    var customers = dbCtx.Customers.Where(predicate);
    return from cust in customers
           group cust by new { cust.Region, cust.District } into grp
           orderby grp.Key.Region, grp.Key.District
           select grp;
}

Now if this happens, I have to either take the query out of its function, declare a named type somewhere else in the enclosing class, or use a Tuple and try to remember the region is called .Item1 and the district is called .Item2. I'd prefer named tuples, but those aren't supported by Expressions.

[HaloFour]

This was an intentional decision. It was a choice between inference or hoisting to support recursion, and the latter was chosen.

Couldn't find meeting notes but here's a comment:

dotnet/roslyn#2930 (comment)

Sounds like it could potentially be revisited but would require some limitations due to the complexity.

[MCGPPeters]

I understand why var is only supported for locals, but it was implemented when only variables were local. Now that we have local functions, is there a reason C# should not be made to support var function declarations?

Motivation

1. It's common to have nested data structures like Dictionary<CustomerId, Dictionary<InvoiceId, List<OrderDetails>>>. If I want to have a local function that creates such a data structure, I have to name the type multiple times:

Dictionary<CustomerId, Dictionary<InvoiceId, List<OrderDetails>>> FindOrders(Func<Customer, bool> predicate)
{
    var retval = new Dictionary<CustomerId, Dictionary<InvoiceId, List<OrderDetails>>>();
    // populate retval
    return retval;
}

I would like to avoid having the type in multiple places, like this:

var FindOrders(Func<Customer, bool> predicate)
{
    var retval = new Dictionary<CustomerId, Dictionary<InvoiceId, List<OrderDetails>>>();
    // populate retval
    return retval;
}

2. Consider this example to query for customers and group them by region:

IOrderedQueryable<IGrouping<Region, CustomerOrder>> LookupCustomers(Expression<Func<Customer, bool>> predicate)
{
    var customers = dbCtx.Customers.Where(predicate);
    return from cust in customers
           group cust by cust.Region into grp
           orderby grp.Key
           select grp;
}

It's cumbersome to write out the name of the type, but it's tractable. However when somebody decides that the customers need to be grouped by region and district, I fall off a cliff. I can't just change group cust by cust.Region to group cust by new { cust.Region, cust.District} because the anonymous type cannot be spoken in the function signature. Instead I'd like to be able to write it like this:

var LookupCustomers(Expression<Func<Customer, bool>> predicate)
{
    var customers = dbCtx.Customers.Where(predicate);
    return from cust in customers
           group cust by new { cust.Region, cust.District } into grp
           orderby grp.Key.Region, grp.Key.District
           select grp;
}

Now if this happens, I have to either take the query out of its function, declare a named type somewhere else in the enclosing class, or use a Tuple and try to remember the region is called .Item1 and the district is called .Item2. I'd prefer named tuples, but those aren't supported by Expressions.

Have you tried using a lambda in-stead of a local function? Given your (slightly adjusted quick and dirty example so I could test it quickly)

var LookupCustomers = (Expression<Func<CustomerOrder, bool>> predicate) =>
        {
            var _customers = new System.Collections.Generic.List<CustomerOrder>();
            var customers = _customers.Where(predicate.Compile());
            return from cust in customers
                group cust by cust.Region into grp
                orderby grp.Key
                select grp;
        };

LookupCustomers is inferred to be of type => Func<Expression<Func<CustomerOrder, bool>>, IOrderedEnumerable<IGrouping<object, CustomerOrder>>>? ..