Deducción de tipo por contexto

La deducción de tipo de variable por contexto es una característica moderna de varios lenguajes de programación que permite a los compiladores o intérpretes inferir automáticamente el tipo de una variable basado en el contexto en el que se declara.

La elección entre lenguajes tipados y no tipados ha sido un tema de debate constante en el ámbito de la programación.

Una de las ventajas innegables de los lenguajes con tipado dinámico como JavaScript o Python es que la sintaxis es más concisa y sencilla, al evitar tener que especificar el tipo de las variables que creamos.

Sin embargo, a medida que los lenguajes de programación evolucionan, también han surgido mecanismos que buscan simplificar la verbosidad de los lenguajes tipados, sin sacrificar la seguridad y robustez que proporciona el tipado.

Así, lenguajes como C# y C++, se utiliza la palabra reservada var o auto, respectivamente, para indicarle al compilador que queremos que deduzca el tipo de la variable durante la compilación.

Ejemplos de deducción de tipo en distintos lenguajes

Veamos unos ejemplos de deducción de tipo por contexto en diferentes lenguajes de programación.

var numero = 42; // El compilador deduce que 'numero' es de tipo int
var texto = "Hola, mundo"; // El compilador deduce que 'texto' es de tipo string
var lista = new List<string> { "uno", "dos", "tres" }; // El compilador deduce que 'lista' es de tipo List<string>

auto numero = 42; // El compilador deduce que 'numero' es de tipo int
auto texto = std::string("Hola, mundo"); // El compilador deduce que 'texto' es de tipo std::string
auto lista = std::vector<std::string>{"uno", "dos", "tres"}; // El compilador deduce que 'lista' es de tipo std::vector<std::string>

let numero = 42; // El intérprete deduce que 'numero' es de tipo Number
let texto = "Hola, mundo"; // El intérprete deduce que 'texto' es de tipo String
let lista = ["uno", "dos", "tres"]; // El intérprete deduce que 'lista' es de tipo Array

numero = 42 # Python deduce que 'numero' es de tipo int
texto = "Hola, mundo" # Python deduce que 'texto' es de tipo str
lista = ["uno", "dos", "tres"] # Python deduce que 'lista' es de tipo list

Buenas prácticas Consejos

La deducción de tipo por contexto reduce el código repetitivo, y evita la redundancia de tener que el tipo explícitamente, cuando ya es evidente por la asignación.

Además, mejora la legibilidad del código. Por ejemplo, consideremos el siguiente caso en C#.

// es más sencillo de leer 
var lista = new List<string> { "uno", "dos", "tres" }; 

// que esto
List<string> lista = new List<string> { "uno", "dos", "tres" }; 

Por otro lado, también facilita el mantenimiento. Al no depender de una declaración explícita, los cambios en los tipos de datos propagados automáticamente si la asignación inicial cambia.

Por ejemplo, si tenemos una función que devuelve un tipo,

// método que devuelve un objeto de tipo miClase
miClase DoSomething()
{
	// ... contenido de la función	
}

// muchas línas más abajo, crear un objeto con el método
var miObjeto = DoSomething();

Si en algún momento alguien cambia DoSomething para que devuelva otra cosa (por ejemplo, ImiInterface, no es necesario cambiar var miObjeto = DoSomething();, los cambios se “propagan” automáticamente.

Sin embargo, también hay muchos detractores de la deducción de tipo por contexto. Sobre todo la gente que está muy acostumbrada a la programación con lenguajes fuertemente tipados tradicional.

Así, se suele aconsejar que no se emplee en situaciones donde el tipo no es obvio. Por ejemplo,

// aqui es obvio el tipo
var miLista = new List<string>();

// aqui no es obvio el tipo
List<string> miLista = miMetodo();

Al final la decisión es vuestra. Personalmente, recomiendo usar la deducción de tipo por contexto hasta en la sopa. Pero no es una verdad absoluta. Lo mejor es que hagáis vuestro propio criterio.