Los lenguajes de tipo dinámico que conozco nunca permiten que los desarrolladores especifiquen los tipos de variables, o al menos tienen un soporte muy limitado para eso.
JavaScript, por ejemplo, no proporciona ningún mecanismo para imponer tipos de variables cuando sea conveniente hacerlo. PHP permite especificar algunos tipos de argumentos del método, pero no hay manera de utilizar los tipos nativos ( int, string, etc.) para los argumentos, y no hay manera de hacer cumplir tipos para otra cosa que argumentos.
Al mismo tiempo, sería conveniente tener la opción de especificar en algunos casos el tipo de una variable en un lenguaje de tipo dinámico, en lugar de hacer la verificación de tipo manualmente.
¿Por qué hay tal limitación? ¿Es por razones técnicas / de rendimiento (supongo que es en el caso de JavaScript), o solo por razones políticas (que es, creo, el caso de PHP)? ¿Es este el caso de otros idiomas de tipo dinámico con los que no estoy familiarizado?
Editar: siguiendo las respuestas y los comentarios, aquí hay un ejemplo para una aclaración: digamos que tenemos el siguiente método en PHP simple:
public function CreateProduct($name, $description, $price, $quantity)
{
// Check the arguments.
if (!is_string($name)) throw new Exception('The name argument is expected to be a string.');
if (!is_string($description)) throw new Exception('The description argument is expected to be a string.');
if (!is_float($price) || is_double($price)) throw new Exception('The price argument is expected to be a float or a double.');
if (!is_int($quantity)) throw new Exception('The quantity argument is expected to be an integer.');
if (!$name) throw new Exception('The name argument cannot be an empty string.');
if ($price <= 0) throw new Exception('The price argument cannot be less or equal to zero.');
if ($price < 0) throw new Exception('The price argument cannot be less than zero.');
// We can finally begin to write the actual code.
// TODO: Implement the method here.
}Con algunos esfuerzos, esto puede reescribirse como (ver también Programación por contratos en PHP ):
public function CreateProduct($name, $description, $price, $quantity)
{
Component::CheckArguments(__FILE__, __LINE__, array(
'name' => array('value' => $name, 'type' => VTYPE_STRING),
'description' => array('value' => $description, 'type' => VTYPE_STRING),
'price' => array('value' => $price, 'type' => VTYPE_FLOAT_OR_DOUBLE),
'quantity' => array('value' => $quantity, 'type' => VTYPE_INT)
));
if (!$name) throw new Exception('The name argument cannot be an empty string.');
if ($price <= 0) throw new Exception('The price argument cannot be less or equal to zero.');
if ($price < 0) throw new Exception('The price argument cannot be less than zero.');
// We can finally begin to write the actual code.
// TODO: Implement the method here.
}Pero el mismo método se escribiría de la siguiente manera si PHP aceptara opcionalmente tipos nativos para argumentos:
public function CreateProduct(string $name, string $description, double $price, int $quantity)
{
// Check the arguments.
if (!$name) throw new Exception('The name argument cannot be an empty string.');
if ($price <= 0) throw new Exception('The price argument cannot be less or equal to zero.');
if ($price < 0) throw new Exception('The price argument cannot be less than zero.');
// We can finally begin to write the actual code.
// TODO: Implement the method here.
}¿Cuál es más corto de escribir? ¿Cuál es más fácil de leer?