Declaration of ref/out parameters in lambdas without typename

[ViIvanov]

Hello!

I have a little suggestion for C# language.
Let us have delegate like this:

delegate T Parse<T>(string text);

and we want to create an instance:

Parse<int> parse = text => Int32.Parse(text);

All is OK. What about ref/out parameters in a delegate?

delegate bool TryParse<T>(string text, out T result);

when we want to create an instance…

TryParse<int> parse1 = (string text, out int result) => Int32.TryParse(text, out result);

…we shoud to specify types on parameters.

Why is this required? What about a syntax below:

TryParse<int> parse2 = (text, out result) => Int32.TryParse(text, out result);

?

[mikedn]

In this particular case you don't need to write any of the parameter stuff, it's just:

TryParse<int> parse1 = Int32.TryParse;

[alanfo]

This would be a worthwhile improvement to type inference, in my view.

As ref and out are full keywords, they can't possibly be type names and so there appears no reason why the compiler won't be able to infer the type from the delegate signature.

[paulomorgado]

I'm not sure I understand what you are proposing.

Would you care to elaborate a bit more?

[ViIvanov]

@paulomorgado Of course! Let us see a code below:

delegate T Parse<T>(string text);
delegate bool TryParse<T>(string text, out T result);

static void Main() {
  // We can create an instance of Parse<int> like this:
  Parse<int> parseHex1 = (string text) => Int32.Parse(text, NumberStyles.HexNumber);
  // or like this (and, I think, this way is more simple and more readable):
  Parse<int> parseHex2 = text => Int32.Parse(text, NumberStyles.HexNumber);

  // To create an instance of TryParse<int> delegate
  // we must explicitly specify a types of arguments in a lambda expression:
  TryParse<int> tryParseHex1 = (string text, out int result) => Int32.TryParse(text, NumberStyles.HexNumber, null, out result);

  // And we can not now use a sintax like this:
  TryParse<int> tryParseHex2 = (text, out result) => Int32.TryParse(text, NumberStyles.HexNumber, null, out result);
}

Why this is meaningful:

1. In some scenarios user can have a delegates with a few (three, four, …etc) parameters and when at least one of them has a ref or out modifier user must explicitly specify types of all "delegate parameters".
2. Follows from previous - we can not use anonymous types as type-parameters in delegates with ref or out parameters.

[omariom]

👍

[paulomorgado]

I ink you are missing the fact that, although you can't declare by reference type parameters in C#, when a parameter is expressed as of being of type ref T (or out T, which is the same for the CLR - just extra validation from the compiler), the type is, actually, &T, which is not the same as T.

[ViIvanov]

@paulomorgado Excuse me, can you explain what do you mean? Why in you point of view

TryParse<int> tryParseHex1 = (string text, out int result) => Int32.TryParse(text, NumberStyles.HexNumber, null, out result);

is correct (it is valid C# code) and

TryParse<int> tryParseHex2 = (text, out result) => Int32.TryParse(text, NumberStyles.HexNumber, null, out result);

is not? In a both examples, types of arguments exactly the same. But, in the second line, it calculated by the compiler, not specified by user explicitly.

[paulomorgado]

I was trying to understand your issue, and I think I got it: the compiler should be able to infer the types from usage when there are out parameters. Is that it?

[ViIvanov]

@paulomorgado Exactly! I'm sorry for my bad and poor English.

[alrz]

👍

[Thaina]

+1

thanks

[asvishnyakov]

👍

[gafter]

Issue moved to dotnet/csharplang #338 via ZenHub