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

julia> prog = "1 + 1"
"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

julia> ex1.head
:call

El otro son los argumentos de la expresión, que pueden ser símbolos, otras expresiones o literales:

Ejemplo

julia> ex1.args
3-element Vector{Any}:
  :+
 1
 1

Las expresiones también se pueden construir directamente con Expr:

Ejemplo

julia> ex2 = Expr(:call, :+, 1, 1)
:(1 + 1)

Las dos expresiones construidas anteriormente: una construida mediante análisis y otra mediante construcción directa, las dos son equivalentes:

Ejemplo

julia> ex1 == ex2
true

Los objetos Expr también se pueden anidar:

Ejemplo

julia> ex3 = Meta.parse("(4 + 4) / 2")
:((4 + 4) / 2)

También podemos usar Meta.show_sexpr para ver la expresión. El siguiente ejemplo muestra un Expr anidado:

Ejemplo

julia> Meta.show_sexpr(ex3)
(: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

julia> ABC = 100
100

julia> :ABC
:ABC

Citar toda la siguiente expresión:

Ejemplo

julia> :(100-50)
:(100 - 50)

Citar una expresión aritmética:

Ejemplo

julia> ex = :(a+b*c+1)
:(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

julia>      :(a + b*c + 1)       ==
       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

julia> ex = quote
           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

julia> ex1 = :(1 + 2)
:(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

julia> dump(:(1 * cos(pi/2)))
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> a = 1;

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

julia> macro sayhello()
           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

julia> macro sayhello(name)
 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

julia> @sayhello("human")
Hello, human

Podemos usar la función macroexpand para ver la expresión devuelta citada:

Ejemplo

julia> ex = macroexpand(Main, :(@sayhello("human")) )
:(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

julia> @macroexpand @sayhello "human"
:(println("Hello, ", "human"))
Otras extensiones