ASIGNACION Y
COMPROBACION
DINAMICA DE TIPOS
El anlisis de tipos tiene por objetivo asegurar que el uso de los
objetos definidos es correcto: esto es, que su uso se atiene a la
semntica de su definicin
[Escriba el subttulo
del documento]
Contenido
Introduccin ........................................................................................................................................ 2
Anlisis de Tipos: Conceptos Bsicos .................................................................................................. 3
Expresiones de Tipo, Sistemas de Tipos y Comprobadores de Tipos.............................................. 3
Definicin 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 ......................................................................................................................... 9
Equivalencia 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
Introduccin
Los lenguajes de programacin con comprobacin esttica de tipos poseen beneficios
incuestionables
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 en
diversos 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 programacin
con comprobacin hbrida (esttica y dinmica) de tipos o Algunos lenguajes con comprobacin
esttica de tipos tambin han incorporado la posibilidad de incluir tipos dinmicos en su sistema
de tipos
TIOBE Programming Community Index (Agosto 2013)
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 funcin
que 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 es
correcto: esto es, que su uso se atiene a la semntica de su definicin; por ejemplo, que un
array de enteros no es llamado como funcin o que no se intenta incrementar una funcin o
que 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 es
usando 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 este
lenguaje con el sub-lenguaje del lenguaje fuente que consiste en las declaraciones o
definiciones. No tienen por que ser iguales. El compilador traduce las declaraciones de
tipo en expresiones de tipo. El lenguaje de las expresiones de tipo es la representacin
interna que el compilador tiene de estas declaraciones y depende del compilador. El
lenguaje de las declaraciones no.
Definicin 6.1.2 Un sistema de tipos de un lenguaje/compilador es el conjunto de reglas
del lenguaje (que es traducido e interpretado por el compilador que permiten asignar
expresiones 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 compiladores
introduzcan modificaciones en el sistema de tipos del lenguaje. Por ejemplo en Pascal el
tipo de un array incluye los ndices del array6.1). Esto y las reglas de equivalencia de tipos
de Pascal limitan gravemente la genericidad de las funciones en Pascal. Por eso algunos
compiladores Pascal permiten en una llamada a funcin la compatibilidad de tipos entre
arrays de diferente tamao y diferentes conjuntos de ndices. Desgraciadamente la forma en
la que lo hacen puede diferir de compilador a compilador.
Comprobacin de tipos
Definicin 6.1.3 Un comprobador de tipos verifica que el uso de los objetos en los
constructos de uso se atiene a lo especificado en sus declaraciones o definiciones de
acuerdo a las reglas especificadas por el sistema de tipos.
Generalizacin de los conceptos de operandos y operadores para incluir a subprogramas y
sentencia 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
Comprobacin de tipos: actividad que nos asegura que los operandos de un operador son
de tipos compatibles
Tipos compatibles: un tipo legal para el operador o un tipo que atendiendo a determinadas
reglas 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 dinmica
de 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 y
uniones) 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 no
todos los errores pueden detectarse con una comprobacin esttica de tipos
Tipado Esttico y Tipado Dinmico
Definicin 6.1.4 Un lenguaje de programacin tiene tipado esttico si su comprobacin de
tipos ocurre en tiempo de compilacin sin tener que comprobar equivalencias en tiempo de
ejecucin.
La comprobacin esttica de tipos trata de asegurar que los programas no produzcan errores
durante su ejecucin
Sin embargo, algunos programas no pueden ser compilados a pesar de tener un
comportamiento correcto durante la ejecucin. Estos lenguajes siguen un enfoque
pesimista
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.
public class Test {
public static void Main() {
object o;
Console.Write(o.ToString());
// Error de ejecucin
}
}
}
// Error de ejecucin
Un lenguaje de programacin tiene tipado dinmico si el lenguaje realiza comprobaciones
de tipo en tiempo de ejecucin. En un sistema de tipos dinmico los tipos suelen estr
asociados 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 nuevos
cdigos. Parse::Eyapp y Parse::Treeregexp son ejemplos de metaprogramacin. Cada vez
que escribimos un procesador de patrones, templates o esqueletos de programacin
estamos haciendo meta-programacin.
La comprobacin dinmica de tipos realiza todas las comprobaciones de tipo durante la
ejecucin. Estos lenguajes son demasiado optimistas, dado que compilan programas que
podran ser detectados como errneos durante la compilacin
public class Test {
public static void Main() {
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 al
que se traduce el metaprograma se denomina lenguaje objeto. La capacidad de un lenguaje
de programacin para ser su propio metalenguaje se denomina reflexividad. Para que haya
reflexin es conveniente que el cdigo sea un tipo de estructura de datos soportado por el
lenguaje al mismo nivel que otros tipos bsicos y que sea posible traducir dinmicamente
texto a cdigo.
Tipado Fuerte y Tipado Dbil
Definicin 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 con
tipado fuerte suelen reunir alguna de estas caractersticas:
La comprobacin en tiempo de compilacin de las violaciones de las restricciones
impuestas por el sistema de tipos. El compilador asegura que para cualesquiera
operaciones los operandos tienen los tipos vlidos.
Toda operacin sobre tipos invlidos es rechazada bien en tiempo de compilacin o
de ejecucin.
Algunos autores consideran que el trmino implica desactivar cualquier conversin
de 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 de
ejecucin
Pascal
Cercano a tener Tipado Fuerte pero no realiza comprobacin de tipos en los
registros variantes (incluso puede omitirse la etiqueta discriminatoria en dichos
registros)
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 una
conversin de tipos) se trata de una suspensin temporal de la comprobacin de
tipos
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)
Sobrecarga, Polimorfismo e Inferencia de Tipos
Un smbolo se dice sobrecargado si su significado vara dependiendo del contexto. En la
mayora de los lenguajes los operadores aritmticos suelen estar sobrecargados, dado que se
sustancian en diferentes algoritmos segn sus operando sean enteros, flotantes, etc.
En algunos lenguajes se permite la sobrecarga de funciones. as es posible tener dos
funciones llamadas min:
A la hora de evaluar el tipo de las expresiones es el contexto de la llamada el que determina
el 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 a
enteros. 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 deducen
automticamente en tiempo de compilacin - sin informacin adicional del programador, o
bien con anotaciones parciales del programador - el tipo asociado con un uso de un objeto
del programa. Un buen nmero de lenguajes de programacin funcional permiten
implantar inferencia de tipos (Haskell, OCaml, ML, etc).
Vase como ejemplo de inferencia de tipos la siguiente sesin en OCaml:
pl@nereida:~/src/perl/attributegrammar/LanguageAttributeGrammar-.08/examples$ ocaml
Objective Caml version 3.09.2
# let minimo = fun i j -> if i<j then i else j;;
val minimo : 'a -> 'a -> 'a = <fun>
# 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 funcin
minimo es 'a -> 'a -> 'a que es una expresin de tipo que contiene variables de tipo. El
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 una
variable tipo que ser instanciada en el momento del uso de la funcin) y devuelve una
funcin 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 es
usual 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 = <fun>
# 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 que
retornan 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 una
interfaz uniforme a diferentes tipos de datos.
Se conoce como funcin polimorfa a una funcin que puede ser aplicada o evaluada sobre
diferentes tipos de datos.
Un tipo de datos se dice polimorfo si es un tipo de datos generalizado o no completamente
especificado. 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 de
combinaciones que pueden usarse es finito y las combinaciones deben ser definidas antes
de su uso. Se habla de polimorfismo paramtrico si es posible escribir el cdigo sin
mencin especfica de los tipos, de manera que el cdigo puede ser usado con un nmero
arbitrario 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. En
OOP el polimorfismo paramtrico suele denominarse programacin genrica.
Equivalencia de Expresiones de Tipo
La introduccin de nombres para las expresiones de tipo introduce una ambiguedad en la
interpretacin 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 traduce
en la equivalencia de sus rboles sintcticos o DAGs. Si los nombres no son sustituidos se
habla de equivalencia por nombres o de equivalencia de tipos nominal.
Si utilizamos la opcin de sustituir los nombres por sus definiciones y permitimos en la
definicin 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 la
excepcin 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 <stdio.h>
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.c
typeequiv.c: En la funcin 'main':
typeequiv.c:19: error: tipos incompatibles en la asignacin
Compatibilidad de tipos
Mtodos:
Compatibilidad de tipos nominal: dos variables tienen tipos compatibles si estn ligadas al
mismo nombre de tipo
Ej:
type
T = array [1..10] of integer;
var
a, b: T;
begin
a := b;
Fcil de implementar pero muy restrictiva.
Ej. Usando un lenguaje con interpretacin estricta de la compatibilidad de tipos nominal:
type
tipo_indice = 1..100;
var
contador: integer;
indice: tipo_indice;
begin
contador := indice;
indice := contador;
Compatibilidad de tipos estructural: dos variables tienen tipos compatibles si sus tipos
tienen la misma estructura
Ej:
type
T = array [1..10] of integer;
S = array [1..10] of integer;
var
a: S;
b: T;
begin
a := 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?
No acepta diferencias entre tipos con la misma estructura
Ej:
type
longitud = real;
tiempo = real;
var
l: longitud;
t: tiempo;
l y t son compatibles (tienen la misma estructura), aunque quizs no deberan
considerarse equivalentes: son abstracciones de diferentes categoras de valores del
problema.
Equivalencia de declaracin: dos variables tienen tipos compatibles si uno de los tipos est
definido con el nombre del otro
Ej:
type
T = array [1..10] of integer;
S = T;
var
a: S;
b: T;
begin
a := b;
La mayora de LP utilizan combinaciones de estos tres mtodos de compatibilidad
Tipo annimo: tipo asociado directamente con una variable mediante una declaracin sin
proporcionarle un nombre
Ej. en Ada:
a, b: array (1..10) of INTEGER;
c: array (1..10) of INTEGER;
La interpretacin es obvia usando compatibilidad de tipos estructural
Compatibilidad nominal? Ej. Ada a, b y c son incompatibles
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 dinmico
en 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 misma
interfaz 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 razonamiento
inductivo atribuida a James Whitcomb Riley (ver Historia ms abajo), que pudo ser como
sigue:
If it waddles like a duck, and quacks like a duck, it's a duck!. "Cuando veo un ave que
camina 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 propiedades
determina 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, y
no del tipo de objeto que se trata. Por ejemplo en un lenguaje sin duck-typing uno puede
crear 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 un
objeto de cualquier tipo e invocara los mtodos caminar y parpar. Si el objeto tratado no
tiene 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 correctamente
los mtodos solicitados es lo que evoca la cita precedente y da nombre a la forma de
tipificacin.
El Duck typing usualmente es acompaado por el hbito de no probar el tipo de los
argumentos en los mtodos y funciones, y en vez de eso confiar en la buena
documentacin, el cdigo claro y la prueba para asegurar el uso correcto. Los usuarios de
lenguajes con tipificado esttico al iniciarse con lenguajes de tipificado dinmico a menudo
se ven tentados a agregar chequeos de tipo estticos (previos a ejecucin), desaprovechando
la 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,
ejemplo1 = calcular
ejemplo2 = calcular
ejemplo3 = calcular
b, c) => devuelve (a+b)*c
(1, 2, 3)
([1, 2, 3], [4, 5, 6], 2)
('manzanas ', 'y naranjas, ', 3)
mostrar a_cadena ejemplo1
mostrar a_cadena ejemplo2
mostrar 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 soporten
los mtodos "+" y "*" la operacin tendr xito. Si se traduce este algoritmo a Ruby o
Python 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 la
funcin calcular para las variables es que soporten los mtodos "+" y "*".
Subtipos y tipos derivados
Subtipo: versin (posiblemente restringida en el rango) de un tipo existente con el que es
compatible. 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 tipo
Integer y n del tipo Natural.
Tipo derivado: nuevo tipo basado en algn otro previamente definido con el que es
incompatible, aunque sean estructuralmente idnticos. Heredan todas las propiedades de su
tipo 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)
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
