Julia Metaprogramación
Julia representa su propio código como estructuras de datos del lenguaje, de modo que podemos escribir programas que manipulan programas.
La metaprogramación también se puede entender simplemente como escribir código que puede generar código.
La metaprogramación (en inglés: Metaprogramming) se refiere a la escritura de cierto tipo de programas de computadora que escriben o manipulan otros programas (o a sí mismos) como sus datos, o que completan en tiempo de compilación parte del trabajo que debería realizarse en tiempo de ejecución. En la mayoría de los casos, en comparación con escribir todo el código manualmente, los programadores pueden obtener una mayor eficiencia de trabajo, o dar al programa una mayor flexibilidad para manejar nuevas situaciones sin necesidad de recompilar.
El lenguaje utilizado para escribir metaprogramas se denomina metalenguaje. El lenguaje del programa manipulado se denomina "lenguaje objetivo". La capacidad de un lenguaje de programación de ser también su propio metalenguaje se denomina "reflexión" o "reflexividad".
-- Wikipedia
Etapas de ejecución del código fuente de Julia
1. Analizar el código Julia original: El analizador de Julia primero analiza la cadena para obtener el árbol de sintaxis abstracta (AST). El AST es una estructura que contiene todo el código en un formato fácil de manipular.
2. Ejecutar el código Julia analizado:: En esta etapa, se ejecuta el código Julia analizado.
Cuando ingresamos código en el entorno de programación interactivo (REPL) y presionamos Enter, se ejecutan las dos etapas anteriores.
Con las herramientas de metaprogramación, podemos acceder al código Julia entre estas dos etapas, es decir, después del análisis del código fuente, pero antes de su ejecución.
Representación de programas
Julia proporciona una clase Meta, en la que se puede usar Meta.parse(str) para analizar una cadena, y typeof(e1) devuelve Expr:
Ejemplo
"1 + 1"
julia> ex1 = Meta.parse(prog)
:(1 + 1)
julia> typeof(ex1)
Expr
Devuelve:(1 + 1), este valor devuelto consiste en dos puntos y la expresión posterior. typeof(ex1) devuelve Expr.
El objeto Expr contiene dos partes (ex1 incluye los atributos head y args):
Un objeto símbolo que identifica el tipo de expresión.
Ejemplo
:call
El otro son los argumentos de la expresión, que pueden ser símbolos, otras expresiones o literales:
Ejemplo
3-element Vector{Any}:
:+
1
1
Las expresiones también se pueden construir directamente con Expr:
Ejemplo
:(1 + 1)
Las dos expresiones construidas anteriormente: una construida mediante análisis y otra mediante construcción directa, las dos son equivalentes:
Ejemplo
true
Los objetos Expr también se pueden anidar:
Ejemplo
:((4 + 4) / 2)
También podemos usar Meta.show_sexpr para ver la expresión. El siguiente ejemplo muestra un Expr anidado:
Ejemplo
(:call, :/, (:call, :+, 4, 4), 2)
Símbolos
Podemos, mediante el operador de prefijo de dos puntos,:almacenar una expresión no evaluada pero analizada.
Ejemplo
100
julia> :ABC
:ABC
Citar toda la siguiente expresión:
Ejemplo
:(100 - 50)
Citar una expresión aritmética:
Ejemplo
:(a + b * c + 1)
julia> typeof(ex)
Expr
Ten en cuenta que las expresiones equivalentes también se pueden construir usando Meta.parse o directamente con Expr:
Ejemplo
Meta.parse("a + b*c + 1") ==
Expr(:call, :+, :a, Expr(:call, :*, :b, :c), 1)
true
Citar múltiples expresiones también puede hacersequote ... endincluyendo bloques de código.
Ejemplo
x = 1
y = 2
x + y
end
quote
#= none:2 =#
x = 1
#= none:3 =#
y = 2
#= none:4 =#
x + y
end
julia> typeof(ex)
Expr
Ejecutar expresiones
Después de analizar la expresión, podemos usar la función eval() para ejecutarla:
Ejemplo
:(1 + 2)
julia> eval(ex1)
3
julia> ex = :(a + b)
:(a + b)
julia> eval(ex)
ERROR: UndefVarError: b not defined
[...]
julia> a = 1; b = 2;
julia> eval(ex)
3
Árbol de sintaxis abstracta (AST)
El árbol de sintaxis abstracta (AST) es una estructura, una representación abstracta de la estructura sintáctica del código fuente.
Presenta la estructura sintáctica del lenguaje de programación en forma de árbol; cada nodo del árbol representa una estructura en el código fuente.
Podemos ver la estructura jerárquica de la expresión con la función dump():
Ejemplo
Expr
head: Symbol call
args: Array{Any}((3,))
1: Symbol *
2: Int64 1
3: Expr
head: Symbol call
args: Array{Any}((2,))
1: Symbol cos
2: Expr
head: Symbol call
args: Array{Any}((3,))
1: Symbol /
2: Symbol pi
3: Int64 2
Interpolación
Aunque construir objetos Expr directamente con parámetros de valor es muy potente, en comparación con la sintaxis de Julia, el constructor de Expr puede resultar tedioso. Como método alternativo, Julia permite insertar literales o expresiones en una expresión citada. La interpolación de expresiones se indica con el prefijo $.
En este ejemplo, se inserta el valor de la variable a:
Ejemplo
julia> ex = :($a + b)
:(1 + b)
No se admite la interpolación en expresiones no citadas; esto provocará un error en tiempo de compilación:
julia> $a + b ERROR: syntax: "$" expression outside quote
En este ejemplo, la tupla (1,2,3) se inserta como expresión en la prueba de condición:
julia> ex = :(a in $:((1,2,3)) ) :(a in (1, 2, 3))
El uso de $ en la interpolación de expresiones está pensado para recordar a la interpolación de cadenas y a la interpolación de comandos. La interpolación de expresiones hace que la construcción programática de expresiones complejas de Julia sea conveniente y legible.
macro
Las macros proporcionan un mecanismo para incluir código generado en el cuerpo final del programa. Una macro asigna un conjunto de argumentos a una expresión devuelta, y la expresión generada se compila directamente sin necesidad de llamadas eval en tiempo de ejecución. Los argumentos de una macro pueden incluir expresiones, literales y símbolos.
Este es un macro muy simple:
Ejemplo
return :( println("Hello, world!") )
end
@sayhello (macro with 1 method)
En la sintaxis de Julia, los macros tienen un carácter especial @ (arroba), seguido inmediatamente por el nombre único del macro, que se declara con la forma macro NAME ... end. En este ejemplo, el compilador reemplazará todos los @sayhello por:
:( println("Hello, world!") )
Cuando @sayhello se ingresa en el REPL, el intérprete lo ejecuta inmediatamente, por lo que solo veremos el resultado calculado:
julia> @sayhello() Hello, world!
Ahora, consideremos un macro un poco más complejo:
Ejemplo
return :( println("Hello, ", $name) )
end
@sayhello (macro with 1 method)
Este macro acepta un argumento name. Cuando se encuentra @sayhello, la expresión citada se expande y el valor del argumento se inserta en la expresión final:
Ejemplo
Hello, human
Podemos usar la función macroexpand para ver la expresión devuelta citada:
Ejemplo
:(Main.println("Hello, ", "human"))
julia> typeof(ex)
Expr
Podemos ver que el literal "human" se ha insertado en la expresión.
También existe un macro @macroexpand, que puede ser más conveniente que la función macroexpand:
Ejemplo
:(println("Hello, ", "human"))