Tipeo implícito; ¿por qué solo variables locales?

¿Alguien sabe o le interesa especular por qué la tipificación implícita se limita a las variables locales?

var thingy = new Foo(); 

Pero por qué no…

 var getFoo() { return new Foo(); } 

Eric Lippert hizo una publicación de blog completa sobre el tema.

En resumen, el principal problema es que habría requerido una gran re-architecture del comstackdor de C # para hacerlo. Las declaraciones se procesan actualmente de una sola vez. Esto requeriría pases múltiples debido a la capacidad de formar ciclos entre variables inferidas. VB.net tiene más o menos el mismo problema.

Jared tiene un enlace fantástico en su respuesta, a un tema fantástico.

Creo que no responde la pregunta explícitamente.

Por qué no?

 var getFoo() { return new Foo(); } 

La razón de esto es:

¿Y si?

 class Foo {} var GetFoo() { return GetBar(); } var GetBar() { return GetBaz(); } var GetBaz() { return new Foo(); } 

Se podría deducir que GetFoo va a devolver Foo , pero tendrá que rastrear a través de todas las llamadas que hace el método y hace que sus hijos solo infieran el tipo. Tal como está, el comstackdor de C # no está diseñado para funcionar de esta manera. Necesita métodos y tipos de campo al principio del proceso antes de que se pueda ejecutar el código que infiere los tipos.

En un nivel puramente estético, encuentro que las definiciones de los var sobre los métodos confunden las cosas. Es un lugar donde creo que ser explícito siempre ayuda, te protege de dispararte en el pie al devolver accidentalmente un tipo que hace que cambie tu firma y un montón de otras firmas de métodos dependientes. Lo peor es que podrías cambiar todas las firmas de una cadena de métodos sin siquiera saber que lo hiciste si devuelves el valor de un método que devuelve un objeto y resulta afortunado.

Creo que los métodos var son mejor dejarlos para lenguajes dynamics como Ruby

Porque es mucho más fácil de hacer. Si tuvieras que inferir todos los tipos, uno necesitaría algo así como el sistema de inferencia del tipo de Hindley Milner, que hará que tu amada C # se convierta en un lenguaje derivado de Haskel.

Básicamente, el problema con el que se está enfrentando es que C # (hasta ahora) es un lenguaje estáticamente tipado. Una variable local definida como var todavía está tipada estáticamente, pero oculta sintácticamente. Un método que devuelve var, por otro lado, tiene muchas implicaciones. Se convierte en una interfaz más para el uso y no se gana nada al usar var.

puedes usar en vs 2010 Dynamic

 Dynamic getFoo() { return new Foo(); } 

Creo que es porque el scope de ese tipo implícito es mucho más amplio y, por lo tanto, es más probable que cause problemas que dentro del scope de un único método.