Digitação forte e fraca

Da Wikipédia, a enciclopédia livre
Ir para a navegação Saltar para pesquisar

Na programação de computadores , uma das muitas maneiras pelas quais as linguagens de programação são classificadas coloquialmente é se o sistema de tipos da linguagem a torna fortemente tipada ou fracamente tipada ( frouxamente tipada ). No entanto, não há uma definição técnica precisa do que os termos significam e diferentes autores discordam sobre o significado implícito dos termos e as classificações relativas da "força" dos sistemas de tipos das linguagens de programação convencionais.

Geralmente, uma linguagem fortemente tipada tem regras de tipagem mais rígidas em tempo de compilação , o que implica que erros e exceções são mais prováveis ​​de ocorrer durante a compilação. A maioria dessas regras afeta a atribuição de variáveis, valores de retorno de função, argumentos de procedimento e chamada de função. Linguagens tipadas dinamicamente (onde a verificação de tipo acontece em tempo de execução ) também podem ser fortemente tipadas. Observe que em linguagens tipadas dinamicamente, os valores têm tipos, não variáveis.

Uma linguagem de tipagem fraca tem regras de digitação mais flexíveis e pode produzir resultados imprevisíveis ou até errôneos ou pode realizar conversão de tipo implícita em tempo de execução. [1] Defensores de linguagens dinamicamente tipadas (geralmente "fracamente tipadas") acham que tais preocupações são exageradas e acreditam que a tipagem estática realmente introduz um conjunto exponencialmente maior de problemas e ineficiências. [2] Um conceito diferente, mas relacionado, é a tipagem latente .

História

Em 1974, Liskov e S. Zilles definiram uma linguagem fortemente tipada como aquela em que "sempre que um objeto é passado de uma função chamadora para uma função chamada, seu tipo deve ser compatível com o tipo declarado na função chamada". [3] Em 1977, K. Jackson escreveu: "Em uma linguagem fortemente tipada, cada área de dados terá um tipo distinto e cada processo indicará seus requisitos de comunicação em termos desses tipos". [4]

Definições de "forte" ou "fraco"

Várias decisões de design de linguagem diferentes foram referidas como evidência de tipagem "forte" ou "fraca". Muitos deles são entendidos com mais precisão como a presença ou ausência de segurança de tipo, segurança de memória , verificação de tipo estática ou verificação de tipo dinâmica .

"Digitação forte" geralmente se refere ao uso de tipos de linguagem de programação para capturar invariantes do código e garantir sua correção e excluir definitivamente certas classes de erros de programação. Assim, existem muitas disciplinas de "tipagem forte" usadas para atingir esses objetivos.

Conversões de tipo implícitas e "tipo trocadilhos"

Algumas linguagens de programação facilitam o uso de um valor de um tipo como se fosse um valor de outro tipo. Isso às vezes é descrito como "digitação fraca".

Por exemplo, Aahz Maruch observa que "a coerção ocorre quando você tem uma linguagem estaticamente tipada e usa os recursos sintáticos da linguagem para forçar o uso de um tipo como se fosse um tipo diferente (considere o uso comum de void* em C ). A coerção geralmente é um sintoma de tipagem fraca. A conversão, por outro lado, cria um objeto totalmente novo do tipo apropriado." [5]

Como outro exemplo, o GCC descreve isso como troca de tipo e avisa que quebrará o alias estrito . Thiago Macieira discute vários problemas que podem surgir quando a troca de tipos faz com que o compilador faça otimizações inadequadas . [6]

Existem muitos exemplos de linguagens que permitem conversões de tipo implícitas , mas de maneira segura para o tipo. Por exemplo, tanto C++ quanto C# permitem que programas definam operadores para converter um valor de um tipo para outro com semântica bem definida. Quando um compilador C++ encontra essa conversão, ele trata a operação como uma chamada de função. Em contraste, converter um valor para o tipo C void* é uma operação insegura que é invisível para o compilador.

Ponteiros

Algumas linguagens de programação expõem ponteiros como se fossem valores numéricos e permitem que os usuários realizem operações aritméticas neles. Essas linguagens são às vezes chamadas de "tipadas fracamente", uma vez que a aritmética de ponteiros pode ser usada para contornar o sistema de tipos da linguagem.

Sindicatos não marcados

Algumas linguagens de programação suportam uniões não marcadas , que permitem que um valor de um tipo seja visto como se fosse um valor de outro tipo.

Verificação de tipo estático

No artigo Typeful Programming de Luca Cardelli , [7] um "sistema de tipo forte" é descrito como aquele em que não há possibilidade de um erro de tipo de tempo de execução não verificado. Em outras palavras, a ausência de erros de tempo de execução não verificados é chamada de segurança ou segurança de tipo ; Os primeiros documentos de Tony Hoare chamam isso de segurança patrimonial . [8]

Verificação dinâmica de tipo

Algumas linguagens de programação não possuem verificação de tipo estática. Em muitas dessas linguagens, é fácil escrever programas que seriam rejeitados pela maioria dos verificadores de tipo estáticos. Por exemplo, uma variável pode armazenar um número ou o valor booleano "false".

Variação entre linguagens de programação

Observe que algumas dessas definições são contraditórias, outras são meramente conceitualmente independentes e outras ainda são casos especiais (com restrições adicionais) de outras definições mais "liberais" (menos fortes). Devido à grande divergência entre essas definições, é possível defender afirmações sobre a maioria das linguagens de programação de que elas são fortemente ou fracamente tipadas. Por exemplo:

  • Java , Pascal , Ada e C requerem que todas as variáveis ​​tenham um tipo declarado e suportam o uso de conversões explícitas de valores aritméticos para outros tipos aritméticos. Java, C#, Ada e Pascal são às vezes considerados mais fortemente tipados do que C, uma afirmação que provavelmente é baseada no fato de que C suporta mais tipos de conversões implícitas, e C também permite que valores de ponteiro sejam explicitamente convertidos enquanto Java e Pascal não faça. O próprio Java pode ser considerado mais fortemente tipado do que o Pascal, pois os métodos de evasão do sistema de tipo estático em Java são controlados pela máquina virtual Javasistema de tipos. C# e VB.NET são semelhantes a Java nesse aspecto, embora permitam desabilitar a verificação de tipo dinâmico colocando explicitamente segmentos de código em um "contexto inseguro". O sistema de tipos do Pascal foi descrito como "muito forte", porque o tamanho de um array ou string faz parte de seu tipo, tornando algumas tarefas de programação muito difíceis. [9]
  • Smalltalk , Perl , Ruby , Python e Self são todos "fortemente tipados" no sentido de que erros de digitação são evitados em tempo de execução e fazem pouca conversão de tipo implícita , mas essas linguagens não fazem uso de verificação estática de tipo: o compilador não verifica ou impor regras de restrição de tipo. O termo tipagem de pato agora é usado para descrever o paradigma de tipagem dinâmica usado pelas linguagens deste grupo.
  • A família de linguagens Lisp são todas "fortemente tipadas" no sentido de que erros de digitação são evitados em tempo de execução. Alguns dialetos Lisp como Common Lisp ou Clojure suportam várias formas de declarações de tipo [10] e alguns compiladores ( CMUCL [11] e relacionados) usam essas declarações junto com inferência de tipo para permitir várias otimizações e também formas limitadas de verificações de tipo em tempo de compilação.
  • Standard ML , F# , OCaml , Haskell , Go e Rust são verificados estaticamente, mas o compilador infere automaticamente um tipo preciso para a maioria dos valores.
  • A linguagem assembly e Forth podem ser caracterizadas como não tipadas . Não há verificação de tipo; cabe ao programador garantir que os dados fornecidos às funções sejam do tipo apropriado. Qualquer conversão de tipo necessária é explícita.

Por esta razão, os escritores que desejam escrever sem ambiguidade sobre sistemas de tipos muitas vezes evitam o termo "tipagem forte" em favor de expressões específicas como " segurança de tipos ".

Veja também

Referências

  1. ^ "CS1130. Transição para programação OO. – Primavera de 2012 --versão de ritmo próprio" . Universidade de Cornell, Departamento de Ciência da Computação. 2005. Arquivado a partir do original em 2005 . Recuperado em 23/11/2015 .
  2. ^ "A eficácia irracional da digitação dinâmica para programas práticos" . Vimeo . 12 de setembro de 2013 . Recuperado em 21 de março de 2021 .{{cite web}}: CS1 maint: url-status ( link )
  3. ^ Liskov, B; Zilles, S (1974). "Programação com tipos de dados abstratos". Avisos ACM SIGPLAN . 9 (4): 50–59. CiteSeerX 10.1.1.136.3043 . doi : 10.1145/942572.807045 . 
  4. ^ Jackson, K. (1977). Processamento paralelo e construção modular de software . Desenho e Implementação de Linguagens de Programação . Notas de aula em Ciência da Computação. Vol. 54. pp. 436–443. doi : 10.1007/BFb0021435 . ISBN 3-540-08360-X.
  5. ^ Aah. "Digitação: Forte vs. Fraco, Estático vs. Dinâmico" . Recuperado em 16 de agosto de 2015 .
  6. ^ "Type-punning e strict-aliasing - Qt Blog" . Qt Blog . Recuperado em 18 de fevereiro de 2020 .
  7. ^ Luca Cardelli, "programação tipificada"
  8. ^ Hoare, CAR 1974. Dicas no projeto da linguagem de programação. Em Confiabilidade de Sistemas Computacionais , ed. C. Bunyan. Vol. 20 pp. 505-534.
  9. ^ InfoWorld . 25-04-1983 . Recuperado em 16 de agosto de 2015 .
  10. ^ "CLHS: Capítulo 4" . Recuperado em 16 de agosto de 2015 .
  11. ^ "Manual do usuário CMUCL: O compilador" . Arquivado a partir do original em 8 de março de 2016 . Recuperado em 16 de agosto de 2015 .