Tipado sensitivo al flujo

De Wikipedia, la enciclopedia libre
Ir a la navegación Ir a la búsqueda

En teoría de lenguaje de programación, tipado sensitivo al flujo es un sistema de tipos donde el tipo de una variable es determinado por el flujo de control.

Clásicamente, en los lenguajes con tipado estático, una variable queda ligada a un tipo durante todo su tiempo de uso. En los sistemas de tipado sensible al flujo, el tipo de una variable puede cambiar dentro del cuerpo de un método, mientras atraviesa (o fluye a través de) las estructuras de control. El tipo se determina usando inferencia de tipos y la información de tipos fluye usando Tipo de dato algebraico.

Ejemplo[editar]

El siguiente ejemplo en Ceylon ilustra el concepto:

 1 // Object? significa que la variable "name" es de tipo Object pero puedes ser null
 2 void hello(Object? name) {
 3     if (is String name) {
 4         // Ahora "name" has tipo String en este bloque
 5         print("Hola, ``name``!");
 6         // es posible ahora usar métodos sobre String en ella
 7         print(" String.size vale ``name.size``");
 8     }
 9     else if (exists name) {
10         // Ahora "name" tiene tipo Object en este bloque
11         print("Hola, objeto ``name``!");
12     }
13     else {
14         print("Hola a todos!");
15     }
16 }
17 
18           
19 hello(null);
20 hello(1);
21 hello("Pedro Pérez");

Su salida es la siguiente:

Hola a todos!
Hola, objeto 1!
Hola, Pedro Pérez!
 String.size vale 8

Beneficios[editar]

Esta técnica en conjunto con la inferencia de tipos reduce la necesidad de escribir anotaciones de tipo para todas las variables o hacer conversión de tipos, como ocurre en lenguajes con sistemas dinámicos de tipos, reduce la verbosidad en los lenguajes y ayuda a producir código más conciso, más fácil de leer y modificar.

Puede también ayudar a obtener implementaciones más rápidas de lenguajes con tipos dinámicos al predecir estáticamente el tipo de objetos.[1]

Implementaciones[editar]

Whiley, creado por David J. Pearce, fue el primer lenguaje en hacer uso de tipado sensitivo al flujo en 2009.[2][3]

Desde su introducción, otros lenguas han hecho uso de él, concretamente Ceylon, Kotlin, TypeScript[4]​ y Facebook Flow.[5][6][7][8]

Referencias[editar]

  1. Lukas Eder (11 de diciembre de 2014). «The Inconvenient Truth About Dynamic vs. Static Typing». blog.jooq.org. Consultado el 29 de marzo de 2016. 
  2. David J. Pearce (22 de septiembre de 2010). «On Flow-Sensitive Types in Whiley». whiley.org. Consultado el 29 de marzo de 2016. 
  3. David J. Pearce (8 de abril de 2012). «Whiley - Flow Typing». whiley.org. Consultado el 29 de marzo de 2016. 
  4. Ryan Cavanaugh (18 de noviembre de 2014). «TypeScript 1.4 sneak peek: union types, type guards, and more». blogs.msdn.microsoft.com. Consultado el 29 de marzo de 2016. 
  5. «Ceylon - Quick introduction - Typesafe null and flow-sensitive typing». ceylon-lang.org. Consultado el 29 de marzo de 2016. 
  6. «Null Safety». kotlinlang.org. Consultado el 29 de marzo de 2016. 
  7. «Type Checks and Casts». kotlinlang.org. Consultado el 29 de marzo de 2016. 
  8. Avik Chaudhuri, Basil Hosmer, Gabriel Levi (18 de noviembre de 2014). «Flow, a new static type checker for JavaScript». code.facebook.com. Consultado el 29 de marzo de 2016.