repo/luan: website/src/manual.html.luan comparison

comparison website/src/manual.html.luan @ 464:eddf7c73373b

fix references in the manual

author	Franklin Schmidt <fschmidt@gmail.com>
date	Thu, 07 May 2015 21:31:19 -0600
parents	e3a6d9dbd694
children	47c7de1f2322

comparison

equal deleted inserted replaced

-:895afcd2b281
+:eddf7c73373b
 				<li><a href="#constructors">Table Constructors</a></li>
 				<li><a href="#fn_calls">Function Calls</a></li>
 				<li><a href="#fn_def">Function Definitions</a></li>
 			</ul>
 		</li>
-		<li><a href="#visibility">>Visibility Rules</a></li>
+		<li><a href="#visibility">Visibility Rules</a></li>
 	</ul>
 </div>
 <hr/>
 <i>Binary</i> is implemented as the Java type <i>byte[]</i>.
 <p>
 Luan can call (and manipulate) functions written in Luan and
-functions written in Java (see <a href="#3.4.10">&sect;3.4.10</a>).
+functions written in Java (see <a href="#fn_calls">Function Calls</a>).
 Both are represented by the type <i>function</i>.
 <p>
 The type <i>userdata</i> is provided to allow arbitrary Java objects to
 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 <tt>a.name</tt> as syntactic sugar for <tt>a["name"]</tt>.
 There are several convenient ways to create tables in Luan
-(see <a href="#3.4.9">&sect;3.4.9</a>).
+(see <a href="#constructors">Table Constructors</a>).
 <p>
 We use the term <i>sequence</i> to denote a table where
 the set of all positive numeric keys is equal to {1..<i>n</i>}
 for some non-negative integer <i>n</i>,
-which is called the length of the sequence (see <a href="#3.4.7">&sect;3.4.7</a>).
+which is called the length of the sequence (see <a href="#length">The Length Operator</a>).
 <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 <i>methods</i> (see <a href="#3.4.11">&sect;3.4.11</a>).
+Thus tables can also carry <i>methods</i> (see <a href="#fn_def">Function Definitions</a>).
 <p>
 The indexing of tables follows
 the definition of raw equality in the language.
 <h3 margin-top="1em"><a name="env">Environments</a></h3>
 <p>
-As will be discussed in <a href="#3.2">&sect;3.2</a> and <a href="#3.3.3">&sect;3.3.3</a>,
+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) <tt>var</tt>
 is syntactically translated to <tt>_ENV.var</tt>.
 Moreover, every chunk is compiled in the scope of
-an external local variable named <tt>_ENV</tt> (see <a href="#3.3.2">&sect;3.3.2</a>),
+an external local variable named <tt>_ENV</tt> (see <a href="#chunks">Chunks</a>),
 so <tt>_ENV</tt> itself is never a free name in a chunk.
 <p>
 Despite the existence of this external <tt>_ENV</tt> variable and
 <tt>_ENV</tt> is a completely regular name.
 In particular,
 you can define new variables and parameters with that name.
 Each reference to a free name uses the <tt>_ENV</tt> that is
 visible at that point in the program,
-following the usual visibility rules of Luan (see <a href="#3.5">&sect;3.5</a>).
+following the usual visibility rules of Luan (see <a href="#visibility">Visibility Rules</a>).
 <p>
 Any table used as the value of <tt>_ENV</tt> is called an <i>environment</i>.
 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="#3.4.7">&sect;3.4.7</a>).
+then Luan uses the table length operation (see <a href="#length">The Length Operator</a>).
 Otherwise, Luan raises an error.
 </li>
 <li><b>"eq": </b>
 the <tt>==</tt> (equal) operation.
 <p><tt><pre>
 	var ::= Name
 </pre></tt></p>
 <p>
-Name denotes identifiers, as defined in <a href="#3.1">&sect;3.1</a>.
+Name denotes identifiers, as defined in <a href="#lex">Lexical Conventions</a>.
 <p>
 Any variable name is assumed to be global unless explicitly declared
-as a local (see <a href="#3.3.7">&sect;3.3.7</a>).
+as a local (see <a href="#local_stmt">Local Declarations</a>).
 Local variables are <i>lexically scoped</i>:
 local variables can be freely accessed by functions
-defined inside their scope (see <a href="#3.5">&sect;3.5</a>).
+defined inside their scope (see <a href="#visibility">Visibility Rules</a>).
 <p>
 Before the first assignment to a variable, its value is <b>nil</b>.
 <p>
 The meaning of accesses to table fields can be changed via metatables.
 An access to an indexed variable <tt>t[i]</tt> is equivalent to
 a call <tt>gettable_event(t,i)</tt>.
-(See <a href="#2.4">&sect;2.4</a> for a complete description of the
+(See <a href="#meta">Metatables and Metamethods</a> for a complete description of the
 <tt>gettable_event</tt> function.
 This function is not defined or callable in Luan.
 We use it here only for explanatory purposes.)
 <p>
 An access to a global variable <tt>x</tt>
 is equivalent to <tt>_ENV.x</tt>.
 Due to the way that chunks are compiled,
-<tt>_ENV</tt> is never a global name (see <a href="#2.2">&sect;2.2</a>).
+<tt>_ENV</tt> is never a global name (see <a href="#env">Environments</a>).
 <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="#3.3.4">&sect;3.3.4</a>).
+of another block (see <a href="#control">Control Structures</a>).
 </pre></tt></p>
 <p>
 Luan handles a chunk as the body of an anonymous function
 with a variable number of arguments
-(see <a href="#3.4.11">&sect;3.4.11</a>).
+(see <a href="#fn_def">Function Definitions</a>).
 As such, chunks can define local variables,
 receive arguments, and return values.
 <p>
 	varlist ::= var {&lsquo;<b>,</b>&rsquo; var}
 	explist ::= exp {&lsquo;<b>,</b>&rsquo; exp}
 </pre></tt></p>
 <p>
-Expressions are discussed in <a href="#3.4">&sect;3.4</a>.
+Expressions are discussed in <a href="#expressions">Expressions</a>.
 <p>
 Before the assignment,
 the list of values is <i>adjusted</i> to the length of
 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="#3.4">&sect;3.4</a>).
+(except when the call is enclosed in parentheses; see <a href="#expressions">Expressions</a>).
 <p>
 The assignment statement first evaluates all its expressions
 and only then the assignments are performed.
 <p>
 The meaning of assignments to global variables
 and table fields can be changed via metatables.
 An assignment to an indexed variable <tt>t[i] = val</tt> is equivalent to
 <tt>settable_event(t,i,val)</tt>.
-(See <a href="#2.4">&sect;2.4</a> for a complete description of the
+(See <a href="#meta">Metatables and Metamethods</a> for a complete description of the
 <tt>settable_event</tt> function.
 This function is not defined or callable in Luan.
 We use it here only for explanatory purposes.)
 <p>
 An assignment to a global name <tt>x = val</tt>
 is equivalent to the assignment
-<tt>_ENV.x = val</tt> (see <a href="#2.2">&sect;2.2</a>).
+<tt>_ENV.x = val</tt> (see <a href="#env">Environments</a>).
 <h4 margin-top="1em"><a name="control">Control Structures</a></h4>
 	stat ::= <b>repeat</b> block <b>until</b> exp
 	stat ::= <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b>
 </pre></tt></p>
 <p>
-Luan also has a <b>for</b> statement (see <a href="#3.3.5">&sect;3.3.5</a>).
+Luan also has a <b>for</b> statement (see <a href="#for">For Statement</a>).
 <p>
 The condition expression of a
 control structure must be a boolean.
 	stat ::= functioncall
 </pre></tt></p>
 <p>
 In this case, all returned values are thrown away.
-Function calls are explained in <a href="#3.4.10">&sect;3.4.10</a>.
+Function calls are explained in <a href="#fn_calls">Function Calls</a>.
 <h4 margin-top="1em"><a name="local_stmt">Local Declarations</a></h4>
 	stat ::= <b>local</b> namelist [&lsquo;<b>=</b>&rsquo; explist]
 </pre></tt></p>
 <p>
 If present, an initial assignment has the same semantics
-of a multiple assignment (see <a href="#3.3.3">&sect;3.3.3</a>).
+of a multiple assignment (see <a href="#assignment">Assignment</a>).
 Otherwise, all variables are initialized with <b>nil</b>.
 <p>
-A chunk is also a block (see <a href="#3.3.2">&sect;3.3.2</a>),
+A chunk is also a block (see <a href="#chunks">Chunks</a>),
 and so local variables can be declared in a chunk outside any explicit block.
 <p>
-The visibility rules for local variables are explained in <a href="#3.5">&sect;3.5</a>.
+The visibility rules for local variables are explained in <a href="#visibility">Visibility Rules</a>.
 <h3 margin-top="1em"><a name="expressions">Expressions</a></h3>
 	exp ::= unop exp
 	prefixexp ::= var | functioncall | &lsquo;<b>(</b>&rsquo; exp &lsquo;<b>)</b>&rsquo;
 </pre></tt></p>
 <p>
-Numerals and literal strings are explained in <a href="#3.1">&sect;3.1</a>;
+Numerals and literal strings are explained in <a href="#lex">Lexical Conventions</a>;
-variables are explained in <a href="#3.2">&sect;3.2</a>;
+variables are explained in <a href="#vars">Variables</a>;
-function definitions are explained in <a href="#3.4.11">&sect;3.4.11</a>;
+function definitions are explained in <a href="#fn_def">Function Definitions</a>;
-function calls are explained in <a href="#3.4.10">&sect;3.4.10</a>;
+function calls are explained in <a href="#fn_calls">Function Calls</a>;
-table constructors are explained in <a href="#3.4.9">&sect;3.4.9</a>.
+table constructors are explained in <a href="#constructors">Table Constructors</a>.
 Vararg expressions,
 denoted by three dots ('<tt>...</tt>'), can only be used when
 directly inside a vararg function;
-they are explained in <a href="#3.4.11">&sect;3.4.11</a>.
+they are explained in <a href="#fn_def">Function Definitions</a>.
 <p>
-Binary operators comprise arithmetic operators (see <a href="#3.4.1">&sect;3.4.1</a>),
+Binary operators comprise arithmetic operators (see <a href="#arithmetic">Arithmetic Operators</a>),
-relational operators (see <a href="#3.4.4">&sect;3.4.4</a>), logical operators (see <a href="#3.4.5">&sect;3.4.5</a>),
+relational operators (see <a href="#relational">Relational Operators</a>), logical operators (see <a href="#logical_ops">Logical Operators</a>),
-and the concatenation operator (see <a href="#3.4.6">&sect;3.4.6</a>).
+and the concatenation operator (see <a href="#concatenation">Concatenation</a>).
-Unary operators comprise the unary minus (see <a href="#3.4.1">&sect;3.4.1</a>),
+Unary operators comprise the unary minus (see <a href="#arithmetic">Arithmetic Operators</a>),
-the unary logical <b>not</b> (see <a href="#3.4.5">&sect;3.4.5</a>),
+the unary logical <b>not</b> (see <a href="#logical_ops">Logical Operators</a>),
-and the unary <em>length operator</em> (see <a href="#3.4.7">&sect;3.4.7</a>).
+and the unary <em>length operator</em> (see <a href="#length">The Length Operator</a>).
 <p>
 Both function calls and vararg expressions can result in multiple values.
-If a function call is used as a statement (see <a href="#3.3.6">&sect;3.3.6</a>),
+If a function call is used as a statement (see <a href="#fn_stmt">Function Calls as Statements</a>),
 then its return list is adjusted to zero elements,
 thus discarding all returned values.
 If an expression is used as the last (or the only) element
 of a list of expressions,
 then no adjustment is made
 it is different from any previously existing table.
 Closures are also compared by reference.
 <p>
 You can change the way that Luan compares tables
-by using the "eq" metamethod (see <a href="#2.4">&sect;2.4</a>).
+by using the "eq" metamethod (see <a href="#meta">Metatables and Metamethods</a>).
 <p>
 Userdata are Java objects.  They are compared for equality with the Java <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)"><tt>equals</tt></a> method.
 <p>
 then they are compared following
 the usual rule for binary operations.
 Otherwise, if both arguments are strings,
 then their values are compared according to the current locale.
 Otherwise, Luan tries to call the "lt" or the "le"
-metamethod (see <a href="#2.4">&sect;2.4</a>).
+metamethod (see <a href="#meta">Metatables and Metamethods</a>).
 A comparison <tt>a &gt; b</tt> is translated to <tt>b &lt; a</tt>
 and <tt>a &gt;= b</tt> is translated to <tt>b &lt;= a</tt>.
 <p>
 The logical operators in Luan are
 <b>and</b>, <b>or</b>, and <b>not</b>.
 The <b>and</b> and <b>or</b> operators consider both <b>false</b> and <b>nil</b> as false
 and anything else as true.
-Like the control structures (see <a href="#3.3.4">&sect;3.3.4</a>),
+Like the control structures (see <a href="#control">Control Structures</a>),
 the <b>not</b> operator requires a boolean value.
 <p>
 The negation operator <b>not</b> always returns <b>false</b> or <b>true</b>.
 The conjunction operator <b>and</b> returns its first argument
 The length of a binary is its number of bytes.
 <p>
 A program can modify the behavior of the length operator for
-any table through the <tt>__len</tt> metamethod (see <a href="#2.4">&sect;2.4</a>).
+any table through the <tt>__len</tt> metamethod (see <a href="#meta">Metatables and Metamethods</a>).
 <p>
 Unless a <tt>__len</tt> metamethod is given,
 the length of a table <tt>t</tt> is defined
 <p>
 If the last field in the list has the form <tt>exp</tt>
 and the expression is a function call or a vararg expression,
 then all values returned by this expression enter the list consecutively
-(see <a href="#3.4.10">&sect;3.4.10</a>).
+(see <a href="#fn_calls">Function Calls</a>).
 <p>
 The field list can have an optional trailing separator,
 as a convenience for machine-generated code.
 then this function is called
 with the given arguments.
 Otherwise, the prefixexp "call" metamethod is called,
 having as first parameter the value of prefixexp,
 followed by the original call arguments
-(see <a href="#2.4">&sect;2.4</a>).
+(see <a href="#meta">Metatables and Metamethods</a>).
 <p>
 Arguments have the following syntax:
 g(3, 4, 5, 8)    a=3, b=4,   ... --&gt;  5  8
 g(5, r())        a=5, b=1,   ... --&gt;  2  3
 </pre></tt></p>
 <p>
-Results are returned using the <b>return</b> statement (see <a href="#3.3.4">&sect;3.3.4</a>).
+Results are returned using the <b>return</b> statement (see <a href="#control">Control Structures</a>).
 If control reaches the end of a function
 without encountering a <b>return</b> statement,
 then the function returns with no results.

Mercurial Hosting > luan

comparison website/src/manual.html.luan @ 464:eddf7c73373b