Talking to the compiler (the :meta
mechanism)¶
In some circumstances, one might wish to provide hints or instructions
that a given block of code has special properties: you might always
want to inline it, or you might want to turn on special compiler
optimization passes. Starting with version 0.4, Julia has a
convention that these instructions can be placed inside a :meta
expression, which is typically (but not necessarily) the first
expression in the body of a function.
:meta
expressions are created with macros. As an example, consider
the implementation of the @inline
macro:
macroinline(ex)esc(_inline(ex))end_inline(ex::Expr)=pushmeta!(ex,:inline)_inline(arg)=arg
Here, ex
is expected to be an expression defining a function.
A statement like this:
@inlinefunction myfunction(x)x*(x+3)end
gets turned into an expression like this:
quotefunction myfunction(x)Expr(:meta,:inline)x*(x+3)endend
pushmeta!(ex,:symbol,args...)
appends :symbol
to the end of
the :meta
expression, creating a new :meta
expression if
necessary. If args
is specified, a nested expression containing
:symbol
and these arguments is appended instead, which can be used
to specify additional information.
To use the metadata, you have to parse these :meta
expressions.
If your implementation can be performed within Julia, popmeta!
is
very handy: popmeta!(body,:symbol)
will scan a function body
expression (one without the function signature) for a :meta
expression, extract any arguments, and return a tuple (found::Bool,args::Array{Any})
. If the metadata did not have any arguments, or
:symbol
was not found, the args
array will be empty.
Not yet provided is a convenient infrastructure for parsing :meta
expressions from C++.