Escritura sensible al flujo

En la teoría de los lenguajes de programación , el tipado sensible al flujo (también llamado tipado de flujo o tipado de ocurrencia ) es un sistema de tipos donde el tipo de una expresión depende de su posición en el flujo de control .

En los lenguajes de tipado estático , el tipo de una expresión viene determinado por los tipos de las subexpresiones que la componen. Sin embargo, en el tipado sensible al flujo, el tipo de una expresión puede actualizarse a un tipo más específico si sigue una operación que valida su tipo. Las operaciones de validación pueden incluir predicados de tipo, actualizaciones imperativas y control de flujo.

Esta técnica, junto con la inferencia de tipos, reduce la necesidad de escribir anotaciones de tipo para todas las variables o de realizar conversiones de tipo , como ocurre con los lenguajes dinámicos que utilizan tipado dinámico . Reduce la verbosidad y genera un código más conciso, más fácil de leer y modificar.

También puede ayudar a los implementadores de lenguajes a proporcionar implementaciones que ejecuten lenguajes dinámicos más rápidamente prediciendo el tipo de objetos de forma estática. ^{[ 1 ]}

Finalmente, aumenta la seguridad de tipos y puede prevenir problemas debidos a punteros nulos , etiquetados por CAR Hoare —el inventor de la referencia nula— como "el error de mil millones de dólares" ^{[ 2 ].}

Desde la perspectiva de los lenguajes de programación, es razonable afirmar que el tipado sensible al flujo es la característica que finalmente permitió construir lenguajes de programación utilizables y seguros en cuanto a tipos, con tipos de unión y sin comprobaciones dinámicas excesivas. Hasta este momento, los intentos de añadir esta característica a lenguajes como Scheme generalmente resultaban en representaciones de tipos excesivamente grandes. Un ejemplo de un sistema con soporte limitado para tipos de unión es Soft Scheme de Wright y Cartwright . ^{[ 3 ]}

La historia de la idea se remonta al menos a los "discriminadores de clase de registro" de Tony Hoare de mediados de la década de 1960. ^{[ 4 ]} Sin embargo, los sistemas de tipos prácticos que la incluyen como característica son mucho más recientes.

Typed Scheme, un sistema de tipos para Scheme desarrollado por Sam Tobin-Hochstadt y publicado por primera vez en 2008, fue el primer sistema de tipos en incluir la tipificación de ocurrencias. ^{[ 5 ]} Su sucesor, Typed Racket (un dialecto de Racket ), también se basa en la tipificación de ocurrencias. ^{[ 6 ]} Poco después de Typed Scheme, David J. Pearce reinventó de forma independiente la tipificación de flujo en Whiley . ^{[ 7 ] [ 8 ]}

Typed JavaScript observó que en los lenguajes de "scripting", el tipado de flujo depende de algo más que predicados condicionales; también depende del estado y del flujo de control. ^{[ 9 ]} Este estilo se ha adoptado desde entonces en lenguajes como Ceylon , ^{[ 10 ]} TypeScript ^{[ 11 ]} y Facebook Flow. ^{[ 12 ]}

También hay algunos lenguajes que no tienen tipos de unión pero sí tipos anulables , que tienen una forma limitada de esta característica que solo se aplica a los tipos anulables, como C# , ^{[ 13 ]} Kotlin , ^{[ 14 ] [ 15 ]} y Lobster. ^{[ 16 ]}

La coincidencia de patrones alcanza los mismos objetivos que la tipificación sensible al flujo: reducir la verbosidad y generar código más conciso, fácil de leer y modificar. Lo logra de una manera diferente: permite hacer coincidir el tipo de una estructura y extraer datos de ella simultáneamente mediante la declaración de una nueva variable. De esta forma, reduce la complejidad de la conversión de tipos y la extracción de valores. La coincidencia de patrones funciona mejor cuando se utiliza junto con tipos de datos algebraicos, ya que todos los casos pueden enumerarse y ser verificados estáticamente por el compilador.

Vea este ejemplo simulado para Java: ^{[ 17 ]}

int eval ( Nodo n ) {return switch ( n ) {// Intenta convertir el tipo "Node" a "IntNode" y crea la variable "i" de tipo "int".// Si eso funciona, entonces devuelve el valor de "i".caso IntNode ( int i ) -> i ;// intenta convertir el tipo "Node" a "NegNode" y crea la variable "n" de tipo "Node".// Si eso funciona, entonces devuelve la negación de evaluar el nodo "n".caso NegNode ( Nodo n ) -> - eval ( n );// Intenta convertir el tipo "Node" a "AddNode" y crea las variables "left" y "right" de tipo "Node".// Si eso funciona, entonces devuelve la suma de la evaluación de los nodos "izquierdo" y "derecho".caso AddNode ( Nodo izquierda , Nodo derecha ) -> eval ( izquierda ) + eval ( derecha );// Intenta convertir el tipo "Node" a "MulNode" y crea las variables "left" y "right" de tipo "Node".// Si funciona, entonces devuelve el producto de evaluar los nodos "izquierdo" y "derecho".caso MulNode ( Nodo izquierda , Nodo derecha ) -> eval ( izquierda ) * eval ( derecha );// No hay "predeterminado" porque el compilador sabe que se han enumerado todos los casos posibles.};}

En un lenguaje de tipado estático, la ventaja de la coincidencia de patrones sobre el tipado sensible al flujo es que el tipo de una variable siempre permanece igual: no cambia según el flujo de control. Al escribir el patrón que se va a comparar, se declara una nueva variable que tendrá el nuevo tipo.