¿Julia se escribe dinámicamente?

La respuesta de Tim Holy es bastante correcta, pero voy a elaborar un poco. En primer lugar, vamos a definir algunos términos – usted puede estar en desacuerdo con mis definiciones, pero al menos usted sabrá lo que estoy diciendo. La principal diferencia entre lenguajes estáticos y dinámicos, en mi opinión, es esta: en lenguajes estáticos, las expresiones tienen tipos; en lenguajes dinámicos, los valores tienen tipos.

En un lenguaje estático, hay reglas para determinar el tipo de cada expresión en un programa. Los tipos de expresiones dictan la comportamiento del programa. Un programa que no admite que se determine un tipo consistente para cada expresión se considera incorrecto y no compilará. En presencia de polimorfismo, el tipo de una expresión puede no ser un solo tipo concreto: el polimorfismo paramétrico se puede pensar como una forma de permitir que el mismo código describa una familia completa de algoritmos tipificados concretamente, indexados por los parámetros de los tipos; el polimorfismo subtipo se puede pensar como la introducción de una cantidad limitada de comportamiento dinámico en un lenguaje estático.

Los lenguajes dinámicos, por otro lado, no tienen reglas para asignar tipos a expresiones: los tipos están implícitos en la forma en que los datos fluyen a través del programa mientras ejecuta. En general, las expresiones pueden producir valores de cualquier tipo. Debido a esto, los teóricos de tipos a veces describen lenguajes dinámicos como "unityped" - es decir, desde la perspectiva estática, donde un" tipo " es inherentemente una propiedad de una expresión, todos las expresiones en un lenguaje dinámico tienen el tipo Any. Por supuesto, eso es aplicar la noción estática de tipo, que solo es significativa para expresiones, a un lenguaje donde la noción de tipo solo es significativa para valores.

Julia está directamente en el campo dinámico: los tipos son una propiedad de valores, no expresiones. El tipo de código resultante está determinado por la forma en que los valores fluyen a través de él cuando se ejecuta; el lenguaje no incluye ninguna regla para asignar tipos a expresiones antes de ejecutar ellos. Sin embargo, a diferencia de muchos lenguajes dinámicos, Julia tiene un lenguaje bastante sofisticado para hablar de tipos, y puede anotar expresiones con tipos. Por ejemplo, x::T es una afirmación de que x es un valor de tipo T; si eso es verdadero, x::T evalúa el valor de x, de lo contrario se genera un error y la expresión no devuelve ningún valor. Las anotaciones de tipo en las firmas de método tienen un significado ligeramente diferente: en lugar de afirmar el tipo de un valor existente, indican que el método solo se aplica si el argumento correspondiente es del tipo indicado. En cualquier caso, el siguiente código puede suponer con seguridad que el valor de x es de tipo T.

[Aparte: En algunos idiomas con escritura "gradual" u "opcional", las anotaciones de tipo cambian el idioma de modo dinámico a estático: los métodos sin anotaciones de tipo son dinámicos; los métodos con anotaciones de tipo son estáticos. En código estático, hay reglas para asignar tipos a todas las expresiones y el código debe satisfaga esos. Así no funciona Julia: el código con anotaciones de tipo sigue siendo dinámico y tiene la misma semántica que el código sin anotaciones de tipo.]

La inferencia de tipos en lenguajes como F#, OCaml o Haskell es parte de cómo se determinan los tipos de expresiones. Si el compilador no puede inferir el tipo de cualquier expresión, su programa está roto y no compilará. Todos estos lenguajes utilizan alguna forma de inferencia de tipo Hindley-Milner, que es una forma muy inteligente de derivar los tipos de expresiones de la estructura del código sin tener que escribir tipos explícitos (compare esto con lenguajes dinámicos donde los tipos están implícitos por la ejecución del código). La mayoría de las veces no se requieren anotaciones de tipo, lo cual es bastante agradable en comparación con las declaraciones de tipo detalladas que pueden ser necesarias en lenguajes como C++, C# y Java. Esto es muy diferente, sin embargo, de lenguajes dinámicos como Julia y Python donde no se requieren anotaciones de tipo simplemente porque es perfectamente aceptable que las expresiones no tengan un tipo predeterminado. En los lenguajes Hindley-Milner, puede que no tenga que escribir tantos tipos como en C++ o Java, pero cada expresión tiene un tipo predeterminado que el compilador puede calcular.

El compilador de Julia hace inferencia de tipos, pero es muy diferente: no es necesario que cada expresión tenga un tipo inferible. El compilador analiza el código para intentar predecir los tipos de expresiones y utiliza esa información para generar más código de máquina eficiente. Pero si no puede determinar el tipo de una expresión, no es gran cosa: el compilador solo emite código genérico que funcionará de todos modos, utilizando información de tipo en tiempo de ejecución. En su mayor parte, en Julia, la inferencia de tipos es solo una optimización: su código funcionará de la misma manera con o sin él, pero con una inferencia de tipos exitosa, se ejecutará mucho más rápido.