Infer "var" in "Func<var>" from a return value of lambda; Add a possibility to alias local anonymous types.

[andrey-messi]

I don't know should this proposal be a language feature or it mostly relates to a compiler.

I don't know why 'var' as a result type of 'Func' is disallowed because it can obviously be inferred from a lambda-expression.
Func<int, var> getSqrOfInt = x => x * x;
In vs2017 version 15.4.4 it returns a compile-time error "The contextual keyword 'var' may only appear within a local variable declaration or in script code";

And let's see that code that I want to use, it has a reusable part as Func that should do "select And Concatenate All KittenNames By Every CatMother":

class Cat
{
	public string Name;
	public string CatMotherName;
	
	public void Func1()
	{
		string GetCatString(IEnumerable<Cat> kittensThatEatWhiskas, IEnumerable<Cat> kittensThatEatKitecat)
		{
			var delimiter = ", ";
			var delimiter2 = "; ";
			//select And Concatenate All KittenNames By Every CatMother
			// Cause a compile-time error "The contextual keyword 'var' may only appear within a local variable declaration Or In Script Code".
			// I don't know why 'var' as a result type of 'Func' is disallowed; but I can't put any type name because the result type is an anonymous type
			Func<IEnumerable<Cat>, IEnumerable<var>> selectAndConcatenateAllKittenNamesByEveryCatMother =
				littleCats => littleCats.Select(cat => new { KittenMotherName = cat.CatMotherName, KittenName = cat.Name }).GroupBy(cat => cat.KittenMotherName).Select(
					cat => new { KittenMotherName = cat.Key, KittenNames = cat.Select(c => c.KittenName).Aggregate((n1, n2) => n1 + delimiter + n2) });
			var motherAndTheirKittensThatEatWhiskas = selectAndConcatenateAllKittenNamesByEveryCatMother(kittensThatEatWhiskas)
				//concatenate all CatMothers And Their Kittens That Eat Whiskas
				.Aggregate("", (acc, i) => $"{acc}{i.KittenNames} were borned by {i.KittenMotherName} the cat {delimiter2}");
			var motherAndTheirKittensThatEatKitecat = selectAndConcatenateAllKittenNamesByEveryCatMother(kittensThatEatKitecat)
				//concatenate all CatMothers And Their Kittens That Eat Kitecat
				.Aggregate("", (acc, i) => $"{acc}{i.KittenNames} were borned by {i.KittenMotherName} the cat {delimiter2}");

			return $"{motherAndTheirKittensThatEatWhiskas}and they like to eat Whiskas;\nbut {motherAndTheirKittensThatEatKitecat}and they like to eat Kitecat";
		}
		var kittens = new List<Cat>(4) { new Cat { CatMotherName = "Musya", Name = "Barsik" }, new Cat { CatMotherName = "Musya", Name = "Murzik" },
			new Cat { CatMotherName = "Tusya", Name = "Boris" }, new Cat { CatMotherName = "Tusya", Name = "Vasya" }};
		var otherKittens = new List<Cat>(4) { new Cat { CatMotherName = "Dusya", Name = "Baksik" }, new Cat { CatMotherName = "Dusya", Name = "Tuzik" },
			new Cat { CatMotherName = "Murka", Name = "Maxim" }, new Cat { CatMotherName = "Murka", Name = "Ponchik" }};
		// should return:
		//@"Barsik, Murzik were borned by Musya the cat ; Boris, Vasya were borned by Tusya the cat ; and they like to eat Whiskas;
		//but Baksik, Tuzik were borned by Dusya the cat ; Maxim, Ponchik were borned by Murka the cat ; and they like to eat Kitecat"
		var result = GetCatString(kittens, otherKittens);
	}
}

but it doesn't compile because of
Func<IEnumerable<Cat>, IEnumerable<var>>

Instead I should use this code that duplicates a part of code that should do "select And Concatenate All KittenNames By Every CatMother" :

string GetCatString(IEnumerable<Cat> kittensThatEatWhiskas, IEnumerable<Cat> kittensThatEatKitecat)
{
	var delimiter = ", ";
	var delimiter2 = "; ";
	var motherAndTheirKittensThatEatWhiskas = kittensThatEatWhiskas
		 //select And Concatenate All KittenNames By Every CatMother
		 .Select(cat => new { KittenMotherName = cat.CatMotherName, KittenName = cat.Name }).GroupBy(cat => cat.KittenMotherName).Select(
			 cat => new { KittenMotherName = cat.Key, KittenNames = cat.Select(c => c.KittenName).Aggregate((n1, n2) => n1 + delimiter + n2) })
		 //concatenate all CatMothers And Their Kittens That Eat Whiskas
		 .Aggregate("", (acc, i) => $"{acc}{i.KittenNames} were borned by {i.KittenMotherName} the cat {delimiter2}");
	var motherAndTheirKittensThatEatKitecat = kittensThatEatKitecat
		 //select And Concatenate All KittenNames By Every CatMother
		 .Select(cat => new { KittenMotherName = cat.CatMotherName, KittenName = cat.Name }).GroupBy(cat => cat.KittenMotherName).Select(
			 cat => new { KittenMotherName = cat.Key, KittenNames = cat.Select(c => c.KittenName).Aggregate((n1, n2) => n1 + delimiter + n2) })
		 //concatenate all CatMothers And Their Kittens That Eat Kitecat
		 .Aggregate("", (acc, i) => $"{acc}{i.KittenNames} were borned by {i.KittenMotherName} the cat {delimiter2}");

	return $"{motherAndTheirKittensThatEatWhiskas}and they like to eat Whiskas;\nbut {motherAndTheirKittensThatEatKitecat}and they like to eat Kitecat";
}

This was my first proposal and it somehow relates to #265 and #943 (except that mine is about Func-s and their proposals are about local functions).

Second proposal: what I want to do next is to make a part that should do "concatenate all CatMothers And Their Kittens" also reusable as Func:

string GetCatString(IEnumerable<Cat> kittensThatEatWhiskas, IEnumerable<Cat> kittensThatEatKitecat)
{
	var delimiter = ", ";
	var delimiter2 = "; ";
	//select And Concatenate All KittenNames By Every CatMother
	// var{MyClass} should be an anonymous class with alias MyClass
	Func<IEnumerable<Cat>, IEnumerable<var{MyClass}>> selectAndConcatenateAllKittenNamesByEveryCatMother =
		littleCats => littleCats.Select(cat => new { KittenMotherName = cat.CatMotherName, KittenName = cat.Name }).GroupBy(cat => cat.KittenMotherName).Select(
			cat => new { KittenMotherName = cat.Key, KittenNames = cat.Select(c => c.KittenName).Aggregate((n1, n2) => n1 + delimiter + n2) });
	// concatenate all CatMothers And Their Kittens
	// I can't declare it because MyClass is an anonymous type from first Func
	Func<IEnumerable<MyClass>, string> concatenateAllCatMothersAndTheirKittens =
		littleCats => littleCats.Aggregate("", (acc, i) => $"{acc}{i.KittenNames} were borned by {i.KittenMotherName} the cat {delimiter2}");
	var motherAndTheirKittensThatEatWhiskas = concatenateAllCatMothersAndTheirKittens(selectAndConcatenateAllKittenNamesByEveryCatMother(kittensThatEatWhiskas));
	var motherAndTheirKittensThatEatKitecat = concatenateAllCatMothersAndTheirKittens(selectAndConcatenateAllKittenNamesByEveryCatMother(kittensThatEatKitecat));

	return $"{motherAndTheirKittensThatEatWhiskas}and they like to eat Whiskas;\nbut {motherAndTheirKittensThatEatKitecat}and they like to eat Kitecat";
}

but I can't because a first Func returns an anonymous type and I can't declare a second Func with an anonymous type parameter.
It can be fixed by introductions of anonymous types aliases in scopes of local functions.
Second proposal relates to this proposal for aliases #430

[HaloFour]

These are language specification concerns as it is the language specification that forbids both var for anything other than local variables as well as declaring anonymous types as some kind of public type. However, I would submit these proposals separately. There already is an anonymous type proposal so you shouldn't need to submit an additional one as it would likely just be closed as a duplicate unless you can offer a different syntax/implementation.

[MkazemAkhgary]

what happens if you declare Func<var> as a field? it would not make sense. It would make much more sense if local functions could take advantage of var so return type of local function would be inferred if possible.

[andrey-messi]

@HaloFour

as well as declaring anonymous types as some kind of public type

My proposal wasn't about public anonymous types (though I would like it too because if in C#7 I'm able to return valueTuple (which is a structure) from a function then I should be able to do the same with a class).
In fact these my proposals were about that:

1. now I'm forbidden to do that

// it should be compilable
Func<int, var> getObj = i => new {x = i, y = i + 1};
var var1 = getObj(5);
var var2 = getObj(6);

It relates not only to Func, but also to local functions.

2. now I'm forbidden to do that

Func<int, var> getObj = i => new {x = i, y = i + 1};
Func<var, int> multipleXandYFromObj = i => i * i;
var obj = getObj(1);
var obj2 = getObj(2);
var res = multipleXandYFromObj(obj);
var res2 = multipleXandYFromObj(obj2);

My proposal is to allow to give a name\alias for anomymous types within a method:

// it should be compilable
// *MyClass declares a new local class with an alias "MyClass" 
Func<int, *MyClass> getObj = i => new {x = i, y = i + 1};
Func<MyClass, int> multipleXandYFromObj = i => i * i;
var obj = getObj(1);
var obj2 = getObj(2);
var res = multipleXandYFromObj(obj);
var res2 = multipleXandYFromObj(obj2);

@MkazemAkhgary

what happens if you declare Func as a field? it would not make sense.

Of course it would not make sense because outside of methods there are no anomymous classes. Func< var > would make a big sense if var should supposed to be an anonymous class.

[MkazemAkhgary]

in c#7 you can write local functions. but you cant return anonymous type. I suggest you to use tuple instead.

your syntax

Func<int, var> getObj = i => new {x = i, y = i + 1};

becomes

(int x, int y) getObj(int i) => (i, i+1);

currently its not possible to use var return for local functions, but i think it would be nice to have.