As linguagens de tipo dinâmico que eu conheço nunca deixam os desenvolvedores especificarem os tipos de variáveis ou, pelo menos, têm um suporte muito limitado para isso.
O JavaScript, por exemplo, não fornece nenhum mecanismo para impor tipos de variáveis quando for conveniente. PHP permitem especificar alguns tipos de argumentos de método, mas não há maneira de usar tipos nativos ( int, string, etc.) para os argumentos, e não há nenhuma maneira de impor tipos para outra coisa senão argumentos.
Ao mesmo tempo, seria conveniente ter a opção de especificar, em alguns casos, o tipo de uma variável em um idioma digitado dinamicamente, em vez de fazer a verificação do tipo manualmente.
Por que existe essa limitação? É por razões técnicas / de desempenho (suponho que seja no caso do JavaScript) ou apenas por razões políticas (que é, acredito, o caso do PHP)? Esse é o caso de outras linguagens de tipo dinâmico que eu não conheço?
Edit: seguindo as respostas e os comentários, aqui está um exemplo para um esclarecimento: digamos que temos o seguinte método no PHP simples:
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.
}Com alguns esforços, isso pode ser reescrito como (também consulte Programação por contratos em 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.
}Mas o mesmo método seria escrito da seguinte forma se o PHP opcionalmente aceitasse 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.
}Qual é o mais curto para escrever? Qual é mais fácil de ler?