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

comparison website/src/manual.html.luan @ 417:a40e99cf0b0b

work on manual

author	Franklin Schmidt <fschmidt@gmail.com>
date	Thu, 30 Apr 2015 21:30:32 -0600
parents	ba8b0aae6453
children	455784e2227d

comparison

equal deleted inserted replaced

-:91af5337b9ae
+:a40e99cf0b0b
 				<li><a href="#logical_ops">Logical Operators</a></li>
 				<li><a href="#concatenation">Concatenation</a></li>
 				<li><a href="#length">The Length Operator</a></li>
 				<li><a href="#precedence">Precedence</a></li>
 				<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>
 	</ul>
 </div>
 <hr/>
 Every time you create a new table,
 it is different from any previously existing table.
 Closures are also compared by reference.
 <p>
-You can change the way that Lua compares tables
+You can change the way that Luan compares tables
 by using the "eq" metamethod (see <a href="#2.4">&sect;2.4</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.
-<h3>3.4.10 &ndash; <a name="3.4.10">Function Calls</a></h3><p>
+<h4 margin-top="1em"><a name="fn_calls">Function Calls</a></h4>
-A function call in Lua has the following syntax:
+<p>
-<pre>
+A function call in Luan has the following syntax:
+<p><tt><pre>
 	functioncall ::= prefixexp args
-</pre><p>
+</pre></tt></p>
+<p>
 In a function call,
 first prefixexp and args are evaluated.
-If the value of prefixexp has type <em>function</em>,
+If the value of prefixexp has type <i>function</i>,
 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>).
 <p>
-The form
-<pre>
-	functioncall ::= prefixexp &lsquo;<b>:</b>&rsquo; Name args
-</pre><p>
-can be used to call "methods".
-A call <code>v:name(<em>args</em>)</code>
-is syntactic sugar for <code>v.name(v,<em>args</em>)</code>,
-except that <code>v</code> is evaluated only once.
-<p>
 Arguments have the following syntax:
-<pre>
+<p><tt><pre>
 	args ::= &lsquo;<b>(</b>&rsquo; [explist] &lsquo;<b>)</b>&rsquo;
 	args ::= tableconstructor
 	args ::= LiteralString
-</pre><p>
+</pre></tt></p>
+<p>
 All argument expressions are evaluated before the call.
-A call of the form <code>f{<em>fields</em>}</code> is
+A call of the form <tt>f{<i>fields</i>}</tt> is
-syntactic sugar for <code>f({<em>fields</em>})</code>;
+syntactic sugar for <tt>f({<i>fields</i>})</tt>;
 that is, the argument list is a single new table.
-A call of the form <code>f'<em>string</em>'</code>
+A call of the form <tt>f'<i>string</i>'</tt>
-(or <code>f"<em>string</em>"</code> or <code>f[[<em>string</em>]]</code>)
+(or <tt>f"<i>string</i>"</tt> or <tt>f[[<i>string</i>]]</tt>)
-is syntactic sugar for <code>f('<em>string</em>')</code>;
+is syntactic sugar for <tt>f('<i>string</i>')</tt>;
 that is, the argument list is a single literal string.
 <p>
-A call of the form <code>return <em>functioncall</em></code> is called
+A call of the form <tt>return <i>functioncall</i></tt> is called
-a <em>tail call</em>.
+a <i>tail call</i>.
-Lua implements <em>proper tail calls</em>
+Luan implements <i>proper tail calls</i>
-(or <em>proper tail recursion</em>):
+(or <i>proper tail recursion</i>):
 in a tail call,
 the called function reuses the stack entry of the calling function.
 Therefore, there is no limit on the number of nested tail calls that
 a program can execute.
 However, a tail call erases any debug information about the
 where the <b>return</b> has one single function call as argument;
 this syntax makes the calling function return exactly
 the returns of the called function.
 So, none of the following examples are tail calls:
-<pre>
+<p><tt><pre>
 return (f(x))        -- results adjusted to 1
 return 2 * f(x)
 return x, f(x)       -- additional results
 f(x); return         -- results discarded
 return x or f(x)     -- results adjusted to 1
-</pre>
+</pre></tt></p>
-<h3>3.4.11 &ndash; <a name="3.4.11">Function Definitions</a></h3>
+<h4 margin-top="1em"><a name="fn_def">Function Definitions</a></h4>
 <p>
 The syntax for function definition is
-<pre>
+<p><tt><pre>
 	functiondef ::= <b>function</b> funcbody
 	funcbody ::= &lsquo;<b>(</b>&rsquo; [parlist] &lsquo;<b>)</b>&rsquo; block <b>end</b>
-</pre>
+</pre></tt></p>
 <p>
 The following syntactic sugar simplifies function definitions:
-<pre>
+<p><tt><pre>
 	stat ::= <b>function</b> funcname funcbody
 	stat ::= <b>local</b> <b>function</b> Name funcbody
 	funcname ::= Name {&lsquo;<b>.</b>&rsquo; Name} [&lsquo;<b>:</b>&rsquo; Name]
-</pre><p>
+</pre></tt></p>
+<p>
 The statement
-<pre>
+<p><tt><pre>
-function f () <em>body</em> end
+function f () <i>body</i> end
-</pre><p>
+</pre></tt></p>
+<p>
 translates to
-<pre>
+<p><tt><pre>
-f = function () <em>body</em> end
+f = function () <i>body</i> end
-</pre><p>
+</pre></tt></p>
+<p>
 The statement
-<pre>
+<p><tt><pre>
-function t.a.b.c.f () <em>body</em> end
+function t.a.b.c.f () <i>body</i> end
-</pre><p>
+</pre></tt></p>
+<p>
 translates to
-<pre>
+<p><tt><pre>
-t.a.b.c.f = function () <em>body</em> end
+t.a.b.c.f = function () <i>body</i> end
-</pre><p>
+</pre></tt></p>
+<p>
 The statement
-<pre>
+<p><tt><pre>
-local function f () <em>body</em> end
+local function f () <i>body</i> end
-</pre><p>
+</pre></tt></p>
+<p>
 translates to
-<pre>
+<p><tt><pre>
 local f; f = function () <em>body</em> end
-</pre><p>
+</pre></tt></p>
+<p>
 not to
-<pre>
+<p><tt><pre>
 local f = function () <em>body</em> end
-</pre><p>
+</pre></tt></p>
+<p>
 (This only makes a difference when the body of the function
-contains references to <code>f</code>.)
+contains references to <tt>f</tt>.)
 <p>
 A function definition is an executable expression,
-whose value has type <em>function</em>.
+whose value has type <i>function</i>.
-When Lua precompiles a chunk,
+When Luan precompiles a chunk,
 all its function bodies are precompiled too.
-Then, whenever Lua executes the function definition,
+Then, whenever Luan executes the function definition,
-the function is <em>instantiated</em> (or <em>closed</em>).
+the function is <i>instantiated</i> (or <i>closed</i>).
-This function instance (or <em>closure</em>)
+This function instance (or <i>closure</i>)
 is the final value of the expression.
 <p>
 Parameters act as local variables that are
 initialized with the argument values:
-<pre>
+<p><tt><pre>
 	parlist ::= namelist [&lsquo;<b>,</b>&rsquo; &lsquo;<b>...</b>&rsquo;] | &lsquo;<b>...</b>&rsquo;
-</pre><p>
+</pre></tt></p>
+<p>
 When a function is called,
 the list of arguments is adjusted to
 the length of the list of parameters,
-unless the function is a <em>vararg function</em>,
+unless the function is a <i>vararg function</i>,
-which is indicated by three dots ('<code>...</code>')
+which is indicated by three dots ('<tt>...</tt>')
 at the end of its parameter list.
 A vararg function does not adjust its argument list;
 instead, it collects all extra arguments and supplies them
-to the function through a <em>vararg expression</em>,
+to the function through a <i>vararg expression</i>,
 which is also written as three dots.
 The value of this expression is a list of all actual extra arguments,
 similar to a function with multiple results.
 If a vararg expression is used inside another expression
 or in the middle of a list of expressions,
 <p>
 As an example, consider the following definitions:
-<pre>
+<p><tt><pre>
 function f(a, b) end
 function g(a, b, ...) end
 function r() return 1,2,3 end
-</pre><p>
+</pre></tt></p>
+<p>
 Then, we have the following mapping from arguments to parameters and
 to the vararg expression:
-<pre>
+<p><tt><pre>
 CALL            PARAMETERS
 f(3)             a=3, b=nil
 f(3, 4)          a=3, b=4
 f(3, 4, 5)       a=3, b=4
 g(3)             a=3, b=nil, ... --&gt;  (nothing)
 g(3, 4)          a=3, b=4,   ... --&gt;  (nothing)
 g(3, 4, 5, 8)    a=3, b=4,   ... --&gt;  5  8
 g(5, r())        a=5, b=1,   ... --&gt;  2  3
-</pre>
+</pre></tt></p>
 <p>
 Results are returned using the <b>return</b> statement (see <a href="#3.3.4">&sect;3.3.4</a>).
 If control reaches the end of a function
 without encountering a <b>return</b> statement,
 then the function returns with no results.
-<p>
-There is a system-dependent limit on the number of values
+<h3 margin-top="1em"><a name="visibility">Visibility Rules</a></h3>
-that a function may return.
-This limit is guaranteed to be larger than 1000.
+<p>
+Luan is a lexically scoped language.
-<p>
-The <em>colon</em> syntax
-is used for defining <em>methods</em>,
-that is, functions that have an implicit extra parameter <code>self</code>.
-Thus, the statement
-<pre>
-function t.a.b.c:f (<em>params</em>) <em>body</em> end
-</pre><p>
-is syntactic sugar for
-<pre>
-t.a.b.c.f = function (self, <em>params</em>) <em>body</em> end
-</pre>
-<h2>3.5 &ndash; <a name="3.5">Visibility Rules</a></h2>
-<p>
-Lua is a lexically scoped language.
 The scope of a local variable begins at the first statement after
 its declaration and lasts until the last non-void statement
 of the innermost block that includes the declaration.
 Consider the following example:
-<pre>
+<p><tt><pre>
 x = 10                -- global variable
 do                    -- new block
 local x = x         -- new 'x', with value 10
 print(x)            --&gt; 10
 x = x+1
 print(x)          --&gt; 12
 end
 print(x)            --&gt; 11
 end
 print(x)              --&gt; 10  (the global one)
-</pre>
+</pre></tt></p>
 <p>
-Notice that, in a declaration like <code>local x = x</code>,
+Notice that, in a declaration like <tt>local x = x</tt>,
-the new <code>x</code> being declared is not in scope yet,
+the new <tt>x</tt> being declared is not in scope yet,
-and so the second <code>x</code> refers to the outside variable.
+and so the second <tt>x</tt> refers to the outside variable.
 <p>
 Because of the lexical scoping rules,
 local variables can be freely accessed by functions
 defined inside their scope.
 A local variable used by an inner function is called
-an <em>upvalue</em>, or <em>external local variable</em>,
+an <i>upvalue</i>, or <i>external local variable</i>,
 inside the inner function.
 <p>
 Notice that each execution of a <b>local</b> statement
 defines new local variables.
 Consider the following example:
-<pre>
+<p><tt><pre>
 a = {}
 local x = 20
 for i=1,10 do
 local y = 0
 a[i] = function () y=y+1; return x+y end
 end
-</pre><p>
+</pre></tt></p>
+<p>
 The loop creates ten closures
 (that is, ten instances of the anonymous function).
-Each of these closures uses a different <code>y</code> variable,
+Each of these closures uses a different <tt>y</tt> variable,
-while all of them share the same <code>x</code>.
+while all of them share the same <tt>x</tt>.

Mercurial Hosting > luan

comparison website/src/manual.html.luan @ 417:a40e99cf0b0b