Mercurial Hosting > luan
diff website/src/m.html.luan @ 1656:540bf2343078
manual work
| author | Franklin Schmidt <fschmidt@gmail.com> |
|---|---|
| date | Tue, 05 Apr 2022 21:50:24 -0600 |
| parents | |
| children | 2968e43cdd44 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/website/src/m.html.luan Tue Apr 05 21:50:24 2022 -0600 @@ -0,0 +1,968 @@ +local Luan = require "luan:Luan.luan" +local error = Luan.error +local Io = require "luan:Io.luan" +local Http = require "luan:http/Http.luan" +local Shared = require "site:/lib/Shared.luan" +local head = Shared.head or error() +local docs_header = Shared.docs_header or error() +local show_toc = Shared.show_toc or error() +local show_content = Shared.show_content or error() + + +local content = { + intro = { + title = "Introduction" + content = function() +%> +<p> +Luan is a high level programming language based on <a href="http://www.lua.org">Lua</a>. A great strength of Lua is its simplicity and Luan takes this even further, being even simpler than Lua. The goal is to provide a simple programming language for the casual programmer with as few concepts as possible so that one can quickly learn the language and then easily understand any code written in Luan. +</p> + +<p> +Luan is implemented in Java and is tightly coupled with Java. So it makes a great scripting language for Java programmers. +</p> + +<p> +Unlike Lua which is meant to be embedded, Luan is meant to be a full scripting language. This done not by adding features to Luan, but rather by providing a complete set of libraries. +</p> +<% + end + } + basic = { + title = "Basic Concepts" + content = function() +%> +<p> +This section describes the basic concepts of the language. +</p> +<% + end + subs = { + types = { + title = "Values and Types" + content = function() +%> +<p> +Luan is a <em>dynamically typed language</em>. +This means that +variables do not have types; only values do. +There are no type definitions in the language. +All values carry their own type. +</p> + +<p> +All values in Luan are <em>first-class values</em>. +This means that all values can be stored in variables, +passed as arguments to other functions, and returned as results. +</p> + +<p> +There are eight basic types in Luan: +<em>nil</em>, <em>boolean</em>, <em>number</em>, +<em>string</em>, <em>binary</em>, <em>function</em>, <em>java</em>, +and <em>table</em>. +<em>Nil</em> is the type of the value <b>nil</b>, +whose main property is to be different from any other value; +it usually represents the absence of a useful value. +<em>Nil</em> is implemented as the Java value <em>null</em>. +<em>Boolean</em> is the type of the values <b>false</b> and <b>true</b>. +<em>Boolean</em> is implemented as the Java class <em>Boolean</em>. +<em>Number</em> represents both +integer numbers and real (floating-point) numbers. +<em>Number</em> is implemented as the Java class <em>Number</em>. Any Java subclass of <em>Number</em> is allowed and this is invisible to the Luan user. Operations on numbers follow the same rules of +the underlying Java implementation. +<em>String</em> is implemented as the Java class <em>String</em>. +<em>Binary</em> is implemented as the Java type <em>byte[]</em>. +</p> + +<p> +Luan can call (and manipulate) functions written in Luan and +functions written in Java (see <a href="#fn_calls">Function Calls</a>). +Both are represented by the type <em>function</em>. +</p> + +<p> +The type <em>java</em> is provided to allow arbitrary Java objects to +be stored in Luan variables. +A <em>java</em> value is a Java object that isn't one of the standard Luan types. +Java values have no predefined operations in Luan, +except assignment and identity test. +Java values are useful when Java access is enabled in Luan. +</p> + +<p> +The type <em>table</em> implements associative arrays, +that is, arrays that can be indexed not only with numbers, +but with any Luan value except <b>nil</b>. +Tables can be <em>heterogeneous</em>; +that is, they can contain values of all types (except <b>nil</b>). +Any key with value <b>nil</b> is not considered part of the table. +Conversely, any key that is not part of a table has +an associated value <b>nil</b>. +</p> + +<p> +Tables are the sole data-structuring mechanism in Luan; +they can be used to represent ordinary arrays, sequences, +symbol tables, sets, records, graphs, trees, etc. +To represent records, Luan uses the field name as an index. +The language supports this representation by +providing <code>a.name</code> as syntactic sugar for <code>a["name"]</code>. +There are several convenient ways to create tables in Luan +(see <a href="#constructors">Table Constructors</a>). +</p> + +<p> +We use the term <em>sequence</em> to denote a table where +the set of all positive numeric keys is equal to {1..<em>n</em>} +for some non-negative integer <em>n</em>, +which is called the length of the sequence (see <a href="#length">The Length Operator</a>). +</p> + +<p> +Like indices, +the values of table fields can be of any type. +In particular, +because functions are first-class values, +table fields can contain functions. +Thus tables can also carry <em>methods</em> (see <a href="#fn_def">Function Definitions</a>). +</p> + +<p> +The indexing of tables follows +the definition of raw equality in the language. +The expressions <code>a[i]</code> and <code>a[j]</code> +denote the same table element +if and only if <code>i</code> and <code>j</code> are raw equal +(that is, equal without metamethods). +In particular, floats with integral values +are equal to their respective integers +(e.g., <code>1.0 == 1</code>). +</p> + +<p> +Luan values are <em>objects</em>: +variables do not actually <em>contain</em> values, +only <em>references</em> to them. +Assignment, parameter passing, and function returns +always manipulate references to values; +these operations do not imply any kind of copy. +</p> + +<p> +The library function <a href="#Luan.type"><code>Luan.type</code></a> returns a string describing the type +of a given value. +</p> +<% + end + } + env = { + title = "Environments" + content = function() +%> +<p> +The environment of a chunk starts with only one local variable: <code><a href="#require">require</a></code>. This function is used to load and access libraries and other modules. All other variables must be added to the environment using <a href="http://localhost:8080/manual.html#local_stmt">local declarations</a>. +</p> + +<p> +As will be discussed in <a href="#vars">Variables</a> and <a href=#assignment">Assignment</a>, +any reference to a free name +(that is, a name not bound to any declaration) <code>var</code> +can be syntactically translated to <code>_ENV.var</code> if <code>_ENV</code> is defined. +</p> +<% + end + } + error = { + title = "Error Handling" + content = function() +%> +<p> +Luan code can explicitly generate an error by calling the +<a href="#Luan.error"><code>error</code></a> function. +If you need to catch errors in Luan, +you can use the <a href="#try">Try Statement</code></a>. +</p> + +<p> +Whenever there is an error, +an <em>error table</em> +is propagated with information about the error. +See <a href="#Luan.new_error"><code>Luan.new_error</code></a>. +</p> +<% + end + } + meta = { + title = "Metatables and Metamethods" + content = function() +%> +<p> +Every table in Luan can have a <em>metatable</em>. +This <em>metatable</em> is an ordinary Luan table +that defines the behavior of the original value +under certain special operations. +You can change several aspects of the behavior +of operations over a value by setting specific fields in its metatable. +For instance, when a table is the operand of an addition, +Luan checks for a function in the field "<code>__add</code>" of the table's metatable. +If it finds one, +Luan calls this function to perform the addition. +</p> + +<p> +The keys in a metatable are derived from the <em>event</em> names; +the corresponding values are called <ii>metamethods</em>. +In the previous example, the event is <code>"add"</code> +and the metamethod is the function that performs the addition. +</p> + +<p> +You can query the metatable of any table +using the <a href="#Luan.get_metatable"><code>get_metatable</code></a> function. +</p> + +<p> +You can replace the metatable of tables +using the <a href="#Luan.set_metatable"><code>set_metatable</code></a> function. +</p> + +<p> +A metatable controls how a table behaves in +arithmetic operations, bitwise operations, +order comparisons, concatenation, length operation, calls, and indexing. +</p> + +<p> +A detailed list of events controlled by metatables is given next. +Each operation is identified by its corresponding event name. +The key for each event is a string with its name prefixed by +two underscores, '<code>__</code>'; +for instance, the key for operation "add" is the +string "<code>__add</code>". +Note that queries for metamethods are always raw; +the access to a metamethod does not invoke other metamethods. +You can emulate how Luan queries a metamethod for an object <code>obj</code> +with the following code: +</p> + +<pre> + raw_get(get_metatable(obj) or {}, "__" .. event_name) +</pre> + +<p> +Here are the events: +</p> + +<ul> + +<li><p> +<b>"add": </b> +the <code>+</code> operation. + +If any operand for an addition is a table, +Luan will try to call a metamethod. +First, Luan will check the first operand (even if it is valid). +If that operand does not define a metamethod for the "<code>__add</code>" event, +then Luan will check the second operand. +If Luan can find a metamethod, +it calls the metamethod with the two operands as arguments, +and the result of the call +(adjusted to one value) +is the result of the operation. +Otherwise, +it raises an error. +</p></li> + +<li><p> +<b>"sub": </b> +the <code>-</code> operation. +Behavior similar to the "add" operation. +</li> + +<li><p><b>"mul": </b> +the <code>*</code> operation. +Behavior similar to the "add" operation. +</p></li> + +<li><p> +<b>"div": </b> +the <code>/</code> operation. +Behavior similar to the "add" operation. +</p></li> + +<li><p> +<b>"mod": </b> +the <code>%</code> operation. +Behavior similar to the "add" operation. +</p></li> + +<li><p> +<b>"pow": </b> +the <code>^</code> (exponentiation) operation. +Behavior similar to the "add" operation. +</p></li> + +<li><p> +<b>"unm": </b> +the <code>-</code> (unary minus) operation. +Behavior similar to the "add" operation. +</p></li> + +<li><p> +<b>"concat": </b> +the <code>..</code> (concatenation) operation. +Behavior similar to the "add" operation. +</p></li> + +<li><p> +<b>"len": </b> +the <code>#</code> (length) operation. +If there is a metamethod, +Luan calls it with the object as argument, +and the result of the call +(always adjusted to one value) +is the result of the operation. +If there is no metamethod but the object is a table, +then Luan uses the table length operation (see <a href="#length">The Length Operator</a>). +Otherwise, Luan raises an error. +</p></li> + +<li><p> +<b>"eq": </b> +the <code>==</code> (equal) operation. +Behavior similar to the "add" operation, +except that Luan will try a metamethod only when the values +being compared are both tables +and they are not primitively equal. +The result of the call is always converted to a boolean. +</p></li> + +<li><p> +<b>"lt": </b> +the <code><</code> (less than) operation. +Behavior similar to the "add" operation. +The result of the call is always converted to a boolean. +</p></li> + +<li><p> +<b>"le": </b> +the <code><=</code> (less equal) operation. +Unlike other operations, +The less-equal operation can use two different events. +First, Luan looks for the "<code>__le</code>" metamethod in both operands, +like in the "lt" operation. +If it cannot find such a metamethod, +then it will try the "<code>__lt</code>" event, +assuming that <code>a <= b</code> is equivalent to <code>not (b < a)</code>. +As with the other comparison operators, +the result is always a boolean. +</p></li> + +<li> +<p> +<b>"index": </b> +The indexing access <code>table[key]</code>. +This event happens +when <code>key</code> is not present in <code>table</code>. +The metamethod is looked up in <code>table</code>. +</p> + +<p> +Despite the name, +the metamethod for this event can be any type. +If it is a function, +it is called with <code>table</code> and <code>key</code> as arguments. +Otherwise +the final result is the result of indexing this metamethod object with <code>key</code>. +(This indexing is regular, not raw, +and therefore can trigger another metamethod if the metamethod object is a table.) +</p> +</li> + +<li> +<p> +<b>"new_index": </b> +The indexing assignment <code>table[key] = value</code>. +Like the index event, +this event happens when +when <code>key</code> is not present in <code>table</code>. +The metamethod is looked up in <code>table</code>. +</p> + +<p> +Like with indexing, +the metamethod for this event can be either a function or a table. +If it is a function, +it is called with <code>table</code>, <code>key</code>, and <code>value</code> as arguments. +If it is a table, +Luan does an indexing assignment to this table with the same key and value. +(This assignment is regular, not raw, +and therefore can trigger another metamethod.) +</p> + +<p> +Whenever there is a "new_index" metamethod, +Luan does not perform the primitive assignment. +(If necessary, +the metamethod itself can call <a href="#Luan.raw_set"><code>raw_set</code></a> +to do the assignment.) +</p> +</li> + +<li><p> +<b>"gc":</b> +This is when a table is garbage collected. When the table's <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#finalize()">finalize</a> method is called by the Java garbage collector, if there is a "<code>__gc</code>" metamethod then it is called with the table as a parameter. +</p></li> + +</ul> +<% + end + } + gc = { + title = "Garbage Collection" + content = function() +%> +<p> +Luan uses Java's garbage collection. +</p> +<% + end + } + } + } + lang = { + title = "The Language" + content = function() +%> +<p> +This section describes the lexis, the syntax, and the semantics of Luan. +In other words, +this section describes +which tokens are valid, +how they can be combined, +and what their combinations mean. +</p> + +<p> +Language constructs will be explained using the usual extended BNF notation, +in which +{<em>a</em>} means 0 or more <em>a</em>'s, and +[<em>a</em>] means an optional <em>a</em>. +Non-terminals are shown like non-terminal, +keywords are shown like <b>kword</b>, +and other terminal symbols are shown like ‘<b>=</b>’. +The complete syntax of Luan can be found in <a href="#9">§9</a> +at the end of this manual. +</p> +<% + end + subs = { + lex = { + title = "Lexical Conventions" + content = function() +%> +<p> +Luan ignores spaces and comments +between lexical elements (tokens), +except as delimiters between names and keywords. +Luan considers the end of a line to be the end of a statement. This catches errors and encourages readability. If you want to continue a statement on another line, you can use a backslash followed by a newline which will be treated as white space. +</p> + +<p> +<em>Names</em> +(also called <em>identifiers</em>) +in Luan can be any string of letters, +digits, and underscores, +not beginning with a digit. +Identifiers are used to name variables, table fields, and labels. +</p> + +<p> +The following <em>keywords</em> are reserved +and cannot be used as names: +</p> + +<p keywords> + <span>and</span> + <span>break</span> + <span>catch</span> + <span>continue</span> + <span>do</span> + <span>else</span> + <span>elseif</span> + <span>end_do</span> + <span>end_for</span> + <span>end_function</span> + <span>end_if</span> + <span>end_try</span> + <span>end_while</span> + <span>false</span> + <span>finally</span> + <span>for</span> + <span>function</span> + <span>if</span> + <span>in</span> + <span>local</span> + <span>nil</span> + <span>not</span> + <span>or</span> + <span>repeat</span> + <span>return</span> + <span>then</span> + <span>true</span> + <span>try</span> + <span>until</span> + <span>while</span> +</p> + +<p> +Luan is a case-sensitive language: +<code>and</code> is a reserved word, but <code>And</code> and <code>AND</code> +are two different, valid names. +</p> + +<p> +The following strings denote other tokens: +</p> + +<pre> + + - * / % ^ # + & ~ | << >> // + == ~= <= >= < > = + ( ) { } [ ] :: + ; : , . .. ... +</pre> + +<p> +<em>Literal strings</em> +can be delimited by matching single or double quotes, +and can contain the following C-like escape sequences: +'<code>\a</code>' (bell), +'<code>\b</code>' (backspace), +'<code>\f</code>' (form feed), +'<code>\n</code>' (newline), +'<code>\r</code>' (carriage return), +'<code>\t</code>' (horizontal tab), +'<code>\v</code>' (vertical tab), +'<code>\\</code>' (backslash), +'<code>\"</code>' (quotation mark [double quote]), +and '<code>\'</code>' (apostrophe [single quote]). +A backslash followed by a real newline +results in a newline in the string. +The escape sequence '<code>\z</code>' skips the following span +of white-space characters, +including line breaks; +it is particularly useful to break and indent a long literal string +into multiple lines without adding the newlines and spaces +into the string contents. +</p> + +<p> +Luan can specify any character in a literal string by its numerical value. +This can be done +with the escape sequence <code>\x<em>XX</em></code>, +where <em>XX</em> is a sequence of exactly two hexadecimal digits, +or with the escape sequence <code>\u<em>XXXX</em></code>, +where <em>XXXX</em> is a sequence of exactly four hexadecimal digits, +or with the escape sequence <code>\<em>ddd</em></code>, +where <em>ddd</em> is a sequence of up to three decimal digits. +(Note that if a decimal escape sequence is to be followed by a digit, +it must be expressed using exactly three digits.) +</p> + +<p> +Literal strings can also be defined using a long format +enclosed by <em>long brackets</em>. +We define an <em>opening long bracket of level <em>n</em></em> as an opening +square bracket followed by <em>n</em> equal signs followed by another +opening square bracket. +So, an opening long bracket of level 0 is written as <code>[[</code>, +an opening long bracket of level 1 is written as <code>[=[</code>, +and so on. +A <em>closing long bracket</em> is defined similarly; +for instance, +a closing long bracket of level 4 is written as <code>]====]</code>. +A <em>long literal</em> starts with an opening long bracket of any level and +ends at the first closing long bracket of the same level. +It can contain any text except a closing bracket of the same level. +Literals in this bracketed form can run for several lines, +do not interpret any escape sequences, +and ignore long brackets of any other level. +Any kind of end-of-line sequence +(carriage return, newline, carriage return followed by newline, +or newline followed by carriage return) +is converted to a simple newline. +</p> + +<p> +Any character in a literal string not +explicitly affected by the previous rules represents itself. +However, Luan opens files for parsing in text mode, +and the system file functions may have problems with +some control characters. +So, it is safer to represent +non-text data as a quoted literal with +explicit escape sequences for non-text characters. +</p> + +<p> +For convenience, +when the opening long bracket is immediately followed by a newline, +the newline is not included in the string. +As an example +the five literal strings below denote the same string: +</p> + +<pre> + a = 'alo\n123"' + a = "alo\n123\"" + a = '\97lo\10\04923"' + a = [[alo + 123"]] + a = [==[ + alo + 123"]==] +</pre> + +<p> +A <em>numerical constant</em> (or <em>numeral</em>) +can be written with an optional fractional part +and an optional decimal exponent, +marked by a letter '<code>e</code>' or '<code>E</code>'. +Luan also accepts hexadecimal constants, +which start with <code>0x</code> or <code>0X</code>. +Hexadecimal constants also accept an optional fractional part +plus an optional binary exponent, +marked by a letter '<code>p</code>' or '<code>P</code>'. +A numeric constant with a fractional dot or an exponent +denotes a float; +otherwise it denotes an integer. +Examples of valid integer constants are +</p> + +<pre> + 3 345 0xff 0xBEBADA +</pre> + +<p> +Examples of valid float constants are +</p> + +<pre> + 3.0 3.1416 314.16e-2 0.31416E1 34e1 + 0x0.1E 0xA23p-4 0X1.921FB54442D18P+1 +</pre> + +<p> +A <em>comment</em> starts with a double hyphen (<code>--</code>) +anywhere outside a string. +If the text immediately after <code>--</code> is not an opening long bracket, +the comment is a <em>short comment</em>, +which runs until the end of the line. +Otherwise, it is a <em>long comment</em>, +which runs until the corresponding closing long bracket. +Long comments are frequently used to disable code temporarily. +</p> +<% + end + } + vars = { + title = "Variables" + content = function() +%> +<p> +Variables are places that store values. +There are three kinds of variables in Luan: +global variables, local variables, and table fields. +</p> + +<p> +A single name can denote a global variable or a local variable +(or a function's formal parameter, +which is a particular kind of local variable): +</p> + +<pre> + var ::= Name +</pre> + +<p> +Name denotes identifiers, as defined in <a href="#lex">Lexical Conventions</a>. +</p> + +<p> +Local variables are <em>lexically scoped</em>: +local variables can be freely accessed by functions +defined inside their scope (see <a href="#visibility">Visibility Rules</a>). +</p> + +<p> +Before the first assignment to a variable, its value is <b>nil</b>. +</p> + +<p> +Square brackets are used to index a table: +</p> + +<pre> + var ::= prefixexp ‘<b>[</b>’ exp ‘<b>]</b>’ +</pre> + +<p> +The meaning of accesses to table fields can be changed via metatables. +An access to an indexed variable <code>t[i]</code> is equivalent to +a call <code>gettable_event(t,i)</code>. +(See <a href="#meta">Metatables and Metamethods</a> for a complete description of the +<code>gettable_event</code> function. +This function is not defined or callable in Luan. +We use it here only for explanatory purposes.) +</p> + +<p> +The syntax <code>var.Name</code> is just syntactic sugar for +<code>var["Name"]</code>: +</p> + +<pre> + var ::= prefixexp ‘<b>.</b>’ Name +</pre> + +<p> +Global variables are not available by default. To enable global variable, you must define <code>_ENV</code> as a local variable whose value is a table. If <code>_ENV</code> is not defined, then an unrecognized variable name will produce a compile error. If <code>_ENV</code> is defined then an access to an unrecognized variable name will be consider a global variable. So then an acces to global variable <code>x</code> +is equivalent to <code>_ENV.x</code>. +Due to the way that chunks are compiled, +<code>_ENV</code> is never a global name (see <a href="#env">Environments</a>). +</p> +<% + end + } + stmt = { + title = "Statements" + content = function() +%> +<p> +Luan supports an almost conventional set of statements, +similar to those in Pascal or C. +This set includes +assignments, control structures, function calls, +and variable declarations. +</p> +<% + end + subs = { + blocks = { + title = "Blocks" + content = function() +%> +<p> +A block is a list of statements, +which are executed sequentially: +</p> + +<pre> + block ::= {stat} +</pre> + +<p> +Luan has <em>empty statements</em> +that allow you to separate statements with semicolons, +start a block with a semicolon +or write two semicolons in sequence: +</p> + +<pre> + stat ::= ‘<b>;</b>’ +</pre> + +<p> +A block can be explicitly delimited to produce a single statement: +</p> + +<pre> + stat ::= <b>do</b> block end_do + end_do ::= <b>end_do</b> | <b>end</b> +</pre> + +<p> +Explicit blocks are useful +to control the scope of variable declarations. +Explicit blocks are also sometimes used to +add a <b>return</b> statement in the middle +of another block (see <a href="#control">Control Structures</a>). +</p> +<% + end + } + chunks = { + title = "Chunks" + content = function() +%> +<p> +The unit of compilation of Luan is called a <em>chunk</em>. +Syntactically, +a chunk is simply a block: +</p> + +<pre> + chunk ::= block +</pre> + +<p> +Luan handles a chunk as the body of an anonymous function +with a variable number of arguments +(see <a href="#fn_def">Function Definitions</a>). +As such, chunks can define local variables, +receive arguments, and return values. +</p> + +<p> +A chunk can be stored in a file or in a string inside the host program. +To execute a chunk, +Luan first <em>loads</em> it, +compiling the chunk's code, +and then Luan executes the compiled code. +</p> +<% + end + } + assignment = { + title = "Assignment" + content = function() +%> +<p> +Luan allows multiple assignments. +Therefore, the syntax for assignment +defines a list of variables on the left side +and a list of expressions on the right side. +The elements in both lists are separated by commas: +</p> + +<pre> + stat ::= varlist ‘<b>=</b>’ explist + varlist ::= var {‘<b>,</b>’ var} + explist ::= exp {‘<b>,</b>’ exp} +</pre> + +<p> +Expressions are discussed in <a href="#expressions">Expressions</a>. +</p> + +<p> +Before the assignment, +the list of values is <em>adjusted</em> to the length of +the list of variables. +If there are more values than needed, +the excess values are thrown away. +If there are fewer values than needed, +the list is extended with as many <b>nil</b>'s as needed. +If the list of expressions ends with a function call, +then all values returned by that call enter the list of values, +before the adjustment +(except when the call is enclosed in parentheses; see <a href="#expressions">Expressions</a>). +</p> + +<p> +The assignment statement first evaluates all its expressions +and only then the assignments are performed. +Thus the code +</p> + +<pre> + i = 3 + i, a[i] = i+1, 20 +</pre> + +<p> +sets <code>a[3]</code> to 20, without affecting <code>a[4]</code> +because the <code>i</code> in <code>a[i]</code> is evaluated (to 3) +before it is assigned 4. +Similarly, the line +</p> + +<pre> + x, y = y, x +</pre> + +<p> +exchanges the values of <code>x</code> and <code>y</code>, +and +</p> + +<pre> + x, y, z = y, z, x +</pre> + +<p> +cyclically permutes the values of <code>x</code>, <code>y</code>, and <code>z</code>. +</p> + +<p> +The meaning of assignments to global variables +and table fields can be changed via metatables. +An assignment to an indexed variable <code>t[i] = val</code> is equivalent to +<code>settable_event(t,i,val)</code>. +(See <a href="#meta">Metatables and Metamethods</a> for a complete description of the +<code>settable_event</code> function. +This function is not defined or callable in Luan. +We use it here only for explanatory purposes.) +</p> + +<p> +An assignment to a global name <code>x = val</code> +is equivalent to the assignment +<code>_ENV.x = val</code> (see <a href="#env">Environments</a>). +Global names are only available when <code>_ENV</code> is defined. +</p> +<% + end + } + } + } + } + } +} + + +return function() + Io.stdout = Http.response.text_writer() +%> +<!doctype html> +<html> + <head> +<% head() %> + <title>Luan Reference Manual</title> + <style> + p[keywords] { + font-family: monospace; + margin-left: 40px; + max-width: 700px; + } + p[keywords] span { + display: inline-block; + width: 100px; + } + </style> + </head> + <body> +<% docs_header() %> + <div content> + <h1><a href="manual.html">Luan Reference Manual</a></h1> + <p small> + Original copyright © 2015 Lua.org, PUC-Rio. + Freely available under the terms of the + <a href="http://www.lua.org/license.html">Lua license</a>. + Modified for Luan. + </p> + <hr> + <h2>Contents</h2> + <div toc> +<% show_toc(content) %> + </div> + <hr> +<% show_content(content,2) %> + </div> + </body> +</html> +<% +end