asignaciÓn y comprobaciÓn dinÁmica de tipos

8/10/2019 ASIGNACIN Y COMPROBACIN DINMICA DE TIPOS

1/17

ASIGNACIO N YCOMPROBACIO N

DINA MICA DE TIPOS

El anlisis de tipos tiene por objetivo asegurar que el uso de losobjetos definidos es correcto: esto es, que su uso se atiene a la

semntica de su definicin

[Escriba el subttulodel documento]


2/17

Contenido

Introduccin ........................................................................................................................................ 2

Anlisis de Tipos: Conceptos Bsicos .................................................................................................. 3

Expresiones de Tipo, Sistemas de Tipos y Comprobadores de Tipos .............................................. 3Definicin 6.1.1 ........................................................................................................................... 3

Definicin 6.1.2 ........................................................................................................................... 3

Comprobacin de tipos ................................................................................................................... 3

Definicin 6.1.3 ........................................................................................................................... 3

Tipado Esttico y Tipado Dinmico ................................................................................................. 5

Definicin 6.1.4 ........................................................................................................................... 5

Definicin 6.1.5 ........................................................................................................................... 6

Tipado Fuerte y Tipado Dbil .......................................................................................................... 7

Definicin 6.1.6 ........................................................................................................................... 7

Tipado Fuerte (strong typing) ......................................................................................................... 7

Sobrecarga, Polimorfismo e Inferencia de Tipos ............................................................................ 8

Definicin 6.1.7 ........................................................................................................................... 8

Definicin 6.1.8 ........................................................................................................................... 9

Definicin 6.1.9 ........................................................................................................................... 9

Definicin 6.1.10 ......................................................................................................................... 9Equivalencia de Expresiones de Tipo ............................................................................................ 10

Definicin 6.1.11 ....................................................................................................................... 10

Compatibilidad de tipos ................................................................................................................ 11

Mtodos: ................................................................................................................................... 11

Duck Typing ................................................................................................................................... 13

Definicin 6.1.12 ....................................................................................................................... 13

Subtipos y tipos derivados ............................................................................................................ 15

Subtipo ...................................................................................................................................... 15

Bibliografa ........................................................................................................................................ 16


3/17

IntroduccinLos lenguajes de programacin con comprobacin esttica de tipos poseen beneficiosincuestionables

Deteccin temprana de errores

Mayores oportunidades para realizar optimizaciones Entornos de desarrollo Documentacin

No obstante, los lenguajes con comprobacin dinmica de tipos son utilizados comnmente endiversos escenarios del desarrollo del software (p. ej. ingeniera web o el desarrollo rpido de

prototipos) dado que ofrecen

Simplicidad Alto nivel de flexibilidad Metaprogramacin Generacin dinmica de cdigo

Dado que ambos enfoques ofrecen diferentes beneficios, han surgido lenguajes de programacincon comprobacin hbrida (esttica y dinmica) de tipos o Algunos lenguajes con comprobacinesttica de tipos tambin han incorporado la posibilidad de incluir tipos dinmicos en su sistema

de tipos

TIOBE Programming Community Index (Agosto 2013)


4/17

Anlisis de Tipos: Conceptos Bsicos

En la mayora de los lenguajes los objetos manipulados son declarados en alguna parte del programa y usados en otras. Ya dijimos que el anlisis de mbito es el clculo de la funcinque asigna a un uso de un objeto la definicin que se le aplica.

El anlisis de tipos tiene por objetivo asegurar que el uso de los objetos definidos escorrecto: esto es, que su uso se atiene a la semntica de su definicin; por ejemplo, que unarray de enteros no es llamado como funcin o que no se intenta incrementar una funcin oque el valor retornado por una funcin es de la naturaleza descrita en su definicin.

Expresiones de Tipo, Sistemas de Tipos y Comprobadores de Tipos

Definicin 6.1.1 Una forma adecuada de representar los tipos dentro de un compilador esusando un lenguaje de expresiones de tipo . Un lenguaje de las expresiones de tipo debe

describir de manera clara y sencilla los tipos del lenguaje fuente. No confunda estelenguaje con el sub-lenguaje del lenguaje fuente que consiste en las declaraciones odefiniciones. No tienen por que ser iguales. El compilador traduce las declaraciones detipo en expresiones de tipo. El lenguaje de las expresiones de tipo es la representacininterna que el compilador tiene de estas declaraciones y depende del compilador. Ellenguaje de las declaraciones no.

Definicin 6.1.2 Un sistema de tipos de un lenguaje/compilador es el conjunto de reglasdel lenguaje (que es traducido e interpretado por el compilador que permiten asignarexpresiones de tipo a las instancias de uso de los objetos del programa.

Si bien el sistema de tipos es una propiedad del lenguaje, no es raro que los compiladoresintroduzcan modificaciones en el sistema de tipos del lenguaje. Por ejemplo en Pascal eltipo de un array incluye los ndices del array 6.1 ). Esto y las reglas de equivalencia de tiposde Pascal limitan gravemente la genericidad de las funciones en Pascal. Por eso algunoscompiladores Pascal permiten en una llamada a funcin la compatibilidad de tipos entrearrays de diferente tamao y diferentes conjuntos de ndices. Desgraciadamente la forma enla que lo hacen puede diferir de compilador a compilador.

Comprobacin de tiposDefinicin 6.1.3 Un comprobador de tipos verifica que el uso de los objetos en losconstructos de uso se atiene a lo especificado en sus declaraciones o definiciones deacuerdo a las reglas especificadas por el sistema de tipos .

Generalizacin de los conceptos de operandos y operadores para incluir a subprogramas ysentencia de asignacin:

Subprogramas operadores cuyos operandos son sus parmetros Asignacin operador binario cuyos operandos son la variable a la que se asigna

el valor y la expresin a evaluar


5/17

Comprobacin de tipos : actividad que nos asegura que los operandos de un operador sonde tipos compatibles

Tipos compatibles : un tipo legal para el operador o un tipo que atendiendo a determinadasreglas del lenguaje puede ser convertido implcitamente mediante cdigo generado por el

compilador en un tipo legal. Esta conversin automtica se denomina coaccin (coercion)

Error de tipos : aplicacin de un operador a un operando de tipo inapropiado

Si todas las ligaduras de tipos a variables son estticas las comprobaciones de tipo pueden realizarse de forma esttica

Si hay ligadura dinmica de tipos a variables debe realizarse una comprobacin dinmicade tipos (ms costosa que en tiempo de compilacin)

LP (Pascal, Ada, C) que permiten el almacenamiento en la misma celda de memoria de

valores de tipos diferentes en momentos distintos de la ejecucin (registros variantes yuniones) la comprobacin de tipos para estas clases de datos debe ser dinmica requiere mantener durante la ejecucin el tipo actual asociado a la celda de memoria notodos los errores pueden detectarse con una comprobacin esttica de tipos


6/17

Tipado Esttico y Tipado DinmicoDefinicin 6.1.4 Un lenguaje de programacin tiene tipado esttico si su comprobacin detipos ocurre en tiempo de compilacin sin tener que comprobar equivalencias en tiempo deejecucin.

La comprobacin esttica de tipos trata de asegurar que los programas no produzcan erroresdurante su ejecucinSin embargo, algunos programas no pueden ser compilados a pesar de tener uncomportamiento correcto durante la ejecucin. Estos lenguajes siguen un enfoquepesimista

public class Test {public static void Main() {

object [] v = new object [10];int suma = 0;for ( int i = 0; i < 10; i++) {

v[i] = i+1;suma += v[i]; // Error C.

}}

}

// Error C.


object o;Console .Write(o.ToString());// Error de ejecucin}

}}

// Error de ejecucin


7/17

Un lenguaje de programacin tiene tipado dinmico si el lenguaje realiza comprobacionesde tipo en tiempo de ejecucin. En un sistema de tipos dinmico los tipos suelen estrasociados con los valores no con las variables .

Definicin 6.1.5 El tipado dinmico hace ms sencilla la escritura de metaprogramas : programas que reciben como datos otros cdigos y los manipulan para producir nuevoscdigos. Parse::Eyapp y Parse::Treeregexp son ejemplos de metaprogramacin. Cada vezque escribimos un procesador de patrones, templates o esqueletos de programacinestamos haciendo meta-programacin.

La comprobacin dinmica de tipos realiza todas las comprobaciones de tipo durante laejecucin. Estos lenguajes son demasiado optimistas, dado que compilan programas que

podran ser detectados como errneos durante la compilacin


dynamic myObject = "StaDyn" ;

System. Console .Write(myObject*2);// Sin errores de compilacin }

}

// Sin errores

El lenguaje en el que se escribe el metaprograma se denomina metalenguaje . El lenguaje alque se traduce el metaprograma se denomina lenguaje objeto . La capacidad de un lenguajede programacin para ser su propio metalenguaje se denomina reflexividad . Para que hayareflexin es conveniente que el cdigo sea un tipo de estructura de datos soportado por ellenguaje al mismo nivel que otros tipos bsicos y que sea posible traducir dinmicamentetexto a cdigo.


8/17

Tipado Fuerte y Tipado DbilDefinicin 6.1.6 Aunque el significado de los trminos Fuertemente Tipado y su contrario

Dbilmente Tipado varan con los autores, parece haber consenso en que los lenguajes contipado fuerte suelen reunir alguna de estas caractersticas:

La comprobacin en tiempo de compilacin de las violaciones de las restriccionesimpuestas por el sistema de tipos. El compilador asegura que para cualesquieraoperaciones los operandos tienen los tipos vlidos.

Toda operacin sobre tipos invlidos es rechazada bien en tiempo de compilacin ode ejecucin.

Algunos autores consideran que el trmino implica desactivar cualquier conversinde tipos implcita. Si el programador quiere una conversin deber explicitarla.

La ausencia de modos de evadir al sistema de tipos. Que el tipo de un objeto de datos no vare durante la vida del objeto. Por ejemplo,

una instancia de una clase no puede ver su clase alterada durante la ejecucin.

Tipado Fuerte (strong typing)Un lenguaje tiene Tipado Fuerte si los errores de tipos se detectan siempre es necesario

determinar los tipos de todos los operandos, ya sea en tiempo de compilacin o deejecucin

Pascal Cercano a tener Tipado Fuerte pero no realiza comprobacin de tipos en los

registros variantes (incluso puede omitirse la etiqueta discriminatoria en dichosregistros)

Ada Resuelve el problema de los registros variantes realizando comprobacin dinmica

de tipos (slo en este caso) Tiene una funcin de biblioteca que permite extraer un valor de una variable de

cualquier tipo (como una cadena de bits) y usarlo como un tipo diferente (no es unaconversin de tipos) se trata de una suspensin temporal de la comprobacin detipos

C No tiene Tipado Fuerte por:

No se realiza comprobacin de tipos sobre las uniones Permite funciones con parmetros sobre los que no se realiza comprobacin

de tipos Java

Tiene Tipado Fuerte (no hay uniones)ML y Haskell

Poseen Tipado Fuerte Los tipos de los parmetros de las funciones (y de estas mismas) se conocen en

tiempo de compilacin (ya sea por declaracin del usuario o por inferencia de tipos)


9/17

Sobrecarga, Polimorfismo e Inferencia de TiposUn smbolo se dice sobrecargado si su significado vara dependiendo del contexto. En lamayora de los lenguajes los operadores aritmticos suelen estar sobrecargados, dado que sesustancian en diferentes algoritmos segn sus operando sean enteros, flotantes, etc.

En algunos lenguajes se permite la sobrecarga de funciones. as es posible tener dosfunciones llamadas min :

A la hora de evaluar el tipo de las expresiones es el contexto de la llamada el que determinael tipo de la expresin:

float x,y;int a,b;string c,d;u = min(x,y); /* Puede que correcto: x e y seran truncados aenteros. Tipo entero */v = min(a,b); /* Correcto: Tipo devuelto es entero */w = min(c,d); /* Correcto: Tipo devuelto es string */t = min(x,c); /* Error */

Definicin 6.1.7 La inferencia de tipos hace referencia a aquellos algoritmos que deducenautomticamente en tiempo de compilacin - sin informacin adicional del programador, obien con anotaciones parciales del programador - el tipo asociado con un uso de un objetodel programa. Un buen nmero de lenguajes de programacin funcional permitenimplantar inferencia de tipos (Haskell, OCaml, ML, etc).

Vase como ejemplo de inferencia de tipos la siguiente sesin en OCaml :

pl@nereida:~/src/perl/attributegrammar/Language-AttributeGrammar-.08/examples$ ocamlObjective Caml version 3.09.2# let minimo = fun i j -> if i 'a =

# minimo 2 3;;- : int = 2# minimo 4.9 5.3;;- : float = 4.9# minimo "hola" "mundo";;- : string = "hola"

El compilador OCaml infiere el tipo de las expresiones. As el tipo asociado con la funcinminimo es 'a -> 'a -> 'a que es una expresin de tipo que contiene variables de tipo . El


10/17

operador -> es asociativo a derechas y asi la expresin debe ser leda como 'a -> ('a ->'a) . Bsicamente dice: es una funcin que toma un argumento de tipo 'a (donde 'a es unavariable tipo que ser instanciada en el momento del uso de la funcin) y devuelve unafuncin que toma elementos de tipo 'a y retorna elementos de tipo 'a .

Definicin 6.1.8 Aunque podra pensarse que una descripcin ms adecuada del tipo de la funcin minimo fuera 'a x 'a -> 'a , lo cierto es que en algunos lenguajes funcionales esusual que todas las funciones sean consideradas como funciones de una sla variable. La

funcin de dos variables 'a x 'a -> 'a puede verse como una funcin 'a -> ('a -> 'a) .

En efecto la funcin minimo cuando recibe un argumento retorna una funcin:

# let min_mundo = minimo "mundo";;val min_mundo : string -> string = # min_mundo "pedro";;- : string = "mundo"# min_mundo "antonio";;- : string = "antonio"# min_mundo 4;;This expression has type int but is here used with type string# min_mundo(string_of_int(4));;- : string = "4"

Esta estrategia de reducir funciones de varias variables a funciones de una variable queretornan funciones de una variable se conoce con el nombre de currying o aplicacin

parcial .

Definicin 6.1.9 El polimorfismo es una propiedad de ciertos lenguajes que permite unainterfaz uniforme a diferentes tipos de datos.

Se conoce como funcin polimorfa a una funcin que puede ser aplicada o evaluada sobrediferentes tipos de datos.

Un tipo de datos se dice polimorfo si es un tipo de datos generalizado o no completamenteespecificado. Por ejemplo, una lista cuyos elementos son de cualquier tipo.

Definicin 6.1.10 Se llama Polimorfismo Ad-hoc a aquel en el que el nmero decombinaciones que pueden usarse es finito y las combinaciones deben ser definidas antesde su uso. Se habla de polimorfismo paramtrico si es posible escribir el cdigo sinmencin especfica de los tipos, de manera que el cdigo puede ser usado con un nmeroarbitrario de tipos.

Por ejemplo, la herencia y la sobrecarga de funciones y mtodos son mecanismos que proveen polimorfismo adhoc.

Los lenguajes funcionales, como OCaml suelen proveer polimorfismo paramtrico. EnOOP el polimorfismo paramtrico suele denominarse programacin genrica.


11/17

Equivalencia de Expresiones de TipoLa introduccin de nombres para las expresiones de tipo introduce una ambiguedad en lainterpretacin de la equivalencia de tipos. Por ejemplo, dado el cdigo:

typedef int v10[10];

v10 a;int b[10];

Se considera que a y b tienen tipos compatibles?

Definicin 6.1.11 Se habla de equivalencia de tipos estructural cuando los nombres de tipo son sustituidos por sus definiciones y la equivalencia de las expresiones de tipo se traduceen la equivalencia de sus rboles sintcticos o DAGs. Si los nombres no son sustituidos sehabla de equivalencia por nombres o de equivalencia de tipos nominal .

Si utilizamos la opcin de sustituir los nombres por sus definiciones y permitimos en ladefinicin de tipo el uso de nombres de tipo no declarados se pueden producir ciclos en el

grafo de tipos.El lenguaje C impide la presencia de ciclos en el grafo de tipos usando dos reglas:

1. Todos los identificadores de tipo han de estar definidos antes de su uso, con laexcepcin de los punteros a registros no declarados

2. Se usa equivalencia estructural para todos los tipos con la excepcin de las struct para las cuales se usa equivalencia nominal

Por ejemplo, el siguiente programa:nereida:~/src/perl/testing> cat -n typeequiv.c#include typedef struct {

int x, y;struct record *next;} record;record z,w;struct recordcopy {

int x, y;struct recordcopy *next;

} r,k;main() {

k = r; /* no produce error */z = w; /* no produce error */r = z;

}

Produce el siguiente mensaje de error:nereida:~/src/perl/testing> gcc -fsyntax-only typeequiv.ctypeequiv.c: En la funcin 'main':typeequiv.c:19: error: tipos incompatibles en la asignacin


12/17

Compatibilidad de tiposMtodos:

Compatibilidad de tipos nominal : dos variables tienen tipos compatibles si estn ligadas almismo nombre de tipoEj:

typeT = array [1..10] of integer;

vara, b: T;

begina := b;

Fcil de implementar pero muy restrictiva.Ej. Usando un lenguaje con interpretacin estricta de la compatibilidad de tipos nominal:

typetipo_indice = 1..100;

varcontador: integer;indice: tipo_indice;

begincontador := indice;indice := contador;

Compatibilidad de tipos estructural : dos variables tienen tipos compatibles si sus tipostienen la misma estructuraEj:

typeT = array [1..10] of integer;S = array [1..10] of integer;

vara: S;b: T;

begina := b;

Debe compararse la estructura de ambos tipos, pero: Son compatibles dos registros con la misma estructura pero con nombres de

campos diferentes? Son compatibles arrays del mismo tipo y con el mismo nmero de elementos pero

con rangos de ndices diferentes (0..9 / 1..10)? Son compatibles tipos enumerados con el mismo nmero de componentes pero

literales diferentes?


13/17


14/17

Duck Typing En lenguajes dinmicos una forma habitual de equivalencia de tipos es el tipado pato:

Definicin 6.1.12 Se denomina duck typing o tipado pato a una forma de tipado dinmicoen la que el conjunto de mtodos y propiedades del objeto determinan la validez de su uso.

Esto es: dos objetos pertenecen al mismo tipo-pato si implementan/soportan la mismainterfaz independientemente de si tienen o no una relacin en la jerarqua de herencia.

El nombre del concepto se refiere a la prueba del pato, una humorada de razonamientoinductivo atribuida a James Whitcomb Riley (ver Historia ms abajo), que pudo ser comosigue:

If it waddles like a duck, and quacks like a duck, it's a duck! . "Cuando veo un ave quecamina como un pato, nada como un pato y suena como un pato, a esa ave yo la llamo un

pato ."

En los lenguajes de programacin orientados a objetos, se conoce como duck typing el

estilo de tipificacin dinmica de datos en que el conjunto actual de mtodos y propiedadesdetermina la validez semntica, en vez de que lo hagan la herencia de una clase en

particular o la implementacin de una interfaz especfica.

En duck typing, el programador solo se ocupa de los aspectos del objeto que van a usarse, yno del tipo de objeto que se trata. Por ejemplo en un lenguaje sin duck-typing uno puedecrear una funcin que toma un objeto de tipo Pato y llama los mtodos "caminar" y"parpar" de ese objeto. En un lenguaje con duck-typing, la funcin equivalente tomara unobjeto de cualquier tipo e invocara los mtodos caminar y parpar. Si el objeto tratado notiene los mtodos pedidos, la funcin enviar una seal de error en tiempo de ejecucin.

Este hecho de que la funcin acepte cualquier tipo de objeto que implemente correctamentelos mtodos solicitados es lo que evoca la cita precedente y da nombre a la forma detipificacin.

El Duck typing usualmente es acompaado por el hbito de no probar el tipo de losargumentos en los mtodos y funciones, y en vez de eso confiar en la buenadocumentacin, el cdigo claro y la prueba para asegurar el uso correcto. Los usuarios delenguajes con tipificado esttico al iniciarse con lenguajes de tipificado dinmico a menudose ven tentados a agregar chequeos de tipo estticos (previos a ejecucin), desaprovechandola flexibilidad y beneficios del duck typing y restringiendo el dinamismo del lenguaje.

Considera el siguiente pseudocdigo para un lenguaje con duck-typing:

funcin calcular(a, b, c) => devuelve (a+b)*cejemplo1 = calcular (1, 2, 3)ejemplo2 = calcular ([1, 2, 3], [4, 5, 6], 2)ejemplo3 = calcular ('manzanas ', 'y naranjas, ', 3)


15/17

mostrar a_cadena ejemplo1mostrar a_cadena ejemplo2mostrar a_cadena ejemplo3

En el ejemplo, cada vez que se llama la funcin calcular se pueden emplear objetos sin

relacin de herencia (nmeros, listas y cadenas). En tanto y en cuanto los objetos soportenlos mtodos "+" y "*" la operacin tendr xito. Si se traduce este algoritmo a Ruby oPython por ejemplo, el resultado de la ejecucin ser:

9[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]manzanas y naranjas, manzanas y naranjas, manzanas y naranjas,

As, el duck typing permite polimorfismo sin herencia. El nico requerimiento de lafuncin calcular para las variables es que soporten los mtodos "+" y "*".


16/17

Subtipos y tipos derivadosSubtipo : versin (posiblemente restringida en el rango) de un tipo existente con el que escompatible. Evita uno de los problemas de la compatibilidad de tipos nominal Ej. Ada:

subtype Natural is Integer range 0.. IntegerLast; subtype Temperatura is Integer range -20..45;n: Natural;i: Integer;t: Temperatura; Las siguientes asignaciones son posibles:

n := i;i := n;t := i;

Se necesita una comprobacin en tiempo de ejecucin que asegure que el valor

que se asigna est en el rango adecuado Para la funcin:

function "**" (i: Integer; n: Natural) return Integer;Y la llamada

j ** k;El compilador comprueba que j y k sean del tipo Integer (o de uno de sus subtipos).Durante la ejecucin se asegura que el valor actual de k est en el rango de Natural.Un lenguaje con compatibilidad de tipos nominal slo aceptara que j fuese del tipoInteger y n del tipo Natural.

Tipo derivado : nuevo tipo basado en algn otro previamente definido con el que esincompatible, aunque sean estructuralmente idnticos. Heredan todas las propiedades de sutipo padre. (Tambin pueden incluir restricciones sobre el rango)Ej. Ada:

type Longitud is new Float;type Tiempo is new Float; Las variables de estos tipos son incompatibles entre ellas y con otras de tipo float (esta regla no se aplica a los literales como 12.5)


17/17

Bibliografa

http://nereida.deioc.ull.es/~pl/perlexamples/node178.html http://icsdonald.files.wordpress.com/2012/02/ligadura-de-una-variable.pdf http://es.wikipedia.org/wiki/Duck_typing http://babel.ls.fi.upm.es/prole2013/miguel_garcia_rodriguez.pdf
http://nereida.deioc.ull.es/~pl/perlexamples/node178.htmlhttp://nereida.deioc.ull.es/~pl/perlexamples/node178.htmlhttp://icsdonald.files.wordpress.com/2012/02/ligadura-de-una-variable.pdfhttp://icsdonald.files.wordpress.com/2012/02/ligadura-de-una-variable.pdfhttp://es.wikipedia.org/wiki/Duck_typinghttp://es.wikipedia.org/wiki/Duck_typinghttp://babel.ls.fi.upm.es/prole2013/miguel_garcia_rodriguez.pdfhttp://babel.ls.fi.upm.es/prole2013/miguel_garcia_rodriguez.pdfhttp://babel.ls.fi.upm.es/prole2013/miguel_garcia_rodriguez.pdfhttp://es.wikipedia.org/wiki/Duck_typinghttp://icsdonald.files.wordpress.com/2012/02/ligadura-de-una-variable.pdfhttp://nereida.deioc.ull.es/~pl/perlexamples/node178.html

asignaciÓn y comprobaciÓn dinÁmica de tipos

Documents