--- a/website/src/manual.html.luan	Thu Apr 30 06:28:25 2015 -0600
+++ b/website/src/manual.html.luan	Thu Apr 30 21:30:32 2015 -0600
@@ -73,8 +73,11 @@
 				<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>
 
@@ -1262,7 +1265,7 @@
 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>
@@ -1476,15 +1479,19 @@
 
 
 
-<h3>3.4.10 &ndash; <a name="3.4.10">Function Calls</a></h3><p>
-A function call in Lua has the following syntax:
-
-<pre>
+<h4 margin-top="1em"><a name="fn_calls">Function Calls</a></h4>
+
+<p>
+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,
@@ -1494,40 +1501,30 @@
 
 
 <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
-syntactic sugar for <code>f({<em>fields</em>})</code>;
+A call of the form <tt>f{<i>fields</i>}</tt> is
+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>
-(or <code>f"<em>string</em>"</code> or <code>f[[<em>string</em>]]</code>)
-is syntactic sugar for <code>f('<em>string</em>')</code>;
+A call of the form <tt>f'<i>string</i>'</tt>
+(or <tt>f"<i>string</i>"</tt> or <tt>f[[<i>string</i>]]</tt>)
+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 <em>tail call</em>.
-Lua implements <em>proper tail calls</em>
-(or <em>proper tail recursion</em>):
+A call of the form <tt>return <i>functioncall</i></tt> is called
+a <i>tail call</i>.
+Luan implements <i>proper tail calls</i>
+(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
@@ -1540,82 +1537,98 @@
 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>
-
-
-
-
-<h3>3.4.11 &ndash; <a name="3.4.11">Function Definitions</a></h3>
+</pre></tt></p>
+
+
+
+
+<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>
-     function f () <em>body</em> end
-</pre><p>
+<p><tt><pre>
+     function f () <i>body</i> end
+</pre></tt></p>
+
+<p>
 translates to
 
-<pre>
-     f = function () <em>body</em> end
-</pre><p>
+<p><tt><pre>
+     f = function () <i>body</i> end
+</pre></tt></p>
+
+<p>
 The statement
 
-<pre>
-     function t.a.b.c.f () <em>body</em> end
-</pre><p>
+<p><tt><pre>
+     function t.a.b.c.f () <i>body</i> end
+</pre></tt></p>
+
+<p>
 translates to
 
-<pre>
-     t.a.b.c.f = function () <em>body</em> end
-</pre><p>
+<p><tt><pre>
+     t.a.b.c.f = function () <i>body</i> end
+</pre></tt></p>
+
+<p>
 The statement
 
-<pre>
-     local function f () <em>body</em> end
-</pre><p>
+<p><tt><pre>
+     local function f () <i>body</i> end
+</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>.
-When Lua precompiles a chunk,
+whose value has type <i>function</i>.
+When Luan precompiles a chunk,
 all its function bodies are precompiled too.
-Then, whenever Lua executes the function definition,
-the function is <em>instantiated</em> (or <em>closed</em>).
-This function instance (or <em>closure</em>)
+Then, whenever Luan executes the function definition,
+the function is <i>instantiated</i> (or <i>closed</i>).
+This function instance (or <i>closure</i>)
 is the final value of the expression.
 
 
@@ -1623,18 +1636,20 @@
 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>,
-which is indicated by three dots ('<code>...</code>')
+unless the function is a <i>vararg function</i>,
+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.
@@ -1649,15 +1664,17 @@
 <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
@@ -1670,7 +1687,7 @@
      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>).
@@ -1679,44 +1696,18 @@
 then the function returns with no results.
 
 
-<p>
-
-There is a system-dependent limit on the number of values
-that a function may return.
-This limit is guaranteed to be larger than 1000.
-
-
-<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.
+
+
+<h3 margin-top="1em"><a name="visibility">Visibility Rules</a></h3>
+
+<p>
+Luan 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
@@ -1729,12 +1720,12 @@
        print(x)            --&gt; 11
      end
      print(x)              --&gt; 10  (the global one)
-</pre>
-
-<p>
-Notice that, in a declaration like <code>local x = x</code>,
-the new <code>x</code> being declared is not in scope yet,
-and so the second <code>x</code> refers to the outside variable.
+</pre></tt></p>
+
+<p>
+Notice that, in a declaration like <tt>local x = x</tt>,
+the new <tt>x</tt> being declared is not in scope yet,
+and so the second <tt>x</tt> refers to the outside variable.
 
 
 <p>
@@ -1742,7 +1733,7 @@
 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.
 
 
@@ -1751,18 +1742,20 @@
 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,
-while all of them share the same <code>x</code>.
+Each of these closures uses a different <tt>y</tt> variable,
+while all of them share the same <tt>x</tt>.