28 lines
32 KiB
HTML
28 lines
32 KiB
HTML
<!DOCTYPE html>
|
|
<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>Julia ASTs · The Julia Language</title><script>(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
|
|
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
|
|
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
|
|
})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
|
|
|
|
ga('create', 'UA-28835595-6', 'auto');
|
|
ga('send', 'pageview');
|
|
</script><link href="https://cdnjs.cloudflare.com/ajax/libs/normalize/4.2.0/normalize.min.css" rel="stylesheet" type="text/css"/><link href="https://fonts.googleapis.com/css?family=Lato|Roboto+Mono" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/default.min.css" rel="stylesheet" type="text/css"/><script>documenterBaseURL=".."</script><script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.2.0/require.min.js" data-main="../assets/documenter.js"></script><script src="../siteinfo.js"></script><script src="../../versions.js"></script><link href="../assets/documenter.css" rel="stylesheet" type="text/css"/><link href="../assets/julia-manual.css" rel="stylesheet" type="text/css"/></head><body><nav class="toc"><a href="../index.html"><img class="logo" src="../assets/logo.png" alt="The Julia Language logo"/></a><h1>The Julia Language</h1><select id="version-selector" onChange="window.location.href=this.value" style="visibility: hidden"></select><form class="search" id="search-form" action="../search.html"><input id="search-query" name="q" type="text" placeholder="Search docs"/></form><ul><li><a class="toctext" href="../index.html">Home</a></li><li><span class="toctext">Manual</span><ul><li><a class="toctext" href="../manual/introduction.html">Introduction</a></li><li><a class="toctext" href="../manual/getting-started.html">Getting Started</a></li><li><a class="toctext" href="../manual/variables.html">Variables</a></li><li><a class="toctext" href="../manual/integers-and-floating-point-numbers.html">Integers and Floating-Point Numbers</a></li><li><a class="toctext" href="../manual/mathematical-operations.html">Mathematical Operations and Elementary Functions</a></li><li><a class="toctext" href="../manual/complex-and-rational-numbers.html">Complex and Rational Numbers</a></li><li><a class="toctext" href="../manual/strings.html">Strings</a></li><li><a class="toctext" href="../manual/functions.html">Functions</a></li><li><a class="toctext" href="../manual/control-flow.html">Control Flow</a></li><li><a class="toctext" href="../manual/variables-and-scoping.html">Scope of Variables</a></li><li><a class="toctext" href="../manual/types.html">Types</a></li><li><a class="toctext" href="../manual/methods.html">Methods</a></li><li><a class="toctext" href="../manual/constructors.html">Constructors</a></li><li><a class="toctext" href="../manual/conversion-and-promotion.html">Conversion and Promotion</a></li><li><a class="toctext" href="../manual/interfaces.html">Interfaces</a></li><li><a class="toctext" href="../manual/modules.html">Modules</a></li><li><a class="toctext" href="../manual/documentation.html">Documentation</a></li><li><a class="toctext" href="../manual/metaprogramming.html">Metaprogramming</a></li><li><a class="toctext" href="../manual/arrays.html">Multi-dimensional Arrays</a></li><li><a class="toctext" href="../manual/linear-algebra.html">Linear algebra</a></li><li><a class="toctext" href="../manual/networking-and-streams.html">Networking and Streams</a></li><li><a class="toctext" href="../manual/parallel-computing.html">Parallel Computing</a></li><li><a class="toctext" href="../manual/dates.html">Date and DateTime</a></li><li><a class="toctext" href="../manual/interacting-with-julia.html">Interacting With Julia</a></li><li><a class="toctext" href="../manual/running-external-programs.html">Running External Programs</a></li><li><a class="toctext" href="../manual/calling-c-and-fortran-code.html">Calling C and Fortran Code</a></li><li><a class="toctext" href="../manual/handling-operating-system-variation.html">Handling Operating System Variation</a></li><li><a class="toctext" href="../manual/environment-variables.html">Environment Variables</a></li><li><a class="toctext" href="../manual/embedding.html">Embedding Julia</a></li><li><a class="toctext" href="../manual/packages.html">Packages</a></li><li><a class="toctext" href="../manual/profile.html">Profiling</a></li><li><a class="toctext" href="../manual/stacktraces.html">Stack Traces</a></li><li><a class="toctext" href="../manual/performance-tips.html">Performance Tips</a></li><li><a class="toctext" href="../manual/workflow-tips.html">Workflow Tips</a></li><li><a class="toctext" href="../manual/style-guide.html">Style Guide</a></li><li><a class="toctext" href="../manual/faq.html">Frequently Asked Questions</a></li><li><a class="toctext" href="../manual/noteworthy-differences.html">Noteworthy Differences from other Languages</a></li><li><a class="toctext" href="../manual/unicode-input.html">Unicode Input</a></li></ul></li><li><span class="toctext">Standard Library</span><ul><li><a class="toctext" href="../stdlib/base.html">Essentials</a></li><li><a class="toctext" href="../stdlib/collections.html">Collections and Data Structures</a></li><li><a class="toctext" href="../stdlib/math.html">Mathematics</a></li><li><a class="toctext" href="../stdlib/numbers.html">Numbers</a></li><li><a class="toctext" href="../stdlib/strings.html">Strings</a></li><li><a class="toctext" href="../stdlib/arrays.html">Arrays</a></li><li><a class="toctext" href="../stdlib/parallel.html">Tasks and Parallel Computing</a></li><li><a class="toctext" href="../stdlib/linalg.html">Linear Algebra</a></li><li><a class="toctext" href="../stdlib/constants.html">Constants</a></li><li><a class="toctext" href="../stdlib/file.html">Filesystem</a></li><li><a class="toctext" href="../stdlib/io-network.html">I/O and Network</a></li><li><a class="toctext" href="../stdlib/punctuation.html">Punctuation</a></li><li><a class="toctext" href="../stdlib/sort.html">Sorting and Related Functions</a></li><li><a class="toctext" href="../stdlib/pkg.html">Package Manager Functions</a></li><li><a class="toctext" href="../stdlib/dates.html">Dates and Time</a></li><li><a class="toctext" href="../stdlib/iterators.html">Iteration utilities</a></li><li><a class="toctext" href="../stdlib/test.html">Unit Testing</a></li><li><a class="toctext" href="../stdlib/c.html">C Interface</a></li><li><a class="toctext" href="../stdlib/libc.html">C Standard Library</a></li><li><a class="toctext" href="../stdlib/libdl.html">Dynamic Linker</a></li><li><a class="toctext" href="../stdlib/profile.html">Profiling</a></li><li><a class="toctext" href="../stdlib/stacktraces.html">StackTraces</a></li><li><a class="toctext" href="../stdlib/simd-types.html">SIMD Support</a></li></ul></li><li><span class="toctext">Developer Documentation</span><ul><li><a class="toctext" href="reflection.html">Reflection and introspection</a></li><li><span class="toctext">Documentation of Julia's Internals</span><ul><li><a class="toctext" href="init.html">Initialization of the Julia runtime</a></li><li class="current"><a class="toctext" href="ast.html">Julia ASTs</a><ul class="internal"><li><a class="toctext" href="#Lowered-form-1">Lowered form</a></li><li><a class="toctext" href="#Surface-syntax-AST-1">Surface syntax AST</a></li></ul></li><li><a class="toctext" href="types.html">More about types</a></li><li><a class="toctext" href="object.html">Memory layout of Julia Objects</a></li><li><a class="toctext" href="eval.html">Eval of Julia code</a></li><li><a class="toctext" href="callconv.html">Calling Conventions</a></li><li><a class="toctext" href="compiler.html">High-level Overview of the Native-Code Generation Process</a></li><li><a class="toctext" href="functions.html">Julia Functions</a></li><li><a class="toctext" href="cartesian.html">Base.Cartesian</a></li><li><a class="toctext" href="meta.html">Talking to the compiler (the <code>:meta</code> mechanism)</a></li><li><a class="toctext" href="subarrays.html">SubArrays</a></li><li><a class="toctext" href="sysimg.html">System Image Building</a></li><li><a class="toctext" href="llvm.html">Working with LLVM</a></li><li><a class="toctext" href="stdio.html">printf() and stdio in the Julia runtime</a></li><li><a class="toctext" href="boundscheck.html">Bounds checking</a></li><li><a class="toctext" href="locks.html">Proper maintenance and care of multi-threading locks</a></li><li><a class="toctext" href="offset-arrays.html">Arrays with custom indices</a></li><li><a class="toctext" href="libgit2.html">Base.LibGit2</a></li><li><a class="toctext" href="require.html">Module loading</a></li></ul></li><li><span class="toctext">Developing/debugging Julia's C code</span><ul><li><a class="toctext" href="backtraces.html">Reporting and analyzing crashes (segfaults)</a></li><li><a class="toctext" href="debuggingtips.html">gdb debugging tips</a></li><li><a class="toctext" href="valgrind.html">Using Valgrind with Julia</a></li><li><a class="toctext" href="sanitizers.html">Sanitizer support</a></li></ul></li></ul></li></ul></nav><article id="docs"><header><nav><ul><li>Developer Documentation</li><li>Documentation of Julia's Internals</li><li><a href="ast.html">Julia ASTs</a></li></ul><a class="edit-page" href="https://github.com/JuliaLang/julia/blob/master/doc/src/devdocs/ast.md"><span class="fa"></span> Edit on GitHub</a></nav><hr/><div id="topbar"><span>Julia ASTs</span><a class="fa fa-bars" href="#"></a></div></header><h1><a class="nav-anchor" id="Julia-ASTs-1" href="#Julia-ASTs-1">Julia ASTs</a></h1><p>Julia has two representations of code. First there is a surface syntax AST returned by the parser (e.g. the <a href="../stdlib/numbers.html#Base.parse-Tuple{Type,Any,Any}"><code>parse()</code></a> function), and manipulated by macros. It is a structured representation of code as it is written, constructed by <code>julia-parser.scm</code> from a character stream. Next there is a lowered form, or IR (intermediate representation), which is used by type inference and code generation. In the lowered form there are fewer types of nodes, all macros are expanded, and all control flow is converted to explicit branches and sequences of statements. The lowered form is constructed by <code>julia-syntax.scm</code>.</p><p>First we will focus on the lowered form, since it is more important to the compiler. It is also less obvious to the human, since it results from a significant rearrangement of the input syntax.</p><h2><a class="nav-anchor" id="Lowered-form-1" href="#Lowered-form-1">Lowered form</a></h2><p>The following data types exist in lowered form:</p><ul><li><p><code>Expr</code></p><p>Has a node type indicated by the <code>head</code> field, and an <code>args</code> field which is a <code>Vector{Any}</code> of subexpressions.</p></li><li><p><code>Slot</code></p><p>Identifies arguments and local variables by consecutive numbering. <code>Slot</code> is an abstract type with subtypes <code>SlotNumber</code> and <code>TypedSlot</code>. Both types have an integer-valued <code>id</code> field giving the slot index. Most slots have the same type at all uses, and so are represented with <code>SlotNumber</code>. The types of these slots are found in the <code>slottypes</code> field of their <code>MethodInstance</code> object. Slots that require per-use type annotations are represented with <code>TypedSlot</code>, which has a <code>typ</code> field.</p></li><li><p><code>CodeInfo</code></p><p>Wraps the IR of a method.</p></li><li><p><code>LineNumberNode</code></p><p>Contains a single number, specifying the line number the next statement came from.</p></li><li><p><code>LabelNode</code></p><p>Branch target, a consecutively-numbered integer starting at 0.</p></li><li><p><code>GotoNode</code></p><p>Unconditional branch.</p></li><li><p><code>QuoteNode</code></p><p>Wraps an arbitrary value to reference as data. For example, the function <code>f() = :a</code> contains a <code>QuoteNode</code> whose <code>value</code> field is the symbol <code>a</code>, in order to return the symbol itself instead of evaluating it.</p></li><li><p><code>GlobalRef</code></p><p>Refers to global variable <code>name</code> in module <code>mod</code>.</p></li><li><p><code>SSAValue</code></p><p>Refers to a consecutively-numbered (starting at 0) static single assignment (SSA) variable inserted by the compiler.</p></li><li><p><code>NewvarNode</code></p><p>Marks a point where a variable is created. This has the effect of resetting a variable to undefined.</p></li></ul><h3><a class="nav-anchor" id="Expr-types-1" href="#Expr-types-1">Expr types</a></h3><p>These symbols appear in the <code>head</code> field of <code>Expr</code>s in lowered form.</p><ul><li><p><code>call</code></p><p>Function call (dynamic dispatch). <code>args[1]</code> is the function to call, <code>args[2:end]</code> are the arguments.</p></li><li><p><code>invoke</code></p><p>Function call (static dispatch). <code>args[1]</code> is the MethodInstance to call, <code>args[2:end]</code> are the arguments (including the function that is being called, at <code>args[2]</code>).</p></li><li><p><code>static_parameter</code></p><p>Reference a static parameter by index.</p></li><li><p><code>line</code></p><p>Line number and file name metadata. Unlike a <code>LineNumberNode</code>, can also contain a file name.</p></li><li><p><code>gotoifnot</code></p><p>Conditional branch. If <code>args[1]</code> is false, goes to label identified in <code>args[2]</code>.</p></li><li><p><code>=</code></p><p>Assignment.</p></li><li><p><code>method</code></p><p>Adds a method to a generic function and assigns the result if necessary.</p><p>Has a 1-argument form and a 4-argument form. The 1-argument form arises from the syntax <code>function foo end</code>. In the 1-argument form, the argument is a symbol. If this symbol already names a function in the current scope, nothing happens. If the symbol is undefined, a new function is created and assigned to the identifier specified by the symbol. If the symbol is defined but names a non-function, an error is raised. The definition of "names a function" is that the binding is constant, and refers to an object of singleton type. The rationale for this is that an instance of a singleton type uniquely identifies the type to add the method to. When the type has fields, it wouldn't be clear whether the method was being added to the instance or its type.</p><p>The 4-argument form has the following arguments:</p><ul><li><p><code>args[1]</code></p><p>A function name, or <code>false</code> if unknown. If a symbol, then the expression first behaves like the 1-argument form above. This argument is ignored from then on. When this is <code>false</code>, it means a method is being added strictly by type, <code>(::T)(x) = x</code>.</p></li><li><p><code>args[2]</code></p><p>A <code>SimpleVector</code> of argument type data. <code>args[2][1]</code> is a <code>SimpleVector</code> of the argument types, and <code>args[2][2]</code> is a <code>SimpleVector</code> of type variables corresponding to the method's static parameters.</p></li><li><p><code>args[3]</code></p><p>A <code>CodeInfo</code> of the method itself. For "out of scope" method definitions (adding a method to a function that also has methods defined in different scopes) this is an expression that evaluates to a <code>:lambda</code> expression.</p></li><li><p><code>args[4]</code></p><p><code>true</code> or <code>false</code>, identifying whether the method is staged (<code>@generated function</code>).</p></li></ul></li><li><p><code>const</code></p><p>Declares a (global) variable as constant.</p></li><li><p><code>null</code></p><p>Has no arguments; simply yields the value <code>nothing</code>.</p></li><li><p><code>new</code></p><p>Allocates a new struct-like object. First argument is the type. The <code>new</code> pseudo-function is lowered to this, and the type is always inserted by the compiler. This is very much an internal-only feature, and does no checking. Evaluating arbitrary <code>new</code> expressions can easily segfault.</p></li><li><p><code>return</code></p><p>Returns its argument as the value of the enclosing function.</p></li><li><p><code>the_exception</code></p><p>Yields the caught exception inside a <code>catch</code> block. This is the value of the run time system variable <code>jl_exception_in_transit</code>.</p></li><li><p><code>enter</code></p><p>Enters an exception handler (<code>setjmp</code>). <code>args[1]</code> is the label of the catch block to jump to on error.</p></li><li><p><code>leave</code></p><p>Pop exception handlers. <code>args[1]</code> is the number of handlers to pop.</p></li><li><p><code>inbounds</code></p><p>Controls turning bounds checks on or off. A stack is maintained; if the first argument of this expression is true or false (<code>true</code> means bounds checks are disabled), it is pushed onto the stack. If the first argument is <code>:pop</code>, the stack is popped.</p></li><li><p><code>boundscheck</code></p><p>Indicates the beginning or end of a section of code that performs a bounds check. Like <code>inbounds</code>, a stack is maintained, and the second argument can be one of: <code>true</code>, <code>false</code>, or <code>:pop</code>.</p></li><li><p><code>copyast</code></p><p>Part of the implementation of quasi-quote. The argument is a surface syntax AST that is simply copied recursively and returned at run time.</p></li><li><p><code>meta</code></p><p>Metadata. <code>args[1]</code> is typically a symbol specifying the kind of metadata, and the rest of the arguments are free-form. The following kinds of metadata are commonly used:</p><ul><li><p><code>:inline</code> and <code>:noinline</code>: Inlining hints.</p></li><li><p><code>:push_loc</code>: enters a sequence of statements from a specified source location.</p><ul><li><p><code>args[2]</code> specifies a filename, as a symbol.</p></li><li><p><code>args[3]</code> optionally specifies the name of an (inlined) function that originally contained the code.</p></li></ul></li><li><p><code>:pop_loc</code>: returns to the source location before the matching <code>:push_loc</code>.</p></li></ul></li></ul><h3><a class="nav-anchor" id="Method-1" href="#Method-1">Method</a></h3><p>A unique'd container describing the shared metadata for a single method.</p><ul><li><p><code>name</code>, <code>module</code>, <code>file</code>, <code>line</code>, <code>sig</code></p><p>Metadata to uniquely identify the method for the computer and the human.</p></li><li><p><code>ambig</code></p><p>Cache of other methods that may be ambiguous with this one.</p></li><li><p><code>specializations</code></p><p>Cache of all MethodInstance ever created for this Method, used to ensure uniqueness. Uniqueness is required for efficiency, especially for incremental precompile and tracking of method invalidation.</p></li><li><p><code>source</code></p><p>The original source code (usually compressed).</p></li><li><p><code>roots</code></p><p>Pointers to non-AST things that have been interpolated into the AST, required by compression of the AST, type-inference, or the generation of native code.</p></li><li><p><code>nargs</code>, <code>isva</code>, <code>called</code>, <code>isstaged</code>, <code>pure</code></p><p>Descriptive bit-fields for the source code of this Method.</p></li><li><p><code>min_world</code> / <code>max_world</code></p><p>The range of world ages for which this method is visible to dispatch.</p></li></ul><h3><a class="nav-anchor" id="MethodInstance-1" href="#MethodInstance-1">MethodInstance</a></h3><p>A unique'd container describing a single callable signature for a Method. See especially <a href="locks.html#Proper-maintenance-and-care-of-multi-threading-locks-1">Proper maintenance and care of multi-threading locks</a> for important details on how to modify these fields safely.</p><ul><li><p><code>specTypes</code></p><p>The primary key for this MethodInstance. Uniqueness is guaranteed through a <code>def.specializations</code> lookup.</p></li><li><p><code>def</code></p><p>The <code>Method</code> that this function describes a specialization of. Or <code>#undef</code>, if this is a top-level Lambda that is not part of a Method.</p></li><li><p><code>sparam_vals</code></p><p>The values of the static parameters in <code>specTypes</code> indexed by <code>def.sparam_syms</code>. For the <code>MethodInstance</code> at <code>Method.unspecialized</code>, this is the empty <code>SimpleVector</code>. But for a runtime <code>MethodInstance</code> from the <code>MethodTable</code> cache, this will always be defined and indexable.</p></li><li><p><code>rettype</code></p><p>The inferred return type for the <code>specFunctionObject</code> field, which (in most cases) is also the computed return type for the function in general.</p></li><li><p><code>inferred</code></p><p>May contain a cache of the inferred source for this function, or other information about the inference result such as a constant return value may be put here (if <code>jlcall_api == 2</code>), or it could be set to <code>nothing</code> to just indicate <code>rettype</code> is inferred.</p></li><li><p><code>ftpr</code></p><p>The generic jlcall entry point.</p></li><li><p><code>jlcall_api</code></p><p>The ABI to use when calling <code>fptr</code>. Some significant ones include:</p><ul><li><p>0 - Not compiled yet</p></li><li><p>1 - JL_CALLABLE <code>jl_value_t *(*)(jl_function_t *f, jl_value_t *args[nargs], uint32_t nargs)</code></p></li><li><p>2 - Constant (value stored in <code>inferred</code>)</p></li><li><p>3 - With Static-parameters forwarded <code>jl_value_t *(*)(jl_svec_t *sparams, jl_function_t *f, jl_value_t *args[nargs], uint32_t nargs)</code></p></li><li><p>4 - Run in interpreter <code>jl_value_t *(*)(jl_method_instance_t *meth, jl_function_t *f, jl_value_t *args[nargs], uint32_t nargs)</code></p></li></ul></li><li><p><code>min_world</code> / <code>max_world</code></p><p>The range of world ages for which this method instance is valid to be called.</p></li></ul><h3><a class="nav-anchor" id="CodeInfo-1" href="#CodeInfo-1">CodeInfo</a></h3><p>A temporary container for holding lowered source code.</p><ul><li><p><code>code</code></p><p>An <code>Any</code> array of statements</p></li><li><p><code>slotnames</code></p><p>An array of symbols giving the name of each slot (argument or local variable).</p></li><li><p><code>slottypes</code></p><p>An array of types for the slots.</p></li><li><p><code>slotflags</code></p><p>A <code>UInt8</code> array of slot properties, represented as bit flags:</p><ul><li><p>2 - assigned (only false if there are <em>no</em> assignment statements with this var on the left)</p></li><li><p>8 - const (currently unused for local variables)</p></li><li><p>16 - statically assigned once</p></li><li><p>32 - might be used before assigned. This flag is only valid after type inference.</p></li></ul></li><li><p><code>ssavaluetypes</code></p><p>Either an array or an <code>Int</code>.</p><p>If an <code>Int</code>, it gives the number of compiler-inserted temporary locations in the function. If an array, specifies a type for each location.</p></li></ul><p>Boolean properties:</p><ul><li><p><code>inferred</code></p><p>Whether this has been produced by type inference.</p></li><li><p><code>inlineable</code></p><p>Whether this should be inlined.</p></li><li><p><code>propagate_inbounds</code></p><p>Whether this should should propagate <code>@inbounds</code> when inlined for the purpose of eliding <code>@boundscheck</code> blocks.</p></li><li><p><code>pure</code></p><p>Whether this is known to be a pure function of its arguments, without respect to the state of the method caches or other mutable global state.</p></li></ul><h2><a class="nav-anchor" id="Surface-syntax-AST-1" href="#Surface-syntax-AST-1">Surface syntax AST</a></h2><p>Front end ASTs consist entirely of <code>Expr</code>s and atoms (e.g. symbols, numbers). There is generally a different expression head for each visually distinct syntactic form. Examples will be given in s-expression syntax. Each parenthesized list corresponds to an Expr, where the first element is the head. For example <code>(call f x)</code> corresponds to <code>Expr(:call, :f, :x)</code> in Julia.</p><h3><a class="nav-anchor" id="Calls-1" href="#Calls-1">Calls</a></h3><table><tr><th>Input</th><th>AST</th></tr><tr><td><code>f(x)</code></td><td><code>(call f x)</code></td></tr><tr><td><code>f(x, y=1, z=2)</code></td><td><code>(call f x (kw y 1) (kw z 2))</code></td></tr><tr><td><code>f(x; y=1)</code></td><td><code>(call f (parameters (kw y 1)) x)</code></td></tr><tr><td><code>f(x...)</code></td><td><code>(call f (... x))</code></td></tr></table><p><code>do</code> syntax:</p><pre><code class="language-julia">f(x) do a,b
|
|
body
|
|
end</code></pre><p>parses as <code>(call f (-> (tuple a b) (block body)) x)</code>.</p><h3><a class="nav-anchor" id="Operators-1" href="#Operators-1">Operators</a></h3><p>Most uses of operators are just function calls, so they are parsed with the head <code>call</code>. However some operators are special forms (not necessarily function calls), and in those cases the operator itself is the expression head. In julia-parser.scm these are referred to as "syntactic operators". Some operators (<code>+</code> and <code>*</code>) use N-ary parsing; chained calls are parsed as a single N-argument call. Finally, chains of comparisons have their own special expression structure.</p><table><tr><th>Input</th><th>AST</th></tr><tr><td><code>x+y</code></td><td><code>(call + x y)</code></td></tr><tr><td><code>a+b+c+d</code></td><td><code>(call + a b c d)</code></td></tr><tr><td><code>2x</code></td><td><code>(call * 2 x)</code></td></tr><tr><td><code>a&&b</code></td><td><code>(&& a b)</code></td></tr><tr><td><code>x += 1</code></td><td><code>(+= x 1)</code></td></tr><tr><td><code>a ? 1 : 2</code></td><td><code>(if a 1 2)</code></td></tr><tr><td><code>a:b</code></td><td><code>(: a b)</code></td></tr><tr><td><code>a:b:c</code></td><td><code>(: a b c)</code></td></tr><tr><td><code>a,b</code></td><td><code>(tuple a b)</code></td></tr><tr><td><code>a==b</code></td><td><code>(call == a b)</code></td></tr><tr><td><code>1<i<=n</code></td><td><code>(comparison 1 < i <= n)</code></td></tr><tr><td><code>a.b</code></td><td><code>(. a (quote b))</code></td></tr><tr><td><code>a.(b)</code></td><td><code>(. a b)</code></td></tr></table><h3><a class="nav-anchor" id="Bracketed-forms-1" href="#Bracketed-forms-1">Bracketed forms</a></h3><table><tr><th>Input</th><th>AST</th></tr><tr><td><code>a[i]</code></td><td><code>(ref a i)</code></td></tr><tr><td><code>t[i;j]</code></td><td><code>(typed_vcat t i j)</code></td></tr><tr><td><code>t[i j]</code></td><td><code>(typed_hcat t i j)</code></td></tr><tr><td><code>t[a b; c d]</code></td><td><code>(typed_vcat t (row a b) (row c d))</code></td></tr><tr><td><code>a{b}</code></td><td><code>(curly a b)</code></td></tr><tr><td><code>a{b;c}</code></td><td><code>(curly a (parameters c) b)</code></td></tr><tr><td><code>[x]</code></td><td><code>(vect x)</code></td></tr><tr><td><code>[x,y]</code></td><td><code>(vect x y)</code></td></tr><tr><td><code>[x;y]</code></td><td><code>(vcat x y)</code></td></tr><tr><td><code>[x y]</code></td><td><code>(hcat x y)</code></td></tr><tr><td><code>[x y; z t]</code></td><td><code>(vcat (row x y) (row z t))</code></td></tr><tr><td><code>[x for y in z, a in b]</code></td><td><code>(comprehension x (= y z) (= a b))</code></td></tr><tr><td><code>T[x for y in z]</code></td><td><code>(typed_comprehension T x (= y z))</code></td></tr><tr><td><code>(a, b, c)</code></td><td><code>(tuple a b c)</code></td></tr><tr><td><code>(a; b; c)</code></td><td><code>(block a (block b c))</code></td></tr></table><h3><a class="nav-anchor" id="Macros-1" href="#Macros-1">Macros</a></h3><table><tr><th>Input</th><th>AST</th></tr><tr><td><code>@m x y</code></td><td><code>(macrocall @m x y)</code></td></tr><tr><td><code>Base.@m x y</code></td><td><code>(macrocall (. Base (quote @m)) x y)</code></td></tr><tr><td><code>@Base.m x y</code></td><td><code>(macrocall (. Base (quote @m)) x y)</code></td></tr></table><h3><a class="nav-anchor" id="Strings-1" href="#Strings-1">Strings</a></h3><table><tr><th>Input</th><th>AST</th></tr><tr><td><code>"a"</code></td><td><code>"a"</code></td></tr><tr><td><code>x"y"</code></td><td><code>(macrocall @x_str "y")</code></td></tr><tr><td><code>x"y"z</code></td><td><code>(macrocall @x_str "y" "z")</code></td></tr><tr><td><code>"x = $x"</code></td><td><code>(string "x = " x)</code></td></tr><tr><td><code>`a b c`</code></td><td><code>(macrocall @cmd "a b c")</code></td></tr></table><p>Doc string syntax:</p><pre><code class="language-julia">"some docs"
|
|
f(x) = x</code></pre><p>parses as <code>(macrocall (|.| Core '@doc) "some docs" (= (call f x) (block x)))</code>.</p><h3><a class="nav-anchor" id="Imports-and-such-1" href="#Imports-and-such-1">Imports and such</a></h3><table><tr><th>Input</th><th>AST</th></tr><tr><td><code>import a</code></td><td><code>(import a)</code></td></tr><tr><td><code>import a.b.c</code></td><td><code>(import a b c)</code></td></tr><tr><td><code>import ...a</code></td><td><code>(import . . . a)</code></td></tr><tr><td><code>import a.b, c.d</code></td><td><code>(toplevel (import a b) (import c d))</code></td></tr><tr><td><code>import Base: x</code></td><td><code>(import Base x)</code></td></tr><tr><td><code>import Base: x, y</code></td><td><code>(toplevel (import Base x) (import Base y))</code></td></tr><tr><td><code>export a, b</code></td><td><code>(export a b)</code></td></tr></table><h3><a class="nav-anchor" id="Numbers-1" href="#Numbers-1">Numbers</a></h3><p>Julia supports more number types than many scheme implementations, so not all numbers are represented directly as scheme numbers in the AST.</p><table><tr><th>Input</th><th>AST</th></tr><tr><td><code>11111111111111111111</code></td><td><code>(macrocall @int128_str "11111111111111111111")</code></td></tr><tr><td><code>0xfffffffffffffffff</code></td><td><code>(macrocall @uint128_str "0xfffffffffffffffff")</code></td></tr><tr><td><code>1111...many digits...</code></td><td><code>(macrocall @big_str "1111....")</code></td></tr></table><h3><a class="nav-anchor" id="Block-forms-1" href="#Block-forms-1">Block forms</a></h3><p>A block of statements is parsed as <code>(block stmt1 stmt2 ...)</code>.</p><p>If statement:</p><pre><code class="language-julia">if a
|
|
b
|
|
elseif c
|
|
d
|
|
else e
|
|
f
|
|
end</code></pre><p>parses as:</p><pre><code class="language-none">(if a (block (line 2) b)
|
|
(block (line 3) (if c (block (line 4) d)
|
|
(block (line 5) e (line 6) f))))</code></pre><p>A <code>while</code> loop parses as <code>(while condition body)</code>.</p><p>A <code>for</code> loop parses as <code>(for (= var iter) body)</code>. If there is more than one iteration specification, they are parsed as a block: <code>(for (block (= v1 iter1) (= v2 iter2)) body)</code>.</p><p><code>break</code> and <code>continue</code> are parsed as 0-argument expressions <code>(break)</code> and <code>(continue)</code>.</p><p><code>let</code> is parsed as <code>(let body (= var1 val1) (= var2 val2) ...)</code>.</p><p>A basic function definition is parsed as <code>(function (call f x) body)</code>. A more complex example:</p><pre><code class="language-julia">function f{T}(x::T; k = 1)
|
|
return x+1
|
|
end</code></pre><p>parses as:</p><pre><code class="language-none">(function (call (curly f T) (parameters (kw k 1))
|
|
(:: x T))
|
|
(block (line 2 file.jl) (return (call + x 1))))</code></pre><p>Type definition:</p><pre><code class="language-julia">mutable struct Foo{T<:S}
|
|
x::T
|
|
end</code></pre><p>parses as:</p><pre><code class="language-none">(type #t (curly Foo (<: T S))
|
|
(block (line 2 none) (:: x T)))</code></pre><p>The first argument is a boolean telling whether the type is mutable.</p><p><code>try</code> blocks parse as <code>(try try_block var catch_block finally_block)</code>. If no variable is present after <code>catch</code>, <code>var</code> is <code>#f</code>. If there is no <code>finally</code> clause, then the last argument is not present.</p><footer><hr/><a class="previous" href="init.html"><span class="direction">Previous</span><span class="title">Initialization of the Julia runtime</span></a><a class="next" href="types.html"><span class="direction">Next</span><span class="title">More about types</span></a></footer></article></body></html>
|