¿C # admite inferencia de tipo del tipo de retorno?

Esto es solo una curiosidad acerca de si hay algo fundamental que detiene algo como esto (o me corrige si ya hay alguna manera):

public TTo Convert(TFrom from) { ... } 

Llamado así:

 SomeType someType = converter.Convert(someOtherType); 

    Porque ¿qué pasaría si hicieras esto?

     static void M(int x){} static void M(double x){} static T N() {} ... M(N()); 

    Ahora que es T? int o doble?

    Resulta muy fácil resolver el problema cuando se sabe a qué tipo de asignación se le asigna, pero la mayor parte del tiempo al que le asigna es lo que está tratando de averiguar en primer lugar .

    Razonar de adentro hacia afuera es bastante difícil. Razonar de afuera hacia adentro es mucho más difícil, y hacer ambas cosas al mismo tiempo es extremadamente difícil . Si es difícil para el comstackdor entender lo que está sucediendo, imagine lo difícil que es para el ser humano que intenta leer, entender y depurar el código cuando se pueden hacer inferencias tanto del tipo como del contexto de una expresión. Este tipo de inferencia hace que los progtwigs sean más difíciles de entender, no más fáciles , por lo que sería una mala idea agregarlos a C #.

    Ahora, dicho esto, C # soporta esta característica con expresiones lambda. Cuando nos enfrentamos a un problema de resolución de sobrecarga en el que la lambda se puede enlazar de dos, tres o un millón de maneras diferentes, lo vinculamos de dos, tres o un millón de maneras diferentes y luego evaluamos esos millones de enlaces posibles diferentes para determinar cuál es “el mejor”. Esto hace que la resolución de sobrecarga sea al menos NP-HARD en C #, y me tomó la mayor parte del año implementarla. Estábamos dispuestos a hacer esa inversión porque (1) los lambdas son impresionantes, y (2) la mayoría de las veces, las personas escriben progtwigs que pueden analizarse en un tiempo razonable y que los humanos pueden entenderlos. Así que valió la pena el costo. Pero en general, ese tipo de análisis avanzado no vale la pena.

    Las expresiones C # siempre * tienen un tipo fijo, independientemente de su entorno.

    Estás pidiendo una expresión cuyo tipo está determinado por lo que sea asignado a; Eso violaría este principio.

    *) excepto las expresiones lambda, los grupos de funciones y el literal null .

    A diferencia de Java, en la referencia de tipo C # no se basa en el tipo de retorno. Y no me preguntes por qué, Eric Lippert respondió a estas preguntas “por qué no puede C # …”:

    porque nadie diseñó, especificó, implementó, probó, documentó y envió esa característica