En la programació informàtica, una de les moltes maneres en què es classifiquen col·loquialment els llenguatges de programació és si el sistema de tipus del llenguatge el fa fortament tipat o feblement tipat (de manera poc definida). Tanmateix, no hi ha una definició tècnica precisa del que signifiquen els termes i diferents autors no es posen d'acord sobre el significat implícit dels termes i les classificacions relatives de la "força" dels sistemes de tipus dels llenguatges de programació convencionals. Per aquesta raó, els escriptors que volen escriure sense ambigüitats sobre sistemes de tipus sovint eviten els termes "tipificació forta" i "tipificació feble" en favor d'expressions específiques com ara "seguretat de tipus".

Generalment, un llenguatge fortament tipat té regles de tipatge més estrictes en temps de compilació, cosa que implica que és més probable que es produeixin errors durant la compilació. La majoria d'aquestes regles afecten l'assignació de variables, els valors de retorn de les funcions, els arguments de procediment i les crides de funcions. Els llenguatges amb tipatge dinàmic (on la comprovació de tipus es produeix en temps d'execució) també poden tenir un tipatge fort. En els llenguatges amb tipatge dinàmic, els valors, en lloc de les variables, tenen tipus.

Un llenguatge feblement tipat té regles de tipificació més flexibles i pot produir resultats imprevisibles o fins i tot erronis o pot realitzar una conversió de tipus implícita en temps d'execució. Un concepte diferent, però relacionat, és la tipificació latent.

Història El 1974, Barbara Liskov i Stephen Zilles van definir un llenguatge fortament tipat com aquell en què "sempre que un objecte es passa d'una funció que fa la crida a una funció que fa la crida, el seu tipus ha de ser compatible amb el tipus declarat a la funció que fa la crida". El 1977, K. Jackson va escriure: "En un llenguatge fortament tipat, cada àrea de dades tindrà un tipus diferent i cada procés establirà els seus requisits de comunicació en termes d'aquests tipus".

Definicions de "fort" o "feble" Diverses decisions de disseny de llenguatges s'han considerat com a prova de tipificació "forta" o "feble". Moltes d'aquestes s'entenen amb més precisió com la presència o absència de seguretat de tipus, seguretat de memòria, comprovació de tipus estàtica o comprovació de tipus dinàmica.

"Tipificació forta" generalment es refereix a l'ús de tipus de llenguatges de programació per capturar invariants del codi, garantir-ne la correcció i excloure definitivament certes classes d'errors de programació. Per tant, hi ha moltes disciplines de "tipificació forta" que s'utilitzen per aconseguir aquests objectius.

Conversions de tipus implícites i "jocs de paraules de tipus" Alguns llenguatges de programació faciliten l'ús d'un valor d'un tipus com si fos un valor d'un altre tipus. Això de vegades es descriu com a "tipificació feble".

Per exemple, Aahz Maruch observa que "la coacció es produeix quan es té un llenguatge tipificat estàticament i s'utilitzen les característiques sintàctiques del llenguatge per forçar l'ús d'un tipus com si fos un tipus diferent (considereu l'ús comú de void* en C). La coacció sol ser un símptoma de tipificació feble. La conversió, en canvi, crea un objecte completament nou del tipus apropiat."

Com a un altre exemple, GCC descriu això com a joc de paraules de tipus i adverteix que trencarà l'aliàsing estricte. Thiago Macieira parla de diversos problemes que poden sorgir quan el joc de paraules de tipus fa que el compilador faci optimitzacions inapropiades.

Hi ha molts exemples de llenguatges que permeten conversions de tipus implícites, però de manera segura pel que fa a tipus. Per exemple, tant C++ com C# permeten als programes definir operadors per convertir un valor d'un tipus a un altre amb una semàntica ben definida. Quan un compilador de C++ troba aquesta conversió, tracta l'operació com una crida de funció. En canvi, convertir un valor al tipus C és una operació no segura que és invisible per al compilador.

Punters Alguns llenguatges de programació exposen els punters com si fossin valors numèrics i permeten als usuaris fer-hi càlculs aritmètics. Aquests llenguatges de vegades s'anomenen "de tipus feble", ja que l'aritmètica de punters es pot utilitzar per evitar el sistema de tipus del llenguatge.

Variació entre llenguatges de programació Algunes d'aquestes definicions són contradictòries, d'altres són simplement conceptualment independents i d'altres són casos especials (amb restriccions addicionals) d'altres definicions més "liberals" (menys fortes). A causa de la gran divergència entre aquestes definicions, és possible defensar les afirmacions sobre la majoria dels llenguatges de programació que estan fortament o feblement tipats. Per exemple:

Java, Pascal, Ada i C requereixen que les variables tinguin un tipus declarat i admeten l'ús de conversions explícites de valors aritmètics a altres tipus aritmètics. De vegades es diu que Java, C#, Ada i Pascal tenen un tipatge més fort que C, perquè C admet més tipus de conversions implícites i permet que els valors dels punters es converteixin explícitament, mentre que Java i Pascal no ho fan. Java es pot considerar més fortament tipat que Pascal, ja que els mètodes per evadir el sistema de tipus estàtics a Java estan controlats pel sistema de tipus de la màquina virtual Java. C# i VB.NET són similars a Java en aquest sentit, tot i que permeten desactivar la comprovació dinàmica de tipus posant explícitament segments de codi en un "context no segur". El sistema de tipus de Pascal s'ha descrit com a "massa fort", perquè la mida d'una matriu o cadena forma part del seu tipus, cosa que dificulta algunes tasques de programació. Tanmateix, Delphi soluciona aquest problema. Smalltalk, Ruby, Python i Self tenen tots un "tipatge fort" en el sentit que s'eviten els errors de tipatge en temps d'execució i fan poca conversió implícita de tipus, però aquests llenguatges no fan ús de la comprovació de tipus estàtica: el compilador no comprova ni aplica les regles de restricció de tipus. El terme "duck typing" s'utilitza ara per descriure el paradigma de tipatge dinàmic utilitzat pels llenguatges d'aquest grup. La família de llenguatges Lisp està "fortament tipada" en el sentit que s'eviten els errors de tipificació en temps d'execució. Alguns dialectes de Lisp com Common Lisp o Clojure admeten diverses formes de declaracions de tipus i alguns compiladors (CMU Common Lisp (CMUCL) i relacionats) utilitzen aquestes declaracions juntament amb la inferència de tipus per permetre diverses optimitzacions i formes limitades de comprovacions de tipus en temps de compilació. Els llenguatges estàndard de ML, F#, OCaml, Haskell, Go i Rust tenen comprovació de tipus estàtica, però el compilador infereix automàticament un tipus precís per a la majoria de valors. El llenguatge assemblador i Forth es poden caracteritzar com a no tipificats. No hi ha comprovació de tipus; és responsabilitat del programador assegurar-se que les dades donades a les funcions siguin del tipus adequat.

Referències

Categoria:Programari